master.txt

// TODO: grabbing sometimes fails, deal with it
// TODO: dropping sometimes fails, deal with it
// TODO: BIG - idle goals (gather)
// TODO: what to do when runs out of batteries?
// TODO: what to do when low on batteries and can't get to recharge (wheeled)
// TODO: don't force reaching the cooldown spot before registering a completed cooldown
// TODO: deal with the no-fly green spheres
// TODO: treat yellow flags as same size as stockpile
extern void object::Master() {}

public class CommandCenter {
	static Const const = new Const();
	static SlaveInfo slaves[] = {};
	static Goal[] goals = {};
	static bool completed = false;
	static bool staticInit = true;

	synchronized void addGoal(Goal goal) {
		goals[sizeof(goals)] = goal;
	}

	synchronized void resetGoals() {
		Goal[] empty = {};
		goals = empty;
	}

	synchronized Goal nextGoal(int bot) {
		for (int i = 0; i < sizeof(goals); i++) {
			Goal g = goals[i].nextGoal(bot);
			if (g != null) {
				g.status = g.IN_PROGRESS;
				return g;
			}
		}
		return null;
	}

	synchronized void checkCompletion() {
		if (completed) return;
		for (int i = 0; i < sizeof(goals); i++) {
			if (goals[i].status != goals[i].DONE) return;
		}

		//mission done!!!
		message("Done! Board Spaceship!");
		completed = true;
	}
	void checkForUnregisteredSlaves(object that) {
		float minDis = 0;
		while (true) {
			object o = radar(const.ALL_BOTS, 0, 360, minDis, 1000, 1, that.team);
			if (o == null) return;
			if (o != that) {
				if (!isRegistered(o)) {
					message("Registering slave: " + o.category, DisplayInfo);
					int ret = 0;
					ret += o.loadProgram(1, "savegame/Jeremy/program/slave.txt");
					ret += o.runProgram(1);
					if (ret == 0) {
						while (!isRegistered(o)) wait(1);
					} else {
						message("Couldn't register", DisplayWarning);
					}
				}
			}

			minDis = distance(that.position, o.position) + 0.05;
		}
	}

	bool isRegistered(object slaveBot) {
		for (int i = 0; i < sizeof(slaves); i++) {
			if (slaves[i].bot == slaveBot) {
				return true;
			}
		}

		return false;
	}

	synchronized SlaveInfo registerSlave(object slaveBot) {
		//check to see if we already have this slave
		for (int i = 0; i < sizeof(slaves); i++) {
			if (slaves[i].bot == slaveBot) {
				//message("Slave tried to register twice", DisplayWarning);
				return slaves[i];
			}
		}

		//register new slave
		SlaveInfo newInfo = new SlaveInfo(slaveBot);
		slaves[sizeof(slaves)] = newInfo;
		return newInfo;
	}

	public SlaveInfo getFreeSlave(int type) {
		for (int i = 0; i < sizeof(slaves); i++) {
			if(slaves[i].status == slaves[i].FREE &&
				 slaves[i].bot.category == type) {
				return slaves[i];
			}
		}

		return null;
	}

	public SlaveInfo getSlave(int type) {
		for (int i = 0; i < sizeof(slaves); i++) {
			if(slaves[i].status != slaves[i].DESTROYED &&
				 (type == Any || slaves[i].bot.category == type)) {
				return slaves[i];
			}
		}
		return null;
	}

	bool hasSlave(int type) {
		return getSlave(type) != null;
	}

	SlaveInfo waitFreeSlave(int type) {
		SlaveInfo slave;
		while(true) {
			slave = getFreeSlave(type);
			if (slave != null) return slave;
			wait(1);
		}
	}

	synchronized void checkForDeadSlaves(object executingSlave) {
		for (int i = 0; i < sizeof(slaves); i++) {
			if (slaves[i].status == slaves[i].DESTROYED) continue;
			if (slaves[i].bot != executingSlave && !slaves[i].bot.isAlive()) {
				message("Slave destroyed! " + slaves[i].bot.category, DisplayError);
				slaves[i].status = slaves[i].DESTROYED;
				if (slaves[i].goal != null) {
					slaves[i].goal.status = slaves[i].goal.NONE;
					slaves[i].goal = null;
				}
			}
		}
	}
}

public class SlaveInfo {
	static int FREE = 0;
	static int BUSY = 1;
	static int DESTROYED = 2;

