- implemented fuel consumption

- destroying transporting units now also adds unit removal updates for the transported units
- supplying units now also resupply units that they're transporting, at the start of each turn
- unloading units is now only possible when both the destination and transporting unit tiles are passable for the unloading unit type

Author: p.witvoet

databases/aiwars.py

@@ -33,31 +33,31 @@
 #================================================================================
 # Unit types
 
-# name, cost, movementPoints, vision, maxAmmunition
+# name, cost, movementPoints, vision, maxAmmunition, maxFuel
 # Ground units
-infantery        = UnitType('Infantery',         1000,   3,  2,  0, canCapture = True)
-mech             = UnitType('Mech',              3000,   2,  2,  3, canCapture = True)
-recon            = UnitType('Recon',             4000,   8,  5,  0)
-apc              = UnitType('APC',               5000,   6,  1,  0, canSupply = True)
-antiAir          = UnitType('Anti-Air',          8000,   6,  2,  9)
-tank             = UnitType('Tank',              7000,   6,  3,  9)
-mediumTank       = UnitType('Medium Tank',      16000,   5,  1,  8)
-heavyTank        = UnitType('Heavy Tank',       22000,   6,  1,  9)
-artillery        = UnitType('Artillery',         6000,   5,  1,  9, minRange = 2, maxRange = 3, canActAfterMoving = False, canRetaliate = False)
-rockets          = UnitType('Rockets',          15000,   5,  1,  6, minRange = 3, maxRange = 5, canActAfterMoving = False, canRetaliate = False)
-missiles         = UnitType('Missiles',         12000,   4,  5,  6, minRange = 3, maxRange = 5, canActAfterMoving = False, canRetaliate = False)
+infantery        = UnitType('Infantery',         1000,   3,  2,  0, 99, canCapture = True)
+mech             = UnitType('Mech',              3000,   2,  2,  3, 70, canCapture = True)
+recon            = UnitType('Recon',             4000,   8,  5,  0, 80)
+apc              = UnitType('APC',               5000,   6,  1,  0, 70, canSupply = True)
+antiAir          = UnitType('Anti-Air',          8000,   6,  2,  9, 60)
+tank             = UnitType('Tank',              7000,   6,  3,  9, 70)
+mediumTank       = UnitType('Medium Tank',      16000,   5,  1,  8, 50)
+heavyTank        = UnitType('Heavy Tank',       22000,   6,  1,  9, 99)
+artillery        = UnitType('Artillery',         6000,   5,  1,  9, 50, minRange = 2, maxRange = 3, canActAfterMoving = False, canRetaliate = False)
+rockets          = UnitType('Rockets',          15000,   5,  1,  6, 50, minRange = 3, maxRange = 5, canActAfterMoving = False, canRetaliate = False)
+missiles         = UnitType('Missiles',         12000,   4,  5,  6, 50, minRange = 3, maxRange = 5, canActAfterMoving = False, canRetaliate = False)
 
 # Aerial units
-fighter          = UnitType('Fighter',          20000,   9,  2,  9)
-bomber           = UnitType('Bomber',           22000,   7,  2,  9)
-battleCopter     = UnitType('Battle copter',     9000,   6,  3,  6)
-transportCopter  = UnitType('Transport copter',  5000,   6,  2,  0)
+fighter          = UnitType('Fighter',          20000,   9,  2,  9, 99)
+bomber           = UnitType('Bomber',           22000,   7,  2,  9, 99)
+battleCopter     = UnitType('Battle copter',     9000,   6,  3,  6, 99)
+transportCopter  = UnitType('Transport copter',  5000,   6,  2,  0, 99)
 
 # Naval units
-battleShip       = UnitType('Battleship',       28000,   5,  2,  9, minRange = 2, maxRange = 6, canActAfterMoving = False, canRetaliate = False)
-cruiser          = UnitType('Cruiser',          18000,   6,  3,  9)
-lander           = UnitType('Lander',           12000,   6,  1,  0)
-sub              = UnitType('Sub',              20000,   5,  5,  6, canHide = True)
+battleShip       = UnitType('Battleship',       28000,   5,  2,  9, 99, minRange = 2, maxRange = 6, canActAfterMoving = False, canRetaliate = False)
+cruiser          = UnitType('Cruiser',          18000,   6,  3,  9, 99)
+lander           = UnitType('Lander',           12000,   6,  1,  0, 99)
+sub              = UnitType('Sub',              20000,   5,  5,  6, 60, canHide = True)
 
 groundUnits = [infantery, mech, recon, apc, antiAir, tank, mediumTank, heavyTank, artillery, rockets, missiles]
 aerialUnits = [fighter, bomber, battleCopter, transportCopter]
