Presentation is loading. Please wait.

Presentation is loading. Please wait.

Robots Battle Project The project consists of two major parts: Parse the robot strategy files Simulate the robots battle main flow –Execute robot strategy.

Similar presentations

Presentation on theme: "Robots Battle Project The project consists of two major parts: Parse the robot strategy files Simulate the robots battle main flow –Execute robot strategy."— Presentation transcript:

1 Robots Battle Project The project consists of two major parts: Parse the robot strategy files Simulate the robots battle main flow –Execute robot strategy –Events –Animation (Interpolation) –Game Rules –Output Results

2 The Simulator System Diagram Input: Robot programs WinnerGraphic output Parse Report error Exit Simulator Internal representation Already Supplied

3 Lexemes Tokens Define the strategy available tokens For example “TURN”, “ASSIGN”,”PLUS” etc. You need to produce a well known defined tokens stream as input for the parsing process.

4 Parsing Parse is one of the major task in the project. Use good design in order to make your task easier. Before parsing, you need to lexical analyze the strategy file to produce a well known tokens (lexemes) The parsing process will convert the tokens stream into some internal representation. A design proposal will presented next.

5 Design hints (major modules) Lexical analyzer Parser Simulator Lexical analyzer –Input program (ascii)  tokens Parser –Tokens  Code Simulator –Code  actions Lexemes Code

6 Lexical analyzer ComputeDistance { $x2 = $x * $x print(“Hello world”) exit() } #define NAME 1 #define OP_PLUS 2 #define OP_TIMES 3 #define PRINT 4 #define STOP 5 #define OPEN 6 #define CLOSE 7 #define CURLY_OPEN 8 #define CURLY CLOSE 9 #define VARIABLE 10 Tokens.h Lex.str Lexemes Stream LexemeValue NAMEComputeDistance CURLY_OPEN VARIABLEx2 OP_EQUALS VARIABLEx OP_TIMES VARIABLEx PRINT OPEN STRINGHello World CLOSE EXIT OPEN CLOSE CURLY_CLOSE

7 Parsing Input a “token’s stream” Examine the validity of the program Produce code #123456#123456 Command Assign AssignExp Turn Move Return P1 $x TIMES GREATER 10 $x2 P2 7 $x2 $tmp P3 $x $x2 ParseSample { $x=7 $x2 = $x * $x $tmp = $x2 > 100 Turn(10) Move($x2) } Parse.str P4 $x 100 Next 2 3 4 5 6 #define ASSIGN 1 #define ASSIGNEXP 2 #define TURN 3 #define MOVE 4 #define RETURN 5 #define IF 6... Commands.h

8 Parsing if #1234567#1234567 Command Assign AssignExp If Fire PrintString Return P1 $x TIMES GREATER $tmp “ Done ” P2 7 $x2 $tmp 6 P3 $x $x2 ParseIfSample { $x=7 $x2 = $x * $x $tmp = $x2 > 100 if $tmp Fire() endif print(“Done”) } ParseIf.str P4 $x 100 Next 2 3 4 5 6 7

9 Parsing While #1234#1234 Command Assign while AssignExp Return P1 $x MINUS P2 7 4 $x P3 $x ParseSample { $x=7 while $x $x=$x-1 endwhile return } P4 1 Next 2 3 2 ParseWhile.str

10 Parsing function call #123456#123456 Command Assign Return Assign Call PrintExp Return P1 TIMES $x 1 $y P2 $y 7 P3 $x Sqr { $y=x*x } ParseSample { $x=7 Sqr() print($y) } P4 $x Next 2 4 5 6 ParseFunc.str FunctionLine Sqr1 ParseSample3

11 System Simulator Main purpose is to simulate the battle flow. Execute robots strategy files. Simulate motion animation (laser beam, robots). Manage the event system. Identify the event and call to the relevant routine handling.

12 Main Game Loop Infinite loop which called every CLOCK_PER_SECOND_TICK Execute robots programs Manage the game rules Manages the motions of the game –Collision –Position –Events

13 Main Game Loop Pseudo Code tick=1 Forever For each robot Execute one instruction Move robot (If needed) Move laser beam (If needed) Check collision, end game?, events calling Render Scene ++tick main loop

14 Motion Interpolation In order to simulate the motion of the robots and the laser beam you need to use linear interpolation as follows: #define MOVE_SPEED_FACTOR //number of pixels for each tick #define MOVE_TIME_STEPS(d) 1.0/d * MOVE_SPEED_FACTOR // center coordinates of the robot StartPositionX = Robot.x StartPositionY = Robot.y // (X,Y) destination coordinates after moving by dist with //respect to the (0,0) dest_X = dist*sin(robot.direction*PI/180) dest_Y = dist*cos(robot.direction*PI/180) time = [0.0,1.0] While(time < 1){ time += MOVE_TIME_STEPS(dist) Robot.x = StartPositionX + dest_X * time Robot.y = StartPositionY + dest_Y * time }

