# 3D: Discrete Dogfighting Duel (Now open to non Java submissions)

UPDATE: isSuicidal() was added to the plane class, this allows you to check if a plane is on an irreversible collision course with the walls!!

UPDATE: updateCoolDown() separated from simulateMove()

UPDATE: non-Java entry wrapper, written by Sparr, available for testing, see comments

UPDATE Zove Games Has written an awesome 3D visualizer for this KOTH, here's a shitty youtube video of PredictAndAVoid fighting PredictAndAVoid.

The simulateMove() function of the Plane class was slightly modified so it doesn't update the cool down anymore, use the new updateCoolDown() function for that, after shooting. The new isSuicidal() returns true if a plane is bound to end up dead, use it to prune enemy moves and avoid hitting walls. To get the updated code, simply replace the Controller and Plane classes by the ones in the github repo.

## Description

The goal of this challenge is to code two dogfighting planes that will face off against two planes by another contestant. Every turn you move one space and have the opportunity to shoot. That's it, it's as simple as that.

Well, almost...

## Arena and possible moves

The arena is a 14x14x14 walled in space. the planes of contestant 1 start at the locations (0,5,0) and (0,8,0) and those of contestant 2 at (13,5,13) and (13,8,13). All planes start out by flying horizontally away from the vertical walls they are closest to.

Now since you are flying planes and not helicopters, you can't just change direction at will or even stop moving, so each plane has a direction and will move one tile in that direction every turn.

The possible directions are: North(N), South(S), East(E), West(W), Up(U) and Down(D) and any logical combination of those six. Where the NS axis corresponds to the x axis, WE to y and DU to z. NW, SU and NED come to mind as possible examples of directions; UD is a great example of an invalid combination.

You can of course change the direction of your planes, but there is a limitation, you can only change your direction by at most 45 degrees. To visualize this, grab your rubik's cube (I know you have one) and imagine all of the 26 outer little cubes are the possible directions (one letter directions are faces, two letter direction are edges and three letter directions are corners). If you're heading in a direction represented by a little cube, you can change direction to each cube that touches yours (diagonally touching counts, but only touching visibly, that is not touching through the cube).

After all planes have indicated to which direction they would like to change, they do so and move one tile simultaneously.

You can also opt to move in a valid direction but keep flying in the direction you were going, in stead of changing your direction into the direction you moved to. This is analogous to the difference between a car going around a corner and a car changing lanes.

## Shooting and dying

You can shoot at most once per round and this has to be decided at the same time you decide which direction to fly in and whether you want to keep your plane (and by extension, your gun) pointed in the same direction or not. The bullet gets shot right after your plane moves. There is a cool down of one turn after shooting, on the third turn, you're good to go again. You can only shoot in the direction you're flying in. A bullet is instant and flies in a straight line until it hits a wall or a plane.

Taking into account the way you can change direction as well as 'change lanes', this means that you can threaten up a column of up to 3x3 lines in front of you additionally to some diagonal, single lines.

If it hits a plane, this plane dies and promptly disappears from the board (because it totally explodes or something). Bullets can only hit one plane at most. Bullets get shot simultaneously, so two planes can shoot each other. Two bullets can not collide in the air though (sad, I know).

Two planes can collide however (if they end up in the same cube and NOT if they cross each other without ending up in the same plane), and this results in both planes dying (and totally exploding). You can also fly into the wall which will result in the plane in question dying and being put in the corner to think about its actions. Collisions get handled before shooting does.

## Communication with the controller

I will accept entries in java as well as other languages. If your entry is in java, you will get input through STDIN and will output through STDOUT.

If your entry is in java, .your entry must extend the following class:

package Planes;

//This is the base class players extend.
//It contains the arena size and 4 plane objects representing the planes in the arena.
public abstract class PlaneControl {

// note that these planes are just for your information, modifying these doesn't affect the actual plane instances,
// which are kept by the controller
protected Plane[] myPlanes = new Plane[2];
protected Plane[] enemyPlanes = new Plane[2];
protected int arenaSize;
protected int roundsLeft;

...

// Notifies you that a new fight is starting
// FightsFought tells you how many fights will be fought.
// the scores tell you how many fights each player has won.
public void newFight(int fightsFought, int myScore, int enemyScore) {}

// notifies you that you'll be fighting anew opponent.
// Fights is the amount of fights that will be fought against this opponent
public void newOpponent(int fights) {}

// This will be called once every round, you must return an array of two moves.
// The move at index 0 will be applied to your plane at index 0,
// The move at index1 will be applied to your plane at index1.
// Any further move will be ignored.
// A missing or invalid move will be treated as flying forward without shooting.
public abstract Move[] act();
}


The instance created of that class will persist throughout the entire competition, so you can store any data you'd like to store in variables. Read the comments in the code for more information.

I've also provided you with the following helper classes:

package Planes;

//Objects of this class contain all relevant information about a plane
//as well as some helper functions.
public class Plane {
private Point3D position;
private Direction direction;
private int arenaSize;
private boolean alive = true;
private int coolDown = 0;

public Plane(int arenaSize, Direction direction, int x, int y, int z) {}

public Plane(int arenaSize, Direction direction, Point3D position) {}

// Returns the x coordinate of the plane
public int getX() {}

// Returns the y coordinate of the plane
public int getY() {}

// Returns the z coordinate of the plane
public int getZ() {}

// Returns the position as a Point3D.
public Point3D getPosition() {}

// Returns the distance between the plane and the specified wall,
// 0 means right next to it, 19 means at the opposite side.
// Returns -1 for invalid input.
public int getDistanceFromWall(char wall) {}

// Returns the direction of the plane.
public Direction getDirection() {}

// Returns all possible turning directions for the plane.
public Direction[] getPossibleDirections() {}

// Returns the cool down before the plane will be able to shoot,
// 0 means it is ready to shoot this turn.
public int getCoolDown() {}

public void setCoolDown(int coolDown) {}

// Returns true if the plane is ready to shoot
public boolean canShoot() {}

// Returns all positions this plane can shoot at (without first making a move).
public Point3D[] getShootRange() {}

// Returns all positions this plane can move to within one turn.
public Point3D[] getRange() {}

// Returns a plane that represents this plane after making a certain move,
// not taking into account other planes.
// Doesn't update cool down, see updateCoolDown() for that.
public Plane simulateMove(Move move) {}

// modifies this plane's cool down
public void updateCoolDown(boolean shot) {
coolDown = (shot && canShoot())?Controller.COOLDOWN:Math.max(0, coolDown - 1);
}

// Returns true if the plane is alive.
public boolean isAlive() {}

// Sets alive to the specified value.
public void setAlive(boolean alive) {}

// returns a copy of itself.
public Plane copy() {}

// Returns a string representing its status.
public String getAsString() {}

// Returns a string suitable for passing to a wrapped plane process
public String getDataString() {}

// Returns true if a plane is on an irreversable colision course with the wall.
// Use this along with simulateMove() to avoid hitting walls or prune possible emeny moves.
public boolean isSuicidal() {}
}

// A helper class for working with directions.
public class Direction {
// The three main directions, -1 means the first letter is in the direction, 1 means the second is, 0 means neither is.
private int NS, WE, DU;

// Creates a direction from 3 integers.
public Direction(int NSDir, int WEDir, int DUDir) {}

// Creates a direction from a directionstring.
public Direction(String direction) {}

// Returns this direction as a String.
public String getAsString() {}

// Returns The direction projected onto the NS-axis.
public int getNSDir() {}

// Returns The direction projected onto the WE-axis.
public int getWEDir() {}

// Returns The direction projected onto the DU-axis.
public int getDUDir() {}

// Returns a Point3D representing the direction.
public Point3D getAsPoint3D() {}

// Returns an array of chars representing the main directions.
public char[] getMainDirections() {}

// Returns all possible turning directions.
public Direction[] getPossibleDirections() {}

// Returns true if a direction is a valid direction to change to
public boolean isValidDirection(Direction direction) {}
}

public class Point3D {
public int x, y, z;

public Point3D(int x, int y, int z) {}

// Returns the sum of this Point3D and the one specified in the argument.

// Returns the product of this Point3D and a factor.
public Point3D multiply(int factor) {}

// Returns true if both Point3D are the same.
public boolean equals(Point3D point3D) {}

// Returns true if Point3D is within a 0-based arena of a specified size.
public boolean isInArena(int size) {}
}

public class Move {
public Direction direction;
public boolean changeDirection;
public boolean shoot;

public Move(Direction direction, boolean changeDirection, boolean shoot) {}
}


You can create instances of these classes and use any of their functions as much as you like. You can find the full code for these helper classes here.

Here's an example of what your entry could look like (Hopefully you'll do better than I did though, most of the matches with these planes end with them flying into a wall, despite their best efforts to avoid the wall.):

package Planes;

public class DumbPlanes extends PlaneControl {

public DumbPlanes(int arenaSize, int rounds) {
super(arenaSize, rounds);
}

@Override
public Move[] act() {
Move[] moves = new Move[2];
for (int i=0; i<2; i++) {
if (!myPlanes[i].isAlive()) {
moves[i] = new Move(new Direction("N"), false, false); // If we're dead we just return something, it doesn't matter anyway.
continue;
}
Direction[] possibleDirections = myPlanes[i].getPossibleDirections(); // Let's see where we can go.

for (int j=0; j<possibleDirections.length*3; j++) {

int random = (int) Math.floor((Math.random()*possibleDirections.length)); // We don't want to be predictable, so we pick a random direction out of the possible ones.

if (myPlanes[i].getPosition().add(possibleDirections[random].getAsPoint3D()).isInArena(arenaSize)) { // We'll try not to fly directly into a wall.
moves[i] = new Move(possibleDirections[random], Math.random()>0.5, myPlanes[i].canShoot() && Math.random()>0.2);
continue; // I'm happy with this move for this plane.
}

// Uh oh.
random = (int) Math.floor((Math.random()*possibleDirections.length));
moves[i] = new Move(possibleDirections[random], Math.random()>0.5, myPlanes[i].canShoot() && Math.random()>0.2);
}
}

return moves;
}

@Override
public void newFight(int fightsFought, int myScore, int enemyScore) {
// Using information is for schmucks.
}

@Override
public void newOpponent(int fights) {
// What did I just say about information?
}
}


