def __init__(self):
# environment parameters
self.world = WorldMap()
# number of defenders and intruders
self.dcount = Config.DEFENDER_COUNT
self.icount = Config.INTRUDER_COUNT
self.lock = Value('i', 1)
self.episode_count = Value('i', 0)
self.init_dstates = []
self.init_istates = []
for d in range(self.dcount):
self.init_dstates.append((-5+12*d, 7-3*d, 0))
for i in range(self.icount):
self.init_istates.append((5-2*i, 10+i, 0))
self.dstates = Array(state_structure, self.init_dstates)
self.istates = Array(state_structure, self.init_istates)
self.done = Value('i', 0)
# defenders and intruders
self.defenders = [] # all the defender objectives
self.intruders = []
for i in range(self.icount):
self.intruders.append(ProcessIntruder(self, i, self.istates[i], self.episode_count))
self.intruders[i].daemon = True
for d in range(self.dcount):
self.defenders.append(ProcessDefender(self, d, self.dstates[d], self.episode_count))
self.defenders[d].daemon = True
def __init__(self, main):
# transition from another state
super(GameState, self).__init__(main)
self.loadPlayer()
# Initialize World
self.wl = WorldLoader(config.WORLD_NAME)
# Initialize World Map
self.worldMap = WorldMap(self.wl)
startMap = os.path.join("tygra", "0_0.map")
# Starting map
self.environment = self.wl.getMap(startMap, self.worldMap)
self.currentMap = startMap
# Initialize HUD
self.hud = HUDManager()
#TODO: FIX MUSIC pygame.mixer.init() filename = "worldAmbient.ogg"
GameState.enemyGroup.add(Enemy(self, self.player.rect.left - 50, self.player.rect.top - 50, "skeleton"))
GameState.enemyGroup.sprites()[0].movetowards(self.player.rect.left, self.player.rect.top)
#''' npc_one = NPC(self, 30, 30, "Skeleton") '''
'''TODO: FIX MUSIC
def __init__(self, propsfile):
self.canvas = Tk()
self.props = json.load(open(propsfile))
self.worldMap = WorldMap(propsfile)
self.wg = WorldGrid(self.canvas, self.props, self.worldMap)
self.wg.registerCallBack(self.processEvent)
self.robot = Robot(self.props, self.worldMap)
self.robot.registerSenseCallBack(self.sense)
self.robot.registerMoveCallBack(self.move)
self.rRow = -1
self.rCol = -1
self.randomizeRobotPosition()
self.robot.sense()
self.shadeSquares()
def generatemap(level, key):
map = WorldMap()
map.playerPosX = WorldMapSize / 2
map.playerPosY = WorldMapSize / 2
map.exitPosX = WorldMapSize
map.exitPosY = WorldMapSize / 2
generateObstacles(map, level)
map.worldmap[map.playerPosX][map.playerPosY] = 'P'
map.worldmap[map.exitPosX][map.exitPosY] = 'E'
if key:
col = map.worldmap[WorldMapSize - 5]
x = len(col)/2
col[x] = 'K'
col = map.worldmap[WorldMapSize - 3]
for i, _ in enumerate(col):
if i == len(col) / 2:
col[i] = 'D'
else:
col[i] = 'W'
return map
def run(self):
"""
WorldMap creation, Beast and food positioning, game mechanics and final
creation of ranking list
also calling of the Visualisation and beastAnalytics
"""
self.running = True
if self.useNetworking:
self.server.prepareGameStart()
# ensure that at least configured minimum number of beasts are registered:
availableBeasts = ['NikolaisBeast()', 'SamysBeast()', 'Team8Beast()']
while (self.gameSignOnPossible() and len(self.beastObjectMap) < Config.__getMinimumBeasts__()):
self.registerBeast(eval(random.choice(availableBeasts)))
#final beastObjectMap gets passed to beastAnalytics
if self.useBeastAnalytics:
self.beastAnalytics.setBeastObjectMap(self.beastObjectMap)
self.gameStarted = True
#size = number of beast * value of fieldFactor(Config) * 25(beast-View)
size = len(self.beastObjectMap) * Config.__getFieldFactor__() * 25
self.worldMap = WorldMap(size, self)
self.worldMap.placeBeasts()
self.worldMap.placeStartFood()
#calls outsourced round mechanic
self.doRounds()
self.gameFinished = True
for beastObject in self.beastObjectMap.values():
#this sends the last ten rounds to client after game is finished
beastObject.beast.bewege(str(beastObject.energy) + ';' + 'Ende' + ';' + self.worldMap.getLastTenRoundsAsString() + ';')
self.log.info(self.getRankingList())
#BeastAnalytics
if self.useBeastAnalytics and self.enableUrwidVisualisation == False:
for i in range(len(self.getStatisticForBeast)):
self.log.info(self.beastAnalytics.getStatistic(self.getStatisticForBeast[i]))
self.beastAnalytics.getStatisticFile(self.getStatisticForBeast[i])
# Added to stop Thread
self.stop()
def __init__(self,propsfile): self.canvas = Tk() self.props = json.load(open(propsfile)) self.worldMap = WorldMap(propsfile) self.wg = WorldGrid(self.canvas,self.props,self.worldMap) self.wg.registerCallBack(self.processEvent) self.robot = Robot(self.props,self.worldMap) self.robot.registerSenseCallBack(self.sense) self.robot.registerMoveCallBack(self.move) self.rRow = -1 self.rCol = -1 self.randomizeRobotPosition() self.robot.sense() self.shadeSquares()
import time
import sys
import random
from PyQt5.QtWidgets import QApplication
sys.path.insert(0, ".")
from WorldMap import WorldMap
from WorldUI import WorldUI
from WorldUnits import UnitOrganic
from WorldProtocols import CreateUnit
if __name__ == "__main__":
app = QApplication(sys.argv)
wmap = WorldMap(5, 5, "#000")
wmap.append_protocol(CreateUnit(2, 2, UnitOrganic()))
wui = WorldUI(wmap)
app.exec_()
class GameState(State):
'''
State for game playing mode.
'''
bgGroup = pygame.sprite.OrderedUpdates()
playerGroup = pygame.sprite.RenderPlain()
guiGroup = pygame.sprite.OrderedUpdates()
enemyGroup = pygame.sprite.RenderPlain()
weaponGroup = pygame.sprite.RenderPlain()
player = None
terrainLayer = None
cachedPathGraph = None
curPathGraph = None
def getPlayer():
assert(player != None)
return GameState.player
@staticmethod
def getCurrentAtMap():
assert(GameState.terrainLayer != None)
return GameState.terrainLayer.getMap().getAtLayer()
def __init__(self, main):
# transition from another state
super(GameState, self).__init__(main)
self.loadPlayer()
# Initialize World
self.wl = WorldLoader(config.WORLD_NAME)
# Initialize World Map
self.worldMap = WorldMap(self.wl)
startMap = os.path.join("tygra", "0_0.map")
# Starting map
self.environment = self.wl.getMap(startMap, self.worldMap)
self.currentMap = startMap
# Initialize HUD
self.hud = HUDManager()
#TODO: FIX MUSIC pygame.mixer.init() filename = "worldAmbient.ogg"
GameState.enemyGroup.add(Enemy(self, self.player.rect.left - 50, self.player.rect.top - 50, "skeleton"))
GameState.enemyGroup.sprites()[0].movetowards(self.player.rect.left, self.player.rect.top)
#''' npc_one = NPC(self, 30, 30, "Skeleton") '''
'''TODO: FIX MUSIC
pygame.mixer.init()
filename = "worldAmbient.ogg"
path = os.path.join(util.GAME_SOUNDS, filename)
path = util.filepath(path)
pygame.mixer.music.load(path)
pygame.mixer.music.play()
'''
def __del__(self):
# transition to another state
super(GameState, self).__del__()
def loadPlayer(self):
self.player = Player(self)
self.player.mapPos = [0,0]
GameState.playerGroup.add(self.player)
def update(self, clock):
super(GameState, self).update(clock)
GameState.guiGroup.update(clock)
enemies = [enemy for enemy in GameState.enemyGroup]
surfaces = [surface for surface in self.environment.atGroup]
GameState.playerGroup.update(clock, self.player, enemies, surfaces)
GameState.enemyGroup.update(clock, self.player, enemies, surfaces)
GameState.weaponGroup.update(clock, self.player, enemies, surfaces)
self.worldMap.update(clock)
self.hud.update(clock, self.player)
def handleEvent(self):
super(GameState, self).handleEvent()
self.sudoNext()
# handle mouse
mousePos = Vector2(pygame.mouse.get_pos())
self.player.orient(mousePos)
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
if pygame.mouse.get_pressed()[0]:
self.player.swingSword()
if pygame.mouse.get_pressed()[2]:
self.player.useMagic()
def sudoNext(self):
#Used for debugging,
from config import keyboard, keymap
mmap = None
if keyboard.downup(keymap.DUP):
mmap = self.wl.north[self.currentMap]
elif keyboard.downup(keymap.DDOWN):
mmap = self.wl.south[self.currentMap]
elif keyboard.downup(keymap.DLEFT):
mmap = self.wl.west[self.currentMap]
elif keyboard.downup(keymap.DRIGHT):
mmap = self.wl.east[self.currentMap]
if mmap is not None:
self.currentMap = mmap
print "MAP: ", mmap
self.environment = self.wl.getMap(mmap, self.worldMap)
# Added for debugging purposes. Remove when not needed
print "MAP: ", mmap
def nextMap(self, direction, pos):
# print "moving to: " + direction + " via: " + str(pos)
mmap = None
if direction == 'up':
mmap = self.wl.north[self.currentMap]
# update player mapPos
self.player.mapPos[1] -= 1
# position player at bottom minus almost half a tile
if mmap is not None:
self.player.setPos(pos[0], config.HEIGHT - 17)
elif direction == 'down':
mmap = self.wl.south[self.currentMap]
self.player.mapPos[1] += 1
if mmap is not None:
self.player.setPos(pos[0], 17)
elif direction == 'right':
self.player.mapPos[0] += 1
mmap = self.wl.east[self.currentMap]
if mmap is not None:
self.player.setPos(64 + 17, pos[1]) # just not touching the hud
elif direction == 'left':
self.player.mapPos[0] -= 1
mmap = self.wl.west[self.currentMap]
if mmap is not None:
self.player.setPos(config.WIDTH - (64 + 17), pos[1])
if mmap is not None:
self.currentMap = mmap
self.environment = self.wl.getMap(mmap, self.worldMap)
# Added for debugging purposes. Remove when not needed
print "MAP: ", mmap
GameState.enemyGroup.empty()
GameState.enemyGroup.add(Enemy(self, randrange(1, config.WIDTH), randrange(1, config.HEIGHT), "skeleton"))
GameState.enemyGroup.add(Enemy(self, randrange(1, config.WIDTH), randrange(1, config.HEIGHT), "skeleton"))
GameState.enemyGroup.add(Enemy(self, randrange(1, config.WIDTH), randrange(1, config.HEIGHT), "skeleton"))
GameState.weaponGroup.empty()
def draw(self):
#draw environment
self.environment.drawBackground(self.main.screen);
# draw player
GameState.playerGroup.draw(self.main.screen)
# draw enemies
GameState.enemyGroup.draw(self.main.screen)
# draw weapons
GameState.weaponGroup.draw(self.main.screen)
# draw gui
self.hud.draw(self.main.screen)
# draw foreground
self.environment.drawForeground(self.main.screen)
# draw world map
self.worldMap.draw(self.main.screen)
# flip screen
super(GameState, self).draw()
class Game(threading.Thread):
"""
global Game class
here will your beast be registered and seated on WorldMap after it has been
created (dependend on the number of beasts)
"""
def __init__(self, getStatisticForBeast=None):
"""
constructor --> initialising Variables
@param getStatisticForBeast List: insert a tupel of chars ('a','b')
"""
threading.Thread.__init__(self)
self.server = None
self.gui = None
self.beastObjectMap = {}
self.rankingList = []
self.worldMap = None
self.foodCounter = 0
self.enableUrwidVisualisation = Config.__getUseUrwidVisualisation__()
self.useNetworking = Config.__getUseNetworking__()
self.startTimeMillis = time.time() + Config.__getStartInSeconds__()
self.startTime = time.ctime(self.startTimeMillis)
self.roundCounter = 0
self.getStatisticForBeast = getStatisticForBeast
self.useBeastAnalytics = True if(getStatisticForBeast) else False
self.deadBeasts = 0
self.urwidRoundDelay = Config.__getUrwidRoundDelay__() / 1000.0
self.gameStarted = False
self.gameFinished = False
self.running = False
self.log = logging.getLogger('beast-arena-logging')
if self.enableUrwidVisualisation:
self.useBeastAnalytics = True
self.getStatisticForBeast = ''
self.beastAnalytics = BeastAnalytics() if(self.useBeastAnalytics) else False
def registerBeast(self, beast):
"""
registers a Beast instance: give it a name, create a BeastObject
instance and store it in internal dictionary 'beastObjectMap'.
This method is called when a new Beast joins.
@param beast Beast: is the clients beast
@return returns the beast's name
"""
#recursive call for every beast in passed beast array
if isinstance(beast,list):
for b in beast:
self.registerBeast(b)
if self.gameSignOnPossible():
name = string.ascii_letters[len(self.beastObjectMap)]
else:
self.log.warning('registered beast limit reached')
return
beastObject = BeastObject(beast, name, self.beastAnalytics)
self.rankingList.append(None) # generates proper length of rankingList
self.beastObjectMap[name] = beastObject
self.log.info("beast " + name + " registered")
return name
def getStartInSeconds(self):
return str(self.startTimeMillis-time.time())
def run(self):
"""
WorldMap creation, Beast and food positioning, game mechanics and final
creation of ranking list
also calling of the Visualisation and beastAnalytics
"""
self.running = True
if self.useNetworking:
self.server.prepareGameStart()
# ensure that at least configured minimum number of beasts are registered:
availableBeasts = ['NikolaisBeast()', 'SamysBeast()', 'Team8Beast()']
while (self.gameSignOnPossible() and len(self.beastObjectMap) < Config.__getMinimumBeasts__()):
self.registerBeast(eval(random.choice(availableBeasts)))
#final beastObjectMap gets passed to beastAnalytics
if self.useBeastAnalytics:
self.beastAnalytics.setBeastObjectMap(self.beastObjectMap)
self.gameStarted = True
#size = number of beast * value of fieldFactor(Config) * 25(beast-View)
size = len(self.beastObjectMap) * Config.__getFieldFactor__() * 25
self.worldMap = WorldMap(size, self)
self.worldMap.placeBeasts()
self.worldMap.placeStartFood()
#calls outsourced round mechanic
self.doRounds()
self.gameFinished = True
for beastObject in self.beastObjectMap.values():
#this sends the last ten rounds to client after game is finished
beastObject.beast.bewege(str(beastObject.energy) + ';' + 'Ende' + ';' + self.worldMap.getLastTenRoundsAsString() + ';')
self.log.info(self.getRankingList())
#BeastAnalytics
if self.useBeastAnalytics and self.enableUrwidVisualisation == False:
for i in range(len(self.getStatisticForBeast)):
self.log.info(self.beastAnalytics.getStatistic(self.getStatisticForBeast[i]))
self.beastAnalytics.getStatisticFile(self.getStatisticForBeast[i])
# Added to stop Thread
self.stop()
def doRounds(self):
"""
round mechanic -runs until maxRounds are reached or only 1 beast remains
random food positioning and calling of move() for every beast
"""
while (self.roundCounter < Config.__getMaxRounds__() and \
self.deadBeasts < len(self.beastObjectMap) - 1 and self.running):
#Generate/Save WorldMap state of last round
self.foodCounter = 0 #needed for food arrangement
for beastObject in self.beastObjectMap.values():
self.arrangeFoodEveryRound()
#calls move() for every beast, also if it's already dead
beastObject.move(self.worldMap)
if self.enableUrwidVisualisation and beastObject.energy > 0:
time.sleep(self.urwidRoundDelay)
self.arrangeFoodEveryRound(whileRoundState=False)
self.worldMap.insertWorldToLastTenRoundsAsString()
self.roundCounter += 1
#BeastAnalytics
if self.useBeastAnalytics:
self.beastAnalytics.nextRound()
def arrangeFoodEveryRound(self, whileRoundState=True):
"""
arranges the correct number of food items every round
@param whileRoundState (default=True) marks if this method is called
while or at the end of a round
"""
if whileRoundState:
#calls placeFoodItem once per per 3/5 beast
rnd = random.randint(1, len(self.beastObjectMap))
if rnd in range(len(self.beastObjectMap) * 3 / 5) and \
self.foodCounter < len(self.beastObjectMap) * 3 / 5:
self.worldMap.placeFoodItem()
self.foodCounter += 1
else:
# is called if not enough food has been rained
if self.foodCounter < len(self.beastObjectMap) * 3 / 5:
counter = 0
while counter in range(len(self.beastObjectMap) * 3 / 5 - self.foodCounter):
self.worldMap.placeFoodItem()
counter += 1
def getBeastByName(self, name):
"""
@param name String: beast name
@return socket, srcAddr: Returns client-socket, client-source-address of given beast-name from BeastObjectMap
"""
beast = self.beastObjectMap.get(name)
return beast.socket, beast.srcAddr
def gameSignOnPossible(self):
"""
Checks if game is full or has already started
@return Boolean
"""
if not(self.gameStarted) and (len(self.beastObjectMap) < len(string.ascii_letters)):
return True
return False
def getRankingList(self):
"""
calculates the ranking of the beasts depending on their time of death or
their remaining energy
@return String: the ranking list of the beasts
"""
survivedBeasts = []
for beast in self.beastObjectMap.values():
if beast.alive:
survivedBeasts.append(beast)
tmp = sorted(survivedBeasts, key=lambda BeastObject:BeastObject.energy, reverse=True)
for i in range(len(tmp)):
self.rankingList[i] = tmp[i]
#Create return string
dots=lambda x: x>=9 and'.'*12 or'.'*13
returnString = 'Ranking:\n'
for i in range(len(self.rankingList)):
returnString += str(i + 1) + str(dots(i)) + str(
self.rankingList[i]) + ' with ' + str(
self.rankingList[i].energy) + ' energy\n'
return returnString
def markDeadBeast(self, name):
"""
marks beasts who died in a fight as dead and writes them in the
rankingList (LIFO)
@param name String: puts in the name of the dead beast
"""
self.rankingList[len(self.rankingList) - 1 - self.deadBeasts] = self.beastObjectMap[name]
self.deadBeasts += 1
def setupUrwid(self):
"""
checks if urwid should be used and starts its loops
"""
if self.enableUrwidVisualisation:
#update content Loop:
self.gui.start()
#main urwid loop:
self.gui.runLoop()
def stop(self):
"""
stops game thread
"""
self.running = False
class Simulation:
def __init__(self, propsfile):
self.canvas = Tk()
self.props = json.load(open(propsfile))
self.worldMap = WorldMap(propsfile)
self.wg = WorldGrid(self.canvas, self.props, self.worldMap)
self.wg.registerCallBack(self.processEvent)
self.robot = Robot(self.props, self.worldMap)
self.robot.registerSenseCallBack(self.sense)
self.robot.registerMoveCallBack(self.move)
self.rRow = -1
self.rCol = -1
self.randomizeRobotPosition()
self.robot.sense()
self.shadeSquares()
def randomizeRobotPosition(self):
# randomly select the starting robot location --
# do this until a valid square (i.e., not a wall) is
# selected
found = False
while (found == False):
row = random.randint(0, self.worldMap.nRows - 1)
col = random.randint(0, self.worldMap.nCols - 1)
if (self.worldMap.isValidSquare(row, col)):
found = True
self.rRow = row
self.rCol = col
def move(self, dirc):
row = self.rRow
col = self.rCol
if (dirc == 1): # NORTH
row -= 1
elif (dirc == 2): # EAST
col += 1
elif (dirc == 4): # SOUTH
row += 1
elif (dirc == 8): # WEST
col -= 1
else:
print "ERROR: Invalid move direction"
self.rRow = row
self.rCol = col
def sense(self):
# NORTH
meas = 0
if (self.worldMap.isValidSquare(self.rRow - 1, self.rCol)):
meas = meas | 1
# EAST
if (self.worldMap.isValidSquare(self.rRow, self.rCol + 1)):
meas = meas | 2
# SOUTH
if (self.worldMap.isValidSquare(self.rRow + 1, self.rCol)):
meas = meas | 4
# WEST
if (self.worldMap.isValidSquare(self.rRow, self.rCol - 1)):
meas = meas | 8
return meas
def run(self):
self.wg.draw()
self.shadeSquares()
self.wg.drawRobot(self.rRow, self.rCol)
self.canvas.geometry(self.props["windowDimensions"])
self.canvas.mainloop()
def shadeSquares(self):
probabilities = self.robot.mapProbabilities
for i in range(0, len(probabilities)):
for j in range(0, len(probabilities[i])):
if (self.worldMap.isWall(i, j) == False):
if (self.robot.mapProbabilities[i][j] > 0):
# 0 is black, 255 is white
c = 125 - math.floor(
self.robot.mapProbabilities[i][j] * 125.0)
#c = 255 - int(self.robot.mapProbabilities[i][j]*255.0)
cstr = "#%02x%02x%02x" % (0, c, 0)
self.wg.shadeSquare(i, j, cstr)
else:
cstr = "#%02x%02x%02x" % (255, 255, 255)
self.wg.shadeSquare(i, j, cstr)
def processEvent(self, event):
self.robot.move()
self.robot.sense()
self.shadeSquares()
self.wg.drawRobot(self.rRow, self.rCol)
class Simulation: def __init__(self,propsfile): self.canvas = Tk() self.props = json.load(open(propsfile)) self.worldMap = WorldMap(propsfile) self.wg = WorldGrid(self.canvas,self.props,self.worldMap) self.wg.registerCallBack(self.processEvent) self.robot = Robot(self.props,self.worldMap) self.robot.registerSenseCallBack(self.sense) self.robot.registerMoveCallBack(self.move) self.rRow = -1 self.rCol = -1 self.randomizeRobotPosition() self.robot.sense() self.shadeSquares() def randomizeRobotPosition(self): # randomly select the starting robot location -- # do this until a valid square (i.e., not a wall) is # selected found = False while (found == False): row = random.randint(0,self.worldMap.nRows-1) col = random.randint(0,self.worldMap.nCols-1) if(self.worldMap.isValidSquare(row,col)): found = True self.rRow = row self.rCol = col def move(self,dirc): row = self.rRow col = self.rCol if(dirc == 1): # NORTH row -= 1 elif(dirc == 2): # EAST col += 1 elif(dirc == 4): # SOUTH row += 1 elif(dirc == 8): # WEST col -= 1 else: print "ERROR: Invalid move direction" self.rRow = row self.rCol = col def sense(self): # NORTH meas = 0 if(self.worldMap.isValidSquare(self.rRow-1,self.rCol)): meas = meas | 1 # EAST if(self.worldMap.isValidSquare(self.rRow,self.rCol+1)): meas = meas | 2 # SOUTH if(self.worldMap.isValidSquare(self.rRow+1,self.rCol)): meas = meas | 4 # WEST if(self.worldMap.isValidSquare(self.rRow,self.rCol-1)): meas = meas | 8 return meas def run(self): self.wg.draw() self.shadeSquares() self.wg.drawRobot(self.rRow,self.rCol) self.canvas.geometry(self.props["windowDimensions"]) self.canvas.mainloop() def shadeSquares(self): probabilities = self.robot.mapProbabilities for i in range(0,len(probabilities)): for j in range(0,len(probabilities[i])): if(self.worldMap.isWall(i,j)==False): if(self.robot.mapProbabilities[i][j]>0): # 0 is black, 255 is white c = 125 - math.floor(self.robot.mapProbabilities[i][j]*125.0) #c = 255 - int(self.robot.mapProbabilities[i][j]*255.0) cstr = "#%02x%02x%02x" % (0,c,0) self.wg.shadeSquare(i,j,cstr) else: cstr = "#%02x%02x%02x" % (255,255,255) self.wg.shadeSquare(i,j,cstr) def processEvent(self,event): self.robot.move() self.robot.sense() self.shadeSquares() self.wg.drawRobot(self.rRow,self.rCol)