15 Interpolation T = 0.0 T = 1.0 T = 0.5 Distance To Travel

16 Software engineering Modularity Functionality Documentation Naming convention Data structures Design-Implement-Test

17 Functionality Functions do one “thing” Repeated code is a function The name of the function should be self explanatory Functions are typically short < 60 lines Line length should be <= 80 characters void fndel(void* item) { node* p = root; while (item != p->value) p = p->next; if (p != NULL) { p->next->prev = p->prev; p->prev->next = p->next; free(p); } bad.c void RemoveItem(void* item) { node* ItemsNode = Find(item); if (ItemsNode != NULL) { Delete(ItemsNode); } good.c

18 Naming and Documentation Document by writing “good” code –Naming convention –Meaningful names –Simple and working code Remarks when appropriate –Module header –Function header –Special parts of code /* * Description: * Search the list for the * input item and delete it * if the item is in the list * Input: * item - to look for and * delete. * Remarks: * May change root to NULL if * the list contains one item. */ void RemoveItem(void* item) { node* ItemsNode = Find(item) if (ItemsNode != NULL) { Delete(ItemsNode); } documentation.c

19 Simple Code Simple - working code is preferable. –Less bugs –Easy for others to read –Easy to maintain void strcpy(char* d, char* s) { for (;*d++=*s++;); } unreadable.c void strcpy(char* d, char* s) { int i; for (i=0; s[i] != ‘\0’; ++i) d[i] = s[i]; d[i] = ‘\0’; } simple.c

20 Modularity A set of functions that manage one entity –List (data structure) –Parser Purpose: –Design tool, divide a difficult (large) problem to easier and smaller problems –Distribute work among team members –No code duplication Less code Fix a bug in one place Ability to change design and improve incrementally –Code re-use by writing standalone modules Graphics List Hash Error handling Lexical analyzer ParserSimulator

21 Modularity Implementation 1..h module interface Data structures of the module that the user uses Function prototypes Constants 2..cpp implementation Implementation of the functions that were defined in the.h Prototypes, functions and constants that are internal to the module

22 Modularity - implementation #ifndef __MYLIST_H #define __MYLIST_H typedef struct _List { struct _List *next; void *data; } List; List* NewList(); void ListInsert(List* head, void *item); void ListDelete(List* head); #endif /* __MYLIST_H */ list.h #include “list.h” /* * Allocates and prepares a new * list. * Return: NULL in case of an error * or a pointer to the head of * the list. */ List* NewList() { List* new_list; new_list=malloc(sizeof(LIST)); if (new_list == NULL) return NULL; new_list->next = NULL; new_list->data = NULL; return new_list; } list.c

23 Data Structures Should be: Generic Handled through functions that manipulate them. { Node* new;... new = malloc(sizeof(Node)); new->item = item; new->next = list->root list->root = new;... new = malloc(sizeof(Node)); new->item = item2; new->next = list->root list->root = new; } ds.c {... ListInsert(list, item);... ListInsert(list, item2); } ds-function.c

24 Design-Implement-Test Spend time on design before starting to code. Leave enough time for debugging and unexpected design flaws. Design Implement Test/ Debug

25 Suggested schedule Design 1w Implement4w integration (port)2w Testing 2w Write Documentation [2w] In parallel ------- Total 9w

26 Asserts /* * Description: * Set an array value * Input: * array - pointer to the * “array structure” * item - to insert * * NOTES: * assume the position is * valid */ void Insert(ARRAY* a, int position, void* item) { assert(position >= 0); assert(position size); a->data[position] = item; } array1.c /* * Description: * Set an array value * Input: * array - pointer to the array * structure * item - to insert * * NOTES: * validate that the position * is valid */ void Insert(ARRAY* a, int position, void* item) { if ( (position >= 0) && (position size) ) { a->data[position] = item; } array2.c

27 How to use asserts For every parameter of a function –assert (parameter meets assumption) For every call to a function –assert(result meets assumptinos) Validate results of computations Validate access to NULL points

28 Using global variables #include “FileManager.h” FilesList* files;... FileManager.c #include “FileManager.h” {... Write(files, 1, data);... } Process.c #ifndef __FILEMANAGER_H #define __FILEMANAGER_H typedef struct _FilesList {... } FilesList; extern FilesList* files; #endif /* __FILEMANAGER_H */ FileManager.h

29 Common pitfalls Plan your time –Start working early (now) Test your project –Try testing individual modules

30 Partners Choose a partner you can work with Meet every week or so –See you’re both on track –Things change: synchronize

31 Unix tools Editors: –emacs –vi –pico (easier to learn) Development environment –kdevelop Debuggers all based on gdb –gdb: command line debuger –ddd: gui to gdb Help –info or tkinfo –man pages

Download ppt "Robots Battle Project The project consists of two major parts: Parse the robot strategy files Simulate the robots battle main flow –Execute robot strategy."

Similar presentations

Ads by Google