DumbPlanes will join the tournament along with the other entries, so if you end last, it's your own fault for not at least doing better than DumbPlanes.

## Restrictions

The restrictions mentioned in the KOTH wiki apply:

• Any attempt to tinker with the controller, runtime or other submissions will be disqualified. All submissions should only work with the inputs and storage they are given.
• Bots should not be written to beat or support specific other bots. (This might be desirable in rare cases, but if this is not a core concept of the challenge, it's better ruled out.)
• I Reserve the right to disqualify submissions that use too much time or memory to run trials with a reasonable amount of resources.
• A bot must not implement the exact same strategy as an existing one, intentionally or accidentally.

Download the Controller code from here. Add your submission as Something.java. Modify Controller.java to include entries for your plane in entries[] and names[]. Compile everything as an Eclipse project or with javac -d . *.java, then run the Controller with java Planes/Controller. A log of the contest will be in test.txt, with a scoreboard at the end. You can also call matchUp() directly with two entries as arguments to just test two planes against each other.

## Winning the fight

The winner of the fight is the one who has the last plane flying, if after 100 turns, there is still more than 1 team left, the team with the most planes left wins. If this is equal, it's a draw.

## Scoring and the competition

The next official tournament will be run when the current bounty runs out.

Each entry will fight every other entry (at least) 100 times, the winner of each match up is the ones with the most wins out of the 100 and will be awarded 2 points. In case of a draw, both entries are awarded 1 point.

The winner of the competition is the one with most points. In case of a draw, the winner is the one who won in a the match up between the entries that drew.

Depending on the amount of entries, The amount of fights between entries could be increased significantly, I might also select the 2-4 best entries after the first tournament and set up an elites tournament between those entries with more fights (and possibly more rounds per fight)

## (preliminary) Scoreboard

We've got a new entry who firmly take sthe second place in yet another exciting tournament, it seems like Crossfire is incredibly hard to shoot for everyone except for PredictAndAvoid. Note that this tournament was run with only 10 fights between each set of planes and is therefor not an entirely accurate representation of how things stand.

----------------------------
¦ 1. PredictAndAvoid:   14 ¦
¦ 2. Crossfire:         11 ¦
¦ 3. Weeeeeeeeeeee:      9 ¦
¦ 4. Whirligig:          8 ¦
¦ 4. MoveAndShootPlane:  8 ¦
¦ 6. StarFox:            4 ¦
¦ 6. EmoFockeWulf:       2 ¦
¦ 7. DumbPlanes:         0 ¦
----------------------------


Here is an example of output from the non-Java wrapper:

NEW CONTEST 14 20 indicates that a new contest is starting, in a 14x14x14 arena, and it will involve 20 turns per fight.

NEW OPPONENT 10 indicates that you're facing a new opponent, and that you will fight this opponent 10 times

NEW FIGHT 5 3 2 indicates that a new fight against the current opponent is starting, that you've fought this opponent 5 times so far, winning 3 and losing 2 fights

ROUNDS LEFT 19 indicates there are 19 rounds left in the current fight

NEW TURN indicates that you're about to receive data for all four planes for this round of the fight

alive 13 8 13 N 0
alive 13 5 13 N 0
dead 0 0 0 N 0
alive 0 8 0 S 0


These four lines indicate that both of your planes are alive, at coordinates [13,8,13] and [13,5,13] respectively, both facing North, both with zero cooldown. The first enemy plane is dead, and the second is alive, at [0,8,0] and facing south with zero cooldown.

At this point your program should output two lines similar to the following:

NW 0 1
SU 1 0


This indicates that your first plane will travel NorthWest, without turning from its current heading, and shooting if able. Your second plane will travel SouthUp, turning to face SouthUp, not shooting.

Now you get ROUNDS LEFT 18 followed by NEW TURN etc. This continues until someone wins or the round times out, at which point you get another NEW FIGHT line with the updated fight count and scores, possibly preceded by a NEW OPPONENT.

• If anyone needs help with this challenge, you can get into the chat I created for this challenge . – overactor Jul 29 '14 at 14:30
• Do planes start headed East/West or North/South? or something else? – pseudonym117 Jul 29 '14 at 18:15
• @overactor there's a bug in the cooldown code. You're using simulateMove in the "Calculate the new positions" section, which decrements cooldown in addition to finding new positions. This means a plane can fire every turn if they ignore their own cooldown counter. – Sparr Jul 30 '14 at 5:19
• For those who may find it useful, this regex will search through the log to find where your plane shoots ^Move(.*?)shoot: true$(replace "Move" with your name, and make sure that . does not capture new lines) – user2813274 Jul 30 '14 at 14:34 • here's a commit for my plane wrapper, along with a dumb python plane. I'd love it if someone would write a smarter plane in perl/python/lua/bash/whatever and give me some feedback on if/how the wrapper works for you. github.com/sparr/Dogfight-KOTH/commit/… if people can/will use this, we can get it into @overactor's repo and allow arbitrary language submissions. – Sparr Jul 30 '14 at 18:56 ## 10 Answers # Crossfire My initial idea was to shoot an enemy plane with both my planes at the same time, but I couldn't work it out... So here is a plane that tries to stay away from walls and out of the shooting-range of the enemy. The planes should never collide nor shoot friendly planes. Edit: the method possibleHits always returned 0, after fixing it and adding several little improvements, it performs better than before. package Planes; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; public class Crossfire extends PlaneControl { final List<Point3D> dangerList = new ArrayList<>(); //danger per point final List<Plane> targets = new ArrayList<>(); //targets being shot Plane[] futurePlanes = null; //future friendly planes public Crossfire(int arenaSize, int rounds) { super(arenaSize, rounds); } @Override public Move[] act() { dangerList.clear(); //initialize targets.clear(); final int PLANE_COUNT = myPlanes.length; Move[] moves = new Move[PLANE_COUNT]; futurePlanes = new Plane[PLANE_COUNT]; // calculate danger per field/enemy for (int i = 0; i < PLANE_COUNT; i++) { updateDanger(enemyPlanes[i]); } // get best moves for each plane for (int i = 0; i < PLANE_COUNT; i++) { moves[i] = getBestMove(myPlanes[i]); futurePlanes[i] = myPlanes[i].simulateMove(moves[i]); updateTargets(futurePlanes[i]); } // try to shoot if no friendly plane is hit by this bullet for (int i = 0; i < myPlanes.length; i++) { if (myPlanes[i].canShoot() && canShootSafely(futurePlanes[i]) && possibleHits(futurePlanes[i]) > 0) { moves[i].shoot = true; } } return moves; } private void updateTargets(Plane plane) { if (!plane.canShoot() || !canShootSafely(plane)) { return; } Point3D[] range = plane.getShootRange(); for (Plane enemyPlane : enemyPlanes) { for (Move move : getPossibleMoves(enemyPlane)) { Plane simPlane = enemyPlane.simulateMove(move); for (Point3D dest : range) { if (dest.equals(simPlane.getPosition())) { targets.add(enemyPlane); } } } } } private void updateDanger(Plane plane) { if (!plane.isAlive()) { return; } for (Move move : getPossibleMoves(plane)) { Plane futurePlane = plane.simulateMove(move); // add position (avoid collision) if (!isOutside(futurePlane)) { dangerList.add(futurePlane.getPosition()); // avoid getting shot if (plane.canShoot()) { for (Point3D dest : futurePlane.getShootRange()) { dangerList.add(dest); } } } } } private Move getBestMove(Plane plane) { if (!plane.isAlive()) { return new Move(new Direction("N"), false, false); } int leastDanger = Integer.MAX_VALUE; Move bestMove = new Move(new Direction("N"), false, false); for (Move move : getPossibleMoves(plane)) { Plane futurePlane = plane.simulateMove(move); int danger = getDanger(futurePlane) - (possibleHits(futurePlane) *2); if (danger < leastDanger) { leastDanger = danger; bestMove = move; } } return bestMove; } private int getDanger(Plane plane) { if (!plane.isAlive() || hugsWall(plane) || collidesWithFriend(plane) || isOutside(plane)) { return Integer.MAX_VALUE - 1; } int danger = 0; Point3D pos = plane.getPosition(); for (Point3D dangerPoint : dangerList) { if (pos.equals(dangerPoint)) { danger++; } } // stay away from walls for (char direction : plane.getDirection().getMainDirections()) { if (plane.getDistanceFromWall(direction) <= 2) { danger++; } } return danger; } private boolean collidesWithFriend(Plane plane) { for (Plane friendlyPlane : futurePlanes) { if (friendlyPlane != null && plane.getPosition().equals(friendlyPlane.getPosition())) { return true; } } return false; } private boolean hugsWall(Plane plane) { if (!plane.isAlive() || isOutside(plane)) { return true; } char[] mainDirs = plane.getDirection().getMainDirections(); if (mainDirs.length == 1) { return plane.getDistanceFromWall(mainDirs[0]) == 0; } if (mainDirs.length == 2) { return plane.getDistanceFromWall(mainDirs[0]) <= 1 && plane.getDistanceFromWall(mainDirs[1]) <= 1; } if (mainDirs.length == 3) { return plane.getDistanceFromWall(mainDirs[0]) <= 1 && plane.getDistanceFromWall(mainDirs[1]) <= 1 && plane.getDistanceFromWall(mainDirs[2]) <= 1; } return false; } private Set<Move> getPossibleMoves(Plane plane) { Set<Move> possibleMoves = new HashSet<>(); for (Direction direction : plane.getPossibleDirections()) { possibleMoves.add(new Move(direction, false, false)); possibleMoves.add(new Move(direction, true, false)); } return possibleMoves; } private boolean canShootSafely(Plane plane) { if (!plane.canShoot() || isOutside(plane)) { return false; } for (Point3D destPoint : plane.getShootRange()) { for (Plane friendlyPlane : futurePlanes) { if (friendlyPlane == null) { continue; } if (friendlyPlane.isAlive() && friendlyPlane.getPosition().equals(destPoint)) { return false; } } } return true; } private int possibleHits(Plane plane) { if (!plane.canShoot() || !canShootSafely(plane)) { return 0; } int possibleHits = 0; Point3D[] range = plane.getShootRange(); for (Plane enemyPlane : enemyPlanes) { for (Move move : getPossibleMoves(enemyPlane)) { Plane simPlane = enemyPlane.simulateMove(move); for (Point3D dest : range) { if (dest.equals(simPlane.getPosition())) { possibleHits++; } } } } return possibleHits; } private boolean isOutside(Plane plane) { return !plane.getPosition().isInArena(arenaSize); } }  • You're currently the second best entry, after PredictAndAvoid. You win against every other entry, but draw quite a lot. Against PredictAndAvoid, Whirligig manages to enforce more wins and draws than you do. Good entry regardless! – overactor Aug 15 '14 at 12:16 • @overactor Thank you for your input! That means I have to work at the shooting-part... – CommonGuy Aug 15 '14 at 12:22 • I just did some more testing, it seems like you lose less against Whirligig than PredictAndAvoid does, PredictAndAvoid manages way more wins though, here's the data for 2000 fights: PredictAndAvoid: 1560 Whirligig: 138 | PredictAndAvoid: 1564 Crossfire: 125 | Whirligig: 25 Crossfire: 600 – overactor Aug 15 '14 at 13:09 • @overactor Found the time to improve my submission. Now, it sometimes wins, draws and looses against PredictAndAvoid. – CommonGuy Aug 20 '14 at 8:43 • Well done, after 10,000 fights: SCORE: PredictAndAvoid: 1240 Crossfire: 6567 – overactor Aug 20 '14 at 10:56 /* PREDICT AND AVOID Rules of behavior: - Avoid hitting walls - Move, safely, to shoot at spaces our enemy might fly to - (contingent) Move to a safe space that aims closer to the enemy - Move to a safe space - Move, unsafely, to shoot at spaces our enemy might fly to - Move to any space (remember to avoid walls) Chooses randomly between equally prioritized moves contingent strategy is evaluated during early fights */ package Planes; import java.util.Random; import java.util.ArrayList; import java.util.Comparator; import java.util.PriorityQueue; import java.util.Queue; public class PredictAndAvoid extends PlaneControl { public PredictAndAvoid(int arenaSize, int rounds) { super(arenaSize, rounds); } private int fightsPerMatch = 0; private int fightNum = 0; private int roundNum = 0; private boolean useHoming = true; private int homingScore = 0; private int[][][] enemyHistory = new int[arenaSize][arenaSize][arenaSize]; // don't need to take roots here, waste of cpu cycles int distanceCubed(Point3D a, Point3D b) { return (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) + (a.z-b.z)*(a.z-b.z); } // is this plane guaranteed to hit a wall, now or soon? boolean dangerZone(Plane icarus) { // outside the arena? // already dead // this should never happen for my planes if (!icarus.getPosition().isInArena(arenaSize)) { return true; } // adjacent to a wall? // directly facing the wall? // death next turn if ( icarus.getDirection().getMainDirections().length==1 && icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[0]) == 0 ) { return true; } // on an edge? // 2d diagonal facing into that edge? // death next turn if ( icarus.getDirection().getMainDirections().length==2 && icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[0]) == 0 && icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[1]) == 0 ) { return true; } // near a corner? // 3d diagonal facing into that corner? // death in 1-2 turns if ( icarus.getDirection().getMainDirections().length==3 && icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[0]) < 2 && icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[1]) < 2 && icarus.getDistanceFromWall(icarus.getDirection().getMainDirections()[2]) < 2 ) { return true; } // there's at least one way out of this position return false; } @Override public Move[] act() { Move[] moves = new Move[2]; for (int i=0; i<2; i++) { Plane p = myPlanes[i]; if (!p.isAlive()) { moves[i] = new Move(new Direction("N"), false, false); // If we're dead we just return something, it doesn't matter anyway. continue; } // a list of every move that doesn't commit us to running into a wall // or a collision with the previously moved friendly plane ArrayList<Move> potentialMoves = new ArrayList<Move>(); for (Direction candidateDirection : p.getPossibleDirections()) { if (i==1 && myPlanes[0].simulateMove(moves[0]).getPosition().equals(myPlanes[1].simulateMove(new Move(candidateDirection,false,false)).getPosition())) { } else { Plane future = new Plane(arenaSize, 0, p.getDirection(), p.getPosition().add(candidateDirection.getAsPoint3D())); if (!dangerZone(future)) { potentialMoves.add(new Move(candidateDirection, false, false)); } future = new Plane(arenaSize, 0, candidateDirection, p.getPosition().add(candidateDirection.getAsPoint3D())); if (!dangerZone(future)) { potentialMoves.add(new Move(candidateDirection, true, false)); } } } // everywhere our enemies might end up // including both directions they could be facing for each location ArrayList<Plane> futureEnemies = new ArrayList<Plane>(); for (Plane e : enemyPlanes) { if (e.isAlive()) { for (Direction candidateDirection : e.getPossibleDirections()) { futureEnemies.add(new Plane( arenaSize, e.getCoolDown(), candidateDirection, e.getPosition().add(candidateDirection.getAsPoint3D()) )); // don't make a duplicate entry for forward moves if (!candidateDirection.getAsPoint3D().equals(e.getDirection().getAsPoint3D())) { futureEnemies.add(new Plane( arenaSize, e.getCoolDown(), e.getDirection(), e.getPosition().add(candidateDirection.getAsPoint3D()) )); } } } } // a list of moves that are out of enemies' potential line of fire // also skipping potential collisions unless we are ahead on planes ArrayList<Move> safeMoves = new ArrayList<Move>(); for (Move candidateMove : potentialMoves) { boolean safe = true; Point3D future = p.simulateMove(candidateMove).getPosition(); for (Plane ec : futureEnemies) { if (ec.getPosition().equals(future)) { if ( (myPlanes[0].isAlive()?1:0) + (myPlanes[1].isAlive()?1:0) <= (enemyPlanes[0].isAlive()?1:0) + (enemyPlanes[1].isAlive()?1:0) ) { safe = false; break; } } if (ec.isAlive() && ec.canShoot()) { Point3D[] range = ec.getShootRange(); for (Point3D t : range) { if (future.equals(t)) { safe = false; break; } } if (safe == false) { break; } } } if (safe == true) { safeMoves.add(candidateMove); } } // a list of moves that let us attack a space an enemy might be in // ignore enemies committed to suicide vs a wall // TODO: don't shoot at friendly planes ArrayList<Move> attackMoves = new ArrayList<Move>(); for (Move candidateMove : potentialMoves) { int attackCount = 0; Plane future = p.simulateMove(candidateMove); Point3D[] range = future.getShootRange(); for (Plane ec : futureEnemies) { for (Point3D t : range) { if (ec.getPosition().equals(t)) { if (!dangerZone(ec)) { attackMoves.add(new Move(candidateMove.direction, candidateMove.changeDirection, true)); attackCount++; } } } } if (attackCount > 0) { } } // find all attack moves that are also safe moves ArrayList<Move> safeAttackMoves = new ArrayList<Move>(); for (Move safeCandidate : safeMoves) { for (Move attackCandidate : attackMoves) { if (safeCandidate.direction == attackCandidate.direction) { safeAttackMoves.add(attackCandidate); } } } // choose the safe move that aims closest potential enemy positions int maxDistanceCubed = arenaSize*arenaSize*arenaSize*8; Move homingMove = null; int bestHomingMoveTotalDistancesCubed = maxDistanceCubed*1000; for (Move candidateMove : safeMoves) { int totalCandidateDistancesCubed = 0; for (Plane ec : futureEnemies) { if (ec.isAlive()) { int distThisEnemyCubed = maxDistanceCubed; Point3D[] range = p.simulateMove(candidateMove).getShootRange(); for (Point3D t : range) { int d1 = distanceCubed(t, ec.getPosition()); if (d1 < distThisEnemyCubed) { distThisEnemyCubed = d1; } } totalCandidateDistancesCubed += distThisEnemyCubed; } } if (totalCandidateDistancesCubed < bestHomingMoveTotalDistancesCubed) { bestHomingMoveTotalDistancesCubed = totalCandidateDistancesCubed; homingMove = candidateMove; } } Random rng = new Random(); // move to attack safely if possible // even if we can't shoot, this is good for chasing enemies if (safeAttackMoves.size() > 0) { moves[i] = safeAttackMoves.get(rng.nextInt(safeAttackMoves.size())); } // turn towards enemies if it's possible and safe // tests indicate value of this strategy varies significantly by opponent // useHoming changes based on outcome of early fights with[out] it // TODO: track enemy movement, aim for neighborhood else if (useHoming == true && homingMove != null) { moves[i] = homingMove; } // make random move, safe from attack else if (safeMoves.size() > 0) { moves[i] = safeMoves.get(rng.nextInt(safeMoves.size())); } // move to attack unsafely only if there are no safe moves else if (attackMoves.size() > 0 && p.canShoot()) { moves[i] = attackMoves.get(rng.nextInt(attackMoves.size())); } // make random move, safe from walls else if (potentialMoves.size() > 0) { moves[i] = potentialMoves.get(rng.nextInt(potentialMoves.size())); } // keep moving forward // this should never happen else { moves[i] = new Move(p.getDirection(), false, true); } } roundNum++; return moves; } @Override public void newFight(int fightsFought, int myScore, int enemyScore) { // try the homing strategy for 1/8 of the match // skip it for 1/8, then choose the winning option if (fightsFought == fightsPerMatch/8) { homingScore = myScore-enemyScore; useHoming = false; } else if (fightsFought == (fightsPerMatch/8)*2) { if (homingScore*2 > myScore-enemyScore) { useHoming = true; } } fightNum = fightsFought; roundNum = 0; } @Override public void newOpponent(int fights) { fightsPerMatch = fights; } }  • currently beats Whirligig almost every time. Need to track down a bug in the enemy-shot-avoidance code. – Sparr Jul 30 '14 at 0:33 • fixed the bug. 0 losses to current opponents now. – Sparr Jul 30 '14 at 1:29 • been working on decreasing draws, significant progress. need smarter enemy planes before I can make much more progress. – Sparr Jul 30 '14 at 5:45 • I would prioritize moving to a safe space, above shooting unsafely – Cruncher Jul 30 '14 at 16:48 • @Cruncher already doing that in my local copy, and it improves performance a few % against the current opponents. Also now avoiding collisions when I'm not ahead on surviving planes. update to come! – Sparr Jul 30 '14 at 17:01 # Dogfight 3D Visualizer I wrote a small, quick visualizer for this challenge. Code and jar files are on my github repo: https://github.com/Hungary-Dude/DogfightVisualizer It's made using libGDX (http://libgdx.com). Right now the UI is pretty bad, I did put this together kind of fast. I'm just learning how to use Git and Gradle so please comment if I did something wrong Run dist/dogfight.bat or dist/dogfight.sh to see DumbPlanes in action! To build from source, you'll need Gradle (http://gradle.org) and Gradle integration for your IDE, if you have one. Then clone the repo and run gradlew desktop:run. Hopefully Gradle will import all the libraries required. The main class is zove.koth.dogfight.desktop.DesktopLauncher. ### Running without importing Copy any plane class files into dist/. Then, run dist/desktop-1.0.jar with this command: java -cp your-class-folder/;desktop-1.0.jar;Planes.jar zove.koth.dogfight.desktop.DesktopLauncher package.YourPlaneController1 package.YourPlaneController2 ...  I will update as the source for the Planes controller is updated, but to update yourself, you'll need to add in some code to Planes.Controller. See the github readme for info on this. Here's a screenshot: If you have any questions or suggestions, leave a comment below! • This is awesome, I've got a project set up where I added the plane classes, how do I now run the visualizer with these planes? Maybe this would be better explained in the chat though. As a suggestion, it would be great if you could paste in a minimal log of a match and then step through that match, also, I believe you might have miced up the cooridates, the planes should start at the floor and the ceiling respectively. Amazing work though!! – overactor Aug 1 '14 at 8:45 • I took the Point3Ds representing plane position and subtracted 6.5 from each coordinate to move them into the view. Something like plane.transform.setToTranslation(new Vector3(point3d.x-6.5f,point3d.y-6.5f,point3d.z-6.5f)) No planes seem to go out of bounds so I doubt something is wrong – DankMemes Aug 1 '14 at 18:17 • Ah wait, are you using the y axis as the height? (like in most games I suppose) In my system, the z represents the height, not that it matters much, since it's symmetrical – overactor Aug 1 '14 at 19:35 • Ohhhhhhh I get it. Sorry I didn't actually look much at your code. I just translated Point3Ds directly to libgdx Vector3s. By the way, I will be away for a week or so starting tomorrow. Sorry if I'm not here if you need something. I'll try to check in while away. – DankMemes Aug 1 '14 at 22:26 # EmoFockeWulf He's back. He's starved himself to 224 bytes. He doesn't know how he ended up like this. package Planes;public class EmoFockeWulf extends PlaneControl{public EmoFockeWulf(int s, int r){super(s,r);}public Move[] act(){Move[] m=new Move[2];m[0]=new Move(myPlanes[0].getDirection(),false,false);m[1]=m[0];return m;}}  • This is seriously getting out of hand now. How about we banish him to the standard loopholes post forever? – user80551 Jul 29 '14 at 15:23 • @user80551 I think it's a valid style of play, regardless. No reason to banish it. – Seiyria Jul 29 '14 at 16:28 • He is 47 bytes fatter than he was! – johnchen902 Jul 30 '14 at 10:14 • He could suicide more quickly than this. Not very effectively emo. – Sparr Jul 30 '14 at 22:15 • @Sparr yes, but then it'd have a higher byte count and it'd lose the irony of not always losing. :P – cjfaure Jul 31 '14 at 21:19 Weeeeeeeeeeee - 344 bytes after removing whitespace Does awesome loops n stuff. Can't lose if you're doing loops. package Planes; public class W extends PlaneControl{ int i,c; int[] s={1,1,1,0,-1,-1,-1,0}; public W(int a,int r){ super(a,r); } public void newFight(int a,int b,int c){ i=4; } public Move[] act(){ Plane p=myPlanes[0]; if(++i<6) c=p.getX()==0?1:-1; Move n=new Move(i<8?p.getDirection():new Direction(c*s[(i+2)%8],0,c*s[i%8]),0<1,i%2<1); Move[] m={n,n}; return m; } }  EDIT: apparently when my plane started as team 2, they just crashed immediately into the wall. I think I fixed that now. Hopefully. • Your return statement is not legal. In Java, to create arrays of objects specifying all the contents on one line you need to use new Type[]{item1, item2, ...} so in this case you would have return new Move[]{new Move(d,z,a),new Move(d,z,a^=z)}; – DankMemes Jul 29 '14 at 21:14 • Also try browxy.com if you don't have an IDE downloaded. (It's not powerful at all but it works) – DankMemes Jul 29 '14 at 21:20 • thanks, i forgot if that worked or not. i just didnt want to download his classes to get all of the inheritance and package working. – pseudonym117 Jul 29 '14 at 21:49 • After running your planes with the new code, it's only returning S and SU and dying in the 15th round every time. Any idea why? – overactor Aug 15 '14 at 12:56 • hmm... nope. apparently i messed up with my change. was really hoping it would just work.... gonna just undo the edit. – pseudonym117 Aug 15 '14 at 13:40 # Move-and-Shoot plane Avoids walls by finding when it's close to a wall & turning, shoots when it can.  package Planes; public class MoveAndShootPlane extends PlaneControl { public MoveAndShootPlane(int arenaSize, int rounds) { super(arenaSize, rounds); } @Override public Move[] act() { Move[] moves = new Move[2]; for (int i=0; i<2; i++) { if (!myPlanes[i].isAlive()) { moves[i] = new Move(new Direction("N"), false, false); // If we're dead we just return something, it doesn't matter anyway. continue; } // What direction am I going again? Direction currentDirection = myPlanes[i].getDirection(); // Is my plane able to shoot? boolean canIShoot = myPlanes[i].canShoot(); // if a wall is near me, turn around, otherwise continue along if (myPlanes[i].getDirection().getAsString().equals("N") && myPlanes[i].getDistanceFromWall('N') <= 2) { if (myPlanes[i].getDistanceFromWall('U') > myPlanes[i].getDistanceFromWall('D')) { moves[i] = new Move(new Direction("NU"), true, canIShoot); } else { moves[i] = new Move(new Direction("ND"), true, canIShoot); } } else if (myPlanes[i].getDirection().getAsString().equals("S") && myPlanes[i].getDistanceFromWall('S') <= 2) { if (myPlanes[i].getDistanceFromWall('U') > myPlanes[i].getDistanceFromWall('D')) { moves[i] = new Move(new Direction("SU"), true, canIShoot); } else { moves[i] = new Move(new Direction("SD"), true, canIShoot); } } else { if (myPlanes[i].getDirection().getAsString().equals("N") || myPlanes[i].getDirection().getAsString().equals("S")) { moves[i] = new Move(currentDirection, false, canIShoot); } else if (myPlanes[i].getDistanceFromWall('N') < myPlanes[i].getDistanceFromWall('S')) { if (myPlanes[i].getDirection().getAsString().equals("NU")) { moves[i] = new Move(new Direction("U"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("U")) { moves[i] = new Move(new Direction("SU"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("SU")) { moves[i] = new Move(new Direction("S"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("ND")) { moves[i] = new Move(new Direction("D"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("D")) { moves[i] = new Move(new Direction("SD"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("SD")) { moves[i] = new Move(new Direction("S"), true, canIShoot); } } else { if (myPlanes[i].getDirection().getAsString().equals("SU")) { moves[i] = new Move(new Direction("U"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("U")) { moves[i] = new Move(new Direction("NU"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("NU")) { moves[i] = new Move(new Direction("N"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("SD")) { moves[i] = new Move(new Direction("D"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("D")) { moves[i] = new Move(new Direction("ND"), true, canIShoot); } else if (myPlanes[i].getDirection().getAsString().equals("ND")) { moves[i] = new Move(new Direction("N"), true, canIShoot); } } } } return moves; } @Override public void newFight(int fightsFought, int myScore, int enemyScore) { // Using information is for schmucks. } @Override public void newOpponent(int fights) { // What did I just say about information? } }  Disclaimer: I am not at all a Java programmer, so if I screwed anything up, please fix it for me! • I haven't tested it yet, but this won't work, you're attempting to turn 180 degrees at once. As a hint, try N->NU->U->SU->S in stead of N->S or replace U by D if the roof is closer than the floor. – overactor Jul 29 '14 at 15:50 • @overactor: I missed the you may only change your angle by 45 degrees bit. – Kyle Kanos Jul 29 '14 at 15:51 • No prob, shouldn't be TOO hard to fix. – overactor Jul 29 '14 at 15:52 • You should probably use HashMap<String> instead of Hashtable. Otherwise, new Direction(wayToGo.get(currentDirection)) won't work as it forgets to cast to String. wayToGo.put after the field also isn't valid, put it in a block {wayToGo.put(blah);blah;} or in the constructor. – Luna Jul 29 '14 at 15:57 • For now it's winning everything by virtue of not flying into walls. – overactor Jul 29 '14 at 18:10 # Whirligig Both planes head towards the center(ish), then loop while shooting as often as possible. One of three axes is chosen per fight, and the pair always rotate around the same axis in opposite directions. package Planes; public class Whirligig extends PlaneControl{ public Whirligig(int arenaSize, int rounds) { super(arenaSize, rounds); cycle = -1; } int cycle; String[][] cycles = { {"E","EU","U","WU","W","WD","D","ED"}, {"N","NU","U","SU","S","SD","D","ND"}, {"S","SW","W","NW","N","NE","E","SE"}, {"ED","D","WD","W","WU","U","EU","E"}, {"ND","D","SD","S","SU","U","NU","N"}, {"SE","E","NE","N","NW","W","SW","S"}, }; private Move act(int idx){ Plane plane = myPlanes[idx]; Move move = new Move(plane.getDirection(), true, plane.canShoot()); if(!plane.isAlive()) return new Move(new Direction("N"), false, false); if(cycle < 0){ if(idx == 0 && (myPlanes[1].getZ() == 0 || myPlanes[1].getZ() == 13)){ return move; } if(distanceToCenter(plane.getPosition()) > 2){ move.direction = initialMove(plane); } else { cycle = (int)(Math.random()*3); } } else { move.direction = continueCycle(plane, cycle + (idx*3)); } return move; } private Direction initialMove(Plane plane){ if(plane.getDirection().getNSDir() > 0) return new Direction("SU"); else return new Direction("ND"); } private Direction continueCycle(Plane plane, int pathIndex){ Direction current = plane.getDirection(); String[] path = cycles[pathIndex]; for(int i=0;i<path.length;i++) if(path[i].equals(current.getAsString())) return new Direction(path[(i+1)%path.length]); Direction[] possible = plane.getPossibleDirections(); int step = (int)(Math.random()*path.length); for(int i=0;i<path.length;i++){ for(int j=0;j<possible.length;j++){ if(path[(i+step)%path.length].equals(possible[j].getAsString())) return new Direction(path[(i+step)%path.length]); } } return plane.getDirection(); } private int distanceToCenter(Point3D pos){ int x = (int)Math.abs(pos.x - 6.5); int y = (int)Math.abs(pos.y - 6.5); int z = (int)Math.abs(pos.z - 6.5); return Math.max(x, Math.max(y,z)); } @Override public Move[] act() { Move[] moves = new Move[2]; for(int i=0;i<2;i++){ moves[i] = act(i); } return moves; } @Override public void newFight(int fought, int wins, int losses){ cycle = -1; } @Override public void newOpponent(int fights){ cycle = -1; } }  # DumbPlanes DumbPlanes try so hard to not fly into the walls, but they're not very smart about it and usually end up hitting the walls anyway. They also shoot occasionally, if only they knew what they're shooting at. package Planes; public class DumbPlanes extends PlaneControl { public DumbPlanes(int arenaSize, int rounds) { super(arenaSize, rounds); } @Override public Move[] act() { Move[] moves = new Move[2]; for (int i=0; i<2; i++) { if (!myPlanes[i].isAlive()) { moves[i] = new Move(new Direction("N"), false, false); // If we're dead we just return something, it doesn't matter anyway. continue; } Direction[] possibleDirections = myPlanes[i].getPossibleDirections(); // Let's see where we can go. for (int j=0; j<possibleDirections.length*3; j++) { int random = (int) Math.floor((Math.random()*possibleDirections.length)); // We don't want to be predictable, so we pick a random direction out of the possible ones. if (myPlanes[i].getPosition().add(possibleDirections[random].getAsPoint3D()).isInArena(arenaSize)) { // We'll try not to fly directly into a wall. moves[i] = new Move(possibleDirections[random], Math.random()>0.5, myPlanes[i].canShoot() && Math.random()>0.2); continue; // I'm happy with this move for this plane. } // Uh oh. random = (int) Math.floor((Math.random()*possibleDirections.length)); moves[i] = new Move(possibleDirections[random], Math.random()>0.5, myPlanes[i].canShoot() && Math.random()>0.2); } } return moves; } @Override public void newFight(int fightsFought, int myScore, int enemyScore) { // Using information is for schmucks. } @Override public void newOpponent(int fights) { // What did I just say about information? } }  ## Starfox (WIP - not yet working): He doesn't actually utilize all the available moves. But he does try to shoot down enemies and not crash into walls. package Planes; import java.util.ArrayList; import java.util.function.Predicate; public class Starfox extends PlaneControl { public Starfox(int arenaSize, int rounds) { super(arenaSize, rounds); } private ArrayList<Point3D> dangerousPositions; private ArrayList<Point3D> riskyPositions; @Override public Move[] act() { dangerousPositions = new ArrayList<>(); riskyPositions = new ArrayList<>(); // add corners as places to be avoided dangerousPositions.add(new Point3D(0,0,0)); dangerousPositions.add(new Point3D(0,0,arenaSize-1)); dangerousPositions.add(new Point3D(0,arenaSize-1,0)); dangerousPositions.add(new Point3D(0,arenaSize-1,arenaSize-1)); dangerousPositions.add(new Point3D(arenaSize-1,0,0)); dangerousPositions.add(new Point3D(arenaSize-1,0,arenaSize-1)); dangerousPositions.add(new Point3D(arenaSize-1,arenaSize-1,0)); dangerousPositions.add(new Point3D(arenaSize-1,arenaSize-1,arenaSize-1)); for (Plane p : super.enemyPlanes) { for (Direction d : p.getPossibleDirections()) { Point3D potentialPosition = new Point3D(p.getX(), p.getY(), p.getZ()).add(d.getAsPoint3D()); if (potentialPosition.isInArena(arenaSize)) { riskyPositions.add(potentialPosition); if (p.canShoot()) { for (Point3D range : p.getShootRange()) { riskyPositions.add(range.add(potentialPosition)); } } } } } ArrayList<Move> moves = new ArrayList<>(); for (Plane p : myPlanes) { if (p.isAlive()) { ArrayList<Direction> potentialDirections = new ArrayList<>(); for (Direction d : p.getPossibleDirections()) { Point3D potentialPosition = new Point3D(p.getX(), p.getY(), p.getZ()).add(d.getAsPoint3D()); if (potentialPosition.isInArena(arenaSize)) { potentialDirections.add(d); } } // remove dangerous positions from flight plan potentialDirections.removeIf(new Predicate<Direction>() { @Override public boolean test(Direction test) { boolean result = false; for (Point3D compare : dangerousPositions) { if (p.getPosition().add(test.getAsPoint3D()).equals(compare)) { result = true; } } return result && potentialDirections.size() > 0; } }); // remove positions with no future from flight plan potentialDirections.removeIf(new Predicate<Direction>() { @Override public boolean test(Direction test) { boolean hasFuture = false; for (Direction compare : p.getPossibleDirections()) { Plane future = new Plane(arenaSize, 0, compare, p.getPosition().add(compare.getAsPoint3D())); if (future!=null && future.getDirection()!=null) { for (Direction d : future.getPossibleDirections()) { if (future.getPosition().add(d.getAsPoint3D()).isInArena(arenaSize)) { hasFuture = true; break; } } } } return !hasFuture; } }); // remove risky positions from flight plan potentialDirections.removeIf(new Predicate<Direction>() { @Override public boolean test(Direction test) { boolean result = false; for (Point3D compare : riskyPositions) { if (p.getPosition().add(test.getAsPoint3D()).equals(compare)) { result = true; } } return result && potentialDirections.size() > 0; } }); // check for targets Direction best = null; if (p.canShoot()) { int potentialHits = 0; for (Direction d : potentialDirections) { Plane future = new Plane(arenaSize, 0, d, p.getPosition().add(d.getAsPoint3D())); for (Point3D t : future.getShootRange()) { int targets = 0; for (Plane e : super.enemyPlanes) { for (Direction s : e.getPossibleDirections()) { Plane target = new Plane(arenaSize, 0, s, e.getPosition().add(s.getAsPoint3D())); if (target.getPosition().equals(t)) { targets++; } } } if (targets > potentialHits) { best = d; potentialHits = targets; } } } } if (best == null) { if (potentialDirections.size() > 0) { best = potentialDirections.get((int) Math.floor(Math.random() * potentialDirections.size())); } else { best = new Direction("N"); } } moves.add(new Move(best, true, false)); dangerousPositions.add(p.getPosition().add(best.getAsPoint3D())); } else { // this plane is dead, not much to do but go hide in corner moves.add(new Move(new Direction("N"), false, false)); } } Move[] movesArr = {moves.get(0), moves.get(1)}; return movesArr; } @Override public void newFight(int fightsFought, int myScore, int enemyScore) { // Using information is for schmucks. } @Override public void newOpponent(int fights) { // What did I just say about information? } }  • But can it do a barrel roll? – Erty Seidohl Jul 29 '14 at 20:17 • I'm getting an exception, Here's the stack trace: Exception in thread "main" java.lang.NullPointerException at Planes.Starfox$2.test(Starfox.java:99) at Planes.Starfox\$2.test(Starfox.java:1) at java.util.ArrayList.removeIf(Unknown Source) at Planes.Starfox.act(Starfox.java:90) at Planes.Controller.fight(Controller.java:141) at Planes.Controller.matchUp(Controller.java:85) at Planes.Controller.main(Controller.java:35) I had to add Package Planes, otherwise it wouldn't compile, maybe that had something to do with it. – overactor Jul 29 '14 at 21:58
• I got it to run but it's not performing as well as expected, I think the problem might be that best is null too often. – overactor Jul 29 '14 at 23:26
• It seems like Starfox moves into enemy fire rather than out of it, you can see what's happening here. – overactor Jul 30 '14 at 0:58

# DangerZoner

• Written in Python and interfaces with the non-Java code wrapper written by Sparr.

• Does all its math in pure Python and is completely unoptimized. A bit slow.

• Highly configurable and extensible.

• Does very well against past submissions. Wins 2:1 fights for every one lost against Crossfire or PredictAndAvoid, and wins 98+% of all fights against other contenders.

### Includes its own optional visualization tool:

Fighting Crossfire/PredictAndAvoid, with the eponymous danger zone ratings visualized in the surrounding volume:

• Visualized using nipy_spectral colourmap from matplotlib. More dangerous coordinates are rendered using colours closer to red/white in the electromagnetic spectrum, and are drawn with bigger dots.

• Danger: Blue < Green < Yellow < Red < Light Grey

### Performance:

1000 rounds with the eight top other algorithms on the leaderboard:

SCORE: DumbPlanes: 0 Dangerzoner: 1000
SCORE: Crossfire: 132 Dangerzoner: 367
SCORE: PredictAndAvoid: 165 Dangerzoner: 465
SCORE: Wee: 0 Dangerzoner: 1000
SCORE: Whirligig: 0 Dangerzoner: 989
SCORE: MoveAndShootPlane: 0 Dangerzoner: 1000
SCORE: Starfox: 4 Dangerzoner: 984
SCORE: DumbPy: 0 Dangerzoner: 1000

SCORES:

DumbPlanes: 2 points.
Crossfire: 12 points.
PredictAndAvoid: 14 points.
Wee: 10 points.
Whirligig: 8 points.
MoveAndShootPlane: 6 points.
Starfox: 4 points.
DumbPy: 0 points.
Dangerzoner: 16 points.

THE OVERALL WINNER(S): Dangerzoner
With 16 points.


### Code:

#!/usr/bin/env python3
"""
DangerZoner

Each turn:
1) Make a list of all possible locations to move to, explicitly excluding suicidal positions that will collide with the walls, an ally, or an ally's bullet.
2) Rate each possible location using heuristics that estimate the approximate danger in that zone, accounting for the following factors:
-Proximity to walls. (Manoeuvring constrictions and risk of collision.)
-Proximity to fronts of planes. (Risk of mid-air collisions.)
-High distance from enemy planes. (Risk of enemies easily turning to shoot.)
-Intersection with all enemy attack vectors. (Explicit safety on the next round.)
-Proximity to enemy forward vectors. (Approximate probability of being targeted in upcoming rounds.)
3) If certain respective thresholds are met in the possible moves' danger ratings, then do the following if possible:
-Take a potshot at a random position that an enemy might move to next turn (but never shoot an ally).
-Take a potshot at an extrapolated position that an enemy will likely move to next turn if they keep up their current rate of turn (but never shoot an ally).
-Turn to pursue the closest enemy.
-Move randomly to confound enemy predictive mechanisms. (Disabled since implementing explicit enemy attack vectors in danger zone calculation.)
4) If none of those thresholds are met, then choose the move rated as least dangerous.
"""

import math, random, functools, sys

#import NGrids
NGrids = lambda: None
class NSpace(object):
"""Object for representing an n-dimensional space parameterized by a list of extents in each dimension."""
def __init__(self, dimensions):
self.dimensions = tuple(dimensions)
def check_coordshape(self, coord):
return len(coord) == len(self.dimensions)
def enforce_coordshape(self, coord):
if not self.check_coordshape(coord):
raise ValueError(f"Attempted to access {len(coord)}-coordinate point from {len(self.dimensions)}-coordinate space: {coord}")
def check_coordrange(self, coord):
return all((0 <= c <= b) for c, b in zip(coord, self.dimensions))
def enforce_coordrange(self, coord):
if not self.check_coordrange(coord):
raise ValueError(f"Attempted to access coordinate point out of range of {'x'.join(str(d) for d in self.dimensions)} space: {coord}")
def check_coordtype(self, coord):
return True
def enforce_coordtype(self, coord):
if not self.check_coordtype(coord):
raise TypeError(f"Attempted to access grid point with invalid coordinates for {type(self).__name__}(): {coord}")
def enforce_coord(self, coord):
for f in (self.enforce_coordshape, self.enforce_coordrange, self.enforce_coordtype):
f(coord)
def coords_grid(self, step=None):
if step is None:
step = tuple(1 for i in self.dimensions)
self.enforce_coord(step)
counts = [math.ceil(d/s) for d, s in zip(self.dimensions, step)]
intervals = [1]
for c in counts:
intervals.append(intervals[-1]*c)
for i in range(intervals[-1]):
yield tuple((i//l)*s % (c*s) for s, l, c in zip(step, intervals, counts))
NGrids.NSpace = NSpace

def Pythagorean(*coords):
return math.sqrt(sum(c**2 for c in coords))

class Plane(object):
"""Object for representing a single dogfighting plane."""
def __init__(self, alive, coord, vec, cooldown=None, name=None):
self.alive = alive
self.set_alive(alive)
self.coord = coord
self.set_coord(coord)
self.vec = vec
self.set_vec(vec)
self.cooldown = cooldown
self.set_cooldown(cooldown)
self.name = name
def set_alive(self, alive):
self.lastalive = self.alive
self.alive = alive
def set_coord(self, coord):
self.lastcoord = self.coord
self.coord = coord
def set_vec(self, vec):
self.lastvec = self.vec
self.vec = vec
def set_cooldown(self, cooldown):
self.lastcooldown = self.cooldown
self.cooldown = cooldown
def update(self, alive=None, coord=None, vec=None, cooldown=None):
if alive is not None:
self.set_alive(alive)
if coord is not None:
self.set_coord(coord)
if vec is not None:
self.set_vec(vec)
if cooldown is not None:
self.set_cooldown(cooldown)
def get_legalvecs(self):
return getNeighbouringVecs(self.vec)
def get_legalcoords(self):
return {tuple(self.coord[i]+v for i, v in enumerate(vec)) for vec in self.get_legalvecs()}
def get_legalfutures(self):
return (lambda r: r.union((c, self.vec) for c, v in r))({(vecAdd(self.coord, vec),vec) for vec in self.get_legalvecs()})

class DangerZones(NGrids.NSpace):
"""Arena object for representing an n-dimensional volume with both enemy and allied planes in it and estimating the approximate safety/danger of positions within it. """
def __init__(self, dimensions=(13,13,13), walldanger=18.0, walldistance=3.5, wallexpo=2.0, walluniformity=5.0, planedanger=8.5, planeexpo=8.0, planeoffset=1.5, planedistance=15.0, planedistancedanger=2.0, planedistanceexpo=1.5, firedanger=9.0, collisiondanger=10.0, collisiondirectionality=0.6, collisiondistance=2.5, collisionexpo=0.2):
NGrids.NSpace.__init__(self, dimensions)
self.walldanger = walldanger
self.walldistance = walldistance
self.wallexpo = wallexpo
self.walluniformity = walluniformity
self.planedanger = planedanger
self.planeexpo = planeexpo
self.planeoffset = planeoffset
self.planedistance = planedistance
self.planedistancedanger = planedistancedanger
self.planedistanceexpo = planedistanceexpo
self.firedanger = firedanger
self.collisiondanger = collisiondanger
self.collisiondirectionality = collisiondirectionality
self.collisiondistance = collisiondistance
self.collisionexpo = collisionexpo
self.set_planes()
self.set_allies()
self.clear_expectedallies()
def filteractiveplanes(self, planes=None):
if planes is None:
planes = self.planes
return (p for p in planes if all((p.alive, p.coord, p.vec)))
def rate_walldanger(self, coord):
self.enforce_coordshape(coord)
return (lambda d: (max(d)*self.walluniformity+sum(d))/(self.walluniformity+1))((1-min(1, (self.dimensions[i]/2-abs(v-self.dimensions[i]/2))/self.walldistance)) ** self.wallexpo * self.walldanger for i, v in enumerate(coord))
def rate_planedanger(self, coord, planecoord, planevec):
for v in (planecoord, planevec, coord):
self.enforce_coordshape(v)
return max(0, (1 - vecAngle(planevec, vecSub(coord, vecSub(planecoord, vecMult(planevec, (self.planeoffset,)*len(self.dimensions)))) ) / math.pi)) ** self.planeexpo * self.planedanger
offsetvec = convertVecTrinary(planevec, length=self.planeoffset)
relcoord = [v-(planecoord[i]-offsetvec[i]) for i, v in enumerate(coord)]
nrelcoord = (lambda m: [(v/m if m else 0) for v in relcoord])(Pythagorean(*relcoord))
planevec = (lambda m: [(v/m if m else 0) for v in planevec])(Pythagorean(*planevec))
return max(0, sum(d*p for d, p in zip(planevec, nrelcoord))+2)/2 ** self.planeexpo * self.planedanger + min(1, Pythagorean(*relcoord)/self.planedistance) ** self.planedistanceexpo * self.planedistancedanger
def rate_planedistancedanger(self, coord, planecoord, planevec):
return Pythagorean(*vecSub(planecoord, coord))/self.planedistance ** self.planedistanceexpo * self.planedistancedanger
def rate_firedanger(self, coord, plane):
return (min(vecAngle(vecSub(coord, c), v) for c, v in plane.get_legalfutures()) < 0.05) * self.firedanger
def rate_collisiondanger(self, coord, planecoord, planevec):
if coord == planecoord:
return self.collisiondanger
offsetvec = tuple(p-c for p,c in zip(planecoord, coord))
return max(0, vecAngle(planevec, offsetvec)/math.pi)**self.collisiondirectionality * max(0, 1-Pythagorean(*offsetvec)/self.collisiondistance)**self.collisionexpo*self.collisiondanger
def set_planes(self, *planes):
self.planes = planes
def set_allies(self, *allies):
self.allies = allies
def rate_planesdanger(self, coord, planes=None):
if planes is None:
planes = {*self.planes}
return max((0, *(self.rate_planedanger(coord, planecoord=p.coord, planevec=p.vec) for p in self.filteractiveplanes(planes))))
def rate_planedistancesdanger(self, coord, planes=None):
if planes is None:
planes = {*self.planes}
return max((0, *(self.rate_planedistancedanger(coord, planecoord=p.coord, planevec=p.vec) for p in self.filteractiveplanes(planes))))
def rate_firesdanger(self, coord, planes=None):
if planes is None:
planes = {*self.planes}
return sum(self.rate_firedanger(coord, p) for p in self.filteractiveplanes(planes))
def rate_collisionsdanger(self, coord, pself=None, planes=None):
if planes is None:
planes = {*self.planes, *self.allies}
return max((0, *(self.rate_collisiondanger(coord , planecoord=p.coord, planevec=p.vec) for p in self.filteractiveplanes(planes) if p is not pself)))
def rate_sumdanger(self, coord, pself=None, planes=None):
return max((self.rate_walldanger(coord), self.rate_planesdanger(coord, planes=planes), self.rate_planedistancesdanger(coord, planes=planes), self.rate_firesdanger(coord, planes=planes), self.rate_collisionsdanger(coord, pself=pself, planes=planes)))
def get_expectedallies(self):
return {*self.expectedallies}
def clear_expectedallies(self):
self.expectedallies = set()
self.expectedallies.update(coords)
def get_expectedshots(self):
return {*self.expectedshots}
def clear_expectedshots(self):
self.expectedshots = set()
self.expectedshots.update(rays)
def tickturn(self):
self.clear_expectedallies()
self.clear_expectedshots()

def stringException(exception):
import traceback
return ''.join(traceback.format_exception(type(exception), exception, exception.__traceback__))

try:
import matplotlib.pyplot, matplotlib.cm, mpl_toolkits.mplot3d, time
class PlottingDangerZones(DangerZones):
"""Arena object for calculating danger ratings and rendering 3D visualizations of the arena state and contents to both files and an interactive display on each turn."""
plotparams = {'dangersize': 80, 'dangersizebase': 0.2, 'dangersizeexpo': 2.0, 'dangeralpha': 0.2, 'dangerres': 1, 'dangervrange': (0, 10), 'dangercmap': matplotlib.cm.nipy_spectral, 'dangermarker': 'o', 'allymarker': 's', 'enemymarker': 'D', 'vectormarker': 'x', 'planesize': 60, 'vectorsize': 50, 'planecolour': 'black', 'deathmarker': '*', 'deathsize': 700, 'deathcolours': ('darkorange', 'red'), 'deathalpha': 0.65, 'shotlength': 4, 'shotcolour': 'darkviolet', 'shotstyle': 'dashed'}
enabledplots = ('enemies', 'allies', 'vectors', 'danger', 'deaths', 'shots', 'names')
def __init__(self, dimensions=(13,13,13), plotparams=None, plotautoturn=0, plotsavedir=None, enabledplots=None, disabledplots=None, tickwait=0.0, plotcycle=0.001, **kwargs):
DangerZones.__init__(self, dimensions, **kwargs)
self.figure = None
self.axes = None
self.frame = None
self.plotobjs = {}
self.plotshown = False
if plotparams:
self.set_plotparams(plotparams)
self.plotautoturn = plotautoturn
self.plotsavedir = plotsavedir
if enabledplots:
self.enabledplots = tuple(enabledplots)
if disabledplots:
self.enabledplots = tuple(m for m in self.enabledplots if m not in disabledplots)
self.tickwait = tickwait
self.plotcycle = plotcycle
self.lasttick = time.time()
def set_plotparams(self, plotparams):
self.plotparams = {**self.plotparams, **plotparams}
def prepare_plotaxes(self, figure=None, clear=True):
if self.figure is None and figure is None:
self.figure = matplotlib.pyplot.figure()
self.frame = 0
if self.axes is None:
elif clear:
self.axes.clear()
for d, h in zip((self.axes.set_xlim, self.axes.set_ylim, self.axes.set_zlim), self.dimensions):
d(0, h)
return (self.figure, self.axes)
def plotter(kind):
def plotterd(funct):
def plott(self):
kws = dict(getattr(self, funct.__name__.replace('plot_', 'plotparams_'))())
if '*args' in kws:
args = tuple(kws.pop('*args'))
else:
args = tuple()
if False and funct.__name__ in self.plotobjs:
self.plotobjs[funct.__name__].set(**kws)
else:
self.plotobjs[funct.__name__] = getattr(self.axes, kind)(*args, **kws)
return plott
return plotterd
def plotparams_enemies(self):
r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['enemymarker'], 's': self.plotparams['planesize'], 'c': self.plotparams['planecolour']}
planes = tuple(self.filteractiveplanes(self.planes))
if planes:
r['xs'], r['ys'], r['zs'] = zip(*(p.coord for p in planes))
return r
def plotparams_allies(self):
r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['allymarker'], 's': self.plotparams['planesize'], 'c': self.plotparams['planecolour']}
planes = tuple(self.filteractiveplanes(self.allies))
if planes:
r['xs'], r['ys'], r['zs'] = zip(*(p.coord for p in planes))
return r
def plotparams_vectors(self):
r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['vectormarker'], 's': self.plotparams['vectorsize'], 'c': self.plotparams['planecolour']}
planes = tuple(self.filteractiveplanes(self.allies+self.planes))
if planes:
r['xs'], r['ys'], r['zs'] = zip(*(vecAdd(p.coord, p.vec) for p in planes))
return r
def plotparams_danger(self):
r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['dangermarker'], 'cmap': self.plotparams['dangercmap'], 'alpha': self.plotparams['dangeralpha']}
coords = tuple(self.coords_grid((self.plotparams['dangerres'],)*len(self.dimensions)))
r['xs'], r['ys'], r['zs'] = zip(*coords)
r['c'] = tuple(self.rate_sumdanger(c) for c in coords)
m = max(r['c'])
r['s'] = tuple((d/m)**self.plotparams['dangersizeexpo']*self.plotparams['dangersize']+self.plotparams['dangersizebase'] for d in r['c'])
if self.plotparams['dangervrange']:
r['vmin'], r['vmax'] = self.plotparams['dangervrange']
return r
def plotparams_deaths(self):
r = {'xs': tuple(), 'ys': tuple(), 'zs': tuple(), 'marker': self.plotparams['deathmarker'], 's': self.plotparams['deathsize'], 'c': self.plotparams['deathcolours'][0], 'linewidths': self.plotparams['deathsize']/180, 'edgecolors': self.plotparams['deathcolours'][1], 'alpha': self.plotparams['deathalpha']}
deaths = tuple(p.lastcoord for p in self.planes+self.allies if p.lastalive and not p.alive)
if deaths:
r['xs'], r['ys'], r['zs'] = zip(*deaths)
return r
def plotparams_shots(self):
r = {'length': self.plotparams['shotlength'], 'linestyles': self.plotparams['shotstyle'], 'color': self.plotparams['shotcolour'], 'arrow_length_ratio': 0.0, '*args': []}
planes = tuple(p for p in self.filteractiveplanes(self.allies+self.planes) if not (p.lastcooldown is None or p.cooldown is None) and (p.cooldown > p.lastcooldown))
if planes:
for s in zip(*(p.coord for p in planes)):
r['*args'].append(s)
for s in zip(*(p.vec for p in planes)):
r['*args'].append(s)
else:
for i in range(6):
r['*args'].append(tuple())
return r
@plotter('scatter')
def plot_enemies(self):
pass
@plotter('scatter')
def plot_allies(self):
pass
@plotter('scatter')
def plot_vectors(self):
pass
@plotter('scatter')
def plot_danger(self):
pass
@plotter('scatter')
def plot_deaths(self):
pass
@plotter('quiver')
def plot_shots(self):
pass
def plot_names(self):
if 'plot_names' in self.plotobjs:
pass
self.plotobjs['plot_names'] = [self.axes.text(*p.coord, s=f"{p.name}") for i, p in enumerate(self.filteractiveplanes(self.allies+self.planes))]
def plotall(self):
for m in self.enabledplots:
getattr(self, f'plot_{m}')()
def updateallplots(self):
self.prepare_plotaxes()
self.plotall()
if self.plotautoturn:
self.axes.view_init(30, -60+self.frame*self.plotautoturn)
matplotlib.pyplot.draw()
if self.plotsavedir:
import os
os.makedirs(self.plotsavedir, exist_ok=True)
self.figure.savefig(os.path.join(self.plotsavedir, f'{self.frame}.png'))
self.frame += 1
if not self.plotshown:
matplotlib.pyplot.ion()
matplotlib.pyplot.show()#block=False)
self.plotshown = True
def tickturn(self):
DangerZones.tickturn(self)
self.updateallplots()
matplotlib.pyplot.pause(max(self.plotcycle, self.lasttick+self.tickwait-time.time()))
self.lasttick = time.time()
except Exception as e:
print(f"Could not define matplotlib rendering dangerzone handler:\n{stringException(e)}", file=sys.stderr)

