Predeclare tests in prepend, run_tests() in postpend

Author: JustATin555

src/bundles/robot_minigame/functions.ts

@@ -12,10 +12,14 @@ interface Point {
 }
 
 // A point (x, y) with rotation
-export interface PointWithRotation extends Point {
+interface PointWithRotation extends Point {
   rotation: number
 }
 
+export interface Robot extends PointWithRotation {
+  radius: number
+}
+
 // A line segment between p1 and p2
 interface LineSegment {
   p1: Point
@@ -44,8 +48,14 @@ export interface Area {
   flags: AreaFlags
 }
 
-export interface Robot extends PointWithRotation {
-  radius: number
+interface Test {
+  type: string
+  test: Function
+}
+
+interface AreaTest extends Test {
+  type: 'area'
+  test: (areas: Area[]) => boolean
 }
 
 export interface RobotMinigame {
@@ -56,6 +66,7 @@ export interface RobotMinigame {
   areas: Area[]
   areaLog: Area[]
   actionLog: Action[]
+  tests: Test[]
   message: string
 }
 
@@ -68,6 +79,7 @@ const state: RobotMinigame = {
   areas: [],
   areaLog: [],
   actionLog: [],
+  tests: [],
   message: ''
 };
 
@@ -235,6 +247,27 @@ export function create_rect_obstacle(
   create_rect_area(x, y, width, height, true, []);
 }
 
+/**
+ * Check if the robot has entered different areas with the given colors in order
+ *
+ * @param colors in the order visited
+ * @returns if the robot entered the given colors in order
+ */
+export function should_enter_colors(
+  colors: string[]
+) {
+  state.tests.push({
+    type: 'area',
+    test: (areas: Area[]) => {
+      const coloredAreas = areas
+        .filter((area: Area) => colors.includes(area.flags.color)) // Filter relevant colors
+        .filter(filterAdjacentDuplicateAreas); // Filter adjacent duplicates
+
+      return coloredAreas.length === colors.length && coloredAreas.every(({ flags: { color } }, i) => color === colors[i]); // Check if each area has the expected color
+    }
+  } as AreaTest);
+}
+
 /**
  * Inform the simulator that the initialisation phase is complete
  */
@@ -368,32 +401,30 @@ export function turn_right() {
 // ======= //
 
 /**
- * Checks if the robot's entered areas satisfy the callback
+ * Run the stored tests in state
  *
- * @returns if the entered areas satisfy the callback
+ * @returns if all tests pass
  */
-export function entered_areas(
-  callback : (areas : Area[]) => boolean
-) : boolean {
-  return callback(state.areaLog);
-}
+export function run_tests() : boolean {
+  // Run each test in order
+  for (const test of state.tests) {
+    // Store status in a variable
+    let success: boolean;
+
+    switch(test.type) {
+      case 'area':
+        success = test.test(state.areaLog);
+        break;
+      default:
+        success = true;
+    }
 
-/**
- * Check if the robot has entered different areas with the given colors in order
- *
- * @param colors in the order visited
- * @returns if the robot entered the given colors in order
- */
-export function entered_colors(
-  colors: string[]
-) : boolean {
-  return entered_areas(areas => {
-    const coloredAreas = areas
-      .filter(area => colors.includes(area.flags.color)) // Filter relevant colors
-      .filter(filterAdjacentDuplicateAreas); // Filter adjacent duplicates
+    // If the test fails, return false
+    if (!success) return false;
+  }
 
-    return coloredAreas.length === colors.length && coloredAreas.every(({ flags: { color } }, i) => color === colors[i]); // Check if each area has the expected color
-  });
+  // If all tests pass, return true
+  return true;
 }
 
 // ==================

src/bundles/robot_minigame/index.ts

@@ -10,5 +10,5 @@ export {
   init, create_area, create_rect_area, create_obstacle, create_rect_obstacle, complete_init,
   get_distance, get_color,
   move_forward, move_forward_to_wall, rotate, turn_left, turn_right,
-  entered_areas, entered_colors
+  should_enter_colors, run_tests
 } from './functions';

src/tabs/RobotMaze/components/RobotSimulation.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useRef, useState } from 'react';
-import type { Area, Action, PointWithRotation, Robot, RobotMinigame } from '../../../bundles/robot_minigame/functions';
+import type { Area, Action, Robot, RobotMinigame } from '../../../bundles/robot_minigame/functions';
 
 /**
  * Calculate the acute angle between 2 angles
@@ -8,7 +8,10 @@ import type { Area, Action, PointWithRotation, Robot, RobotMinigame } from '../.
  * @param current rotation
  * @returns the acute angle between
  */
-const smallestAngle = (target, current) => {
+const smallestAngle = (
+  target: number,
+  current: number
+) => {
   const dr = (target - current) % (2 * Math.PI);
 
   if (dr > 0 && dr > Math.PI) return dr - (2 * Math.PI);
@@ -24,7 +27,11 @@ const smallestAngle = (target, current) => {
  * @param width of the map
  * @param height of the map
  */
-const drawBorders = (ctx: CanvasRenderingContext2D, width: number, height: number) => {
+const drawBorders = (
+  ctx: CanvasRenderingContext2D,
+  width: number,
+  height: number
+) => {
   ctx.beginPath();
   ctx.moveTo(0, 0);
   ctx.lineTo(0, height);
@@ -38,7 +45,10 @@ const drawBorders = (ctx: CanvasRenderingContext2D, width: number, height: numbe
 };
 
 // Draw the areas of the map
-const drawAreas = (ctx: CanvasRenderingContext2D, areas: Area[]) => {
+const drawAreas = (
+  ctx: CanvasRenderingContext2D,
+  areas: Area[]
+) => {
   for (const { vertices, isObstacle, flags } of areas) {
     ctx.beginPath();
     ctx.moveTo(vertices[0].x, vertices[0].y);
@@ -59,7 +69,10 @@ const drawAreas = (ctx: CanvasRenderingContext2D, areas: Area[]) => {
 };
 
 // Draw the robot
-const drawRobot = (ctx: CanvasRenderingContext2D, { x, y, rotation } : PointWithRotation, size: number) => {
+const drawRobot = (
+  ctx: CanvasRenderingContext2D,
+  { x, y, rotation, radius }: Robot
+) => {
   // Save the background state
   ctx.save();
 
@@ -69,7 +82,7 @@ const drawRobot = (ctx: CanvasRenderingContext2D, { x, y, rotation } : PointWith
 
   ctx.beginPath(); // Begin drawing robot
 
-  ctx.arc(0, 0, size, 0, Math.PI * 2, false); // Full circle (0 to 2π radians)
+  ctx.arc(0, 0, radius, 0, Math.PI * 2, false); // Full circle (0 to 2π radians)
 
   ctx.fillStyle = 'black'; // Set the fill color
   ctx.fill(); // Fill the circle
@@ -78,7 +91,7 @@ const drawRobot = (ctx: CanvasRenderingContext2D, { x, y, rotation } : PointWith
   ctx.strokeStyle = 'white';
   ctx.lineWidth = 2;
   ctx.beginPath();
-  ctx.moveTo(size, 0);
+  ctx.moveTo(radius, 0);
   ctx.lineTo(0, 0);
   ctx.stroke();
 
@@ -94,12 +107,12 @@ const drawAll = (
   width : number,
   height : number,
   areas: Area[],
-  {x, y, rotation, radius: robotSize} : Robot
+  robot : Robot
 ) => {
   ctx.reset();
   drawBorders(ctx, width, height);
   drawAreas(ctx, areas);
-  drawRobot(ctx, {x, y, rotation}, robotSize);
+  drawRobot(ctx, robot);
 };
 
 // The speed to move at