	object bot;
	int status;
	Goal goal;

	void SlaveInfo(object slaveBot) {
		bot = slaveBot;
		status = FREE;
		goal = null;
	}
}

public class Goal {
	static int NONE = 0;
	static int IN_PROGRESS = 1;
	static int DONE = 2;

	static Const const = new Const();

	int actorBotType = WheeledGrabber;
	int status = 0; //NONE
	Goal ensureActorSubGoal;
	bool subGoalsInitialized = false;
	Goal[] subGoals;

	bool isComplete() {
		message("isComplete not implemented!", DisplayError);
		throw 1;
	}

	void initializeSubGoals() {
		message("initializeSubGoals not implemented!", DisplayError);
		throw 1;
	}

	bool perform(Bot bot) {
		message("perform not implemented!", DisplayError);
		throw 1;
	}

	string toString() {
		message("toString not implemented!", DisplayError);
		throw 1;
	}

	Goal nextGoal(int bot) {
		if (isComplete()) return null;
		if (status == IN_PROGRESS) return null;
		if (!subGoalsInitialized) {
			ensureActorSubGoal = new EnsureBotGoal(actorBotType);
			initializeSubGoals();
			subGoalsInitialized = true;
		}
		Goal g = ensureActorSubGoal.nextGoal(bot);
		if (g != null) return g;
		bool notReady = false;
		for (int i = 0; i < sizeof(subGoals); i++) {
			if (!subGoals[i].isComplete()) notReady = true;
			g = subGoals[i].nextGoal(bot);
			if (g != null) return g;
		}
		if (notReady) return null;
		if (actorBotType == Any || actorBotType == bot) return this;
		return null;
	}

	void upgradeActor() {
		int newType;
		if (canresearch(ResearchWinged)) {
			actorBotType = WingedGrabber;
		} else {
			actorBotType = TrackedGrabber;
		}
		ensureActorSubGoal = new EnsureBotGoal(actorBotType);
	}

	bool upgradeActor(int type) {
		actorBotType = type;
		ensureActorSubGoal = new EnsureBotGoal(actorBotType);
	}
}

public class Base {
	static bool initialized = false;
	static point center;
	static bool hasSpaceShip;
	static Stockpile[] stockpiles;
	static BuildBuildingGoal[] buildings;

	// Satellite report
	static bool hasEnergy = false;
	static bool energyEverywhere = false;
	static point energyLocation;

	synchronized void Base() {
		if (initialized) return;
		object ship = radar(SpaceShip);
		hasSpaceShip = (ship != null);
		if (hasSpaceShip) {
			center = ship.position;
		} else {
			Const const();
			center = radar(const.ALL_BOTS).position;
		}
		initialized = true;
	}

	synchronized void registerStartingResources(object bot) {
		// TODO: write searchAll (like radarAll) so we don't have to depend on the
		// robot being on the space ship;
		if (distance2d(bot.position, center) > 8) {
			message("Robot is too far from base center to register resoruces", DisplayWarning);
			Bot theBot(bot);
			theBot.botGoto(center);
		}

		Const const();
		int[] types = const.ALL_RESOURCES;
		for (int i = 0; i < sizeof(types); i++) {
			object[] resources = radarall(types[i], 0, 360, 0, 15);
			if (sizeof(resources) > 0 ) {
				// This initializes the stockpile if it doesn't exist
				getStockpile(types[i]).addAll(resources);
				message("Registered " + sizeof(resources) + " " + categoryString(types[i]));
			}
		}
	}

	synchronized object reserveResource(int type) {
		return getStockpile(type).reserve();
	}

	synchronized Stockpile getStockpile(int type) {
		for (int i = 0; i < sizeof(stockpiles); i++) {
			if (stockpiles[i].type == type) return stockpiles[i];
		}
		return initStockpile(type);
	}

	synchronized Stockpile initStockpile(int type) {
		Stockpile pile = new Stockpile(type);
		stockpiles[sizeof(stockpiles)] = pile;
		return pile;
	}

	synchronized point findBuildingSpot(int type) {
		SpotChecker checker = new BuildingSpotChecker();
		int stride = 2;
		float minDist = 0;
		point origin;

		if (type == PowerStation && !hasEnergy) {
			message("No underground energy, can't build Power Station!", DisplayError);
			throw 1;
		}

		if (type == PowerStation && !energyEverywhere) {
			origin = energyLocation;
			stride = 1;
		} else {
			origin = center;
			if (hasSpaceShip) minDist = 30;
		}

		point p = findSpot(checker, origin, minDist, stride);
		produce(p, 0, GreenFlag);
		return p;
	}

