Robots Battle Project

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. Internal representation Simulator Graphic output Winner The Simulator System Diagram Report errorExit Parse Input: Robot programs 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 • Lexical analyzer • Input program (ascii)  tokens • Parser • Tokens  Code • Simulator • Code  actions Lexemes Parser Code Simulator

6. Lexical analyzer Lexemes Stream Lex.str ComputeDistance { $x2 = $x * $x print(“Hello world”) exit() } Tokens.h #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

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

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

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

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

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. 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 Main Game Loop

13. Main Game Loop Pseudo Code main loop 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

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 = 1.0 T = 0.5 T = 0.0 Distance To Travel

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

17. Functionality bad.c 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); } } • 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 good.c void RemoveItem(void* item) { node* ItemsNode = Find(item); if (ItemsNode != NULL) { Delete(ItemsNode); } }

18. Naming and Documentation documentation.c /* * 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); } } • Document by writing “good” code • Naming convention • Meaningful names • Simple and working code • Remarks when appropriate • Module header • Function header • Special parts of code

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

20. Error handling Graphics Parser Simulator Lexical analyzer Hash List 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

21. Modularity Implementation • .h module interface • Data structures of the module that the user uses • Function prototypes • Constants • .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 list.h list.c #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 */ #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; }

23. ds.c Data Structures { 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; } Should be: • Generic • Handled through functions that manipulate them. ds-function.c { ... ListInsert(list, item); ... ListInsert(list, item2); }

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

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

26. Asserts array1.c array2.c /* * 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 < a->size); a->data[position] = item; } /* * 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 < a->size) ) { a->data[position] = item; } }

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 FileManager.c FileManager.h #include “FileManager.h” FilesList* files; ... #ifndef __FILEMANAGER_H #define __FILEMANAGER_H typedef struct _FilesList { . . . } FilesList; extern FilesList* files; #endif /* __FILEMANAGER_H */ Process.c #include “FileManager.h” { ... Write(files, 1, data); ... }

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