Project 4

1. Create a Windows Form Application project with the text boxes that allow the user to enter the number of armies to battle, the number of robots on each army, the number of cells on the grid, etc.
2. Call the constructor for your BattleField object taking the arguments from the user input. Make sure you handle possible exception situations that can occur due to an incorrect input.
3. On your form have a panel object and a multi-line text box object. Please add pointers to the text box and to a Graphics object for the panel as data members to your classes. The text box object will serve as the console for the trace output (use AppendText() instead of cout<<... everywhere you need). If you decide to implement graphical part use the graphics object to draw pictures of your battle objects.
4. All classes you need are to be managed classes either defined as reference classes (__gc) or as value (__value). You may use the classes we have discussed in the class (such as Location or BattleObjectQueue).
5. Please note that for the new queue you do not need the old PRobot class because now we just store managed pointers to battle objects. That is, you need to remove the PRobot class from your UML diagram. Also don't forget to add the Form class for your windows form to the diagram.
6. Use the try ... catch construct where ever is appropriate.
7. Do not forget to comment your code.

Note that despite you have to have the panel for the graphics, the implementation of the graphical part is optional. You can get extra credits for doing this, but I would recommend to do this when your game engine is complete. The text box debugging output is required, though.

The completed project should include two parts:

1. the updated MS Visio document with the UML diagram that shows all your classes and their relations;
2. MS Visual Studio project that is compileable and can handle up to 3 different teams with up to 100 robots on each team.

Additional requirements:

• Define properties position, team, HP for the battle object.
• Please define read only property Item for the class __gc Grid that takes an object of the __value Location type as a parameter and returns the battle object queue that contains all battle objects in the cell corresponding to this location. If you do so, then you can access the queue as:

  grig->Item[robot->position]->remove(robot);

• For the class Cell overload the arithmetic operator + (op_Addition) that is able to add a variable of the Direction type. For example,

  Cell(2, 3) + NorthWest = Cell(1, 2)

  Hint: first implement the following class Direction that uses enumeration EDirection:

  __value enum EDirection : unsigned short int {
     East      =   0,
     NorthEast =  45,
     North     =  90,
     NorthWest = 135,
     West      = 180,
     SouthWest = 225,
     South     = 270,
     SouthEast = 315
  };
  
  __value class Direction {
     private:
        int dir; // angle in degrees counterclockwise from the X-axsis
     public:
        Direction() : dir(0) {};
        Direction(int d)
        {
           if( d < 0 )
              d += (1-d/360)*360;
           dir = d % 360;
        };
        Direction(EDirection d) : dir(d) {};
        static double Cos(Direction d)  {  return Math::Cos( d.dir*Math::PI/180 ); 	};
        static double Sin(Direction d)  {  return Math::Sin( d.dir*Math::PI/180 );  };
        // some operators
        static Direction op_Addition(Direction a, Direction b)    {  return Direction(a.dir+b.dir);  };
        static Direction op_Subtraction(Direction a, Direction b) {  return Direction(a.dir-b.dir);  };
        static bool op_LessThanOrEqual(Direction a, Direction b)    { return a.dir <= b.dir; };
        static bool op_LessThan(Direction a, Direction b)           { return a.dir < b.dir; };
        static bool op_GreaterThanOrEqual(Direction a, Direction b) { return a.dir >= b.dir; };
        static bool op_GreaterThan(Direction a, Direction b)        { return a.dir > b.dir; };
        static bool op_Equality(Direction a, Direction b)           { return a.dir == b.dir; };
        static bool op_Inequality(Direction a, Direction b)         { return a.dir != b.dir; };
  };
  

  and overload operator op_Addition that takes the first argument of the class Cell and the second argument of the class Direction. The same new class Direction can be used in the Location class.
• Also overload operators == and != (op_Equality and op_Inequality) to be able to see is two cells are equal or not.