def vecEquals(vec1, vec2):
return tuple(vec1) == tuple(vec2)

return tuple(sum(p) for p in zip(*vecs))

def vecSub(vec1, vec2):
return tuple(a-b for a, b in zip(vec1, vec2))

def vecMult(*vecs):
return tuple(functools.reduce(lambda a, b: a*b, p) for p in zip(*vecs))

def vecDiv(vec1, vec2):
return tuple(a-b for a, b in zip(vec1, vec2))

def vecDotProduct(*vecs):
return sum(vecMult(*vecs))
#return sum(d*p for d, p in zip(vec1, vec2))

def vecAngle(vec1, vec2):
try:
if all(c == 0 for c in vec1) or all(c == 0 for c in vec2):
return math.nan
return math.acos(max(-1, min(1, vecDotProduct(vec1, vec2)/Pythagorean(*vec1)/Pythagorean(*vec2))))
except Exception as e:
raise ValueError(f"{e!s}: {vec1} {vec2}")

def convertVecTrinary(vec, length=1):
return tuple((max(-length, min(length, v*math.inf)) if v else v) for v in vec)

def getNeighbouringVecs(vec):
vec = convertVecTrinary(vec, length=1)
return {ve for ve in (tuple(v+(i//3**n%3-1) for n, v in enumerate(vec)) for i in range(3**len(vec))) if all(v in (-1,0,1) for v in ve) and any(v and v==vec[i] for i, v in enumerate(ve))}

def getVecRotation(vec1, vec2):
#Just do a cross product/perpendicular to tangential plane/normal?
pass

def applyVecRotation(vec, rotation):
pass

class DangerZoner(Plane):
"""Dogfighting plane control object."""
def __init__(self, arena, snipechance=0.60, snipechoices=3, firesafety=7.5, chasesafety=5.0, jinkdanger=math.inf, jink=0, name=None):
Plane.__init__(self, True, None, None)
self.arena = arena
self.snipechance = snipechance
self.snipechoices = snipechoices
self.firesafety = firesafety
self.chasesafety = chasesafety
self.jinkdanger = jinkdanger
self.jink = jink
self.vec = None
self.name = name
def get_enemies(self):
return (p for p in self.arena.filteractiveplanes(self.arena.planes))
def get_vecsuicidal(self, vec, coord=None, steps=5):
if coord is None:
coord = self.coord
if all(3 < c < self.arena.dimensions[i]-3 for i, c in enumerate(coord)):
return False
if not all(0 < c < self.arena.dimensions[i] for i, c in enumerate(coord)):
return True
elif steps >= 0:
return all(self.get_vecsuicidal(v, coord=vecAdd(coord, vec), steps=steps-1) for v in getNeighbouringVecs(vec))
return False
def get_sanevecs(self):
legalvecs = self.get_legalvecs()
s = {vec for vec in legalvecs if vecAdd(self.coord, vec) not in self.arena.get_expectedallies() and not any(vecAngle(vecSub(vecAdd(self.coord, vec), sc), sv) < 0.05 for sc, sv in self.arena.get_expectedshots()) and not self.get_vecsuicidal(vec, coord=vecAdd(self.coord, vec))}
if not s:
return legalvecs
raise Exception()
return s
return self.arena.rate_sumdanger(tuple(c+v*lookahead for v, c in zip(vec, self.coord)), pself=self)
def get_validshots(self, snipe=True):
if snipe and random.random() < self.snipechance:
enemypossibilities = set.union(*({vecAdd(p.coord, p.vec)} if not p.lastvec or vecEquals(p.vec, p.lastvec) else {vecAdd(p.coord, ve) for ve in sorted(p.get_legalvecs(), key=lambda v: -vecAngle(v, p.lastvec))[:self.snipechoices]} for p in self.get_enemies()))
else:
enemypossibilities = set().union(*(p.get_legalcoords() for p in self.get_enemies()))
validshots = []
if self.cooldown:
return validshots
for vec in self.get_sanevecs():
coord = tuple(c + v for c, v in zip(self.coord, vec))
if any(vecAngle(tuple(n-v for n, v in zip(t, self.coord)), self.vec) < 0.1 for t in enemypossibilities if t != self.coord) and not any(vecAngle(vecSub(a, coord), self.vec) < 0.05 for a in self.arena.get_expectedallies()):
validshots.append({'vec': vec, 'turn': False, 'fire': True})
if any(vecAngle(tuple(n-v for n, v in zip(t, self.coord)), vec) < 0.1 for t in enemypossibilities if t != self.coord) and not any(vecAngle(vecSub(a, coord), vec) < 0.05 for a in self.arena.get_expectedallies()):
validshots.append({'vec': vec, 'turn': True, 'fire': True})
if snipe and not validshots:
validshots = self.get_validshots(snipe=False)
return validshots
def get_chase(self):
enemydirs = {vecSub(vecAdd(p.coord, p.vec), self.coord) for p in self.get_enemies()}
paths = sorted(self.get_sanevecs(), key=lambda vec: min([vecAngle(vec, e) for e in enemydirs if not all(v == 0 for v in e)]+[math.inf]))
if paths:
return paths[0]
def get_move(self):
if not self.alive:
return {'vec': (1,1,1), 'turn': False, 'fire': False}
fires = self.get_validshots()
if fires:
fires = sorted(fires, key=lambda d: self.rate_vec(d['vec']))
if self.rate_vec(fires[0]['vec']) <= self.firesafety:
return fires[0]
vec = self.get_chase()
if vec is None or self.rate_vec(vec) > self.chasesafety:
vec = sorted(self.get_sanevecs(), key=self.rate_vec)
vec = vec[min(len(vec)-1, random.randint(0,self.jink)) if self.rate_vec(vec[0]) > self.jinkdanger else 0]
return {'vec': vec, 'turn': True, 'fire': False}
def move(self):
move = self.get_move()
if move['fire']:
self.arena.add_expectedshots((coord, move['vec'] if move['turn'] else self.vec))
return move

VecsCarts = {(0,-1):'N', (0,1):'S', (1,1):'E', (1,-1):'W', (2,1):'U', (2,-1):'D'}

def translateCartVec(cartesian):
vec = [0]*3
for v,l in VecsCarts.items():
if l in cartesian:
vec[v[0]] = v[1]
return tuple(vec)

def translateVecCart(vec):
vec = convertVecTrinary(vec)
return ''.join(VecsCarts[(i,v)] for i, v in enumerate(vec) if v != 0)

def parsePlaneState(text):
return (lambda d: {'alive':{'alive': True, 'dead': False}[d[0]], 'coord':tuple(int(c) for c in d[1:4]), 'vec':translateCartVec(d[4]), 'cooldown': int(d[5])})(text.split(' '))

def encodePlaneInstruction(vec, turn, fire):
return f"{translateVecCart(vec)} {int(bool(turn))!s} {int(bool(fire))!s}"

"""Object for interacting through STDIN and STDOUT in a dogfight with an arena, controlled planes, and enemy planes."""
def __init__(self, logname='danger_log.txt', arenatype=DangerZones, arenaconf=None, planetype=DangerZoner, planeconf=None, enemyname='Enemy', stdin=sys.stdin, stdout=sys.stdout):
self.logname = logname
self.arenatype = arenatype
self.arenaconf = dict(arenaconf) if arenaconf else dict()
self.planetype = planetype
self.planeconf = dict(planeconf) if planeconf else dict()
self.enemyname = enemyname
self.stdin = stdin
self.stdout = stdout
self.log = open('danger_log.txt', 'w')
def __enter__(self):
return self
def __exit__(self, *exc):
self.log.__exit__()
def getin(self):
self.log.write(f"IN: {l}")
return l
def putout(self, content):
self.log.write(f"OUT: {content}\n")
print(content, file=self.stdout, flush=True)
def logout(self, content):
self.log.write(f"MSG: {content}\n")
def logerr(self, content):
self.log.write(f"ERR: {content}\n")
def run_setup(self, arenasize, rounds):
self.arena = self.arenatype(dimensions=(arenasize,)*3, **self.arenaconf)
self.planes = [self.planetype(arena=self.arena, name=f"{self.planetype.__name__} #{i}", **self.planeconf) for i in range(2)]
self.arena.set_planes(*(Plane(True, None, None, name=f"{self.enemyname} #{i}") for i in range(2)))
self.arena.set_allies(*self.planes)
def run_move(self):
self.arena.tickturn()
for p in self.planes:
p.update(**parsePlaneState(self.getin()))
for p in self.arena.planes:
p.update(**parsePlaneState(self.getin()))
for p in self.planes:
self.putout(encodePlaneInstruction(**p.move()))
def run(self):
line = ''
while not line.startswith('NEW CONTEST '):
line = self.getin()
self.run_setup(arenasize=int(line.split(' ')[2])-1, rounds=None)
while True:
line = self.getin()
if line.startswith('NEW TURN'):
self.run_move()

if True and __name__ == '__main__' and not sys.flags.interactive:
import time
DoPlot = False
#Use the arena object that visualizes progress every turn.
DangerPlot = True
#Compute and render a voxel cloud of danger ratings within the arena each turn if visualizing it.
SparseDangerPlot = False
#Use a lower resolution for the voxel cloud if visualizing danger ratings.
TurntablePlot = True
#Apply a fixed animation to the interactive visualization's rotation if visualizing the arena.
with CtrlReceiver(logname='danger_log.txt', arenatype=PlottingDangerZones if DoPlot else DangerZones, arenaconf=dict(disabledplots=None if DangerPlot else ('danger'), plotparams=dict(dangerres=2) if SparseDangerPlot else dict(dangeralpha=0.1), plotautoturn=1 if TurntablePlot else 0, plotsavedir=f'PngFrames') if DoPlot else None, planetype=DangerZoner) as run:
try:
run.run()
except Exception as e:
run.logerr(stringException(e))
$$$$
`