	synchronized point findStockpileSpot() {
		SpotChecker checker = new StockpileSpotChecker();
		int stride = 4;
		float minDist = 15;
		if (hasSpaceShip) minDist += 30;

		point p = findSpot(checker, center, minDist, stride);
		produce(p, 0, YellowFlag);
		return p;
	}

	synchronized BuildBuildingGoal getBuildingGoal(int type) {
		for (int i = 0; i < sizeof(buildings); i++) {
			if (buildings[i].type == type) return buildings[i];
		}
		BuildBuildingGoal goal(type);
		buildings[sizeof(buildings)] = goal;
		return goal;
	}
}

public class Stockpile {
	int type; // Resource
	private point center;
	private bool hasCenter = false;
	private StockpileItem[] items;

	void Stockpile(int _type) {
		type = _type;
	}

	synchronized object reserve() {
		for (int i = 0; i < sizeof(items); i++) {
			if (items[i].status == items[i].FREE) {
				items[i].status = items[i].RESERVED;
				return items[i].item;
			}
		}
		return null;
	}

	synchronized void add(object o) {
		if (o.category != type) {
			message("Wrong type '" + o.category + "' for stockpile " + type, DisplayError);
			throw 1;
		}
		if (isInStockpile(o)) {
			message("" + o.category + " already in stockpile!", DisplayError);
			throw 1;
		}
		items[sizeof(items)] = new StockpileItem(o);
	}

	synchronized void addAll(object[] resources) {
		for (int i = 0; i < sizeof(resources); i++) {
			add(resources[i]);
		}
	}

	synchronized point getCenter() {
		if (!hasCenter) {
			Base b = new Base();
			center = b.findStockpileSpot();
			hasCenter = true;
		}
		return center;
	}

	synchronized point getDropPoint() {
		SpotChecker checker = new ItemSpotChecker();
		return findSpot(checker, center, 0, 0.5);
	}

	synchronized bool isInStockpile(object item) {
		for (int i = 0; i < sizeof(items); i++) {
			if (items[i].item == item) return true;
		}
		return false;
	}

	synchronized object nextToGather() {
		point c = getCenter();
		float minDistance = 30;
		object item;

		while (true) {
			item = search(type, c, minDistance);
			if (!isInStockpile(item)) break;
			minDistance = distance2d(c, item.position) + 0.1;
		}

		add(item);
		return item;
	}
}

public class StockpileItem {
	static int FREE = 0;
	static int RESERVED = 1;
	int status;
	object item;

	void StockpileItem(object _item) {
		item = _item;
		status = FREE;
	}
}

public class StockpileSpotChecker extends SpotChecker {
	public bool check(point p) {
		if (topo(p) < 0) return false;
		object o = search(Any, p);
		float spaceNeeded = 10 + radius(o);
		if (distance2d(p, o.position) < spaceNeeded) return false;

		// Check for "relatively flat
		float max = topo(p);
		float min = topo(p);

		for (int angle = 0; angle < 360; angle += 90) {
			float height = topo(alongDirection(p, angle, 9));
			if (height > max) max = height;
			if (height < min) min = height;
		}
		if (max - min > 1) return false;

		return true;
	}
}

public class ItemSpotChecker extends SpotChecker {
	public bool check(point p) {
		if (topo(p) < 0) return false;
		object o = search(Any, p);
		// IDEA: if we used put(point, true) and dropped exactly, we should be able
		// to reduce the amount of open space needed.
		float spaceNeeded = 2 + radius(o);
		if (distance2d(p, o.position) < spaceNeeded) return false;
		return true;
	}
}

public class BuildingSpotChecker extends SpotChecker {
	public bool check(point p) {
		if (topo(p) < 0) return false;
		object o = search(Any, p);
		float spaceNeeded = 6 + radius(o);
		if (isBuilding(o)) spaceNeeded += 1;
		if (distance2d(p, o.position) < spaceNeeded) return false;
		if (flatground(p, 6.5) < 6) return false;
		return true;
	}
}

