Added sensor and lazer interaction with bots. (#192)

Includes unit tests.
Also added more tests for the sensor beam.

Author: MLanghof

src/asmcup/runtime/Robot.java

@@ -231,7 +231,7 @@ protected void tickMotor(World world) {
 
 		float tx = x + (float)StrictMath.cos(facing) * s;
 		float ty = y + (float)StrictMath.sin(facing) * s;
-		int radius = COLLIDE_RADIUS;
+		int radius = COLLIDE_RANGE;
 
 		if (!world.isSolid(tx, ty, radius)) {
 			x = tx;
@@ -284,6 +284,12 @@ protected void tickLazer(World world) {
 				lazerEnd = i * RAY_INTERVAL;
 				return;
 			}
+
+			Robot robot = world.getRobot(tx, ty);
+			if (robot != null && robot != this) {
+				robot.damage(LAZER_DAMAGE);
+				return;
+			}
 		}
 
 		lazerEnd = RAY_INTERVAL * RAY_STEPS;
@@ -422,6 +428,15 @@ protected int sensorPoint(World world, float sx, float sy) {
 			}
 		}
 
+		Robot robot = world.getRobot(sx, sy);
+		
+		if ((sensorIgnore & SENSOR_ROBOT) == 0) {
+			if (robot != null && robot != this) {
+				// TODO: Add alliance once implemented!
+				return SENSOR_ROBOT;
+			}
+		}
+		
 		return 0;
 	}
 
@@ -470,6 +485,7 @@ protected static float floatModPositive(float dividend, float divisor) {
 	public static final float FREQUENCY_MAX = 1000 * 10;
 	public static final int LAZER_RANGE = 100;
 	public static final int LAZER_BATTERY_COST = 4;
+	public static final int LAZER_DAMAGE = 1024;
 
 	public static final int SENSOR_WALL = 1;
 	public static final int SENSOR_HAZARD = 2;
@@ -482,5 +498,5 @@ protected static float floatModPositive(float dividend, float divisor) {
 	public static final int RAY_STEPS = 64;
 	public static final int RAY_RANGE = RAY_INTERVAL * RAY_STEPS;
 
-	public static final int COLLIDE_RADIUS = 10;
+	public static final int COLLIDE_RANGE = 10;
 }

src/asmcup/runtime/World.java

@@ -182,6 +182,16 @@ protected void tickItems(Robot robot) {
 		item.collect(robot);
 		cell.removeItem(item);
 	}
+	
+	public Robot getRobot(float x, float y) {
+		for (Robot robot : robots) {
+			if (Math.abs(robot.getX() - x) < Robot.COLLIDE_RANGE
+			 && Math.abs(robot.getY() - y) < Robot.COLLIDE_RANGE) {
+				return robot;
+			}
+		}
+		return null;
+	}
 
 	public void mark(Robot robot, int offset, int value) {
 		int key = robot.getColumn() | (robot.getRow() << 16);

test/asmcup/runtime/RobotTest.java

@@ -139,6 +139,17 @@ public void testIOBattery() {
 		robot.handleIO(world);
 		assertEquals(1.0f, vm.popFloat(), 0.0001f);
 	}
+	
+	@Test
+	public void testIOLazer() {
+		World world = new World();
+		VM vm = robot.getVM();
+		vm.pushFloat(1.0f);
+		vm.push8(Robot.IO_LASER);
+		vm.setIO(true);
+		robot.handleIO(world);
+		assertEquals(1.0f, robot.getLazer(), 0.0001f);
+	}
 
 	@Test
 	public void testIOCompass() {
@@ -213,6 +224,73 @@ public void testMarkOffset() {
 		assertEquals(42, vm.pop8());
 	}
 
+	@Test
+	public void testSensorNothing() {
+		World world = generateEmptyWorld((int) robot.getX(), (int) robot.getY(), Robot.RAY_RANGE + 10);
+		world.addRobot(robot);
+		VM vm = robot.getVM();
+
+		vm.push8(Robot.IO_SENSOR);
+		vm.setIO(true);
+		robot.handleIO(world);
+		
+		assertEquals(vm.pop8() & 0b111111, 0);
+		assertEquals(vm.popFloat(), Robot.RAY_RANGE, 5.0f);
+	}
+	
+	@Test
+	public void testSensorWall() {
+		testSensorHitTile(Cell.TILE_WALL, Robot.SENSOR_WALL);
+	}
+
+	@Test
+	public void testSensorObstacle() {
+		testSensorHitTile(Cell.TILE_OBSTACLE, Robot.SENSOR_OBSTACLE);
+	}
+	
+	@Test
+	public void testSensorHazard() {
+		testSensorHitTile(Cell.TILE_HAZARD, Robot.SENSOR_HAZARD);
+	}
+	
+	protected void testSensorHitTile(int tile, int expectedSensorValue) {
+		World world = generateEmptyWorld((int) robot.getX(), (int) robot.getY(), 100);
+		world.addRobot(robot);
+		VM vm = robot.getVM();
+		float xOffset = 60.0f;
+		world.setTileXY(robot.getX() + xOffset, robot.getY(), tile);
+
+		vm.push8(Robot.IO_SENSOR);
+		vm.setIO(true);
+		robot.handleIO(world);
+		// Saw a wall...
+		assertEquals(vm.pop8() & 0b111111, expectedSensorValue);
+		// ...closeby.
+		assertEquals(vm.popFloat(), xOffset, World.TILE_SIZE);
+	}
+	
+	@Test
+	public void testSensorOtherBot() {
+		World world = generateEmptyWorld((int) robot.getX(), (int) robot.getY(), 50);
+		world.addRobot(robot);
+		VM vm = robot.getVM();
+		
+		float xOffset = 30.0f;
+		
+		Robot dummy = new Robot(13);
+		dummy.position(robot.getX() + xOffset, robot.getY());
+		world.addRobot(dummy);
+
+		vm.push8(Robot.IO_SENSOR);
+		vm.setIO(true);
+		robot.handleIO(world);
+		// Saw a robot...
+		assertEquals(vm.pop8() & 0b111111, Robot.SENSOR_ROBOT);
+		// ...closeby.
+		assertEquals(vm.popFloat(), xOffset, Robot.COLLIDE_RANGE);
+	}
+	
+	@Test
 	public void testBeamAngle() {
 		World world = generateEmptyWorld((int) robot.getX(), (int) robot.getY(), 50);
 		VM vm = robot.getVM();
@@ -234,6 +312,20 @@ public void testBeamAngle() {
 		robot.handleIO(world);
 		assertEquals((float)-Math.PI * 0.75f, robot.getBeamAngle(), 0.0001f);
 	}
+	
+	@Test
+	public void testLazerDamage() {
+		World world = generateEmptyWorld((int) robot.getX(), (int) robot.getY(), 50);
+		Robot dummy = new Robot(13);
+		dummy.position(robot.getX() + 30, robot.getY());
+		world.addRobot(robot);
+		world.addRobot(dummy);
+		
+		int initialBattery = dummy.getBattery();
+		robot.setLazer(1.0f);
+		robot.tick(world);
+		assert(dummy.getBattery() < initialBattery);
+	}
 
 	private World generateEmptyWorld(int x, int y, int radius) {
 		World world = new World();