def ScanForDevices(self):
props = Properties()
# Power off:
print "Powering off..."
props.PowerOff()
time.sleep(5)
# Power on:
print "Powering back on..."
props.PowerOn()
adapter1 = self.bus.get(self.busName, self.path)
adapter1.StartDiscovery()
for i in range(10, 0, -1):
print(i)
time.sleep(1)
# List devices:
objMgr = ObjectManager()
# objMgr.ListDevices()
# List addresses:
devices = objMgr.GetAddresses()
for address in devices:
print "%s\t%s" % (address, devices[address]['Name'])
def returnFirstPairedDevice(self):
# Find all devices that are paired:
pairedDevices = []
objMgr = ObjectManager()
devices = objMgr.GetAddresses()
for address in devices:
if devices[address]['Paired']:
return address
return None
def returnPairedDevices(self):
# Find all devices that are paired:
pairedDevices = []
objMgr = ObjectManager()
devices = objMgr.GetAddresses()
for address in devices:
if devices[address]['Paired']:
pairedDevices.append(address)
return pairedDevices
def pairDevice(self, addressString):
objMgr = ObjectManager()
devices = objMgr.GetAddresses()
newPath = objMgr.DoesDeviceExist(0, addressString)
if newPath != None:
print "Attempting to pair device at path: %s" % newPath
device = self.bus.get(self.busName, newPath)
device.Pair()
else:
print "Unable to find device at: %s" % addressString
class Scene(object):
'''Base Class'''
def __init__(self):
self.manager = ObjectManager()
self.simulation = Simulation()
def init(self):
pass
def update(self, dt):
#log.info("Updating the scene")
# first reset all forces on the objects
self.manager.reset_forces()
# apply forces on the objects
self.solve()
# now update the objects
self.manager.update(dt)
def draw(self):
self.manager.draw()
def reset(self):
'''Reset the scene (just objects for now)'''
self.manager.reset_all()
def RemoveDevice(self, deviceAddress):
objMgr = ObjectManager()
qpath = objMgr.DoesDeviceExist(0, deviceAddress)
if qpath == None:
print("Device at %s not found" % deviceAddress)
else:
print("Removing device at path: %s" % qpath)
adapter1 = self.bus.get(self.busName, self.path)
adapter1.RemoveDevice(qpath)
# Verify its gone:
qpath = objMgr.DoesDeviceExist(0, deviceAddress)
if qpath == None:
print("Device Successfully removed")
else:
print("Unable to remove device")
def __init__(self, scenarioType=None):
self.players = []
self.objects = ObjectManager()
self.harvestables = ObjectManager()
self.astres = []
self.communicationManager = CommunicationManager()
self.newGfxs = []
self.relations = {}
self.tick = 0
self.uidsSent = {}
### loading world according to scenario
if scenarioType:
self.scenario = scenarioType(self)
def __init__(self, scenarioType=None ):
self.players = []
self.objects = ObjectManager()
self.harvestables = ObjectManager()
self.astres = []
self.communicationManager = CommunicationManager()
self.newGfxs = []
self.relations = {}
self.tick = 0
self.uidsSent = {}
### loading world according to scenario
if scenarioType:
self.scenario = scenarioType( self )
#!/usr/bin/env python3
import pygame, display, controls
from pygame.locals import *
from objectmanager import ObjectManager
#from gameobject import GameObject, Player
FPS = 60
# initialisation
fpsClock = pygame.time.Clock()
pygame.init()
objectmanager = ObjectManager()
window = display.initialise((None, None))
gameOver = False
# game loop
while (gameOver == False):
#test for quit event
for event in pygame.event.get():
controls.handleEvent(event, objectmanager)
#update the gameobjects
objectmanager.update()
#update graphics
display.update(window, objectmanager.gameObjects)
gameOver = objectmanager.gameOver()
fpsClock.tick(FPS)
def __init__(self):
self.manager = ObjectManager()
self.simulation = Simulation()
class Game:
def __init__(self, scenarioType=None ):
self.players = []
self.objects = ObjectManager()
self.harvestables = ObjectManager()
self.astres = []
self.communicationManager = CommunicationManager()
self.newGfxs = []
self.relations = {}
self.tick = 0
self.uidsSent = {}
### loading world according to scenario
if scenarioType:
self.scenario = scenarioType( self )
def doTurn(self,playerInputs):
addedObjects = []
removedObjects = []
addedGfxs = []
### manage inputs
for (player,inputs) in playerInputs:
player.inputs = inputs
### comms / chat
self.communicationManager.doTurn( self )
### players play
for player in self.players:
player.doTurn( self )
### do turn objects
ts = {}
for o0 in self.objects.objects:
if o0.alive:
t0 = time()
oldPos = o0.pos
( addedObjectsLocal, removedObjectsLocal, addedGfxsLocal ) = o0.doTurn( self )
self.objects.update( o0, oldPos, o0.pos )
( addedObjects, removedObjects, addedGfxs ) = ( addedObjects+addedObjectsLocal, removedObjects+removedObjectsLocal, addedGfxs+addedGfxsLocal )
t1 = time()
ts[ o0 ] = t1-t0
### do turn astres
for o0 in self.astres:
if o0.alive:
t0 = time()
( addedObjectsLocal, removedObjectsLocal, addedGfxsLocal ) = o0.doTurn( self )
( addedObjects, removedObjects, addedGfxs ) = ( addedObjects+addedObjectsLocal, removedObjects+removedObjectsLocal, addedGfxs+addedGfxsLocal )
t1 = time()
ts[ o0 ] = t1-t0
# tests delai for each objects
ho = None
bt = 0
for k in ts:
if ts[ k ] > bt:
bt = ts[ k ]
ho = k
# print ho
if __debug__ and not self.tick%(config.fps):
print utils.i
utils.i = 0
### remove dead objects
for o1 in removedObjects:
if o1.stats.buildAsHint == "flagship":
if isinstance( o1.player, Human ):
o1.player.flagship = None
o1.player.needToUpdatePossibles = True
if not self.stats.PlayableShips: # No playable ships, it means that scenario will take care of it
self.scenario.spawn( self, o1.player, None )
elif not isinstance( o1.player, Faction ):
print "not human"
self.removePlayer( o1.player )
self.objects.remove( o1 ) # WARNING: this assumes harvestable and astres objects won't be removed
for obj in addedObjects:
self.objects.append( obj )
if not self.tick%(config.fps*5):
## calm tensions between computers and players
for p0 in self.players:
if not isinstance( p0, Computer ):
for p1 in self.players:
if isinstance( p1, Computer ):
rel = self.getRelationBetween( p1, p0 )
if rel < self.stats.Relations[ p1.race ][ p0.race ]:
self.setRelationBetween( p1, p0, rel + 1)
### Scenario
self.scenario.doTurn( self )
self.newGfxs = addedGfxs
### advance frame count
self.tick = self.tick + 1
def getBrief( self, player ):
cobjs = []
for obj in self.objects.objects:
cobjs.append( (obj, cobj) )
def addRemotePlayer(self, username, password ):
player = Human( self.stats.R_HUMAN, username, password )
self.addPlayer( player )
self.uidsSent[ player ] = []
return player
def giveShip( self, player, shipId ):
if not player.flagship and player.points >= self.stats.PlayableShips[ shipId ].points:
self.scenario.spawn( self, player, shipId )
else:
print "giveShip ignored, already has ship (%s) or selected ship unplayable (%s)." % (player.flagship, player.points < self.stats.PlayableShips[ shipId ].points)
def addPlayer( self, player ):
self.relations[ player ] = {}
for other in self.players:
if isinstance( other, Human ):
other.needToUpdateRelations = True
if isinstance( player, Computer ) or isinstance( other, Computer ):
self.relations[ player ][ other ] = self.stats.Relations[ player.race ][ other.race ]
self.relations[ other ][ player ] = self.stats.Relations[ other.race ][ player.race ]
else: ## if both are human players
self.relations[ player ][ other ] = 20
self.relations[ other ][ player ] = 20
self.players.append( player )
if isinstance( player, Human ):
if len( self.stats.PlayableShips ) == 1:
self.scenario.spawn( self, player, self.stats.PlayableShips.keys(0) )
if len( self.stats.PlayableShips ) == 0:
self.scenario.spawn( self, player )
def getPlayer( self, name ):
for p in self.players:
if p.name == name:
return p
def removePlayer( self, player ):
pass
def getRelationBetween( self, p0, p1 ):
if p0 == p1:
return 101
else:
return self.relations[ p0 ][ p1 ]
def setRelationBetween( self, p0, p1, rel=20 ):
if p0 and p1 and p0 != p1 and (isinstance( p0, Human ) or isinstance( p1, Human )):
if isinstance( p0, Human ):
p0.needToUpdateRelations = True
if isinstance( p1, Human ):
p1.needToUpdateRelations = True
self.relations[ p0 ][ p1 ] = rel
def executeCode( self, code ):
eval( code )
def save( self, path ):
f = open( path, "w:bz2" )
success = False
if f:
success = self.dump( f )
f.close
return success
def dump( self, f ):
if self.scenario.steps:
hadSteps = True
steps = self.scenario.steps
step = self.scenario.step
stepsIter = self.scenario.stepsIter
if self.scenario.step:
self.scenario.step = self.scenario.steps.index( self.scenario.step )
self.scenario.steps = None
self.scenario.stepsIter = None
else:
hadSteps = False
try:
title = self.scenario.title
year = self.scenario.year
timePlayed = self.tick/config.fps
description = self.scenario.description
player = filter( lambda player: isinstance( player, Human ), self.players )[0]
username = player.username
if player.flagship:
ship = player.flagship.stats.img
else:
ship = 0
infoDict = {
"title": title,
"year": year,
"timePlayed": timePlayed,
"description": description,
"username": username,
"ship": ship, }
pickle.dump( infoDict, f )
pickle.dump( self, f )
success = True
except Exception, ex:
print "failed to save game:", ex
success = False
return success
class Game:
def __init__(self, scenarioType=None):
self.players = []
self.objects = ObjectManager()
self.harvestables = ObjectManager()
self.astres = []
self.communicationManager = CommunicationManager()
self.newGfxs = []
self.relations = {}
self.tick = 0
self.uidsSent = {}
### loading world according to scenario
if scenarioType:
self.scenario = scenarioType(self)
def doTurn(self, playerInputs):
addedObjects = []
removedObjects = []
addedGfxs = []
### manage inputs
for (player, inputs) in playerInputs:
player.inputs = inputs
### comms / chat
self.communicationManager.doTurn(self)
### players play
for player in self.players:
player.doTurn(self)
### do turn objects
ts = {}
for o0 in self.objects.objects:
if o0.alive:
t0 = time()
oldPos = o0.pos
(addedObjectsLocal, removedObjectsLocal,
addedGfxsLocal) = o0.doTurn(self)
self.objects.update(o0, oldPos, o0.pos)
(addedObjects, removedObjects,
addedGfxs) = (addedObjects + addedObjectsLocal,
removedObjects + removedObjectsLocal,
addedGfxs + addedGfxsLocal)
t1 = time()
ts[o0] = t1 - t0
### do turn astres
for o0 in self.astres:
if o0.alive:
t0 = time()
(addedObjectsLocal, removedObjectsLocal,
addedGfxsLocal) = o0.doTurn(self)
(addedObjects, removedObjects,
addedGfxs) = (addedObjects + addedObjectsLocal,
removedObjects + removedObjectsLocal,
addedGfxs + addedGfxsLocal)
t1 = time()
ts[o0] = t1 - t0
# tests delai for each objects
ho = None
bt = 0
for k in ts:
if ts[k] > bt:
bt = ts[k]
ho = k
# print ho
if __debug__ and not self.tick % (config.fps):
print utils.i
utils.i = 0
### remove dead objects
for o1 in removedObjects:
if o1.stats.buildAsHint == "flagship":
if isinstance(o1.player, Human):
o1.player.flagship = None
o1.player.needToUpdatePossibles = True
if not self.stats.PlayableShips: # No playable ships, it means that scenario will take care of it
self.scenario.spawn(self, o1.player, None)
elif not isinstance(o1.player, Faction):
print "not human"
self.removePlayer(o1.player)
self.objects.remove(
o1
) # WARNING: this assumes harvestable and astres objects won't be removed
for obj in addedObjects:
self.objects.append(obj)
if not self.tick % (config.fps * 5):
## calm tensions between computers and players
for p0 in self.players:
if not isinstance(p0, Computer):
for p1 in self.players:
if isinstance(p1, Computer):
rel = self.getRelationBetween(p1, p0)
if rel < self.stats.Relations[p1.race][p0.race]:
self.setRelationBetween(p1, p0, rel + 1)
### Scenario
self.scenario.doTurn(self)
self.newGfxs = addedGfxs
### advance frame count
self.tick = self.tick + 1
def getBrief(self, player):
cobjs = []
for obj in self.objects.objects:
cobjs.append((obj, cobj))
def addRemotePlayer(self, username, password):
player = Human(self.stats.R_HUMAN, username, password)
self.addPlayer(player)
self.uidsSent[player] = []
return player
def giveShip(self, player, shipId):
if not player.flagship and player.points >= self.stats.PlayableShips[
shipId].points:
self.scenario.spawn(self, player, shipId)
else:
print "giveShip ignored, already has ship (%s) or selected ship unplayable (%s)." % (
player.flagship,
player.points < self.stats.PlayableShips[shipId].points)
def addPlayer(self, player):
self.relations[player] = {}
for other in self.players:
if isinstance(other, Human):
other.needToUpdateRelations = True
if isinstance(player, Computer) or isinstance(other, Computer):
self.relations[player][other] = self.stats.Relations[
player.race][other.race]
self.relations[other][player] = self.stats.Relations[
other.race][player.race]
else: ## if both are human players
self.relations[player][other] = 20
self.relations[other][player] = 20
self.players.append(player)
if isinstance(player, Human):
if len(self.stats.PlayableShips) == 1:
self.scenario.spawn(self, player,
self.stats.PlayableShips.keys(0))
if len(self.stats.PlayableShips) == 0:
self.scenario.spawn(self, player)
def getPlayer(self, name):
for p in self.players:
if p.name == name:
return p
def removePlayer(self, player):
pass
def getRelationBetween(self, p0, p1):
if p0 == p1:
return 101
else:
return self.relations[p0][p1]
def setRelationBetween(self, p0, p1, rel=20):
if p0 and p1 and p0 != p1 and (isinstance(p0, Human)
or isinstance(p1, Human)):
if isinstance(p0, Human):
p0.needToUpdateRelations = True
if isinstance(p1, Human):
p1.needToUpdateRelations = True
self.relations[p0][p1] = rel
def executeCode(self, code):
eval(code)
def save(self, path):
f = open(path, "w:bz2")
success = False
if f:
success = self.dump(f)
f.close
return success
def dump(self, f):
if self.scenario.steps:
hadSteps = True
steps = self.scenario.steps
step = self.scenario.step
stepsIter = self.scenario.stepsIter
if self.scenario.step:
self.scenario.step = self.scenario.steps.index(
self.scenario.step)
self.scenario.steps = None
self.scenario.stepsIter = None
else:
hadSteps = False
try:
title = self.scenario.title
year = self.scenario.year
timePlayed = self.tick / config.fps
description = self.scenario.description
player = filter(lambda player: isinstance(player, Human),
self.players)[0]
username = player.username
if player.flagship:
ship = player.flagship.stats.img
else:
ship = 0
infoDict = {
"title": title,
"year": year,
"timePlayed": timePlayed,
"description": description,
"username": username,
"ship": ship,
}
pickle.dump(infoDict, f)
pickle.dump(self, f)
success = True
except Exception, ex:
print "failed to save game:", ex
success = False
return success
