Implement entered_colors(); Fix rotation render; Change create_area() flag input

Author: JustATin555

src/bundles/robot_minigame/functions.ts

@@ -87,55 +87,6 @@ let bounds: Point[];
 // sets the context to the state obj, mostly for convenience so i dont have to type context.... everytime
 context.moduleContexts.robot_minigame.state = state;
 
-/**
- * Teleport the robot
- *
- * @param x coordinate of the robot
- * @param y coordinate of the robot
- */
-function set_pos(
-  x: number,
-  y: number
-) {
-  // Init functions should not run after initialization
-  if (state.isInit) return;
-
-  robot.x = x;
-  robot.y = y;
-}
-
-/**
- * Set the rotation of the robot
- *
- * @param rotation in radians
- */
-function set_rotation(
-  rotation: number
-) {
-  // Init functions should not run after initialization
-  if (state.isInit) return;
-
-  robot.dx = Math.cos(rotation);
-  robot.dy = -Math.sin(rotation);
-}
-
-/**
- * Set the width and height of the map
- *
- * @param width of the map
- * @param height of the map
- */
-function set_dimensions(
-  width: number,
-  height: number
-) {
-  // Init functions should not run after initialization
-  if (state.isInit) return;
-
-  state.width = width;
-  state.height = height;
-}
-
 // ===== //
 // SETUP //
 // ===== //