public void object::slave()
{
	//register as a slave
	CommandCenter command = new CommandCenter();
	SlaveInfo info = command.registerSlave(this);

	object o = radar(BotFactory);
	if (o != null && distance(position, o.position) < 2) {
		//back out of the bot factory
		move(-7);
	}

	while (true) {
		while(info.goal == null) {
			info.goal = command.nextGoal(this.category);
			if (info.goal != null) break;
			wait(1);
			command.checkCompletion();
			command.checkForDeadSlaves(this);
		}

		message("New goal: " + info.goal.toString(), DisplayInfo);
		// wait(5);
		info.status = info.BUSY;
		bool success = info.goal.perform(new Bot(this));
		if (success) {
			info.goal.status = info.goal.DONE;
			// message("Finished goal: " + info.goal.toString(), DisplayInfo);
		} else {
			message("Failed goal: " + info.goal.toString(), DisplayWarning);
			info.goal.status = info.goal.NONE;
		}
		info.goal = null;
		info.status = info.FREE;
	}
}

public class Level {
	void addGoals(CommandCenter command) {
		message("addGoals not implimented!", DisplayError);
		throw 1;
	}

	void satelliteReport(Base base) {
		message("sateliteReport not implimented!", DisplayError);
		throw 1;
	}

	void solve(object bot) {
		solve(bot, false);
	}

	void solve(object bot, bool skipRegisteringSlaves) {
		CommandCenter command = new CommandCenter();
		command.resetGoals();
		addGoals(command);

		Base base = new Base();
		satelliteReport(base);
		base.registerStartingResources(bot);

		command.registerSlave(bot);
		if (!skipRegisteringSlaves) command.checkForUnregisteredSlaves(bot);

		//run slave script
		bot.slave();
	}
}

public class Bot {
	//States
	int NORMAL = 0;
	int REPAIRING = 1;
	int RECHARGING = 2;
	int COOLDOWN = 3;

	object me;
	int state;
	point lastPos;
	bool notMoving = false;
	float stuckTime = 0;

	//configurable parameters
	float hoverHeight = 10;
	float rechargeLevel = 0.25;
	bool breakOnRefit = false;
	bool swapCell = true;

	public void Bot (object _me) {
		me = _me;
		lastPos = me.position;
		state = NORMAL;
	}

	public bool isFlying() {
		return me.category == WingedGrabber ||
		  me.category == WingedShooter ||
		  me.category == WingedSniffer ||
		  me.category == WingedOrgaShooter;
	}

	public bool get(int category, point searchCenter, float minDistance, bool shouldWait) {
		object o;

		while (true) {
			o = search(category, searchCenter, minDistance);
			if (o != null) break;
			if (!shouldWait) return false;
			wait(0.25);
		};

		return get(o);
	}

  public bool get(object o) {
		while (true) {
			bool success = botGoto(o.position, 2);
			if (!success) return false;
			turn(direction(o.position));
			grab();
			if (o == me.load) return true;
			message("Got the wrong item!");
			drop();
			move(-1);
			if (direction(o.position) > 0) {
				turn(90);
			} else {
				turn(-90);
			}
			move(1);
		}
	}

  public void put(point dropPoint) {
		put(dropPoint, false);
	}

	public void put(point dropPoint, bool exact) {
		if (me.load == null) {
			message("Nothing to put!");
			return;
		}

		botGoto(dropPoint, 1);

		if (exact) {
			turn(direction(dropPoint));
			while(abs(distance2d(me.position, dropPoint) - 1.6) > 0.05) {
				float power = (distance2d(me.position, dropPoint) - 1.6);
				motor(power, power);
				wait(0.05);
			}
			motor(0, 0);
		}

		drop();
	}

	public void deposit(point center) {
		if (me.load == null) {
			message("Nothing to deposit!");
			return;
		}

		//find a free spot
		point free = space(center, 0, 20, 2);
		botGoto(free, 1);
		drop();
	}

  public bool botGoto(point pos) {
    return botGoto(pos, 1);
	}

	public bool botGoto(point pos, float tol) {
		if (isFlying()) {
			return flyto(pos, tol, true);
		} else {
			return driveTo(pos);
		}
	}

	bool driveTo(point pos) {
		checkPower(rechargeLevel);
		checkShields(0.5);

		errmode(0);
		int err = 0;
		bool arrived = false;
		notMoving = false;
		while (!arrived) {
			try {
				err = goto(pos);
				arrived = true;
			} catch (isStuck()) {
				unstick();
			}
		}
		errmode(1);
		if (err != 0) {
			message("Unreachable: " + err);
			return false;
		}
		return true;
	}