@@ -68,6 +68,21 @@
                            fighter, bomber, battleCopter, transportCopter, \
                            battleShip, cruiser, lander, sub])
 
+# Aerial and naval units take some fuel each turn, and they die if they run out of fuel
+for unitType in aerialUnits + navalUnits:
+	unitType.needsFuelToStayAlive = True
+
+fighter.fuelCostPerTurn = 5
+bomber.fuelCostPerTurn = 5
+battleCopter.fuelCostPerTurn = 2
+transportCopter.fuelCostPerTurn = 2
+
+battleShip.fuelCostPerTurn = 1
+cruiser.fuelCostPerTurn = 1
+lander.fuelCostPerTurn = 1
+sub.fuelCostPerTurn = 1
+sub.fuelCostPerTurnWhileHiding = 5
+
 # Infantery can look further when standing on tall mountains
 infantery.overrideVisionForTerrainType(mountain, 4)
 mech.overrideVisionForTerrainType(mountain, 4)

source/core/gameDatabase.py

@@ -119,7 +119,7 @@ def fromStream(self, stream):
 
 		self.unitTypes = []
 		for i in xrange(unitTypesCount):
-			unitType = UnitType('', 0, 0, 0, 0)
+			unitType = UnitType('', 0, 0, 0, 0, 0)
 			unitType.gameDatabase = self
 			readBytesCount += unitType.fromStream(stream[readBytesCount:])
 			self.unitTypes.append(unitType)

source/core/level.py

@@ -146,7 +146,6 @@ def fromStream(self, stream):
 
 		self.buildings = []
 		for i in xrange(buildingsCount):
-			# TODO: Instead of having to create a Building instance with some default type, construct one directly from a stream?
 			building = Building(self.game, self.gameDatabase.getBuildingType(0), 0, Point(0, 0), None)
 			readBytesCount += building.fromStream(stream[readBytesCount:])
 			self.buildings.append(building)

source/core/levelLoaders.py

@@ -76,7 +76,7 @@ def loadFromAwsFile(level, filename):
 			playerData.addBuilding(level.getBuildingAtPosition(Point(x, y)))
 
 
-	# TODO: Load units!
+	# Load units
 	for x in xrange(width):
 		for y in xrange(height):
 			awsUnit = ord(data[readpos]) + 256 * ord(data[readpos + 1])

source/core/pathfinding.py

@@ -48,9 +48,10 @@ def getReachableTiles(level, start, unitType):
 	return [node.position for node in closedList]
 #
 
-# Checks if the specified unit type can follow the given route within one turn. This fu nction only checks the terrain, it does not look for obstructing units.
-def isRouteValid(level, unitType, route):
-	movementPointsLeft = unitType.movementPoints
+# Checks if the specified unit type can follow the given route within one turn. This function only checks the terrain and available fuel,
+# it does not look for obstructing units.
+def isRouteValid(level, unit, route):
+	movementPointsLeft = min(unit.type.movementPoints, unit.fuel)
 	for tile in route:
 		movementPointsLeft -= unitType.movementCostFor(level.getTerrainType(tile))
 		if movementPointsLeft < 0:
@@ -63,14 +64,21 @@ def isRouteValid(level, unitType, route):
 # Returns (success, route, obstructing unit). If there is no obstructing unit, (True, original route, None) is returned.
 # Otherwise, (False, route up to the obstructing unit, obstructing unit) is returned.
 def isRouteUnobstructed(players, route):
-	for i in xrange(len(route)):
+	for i, tile in enumerate(route):
 		for player in players:
-			obstructingUnit = player.getUnitAtPosition(route[i])
+			obstructingUnit = player.getUnitAtPosition(tile)
 			if obstructingUnit != None:
 				return (False, route[:i], obstructingUnit)
 	return (True, route, None)
 #
 