@@ -183,34 +134,80 @@ export function init(
  * @param flags any additional flags the area may have
  */
 export function create_area(
-  rawVertices: number[],
+  vertices: number[],
   isObstacle: boolean,
-  flags: AreaFlags = {}
+  flags: any[]
 ) {
   // Init functions should not run after initialization
   if (state.isInit) return;
 
-  if (rawVertices.length % 2 !== 0) throw new Error('Odd number of arguments given (expected even)');
+  if (vertices.length % 2 !== 0) throw new Error('Odd number of vertice x-y coordinates given (expected even)');
+
+  if (flags.length % 2 !== 0) throw new Error('Odd number of flag arguments given (expected even)');
 
   // Store vertices as Point array
-  const vertices: Point[] = [];
+  const parsedVertices: Point[] = [];
 
   // Parse x-y pairs into Points
-  for (let i = 0; i < rawVertices.length / 2; i++) {
-    vertices[i] = {
-      x: rawVertices[i * 2],
-      y: rawVertices[i * 2 + 1]
+  for (let i = 0; i < vertices.length / 2; i++) {
+    parsedVertices[i] = {
+      x: vertices[i * 2],
+      y: vertices[i * 2 + 1]
     };
   }
 
+  // Store flags as an object
+  const parsedFlags = {};
+
+  // Parse flag-value pairs into flags
+  for (let i = 0; i < flags.length / 2; i++) {
+    // Retrieve flag
+    const flag = flags[i * 2];
+
+    // Check flag is string
+    if (typeof flag !== 'string') throw new Error(`Flag arguments must be strings (${flag} is a ${typeof flag})`);
+
+    // Add flag to object
+    parsedFlags[flag] = flags[i * 2 + 1];
+  }
+
   // Store the new area
   state.areas.push({
-    vertices,
+    vertices: parsedVertices,
     isObstacle,
-    flags
+    flags: parsedFlags
   });
 }
 
+/**
+ * Creates a new rectangular, axis-aligned area
+ *
+ * @param x top left corner of the rectangle
+ * @param y top right corner of the rectangle
+ * @param width of the rectangle
+ * @param height of the rectangle
+ * @param isObstacle a boolean indicating if the area is an obstacle or not
+ * @param flags any additional flags the area may have
+ */
+export function create_rect_area(
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+  isObstacle: boolean,
+  flags: any[]
+) {
+  // Init functions should not run after initialization
+  if (state.isInit) return;
+
+  create_area([
+    x, y,
+    x + width, y,
+    x + width, y + height,
+    x, y + height
+  ], isObstacle, flags);
+}
+
 /**
  * Creates a new obstacle
  *
@@ -222,7 +219,7 @@ export function create_obstacle(
   // Init functions should not run after initialization
   if (state.isInit) return;
 
-  create_area(vertices, true);
+  create_area(vertices, true, []);
 }
 
 /**
@@ -242,12 +239,7 @@ export function create_rect_obstacle(
   // Init functions should not run after initialization
   if (state.isInit) return;
 
-  create_obstacle([
-    x, y,
-    x + width, y,
-    x + width, y + height,
-    x, y + height
-  ]);
+  create_rect_area(x, y, width, height, true, []);
 }
 
 /**
@@ -425,6 +417,15 @@ export function turn_right() {
 // TESTING //
 // ======= //
 
+/**
+ * Inform the simulator that the testing phase is starting
+ */
+export function start_testing() {
+  if (state.isComplete) throw new Error('May not start testing twice!');
+
+  state.isComplete = true;
+}
+
 /**
  * Checks if the robot's entered areas satisfy the condition
  *
@@ -433,9 +434,74 @@ export function turn_right() {
 export function entered_areas(
   callback : (areas : Area[]) => boolean
 ) : boolean {
+  // Testing functions should only run after the simulation is complete
+  if (!state.isComplete) return false;
+
   return callback(state.areaLog);
 }
 
+/**
+ * Check if the robot has entered different areas with the given colors in order
+ *
+ * @param colors in order
+ * @returns if the robot entered the given colors in order
+ */
+export function entered_colors(
+  colors: string[]
+) : boolean {
+  // Testing functions should only run after the simulation is complete
+  if (!state.isComplete) return false;
+
+  return state.areaLog
+    .filter(area => colors.includes(area.flags.color)) // Filter relevant colors
+    .filter(filterAdjacentDuplicateAreas) // Filter adjacent duplicates
+    .every(({ flags: { color } }, i) => color === colors[i]); // Check if each area has the expected color
+}
+
+// ================== //
+// DATA WRITE HELPERS //
+// ================== //
+
+/**
+ * Teleport the robot
+ *
+ * @param x coordinate of the robot
+ * @param y coordinate of the robot
+ */
+function set_pos(
+  x: number,
+  y: number
+) {
+  robot.x = x;
+  robot.y = y;
+}
+
+/**
+ * Set the rotation of the robot
+ *
+ * @param rotation in radians
+ */
+function set_rotation(
+  rotation: number
+) {
+  robot.dx = Math.cos(rotation);
+  robot.dy = -Math.sin(rotation);
+}
+
+/**
+ * Set the width and height of the map
+ *
+ * @param width of the map
+ * @param height of the map
+ */
+function set_dimensions(
+  width: number,
+  height: number
+) {
+  state.width = width;
+  state.height = height;
+}
+
 // ================= //
 // DATA READ HELPERS //
 // ================= //
@@ -707,3 +773,15 @@ function areaEquals(a: Area, b: Area) {
 
   return true;
 }
+
+/**
+ * Filter callback to remove adjacent duplicate areas
+ *
+ * @param area currently being checked
+ * @param i index of area
+ * @param areas the full array being filtered
+ * @returns if the current area is not a duplicate of the previous area
+ */
+const filterAdjacentDuplicateAreas = (area : Area, i : number, areas: Area[]) : boolean =>
+  i === 0 // First one is always correct
+  || !areaEquals(area, areas[i - 1]); // Otherwise check for equality against previous area

src/bundles/robot_minigame/index.ts

@@ -1,16 +1,14 @@
 /**
- * A single sentence summarising the module (this sentence is displayed larger).
- *
- * Sentences describing the module. More sentences about the module.
+ * The robot_minigame module allows us to control a robot to complete various tasks
  *
  * @module robot_minigame
  * @author Koh Wai Kei
  * @author Justin Cheng
  */
 
 export {
-  init, create_area, create_obstacle, create_rect_obstacle, complete_init,
+  init, create_area, create_rect_area, create_obstacle, create_rect_obstacle, complete_init,
   get_distance, get_flags, get_color,
   move_forward, move_forward_to_wall, rotate, turn_left, turn_right,
-  entered_areas
+  start_testing, entered_areas, entered_colors
 } from './functions';

src/tabs/RobotMaze/components/RobotSimulation.tsx

@@ -39,15 +39,17 @@ const drawBorders = (ctx: CanvasRenderingContext2D, width: number, height: numbe
 
 // Draw the areas of the map
 const drawAreas = (ctx: CanvasRenderingContext2D, areas: Area[]) => {
-  for (const { vertices } of areas) {
+  for (const { vertices, isObstacle, flags } of areas) {
     ctx.beginPath();
     ctx.moveTo(vertices[0].x, vertices[0].y);
     for (const vertex of vertices.slice(1)) {
       ctx.lineTo(vertex.x, vertex.y);
     }
     ctx.closePath();
 
-    ctx.fillStyle = 'rgba(169, 169, 169, 0.5)'; // Set the fill color
+    ctx.fillStyle = isObstacle // Obstacles are gray
+      ? 'rgba(169, 169, 169, 0.5)'
+      : flags.color || 'none'; // Areas may have color
     ctx.fill(); // Fill the polygon
 
     ctx.strokeStyle = 'rgb(53, 53, 53)'; // Set the stroke color
@@ -225,7 +227,7 @@ const RobotSimulation : React.FC<MapProps> = ({
           break;
         } case 'rotate':
           // If rotation is close to target rotation
-          if (Math.abs(target.rotation - robot.current.rotation) <= 0.1) {
+          if (Math.abs((target.rotation - robot.current.rotation) % (2 * Math.PI)) < 0.1) {
             // Snap to the target point
             robot.current.rotation = target.rotation;
 

src/tabs/RobotMaze/index.tsx

@@ -34,8 +34,10 @@ export default {
    * @returns {boolean}
    */
   toSpawn(context: DebuggerContext) {
+    // !!! TEMPORARY DEBUGGING FUNCTION, REMOVE ONCE MODULE IS COMPLETE !!!
     console.log(context.context?.moduleContexts?.robot_minigame.state);
-    return context.context?.moduleContexts?.robot_minigame.state.isInit;
+
+    return context.context?.moduleContexts?.robot_minigame.state.isComplete;
   },
 
   /**