	bool isStuck() {
		if (distance(me.position, lastPos) < 0.25) {
			if (notMoving) {
				return abstime() - stuckTime > 3;
			} else {
				notMoving = true;
				stuckTime = abstime();
			}
		} else {
			notMoving = false;
			lastPos = me.position;
			return false;
		}
	}

  void unstick() {
		message("Stuck!");
		abort();
		jet(1);
		motor(-1,-1);
		wait(1);
		if (rand() > 0.5) {
			turn(90);
		} else {
			turn(-90);
		}
		motor(1,1);
		wait(1);
		motor(0,0);
		jet(0);
	}

	public bool flyto(point pos, float tollerance, bool land) {
		notMoving = false;

		while(distance2d(me.position, pos) > tollerance) {
			if (checkRefit() && breakOnRefit) return false;
			checkStuck();
			setEngines(pos, land, -1);
			wait(0.1);
		}

		motor(0,0);
		return true;
	}

	bool checkRefit() {
		bool refit;
		refit = checkTemperature();
		refit = checkPower(rechargeLevel) || refit;
		refit = checkShields(0.5) || refit;
		return refit;
	}

	bool kill() {
		int alienType = AlienAnt;

		hoverHeight = 10;
		rechargeLevel = 0.35;
		breakOnRefit = true;

		object item;

		aim(-20);

		while (true)
		{
			message("Aquiring new target");
			//try and find one a little ways away first
			item = radar(alienType, 0, 360, 40);
			if (item == null) item = radar(alienType);
			if (item == null) break;

			while (item.isAlive()) {
				if (!follow(item, 32, 100)) break;

				motor(1,1);
				if (item != null) {
					turn(direction(item.position));
					//turn(-10);

					//calculate the point to go to if we miss
					point p = alongDirection(item.position, me.orientation, 40);

					//find out which way the ant is facing (and is therefore likely to walk);
					float face = item.orientation - me.orientation;
					while (face > 180) face -= 360;
					while (face < -180) face += 360;

					if (face > 0) {
						motor(1 - (90 - abs(face - 90)) / 90 * 0.3, 1);
					} else {
						motor(1, 1 - (90 - abs(face + 90)) / 90 * 0.3);
					}

					fire(0.5);
					wait(0.5); //wait for bullets to get there

					if (item.isAlive()) {
						message("Missed");

						//goto spot to set up next strafe
						if (!flyto(p, 2, false)) break;
					}
				}
			}
			wait(0.1);
		}

		message("All aliens killed!");

		//get landing spot
		point p = alongDirection(me.position, me.orientation, 25);

		botGoto(p, 3);
	}

	public bool follow(object target, float dis, int matchZ) {
		while(true) {
			if (target == null or !target.isAlive()) {
				return false;
			}

			if (distance(me.position, target.position) < dis &&
			    abs(direction(target.position)) < 5) {
				return true;
			}

			bool refit;
			refit = checkTemperature();
			refit = checkPower(rechargeLevel) || refit;
			refit = checkShields(0.5) || refit;
			if (refit && breakOnRefit) return false;

			point p = target.position;
			p.z += 10;
			setEngines(p, false, matchZ);
			wait(0.1);
		}
	}

	bool checkPower(float minLevel) {
		if (state == NORMAL && me.energyCell.energyLevel < minLevel) {
			object o = radar(PowerStation);
			if (o != null) {
				state = RECHARGING;
				message("Recharging...");
				bool oldRefit = breakOnRefit;
				breakOnRefit = false;
				botGoto(o.position, 1);
				breakOnRefit = oldRefit;
				while(me.energyCell.energyLevel < 1) {
					wait(1);
				}
				state = NORMAL;
				message("Recharging done.");
			} else {
				Base base();
				o = base.reserveResource(PowerCell);
				if (o != null) {
					state = RECHARGING;
					message("Replacing power cell...", DisplayInfo);
					bool oldRefit = breakOnRefit;
					breakOnRefit = false;
					botGoto(o.position, 2);
					bool hadLoad = (me.load != null);
					if (hadLoad) {
						turn(90);
						drop();
					}
					turn(direction(o.position));
					grab(EnergyCell);
					drop(Behind);
					grab(InFront);
					drop(EnergyCell);
					grab(Behind);
					drop(InFront);
					if (hadLoad) {
						turn(90);
						grab();
					}
					breakOnRefit = oldRefit;
					state = NORMAL;
					message("Power cell replaced", DisplayInfo);
				} else {
					//can't recharge
					return false;
				}
			}

			//succesful charge, check to see if we should also repair
			o = radar(RepairCenter);
			if (o != null && distance2d(me.position, o.position) < 100) {
				checkShields(0.90);
			}

			return true;
		}

		return false;
	}