+def fuelCostForRoute(level, unit, route):
+	cost = 0
+	for tile in route:
+		cost += unit.type.movementCostFor(level.getTerrainType(tile))
+	return cost
+#
+
 
 def __tileInNodeList(tile, nodeList):
 	for node in nodeList:

source/core/player.py

@@ -131,7 +131,11 @@ def removeUnit(self, unit):
 			if unit in self.__finishedUnits:
 				self.__finishedUnits.remove(unit)
 
-			self.__visibilityMap.removeVision(unit.position, unit.currentVision(), unit.currentStealthDetectionRange())
+			if not unit.isLoaded():
+				self.__visibilityMap.removeVision(unit.position, unit.currentVision(), unit.currentStealthDetectionRange())
+			
+			for loadedUnit in unit.loadedUnits:
+				self.removeUnit(loadedUnit)
 	#
 
 	# NOTE: Not used? Current approach is to let each command function return a situation update, which is then handled by the caller.
@@ -151,7 +155,19 @@ def startTurn(self):
 		for building in self.buildings:
 			self.money += building.type.income
 
-		# Check all units that can be resupplied or repaired. Units standing on friendly buildings or next to supplying units will be supplied.
+		# First, units that consume fuel per turn will do so.
+		for unit in filter(lambda unit: unit.fuelConsumptionForTurn() > 0, self.units):
+			unitUpdate = situationUpdate.addUnitUpdateForPlayer(self, unit)
+			unit.consumeFuelForTurn()
+			if unit.needsFuelToStayAlive() and unit.fuel <= 0:
+				self.__addLoadedUnitRemovalsToSituationUpdate(unit, situationUpdate)
+				self.removeUnit(unit)
+				unitUpdate.newUnit = None
+		
+		# Check all units that can be resupplied or repaired:
+		# - units standing on friendly buildings
+		# - units standing next to supplying units
+		# - units that are carried by a supplying unit
 		# Units standing on friendly buildings that can repair them will be repaired up to 2 hitpoints (less if not enough funds is available).
 		# Units are checked in the order that they're built.
 		supplyingUnits = filter(Unit.canSupply, self.units)
@@ -160,7 +176,9 @@ def startTurn(self):
 
 			resupply = False
 			if unit.needsResupply():
-				if building != None:
+				if unit.isLoaded() and unit.carriedBy.canSupply():
+					resupply = True
+				elif building != None:
 					resupply = True
 				else:
 					for supplyingUnit in supplyingUnits:
@@ -192,8 +210,6 @@ def startTurn(self):
 						else:
 							break
 
-		# TODO: Subtract fuel for units that use fuel each turn and remove any crashed units (units that ran out of fuel with the setting 'needs-fuel-to-survive')
-		
 		self.__activeUnits = self.units[:]
 		self.__movedUnits = []
 		self.__finishedUnits = []
@@ -203,22 +219,21 @@ def startTurn(self):
 
 		situationUpdate.updateMoneyAmountForPlayer(self, self.money)
 		return (ACTION_RESULT_SUCCESS, situationUpdate)
-		# TODO: Send listeners a situationUpdate! resupplied units + money update!
 	#
 
 	# Returns a (result, situationUpdate) tuple - the situation update is None if the result is invalid.
-	# TODO: Add a utility function that updates the visibility/stealth detection maps and that extracts a list
-	# of no-longer visible and newly visible units/buildings from other players!
 	def moveUnit(self, unitID, route):
 		unit = self.getUnitByID(unitID)
 		if unit == None or not self.unitCanMove(unit):
 			return (ACTION_RESULT_INVALID, None)
 
-		if not isRouteValid(self.game.level, unit.type, route):
+		# If this unit doesn't have sufficient fuel and movement points for the specified route, it's an invalid move.
+		if not isRouteValid(self.game.level, unit, route):
 			return (ACTION_RESULT_INVALID, None)
 
-		# TODO: Also tell what unit obstructed the route, and check if that unit was previously visible - if visible, it's an INVALID move. If invisible, it's a TRAPPED situation!!!
+		# Check up to what point the given route is unobstructed.
 		(unobstructedRoute, route, obstructingUnit) = isRouteUnobstructed(self.game.getOtherPlayers(), route)
+		fuelCost = fuelCostForRoute(self.game.level, unit, route)
 
 		# An empty route is invalid!
 		if len(route) == 0:
@@ -233,7 +248,7 @@ def moveUnit(self, unitID, route):
 
 			# Otherwise, the unit has been trapped.
 			self.__visibilityMap.removeVision(unit.position, unit.currentVision(), unit.currentStealthDetectionRange())
-			unit.moveTo(route[-1])
+			unit.moveTo(route[-1], fuelCost)
 			self.unitIsFinished(unit)
 			self.__visibilityMap.addVision(unit.position, unit.currentVision(), unit.currentStealthDetectionRange())
 
@@ -245,8 +260,10 @@ def moveUnit(self, unitID, route):
 
 		if unitAtDestination != None:
 			if unitAtDestination.canLoad(unit):
+				unit.fuel -= fuelCost
 				return self.__loadUnit(unit, unitAtDestination)
 			elif unit.canCombineWithUnit(unitAtDestination):
+				unit.fuel -= fuelCost
 				return self.__combineUnits(unit, unitAtDestination)
 			else:
 				return (ACTION_RESULT_INVALID, None)
@@ -255,7 +272,7 @@ def moveUnit(self, unitID, route):
 			situationUpdate.addUnitUpdateForPlayer(self, unit)
 
 			self.__visibilityMap.removeVision(unit.position, unit.currentVision(), unit.currentStealthDetectionRange())
-			unit.moveTo(route[-1])
+			unit.moveTo(route[-1], fuelCost)
 			self.__visibilityMap.addVision(unit.position, unit.currentVision(), unit.currentStealthDetectionRange())
 
 			if unit.canActAfterMoving():
@@ -300,7 +317,11 @@ def __combineUnits(self, unit, unitAtDestination):
 
 	def unloadUnit(self, unitID, destination):
 		unit = self.getUnitByID(unitID)
-		if unit == None or unit.carriedBy == None or not self.unitCanMove(unit):
+		if unit == None or not unit.isLoaded() or not self.unitCanMove(unit):
+			return (ACTION_RESULT_INVALID, None)
+		
+		# Units can only be unloaded onto tiles that they can move across, but they must also be able to cross the tile that the transporting unit is on.
+		if not unit.canMoveAcross(self.game.level.getTerrainType(unit.position)) or not unit.canMoveAcross(self.game.level.getTerrainType(destination)):
 			return (ACTION_RESULT_INVALID, None)
 
 		for player in self.game.getAllPlayers():
@@ -367,10 +388,12 @@ def attackUnit(self, unitID, targetID):
 		unit.attackUnit(targetUnit)
 
 		if not targetUnit.alive():
+			self.__addLoadedUnitRemovalsToSituationUpdate(targetUnit, situationUpdate)
 			targetUnit.player.removeUnit(targetUnit)
 			targetUnitUpdate.newUnit = None
 
 		if not unit.alive():
+			self.__addLoadedUnitRemovalsToSituationUpdate(unit, situationUpdate)
 			self.removeUnit(unit)
 			unitUpdate.newUnit = None
 		else:
@@ -456,6 +479,14 @@ def endTurn(self):
 	#
 
 
+	# Recursively adds a unit removal update to the situation update for all transported units (excluding the transporting unit).
+	def __addLoadedUnitRemovalsToSituationUpdate(self, unit, situationUpdate):
+		if unit.isTransportingUnits():
+			for loadedUnit in unit.loadedUnits:
+				situationUpdate.addUnitRemovalForPlayer(loadedUnit.player, loadedUnit)
+				self.__addLoadedUnitRemovalsToSituationUpdate(loadedUnit, situationUpdate)
+	#
+	
 	def unitCanMove(self, unit):
 		return unit in self.__activeUnits
 	#
@@ -521,7 +552,6 @@ def getOldVisibilityMapForSituationUpdate(self, situationUpdate):
 	def toStream(self, hideInformation):
 		return toStream(self.id, \
 		                self.name)
-		# TODO: Also send units and buildings along?
 	#
 
 	# All but the game variable will be deserialized.

source/core/situationUpdate.py

@@ -65,7 +65,6 @@ def addUnitRemovalForPlayer(self, player, unit):
 			return existingUnitUpdate
 	#
 
-	# TODO: Refactor this into the above unit design!!!
 	def addBuildingCreationForPlayer(self, player, building):
 		if building == None:
 			return