- implemented basic situation update system (no filtering for fog-of-war yet, no broadcasting to clients)

Author: p.witvoet

documentation/notes.txt

@@ -106,4 +106,65 @@ In normal mode, just send all units, all data.
 Oh, situation update should also tell the player how much money he has.
 
 
-A full situation update, towards observers, should tell them how much money every player has.
+A full situation update, towards observers, should tell them how much money every player has.
+
+
+
+
+
+
+
+
+
+
+server: has multiple clientPlayerControllers (RENAME to clientController!)
+
+
+
+right now, the game tells a player that it's his turn.
+
+it's clientPlayerController is listening for callbacks,
+and will be informed when it can start - it will send
+a message to it's client.
+
+clientPlayerControllers react to AI client input by
+calling methods on their player, and they send a message
+back based on the result.
+
+The main code will intercept incoming messages however,
+if they're sent by a client who can't move (it's not his turn yet).
+
+
+the player functions will return a (result, Diff) tuple,
+where Diff is a SituationDiff object that contains a number
+of lists: added units, modified units, removed units.
+
+NOTE: How to deal with changed state? only position updates and hiding/
+unhiding are particularly important, hmm? we need to know the previous
+state somehow!!!
+
+perhaps only keep track of previous and current position,
+and let clients do the rest of the diffing? so clients are
+only updated about units that have disappeared from their
+original location and have reappeared somewhere else (or
+have disappeared only, or appeared only).
+
+
+
+So, build a UnitUpdate object as a return value for every command.
+NOTE: Some commands affect multiple units! Attack commands, for example,
+can leave both units damaged (but not moved). Movement commands can
+move multiple units at once (transported units)!
+
+
+
+
+The server code receives a SituationUpdate from the command that it called,
+and it then asks the game to give a player-specific SituationUpdate for
+each player - which it will send to those player clients. The unfiltered
+SituationUpdate will be sent to all observers.
+
+This player-specific SituationUpdate should include all opponent units/buildings
+that have become visible or hidden! I should write a utility function in the
+Player class for this - one that updates the visibility/stealth detection maps
+and that extracts a list of new visible and no-longer-visible units/buildings.

run server.bat

@@ -2,6 +2,6 @@ TITLE AI Wars - Server
 
 CD source
 
-run_server.py localhost 7777 central_island.aws aiwars.py
+python run_server.py localhost 7777 river_bridges.aws aiwars.py
 
 PAUSE

source/core/building.py

@@ -1,18 +1,18 @@
+import copy
 from buildingType import *
 from serialization import *
 
 
 class Building(object):
-	def __init__(self, game, gameDatabase, type, id, position, player):
+	def __init__(self, game, type, id, position, player):
 		self.game = game
-		self.gameDatabase = gameDatabase
 		self.type = type
 		self.id = id
 		self.position = position
 
 		self.player = player
 
-		self.capturePoints = self.type.maxCapturePoints
+		self.capturePoints = self.type.maxCapturePoints if self.type != None else 20
 	#
 
 	def canBuild(self, unitType):
@@ -33,22 +33,31 @@ def isCritical(self):
 
 	#Some units can capture buildings. This function returns true if the building has been fully captured.
 	def capture(self, amount):
-		self.capturePoints = max(0, self.capturePoints - amount)
+		self.capturePoints = int(max(0, self.capturePoints - amount))
 		return self.capturePoints == 0
 	#
 
 	def restoreCapturePoints(self):
 		self.capturePoints = self.type.maxCapturePoints
 	#
 
+	# Special method, called when making a shallow copy
+	def __copy__(self):
+		building = Building(self.game, self.type, self.id, copy.copy(self.position), self.player)
+		
+		building.capturePoints = self.capturePoints
+		
+		return building
+	#
+	
 
 	# Serialization
-	def toStream(self):
-		playerID = -1
+	def toStream(self, hideInformation):
+		playerID = 0
 		if self.player != None:
 			playerID = self.player.id
 
-		return toStream(self.gameDatabase.getIndexOfBuildingType(self.type), \
+		return toStream(self.game.gameDatabase.getIndexOfBuildingType(self.type), \
 		                self.id, \
 		                self.position.x, \
 		                self.position.y, \
@@ -57,16 +66,16 @@ def toStream(self):
 	#
 
 	def fromStream(self, stream):
-		(self.type, \
+		(typeIndex, \
 		 self.id, \
 		 self.position.x, \
 		 self.position.y, \
-		 self.player, \
+		 playerID, \
 		 self.capturePoints, \
 		 readBytesCount) = fromStream(stream, int, int, int, int, int, int)
 
-		self.type = self.gameDatabase.getBuildingType(self.type)
-		self.player = self.game.getPlayerByID(self.player)
+		self.type = self.game.gameDatabase.getBuildingType(typeIndex)
+		self.player = self.game.getPlayerByID(playerID)
 
 		return readBytesCount
 	#

source/core/buildingUpdate.py

@@ -0,0 +1,59 @@
+import copy
+from building import *
+from serialization import *
+
+
+# A building update stores a copy of the building and a reference to it.
+# So if you create a BuildingUpdate before modifying the building,
+# the update will allow you to compare between the previous and current state.
+# For newly captured building, just pass None, and set newBuilding manually.
+# Likewise, for lost buildings, pass None and set oldBuilding manually.
+class BuildingUpdate(object):
+	def __init__(self, game, building):
+		self.game = game
+		
+		self.oldBuilding = copy.copy(building) if building != None else None
+		self.newBuilding = building
+	#
+	
+	def buildingID(self):
+		return self.oldBuilding.id if self.oldBuilding != None else self.newBuilding.id
+	#
+	
+	
+	def toStream(self, hideInformation):
+		stream = toStream(self.oldBuilding.id if self.oldBuilding != None else 0, self.newBuilding.id if self.newBuilding != None else 0)
+		
+		stream += self.__buildingToStream(self.oldBuilding, hideInformation)
+		stream += self.__buildingToStream(self.newBuilding, hideInformation)
+		
+		return stream
+	#
+	
+	def __buildingToStream(self, building, hideInformation):
+		if building == None:
+			return ''
+		else:
+			return building.toStream(hideInformation)
+	#
+	
+	def fromStream(self, stream):
+		oldBuildingID, newBuildingID, totalReadBytesCount = fromStream(stream, int, int)
+		
+		self.oldBuilding, readBytesCount = self.__buildingFromStream(stream[totalReadBytesCount:], oldBuildingID)
+		totalReadBytesCount += readBytesCount
+		self.newBuilding, readBytesCount = self.__buildingFromStreamFromStream(stream[totalReadBytesCount:], newBuildingID)
+		totalReadBytesCount += readBytesCount
+		
+		return totalReadBytesCount
+	#
+	
+	def __buildingFromStream(self, stream, buildingID):
+		if buildingID == 0:
+			return (None, 0)
+		else:
+			building = Building(self.game.gameDatabase, None, 0, Point(0, 0), None)
+			readBytesCount = building.fromStream(stream)
+			return (building, readBytesCount)
+	#
+#

source/core/clientPlayerController.py

@@ -27,12 +27,23 @@ def setPlayer(self, player):
 	#
 
 
+	#================================================================================
+	# Messages sent to the client
+	
+	# Player callbacks
 	def onPlayerStartsTurn(self, player):
-		self.client.sendMessage(STC_START_TURN, '')
+		if player == self.player:
+			self.client.sendMessage(STC_START_TURN, '')
 	#
 
 	def onPlayerEndsTurn(self, player):
-		self.client.sendMessage(STC_END_TURN, '')
+		if player == self.player:
+			self.client.sendMessage(STC_END_TURN, '')
+	#
+	
+	def sendSituationUpdate(self, players, level):
+		# TODO!!!
+		pass
 	#
 
 
@@ -68,55 +79,56 @@ def onMoveCommand(self, message):
 		(unitID, route, readBytesCount) = fromStream(message, int, list)
 		route = self.__intListToPointList(route)
 
-		result = self.player.moveUnit(unitID, route)
+		(result, situationUpdate) = self.player.moveUnit(unitID, route)
 		self.client.sendMessage(STC_RESULT, resultToMessage[result])
+		self.client.sendMessage(STC_SITUATION_UPDATE, '''TODO!!!''') # Check if new units became visible!
 	#
 
 	def onUnloadCommand(self, message):
 		(unitID, destinationX, destinationY, readBytesCount) = fromStream(message, int, int, int)
 		destination = Point(destinationX, destinationY)
 
-		result = self.player.unloadUnit(unitID, destination)
+		(result, situationUpdate) = self.player.unloadUnit(unitID, destination)
 		self.client.sendMessage(STC_RESULT, resultToMessage[result])
 	#
 
 	def onSupplySurroundingUnitsCommand(self, message):
 		(unitID, readBytesCount) = fromStream(message, int)
 
-		result = self.player.supplySurroundingUnits(unitID)
+		(result, situationUpdate) = self.player.supplySurroundingUnits(unitID)
 		self.client.sendMessage(STC_RESULT, resultToMessage[result])
 	#
 
 	def onAttackUnitCommand(self, message):
 		(unitID, targetID, readBytesCount) = fromStream(message, int, int)
 
-		result = self.player.attackUnit(unitID, targetID)
+		(result, situationUpdate) = self.player.attackUnit(unitID, targetID)
 		self.client.sendMessage(STC_RESULT, resultToMessage[result])
 	#
 
 	def onBuildUnitCommand(self, message):
 		(buildingID, unitTypeID, readBytesCount) = fromStream(message, int, int)
 
-		result = self.player.buildUnit(buildingID, unitTypeID)
+		(result, situationUpdate) = self.player.buildUnit(buildingID, unitTypeID)
 		self.client.sendMessage(STC_RESULT, resultToMessage[result])
 	#
 
 	def onCaptureBuildingCommand(self, message):
 		(unitID, readBytesCount) = fromStream(message, int)
 
-		result = self.player.captureBuilding(unitID)
+		(result, situationUpdate) = self.player.captureBuilding(unitID)
 		self.client.sendMessage(STC_RESULT, resultToMessage[result])
 	#
 
 	def onHideUnitCommand(self, message):
 		(unitID, hide, readBytesCount) = fromStream(message, int, bool)
 
-		result = self.player.hideUnit(unitID, hide)
+		(result, situationUpdate) = self.player.hideUnit(unitID, hide)
 		self.client.sendMessage(STC_RESULT, resultToMessage[result])
 	#
 
 	def onEndTurnCommand(self, message):
-		result = self.player.endTurn()
+		(result, situationUpdate) = self.player.endTurn()
 		self.client.sendMessage(STC_RESULT, resultToMessage[result])
 	#
 

source/core/game.py

@@ -27,11 +27,7 @@ def removePlayer(self, player):
 	#
 
 	def getOtherPlayers(self, player):
-		otherPlayers = []
-		for otherPlayer in self.players:
-			if otherPlayer is not player:
-				otherPlayers.append(otherPlayer)
-		return otherPlayers
+		return [p for p in self.players if p != player]
 	#
 
 	def getAllPlayers(self):

source/core/guid.py

@@ -2,6 +2,7 @@
 
 __guid = 0
 
+# Never return 0 - this allows using 0 as a special case!
 def getGUID():
 	global __guid
 	__guid += 1

source/core/level.py

@@ -58,7 +58,7 @@ def setTileData(self, tileData):
 				self.terrain[y][x] = terrainType
 
 				if terrainType.buildingType != None:
-					self.addBuilding(Building(self.game, self.gameDatabase, terrainType.buildingType, getGUID(), Point(x, y), None))
+					self.addBuilding(Building(self.game, terrainType.buildingType, getGUID(), Point(x, y), None))
 	#
 
 	def addBuilding(self, building):
@@ -114,7 +114,7 @@ def toStream(self):
 
 		buildingsStream = ''
 		for building in self.buildings:
-			buildingsStream += building.toStream()
+			buildingsStream += building.toStream(False)
 
 		return toStream(self.name, \
 		                self.author, \
@@ -138,7 +138,7 @@ 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, self.gameDatabase.getBuildingType(0), 0, Point(0, 0), None)
+			building = Building(self.game, self.gameDatabase.getBuildingType(0), 0, Point(0, 0), None)
 			readBytesCount += building.fromStream(stream[readBytesCount:])
 			self.buildings.append(building)
 

source/core/messageTypes.py

@@ -15,6 +15,7 @@
 CTS_CAPTURE_BUILDING          = chr(8)   # Captures a building
 CTS_HIDE_UNIT                 = chr(9)   # Hides or unhides the unit
 CTS_END_TURN                  = chr(10)  # Signals that this client is done with it's turn
+# TODO: Add a 'destroy unit' command?
 
 
 #================================================================================
@@ -29,14 +30,13 @@
 # While the game is going
 STC_START_TURN                = chr(4)   # Tells a client that it is it's turn
 STC_END_TURN                  = chr(5)   # Tells a client that it's turn is over
-STC_SITUATION_UPDATE          = chr(6)   # Sends the latest situation data to the client - only what this client can see!
+STC_SITUATION_UPDATE          = chr(6)   # Sends situation changes to the client - only changes that this client can see! (observer clients can always see every change)
 STC_RESULT                    = chr(7)   # Sends the result of the latest command, see SERVER_RESULT_...
 STC_END_GAME                  = chr(8)   # Informs clients that the game is over
 
 # While the game is going, observer-specific messages
 STC_PLAYER_STARTED_TURN       = chr(9)   # Tells an observer which players turn has started
 STC_PLAYER_ENDED_TURN         = chr(10)  # Tells an observer which players turn has ended
-STC_FULL_SITUATION_UPDATE     = chr(11)  # Complete situation update - observers know everything
 
 
 #================================================================================