	bool checkShields(float minLevel) {
		object o = radar(RepairCenter);
		if (o == null) return false;

		if (state == NORMAL && me.shieldLevel < minLevel) {
			message("Repairing...");
			state = REPAIRING;

			bool oldRefit = breakOnRefit;
			breakOnRefit = false;
			botGoto(o.position, 1);
			breakOnRefit = oldRefit;
			while(me.shieldLevel < 1) {
				wait(1);
			}

			state = NORMAL;
			message("Reparing done.");

			//check to see if we should also recharge
			o = radar(PowerStation);
			if (o != null && distance2d(me.position, o.position) < 100) {
				checkPower(0.75);
			}

			return true;
		}

		return false;
	}

	bool checkTemperature() {
		//check for jet overheat
		if (state != COOLDOWN && me.temperature > 0.7) {
			message("Cooldown...");
			int oldState = state;
			state = COOLDOWN;
			point safe = nearestSafeSpot(me.position, 50);
			message("Found spot.");
			bool oldRefit = breakOnRefit;
			breakOnRefit = false;
			flyto(safe, 1, true);
			breakOnRefit = oldRefit;
			motor(0,0);
			jet(-1);
			while(me.temperature > 0) {
				wait(0.1);
			}
			state = oldState;
			message("Cooldown done.");

			return true;
		}

		return false;
	}

  void checkStuck() {
		if (isStuck()) unstick();
	}

	public void setEngines(point pos, bool land, int matchZ) {
		//Set motors
		float ml, mr;

		float d = distance2d(me.position, pos);
		float moveMult = 0.2;
		if (me.altitude > 0) moveMult = 0.05;

		if (land) {
			ml = d * moveMult;
			mr = d * moveMult;
		} else { //if not landing, don't stop, fly through the point
			ml = 1;
			mr = 1;
		}

		if (ml > 1) ml = 1;
		if (mr > 1) mr = 1;

		float strength = direction(pos) / 45;
		ml += strength * -1;
		mr += strength;

		motor(ml, mr);

		//Jet

		//check terain height
		float alt = topo(me.position);
		if (alt < 0) alt = 0;
		float fly;

		if (matchZ > 0 && d < matchZ) {
			if (pos.z < alt + 2) {
				fly = alt + 2 - me.position.z;
			} else {
				fly = pos.z - me.position.z;
			}
		} else {
			fly = alt - me.position.z;
			if (!land) {
				fly += hoverHeight;
			} else if (d > 5 && d < 5 + hoverHeight) {
				fly += (d - 5);
			} else if (d > 15) {
				fly += hoverHeight;
			} else { // d < 5
				fly = -10;
			}
		}

		jet(fly * 0.1);
	}
}

public class EnsureBotGoal extends Goal {
	int type;

	void EnsureBotGoal(int _type) {
		type = _type;
	}

	bool isComplete() {
		CommandCenter command = new CommandCenter();
		return command.hasSlave(type);
	}

	void initializeSubGoals() {
		subGoals[0] = new BuildBotGoal(type);
	}

	bool perform(Bot bot) {
		if (subGoals[0].status == DONE && !isComplete()) {
			subGoals[0] = new BuildBotGoal(type);
		}

		return isComplete();
	}

	string toString() {
		return "Ensure Bot (" + categoryString(type) + ")";
	}
}

// Loads one of a resource onto the ship
public class LoadGoal extends Goal {
	int resource;

	void LoadGoal(int _resource) {
		resource = _resource;
	}

	bool isComplete() {
		return status == DONE;
	}

	void initializeSubGoals() {
		subGoals[0] = new ReserveResourceGoal(resource, "Load");
	}

	bool perform(Bot bot) {
		ReserveResourceGoal g = subGoals[0];
		bot.get(g.resource);
		bot.put(findShipSpot(), true);
		return true;
	}

	string toString() {
		return "Load (" + categoryString(resource) + ")";
	}
}

// Loads multiple of a resource onto the ship
public class LoadManyGoal extends Goal {
	int resource;
	int count;

	void LoadManyGoal(int _resource, int _count) {
		resource = _resource;
		count = _count;
	}

	bool isComplete() {
		return status == DONE;
	}

	void initializeSubGoals() {
		for (int i = 0; i < count; i++) {
			subGoals[i] = new LoadGoal(resource);
		}
	}

	bool perform(Bot bot) {
		// Nothing to do, this is just a meta goal to get many loads going in parallel
		return true;
	}

	string toString() {
		return "LoadMany (" + categoryString(resource) + ")";
	}
}

// Boards the ship for takeoff
public class BoardGoal extends Goal {
	object boardedBot = null;

	void BoardGoal(int type) {
		actorBotType = type;
	}

	bool isComplete() {
		if (boardedBot == null) return false;
		return distance2d(radar(SpaceShip).position, boardedBot.position) < 10;
	}

	void initializeSubGoals() {}

	bool perform(Bot bot) {
		boardedBot = null;
		object ship = radar(SpaceShip);
		point p = findShipSpot();
		bot.botGoto(p, 1);
		boardedBot = bot.me;
		return true;
	}

	string toString() {
		return "Board (" + categoryString(actorBotType) + ")";
	}
}

public class BuildBuildingGoal extends Goal {
	int type;
	bool hasBuildSpot = false;
	point buildSpot;

	void BuildBuildingGoal(int _type) {
		type = _type;
		// We start out with any bot, they find the building spot and then determine
		// what kind of bot is best to build it.
		actorBotType = Any;
	}

	bool isComplete() {
		return radar(type) != null;
	}

	void initializeSubGoals() {
		//TODO: check if the building type is available
		subGoals[0] = new ReserveResourceGoal(Titanium, categoryString(type));
	}

	bool perform(Bot bot) {
		Base base();

		if (!hasBuildSpot) {
			buildSpot = base.findBuildingSpot(type);
			int newActorType;
			if (distance2d(base.center, buildSpot) > 50) {
				newActorType  = WingedGrabber;
			} else {
				newActorType = WheeledGrabber;
			}
			upgradeActor(newActorType);
			hasBuildSpot = true;
			if (bot.me.category != newActorType) return false;
		}

		ReserveResourceGoal g = subGoals[0];
		bot.get(g.resource);

		bool success = bot.botGoto(buildSpot, 1);
		if (!success) { // Not reachable by wheeled
			upgradeActor();
			drop();
			return false;
		}

		bot.put(buildSpot, true);

		float a;
		object o = radar(SpaceShip);
		if (o != null) {
			a = normalize(angle(o.position, buildSpot) + 180);
		} else {
			a = normalize(bot.me.orientation + 180);
		}

		point p2 = alongDirection(buildSpot, a, 8);
		bot.botGoto(p2, 1);
		turn(direction(buildSpot));
		message("Building building '" + categoryString(type) + "'", DisplayInfo);
		build(type);

		delete(search(GreenFlag, radar(type).position).id);

		return true;
	}

	string toString() {
		return "Build Building (" + categoryString(type) + ")";
	}
}

public class BuildBotGoal extends Goal {
	int type;

	void BuildBotGoal(int _type) {
		type = _type;
	}

	bool isComplete() {
		return status == DONE;
	}

	void initializeSubGoals() {
		int[] research = botResearch(type);
		for (int i = 0; i < sizeof(research); i++) {
			subGoals[i] = new ResearchGoal(research[i]);
		}
		Base base();
		subGoals[sizeof(subGoals)] = base.getBuildingGoal(BotFactory);
		subGoals[sizeof(subGoals)] = new ReserveResourceGoal(Titanium, categoryString(type));
		subGoals[sizeof(subGoals)] = new ReserveResourceGoal(PowerCell, categoryString(type));
	}

	bool perform(Bot bot) {
		ReserveResourceGoal g = subGoals[sizeof(subGoals)-2];
		object titanium = g.resource;
		g = subGoals[sizeof(subGoals)-1];
		object powerCell = g.resource;
		bot.get(titanium);

		object o = radar(BotFactory);
		if (o == null) {
			message("No Robot Factory", DisplayError);
			return false;
		}

		bot.botGoto(o.position, 1);
		drop();
		move(-5);

		message("Building '" + categoryString(type) + "'", DisplayInfo);
		o.factory(type);

		point p = bot.me.position;
		bot.get(powerCell);
		bot.botGoto(p, 1);

		do {
			o = radar(type, 0, 360, 0, 10);
		} while (o == null);

		bot.botGoto(o.position, 1);
		drop();

		move(-5);
		turn(90);
		move(5);

		//load slave program
		o.loadProgram(1, "savegame/Jeremy/program/slave.txt");
		o.runProgram(1);
		wait(0.25); // Wait for slave to register with Command Center

		return true;
	}

	string toString() {
		return "Build Bot (" + categoryString(type) + ")";
	}
}

public class ResearchGoal extends Goal {
	int type;

	void ResearchGoal(int _type) {
		type = _type;
	}

	bool isComplete() {
		researched(type);
	}

	void initializeSubGoals() {
		Base base();
		subGoals[0] = base.getBuildingGoal(ResearchCenter);
		subGoals[1] = new ReserveResourceGoal(PowerCell, researchString(type));
	}

	bool perform(Bot bot) {
		object o = radar(ResearchCenter);
		if (o == null) {
			message("No Research Center", DisplayError);
			return false;
		}

		if (o.energyCell == null || o.energyCell.energyLevel < 1) {
			message("Powering Research Center", DisplayInfo);
			ReserveResourceGoal g = subGoals[1];
			bot.get(g.resource);
			bot.botGoto(o.position, 1);
			motor(1,1);
			wait(0.5);
			motor(0,0);
			drop();
		}

		message("Researching '" + researchString(type) + "'", DisplayInfo);
		o.research(type);

		while (!isComplete()) {
			wait(1);
		}

		return true;
	}

	string toString() {
		return "Research (" + researchString(type) + ")";
	}
}

public class ReserveResourceGoal extends Goal {
	int type;
	object resource = null;
	string purpose;
	Base base = new Base();

	void ReserveResourceGoal(int _type, string _purpose) {
		type = _type;
		purpose = _purpose;
		actorBotType = Any;
	}

	bool isComplete() {
		return resource != null;
	}

	void initializeSubGoals() {}

	bool perform(Bot bot) {
		resource = base.reserveResource(type);
		if (resource == null) {
			subGoals[0] = new GatherGoal(type);
			return false;
		}
		return true;
	}

	string toString() {
		return "Reserve (" + categoryString(type) + " for " + purpose + ")";
	}
}

public class GatherGoal extends Goal {
	int type;
	Stockpile stockpile;
	object item = null;

	void GatherGoal(int _type) {
		type = _type;
		Base b = new Base();
		stockpile = b.getStockpile(type);
		if (canresearch(ResearchWinged)) {
			actorBotType = WingedGrabber;
		} else {
			actorBotType = WheeledGrabber;
		}
	}

	bool isComplete() {
		return status == DONE;
	}

	void initializeSubGoals() {
		if (type == PowerCell) {
			Base base();
			subGoals[0] = base.getBuildingGoal(PowerStation);
		}
	}

	bool perform(Bot bot) {
		if (item == null) item = stockpile.nextToGather();

		//check for adequate power
		if (bot.me.energyCell.energyLevel * const.FLYING_RANGE <
				distance2d(bot.me.position, item.position) &&
				radar(PowerStation) == null) {
			Base base();
			subGoals[sizeof(subGoals)] = base.getBuildingGoal(PowerStation);
			return false;
		}

		bool success = bot.get(item);
		if (!success) { // Not reachable by wheeled
			upgradeActor();
			return false;
		}

		if (type == PowerCell && item.energyLevel < 1) {
			object o = radar(PowerStation);
			bot.botGoto(o.position, 1);
			while(item.energyLevel < 1) {
				wait(1);
			}
		}
		bot.put(stockpile.getDropPoint());
		return true;
	}

	string toString() {
		return "Gather (" + categoryString(type) + ")";
	}
}

public class KillGoal extends Goal {
	void KillGoal() {
		actorBotType = WingedShooter;
	}

	bool isComplete() {
		return radar(AlienAnt) == null;
	}

	void initializeSubGoals() {
		Base base();
		subGoals[0] = base.getBuildingGoal(PowerStation);
		subGoals[0] = base.getBuildingGoal(RepairCenter);
	}

	bool perform(Bot bot) {
		bot.kill();
		return true;
	}

	string toString() {
		return "Kill";
	}
}