def test_player_defeated(self):
env = Environment(3, 0, 1)
env.add_player(PlayerType.USER, 'user')
env.players['user'].field.place_ship_on_field([(1, 0)])
self.assertFalse(env.players['user'].is_player_defeated())
env.players['user'].field.fire_cell(1, 0, Player(PlayerType.BOT, env))
self.assertTrue(env.players['user'].is_player_defeated())
def test_player_have_ship_on_hands(self):
env = Environment(3, 0, 1)
env.add_player(PlayerType.USER, 'user')
self.assertFalse(env.players['user'].is_ship_in_hand(2))
self.assertTrue(env.players['user'].is_ship_in_hand(1))
env.players['user'].field.place_ship_on_field([(1, 0)])
self.assertFalse(env.players['user'].is_ship_in_hand(1))
def test_fire_destroyed(self):
env = Environment(5, 0, 1)
env.add_player(PlayerType.USER, 'user')
env.players['user'].field.place_ship_on_field([(0, 1)])
state = env.players['user'].field.fire_cell(
0, 1, Player(PlayerType.BOT, env))
self.assertTrue(env.players['user'].is_player_defeated())
self.assertEqual(FireResult.DESTROYED, state)
def test_fire_twice(self):
env = Environment(5, 0, 1)
env.add_player(PlayerType.USER, 'user')
state = env.players['user'].field.fire_cell(
0, 1, Player(PlayerType.BOT, env))
self.assertEqual(state, FireResult.MISSED)
state = env.players['user'].field.fire_cell(
0, 1, Player(PlayerType.BOT, env))
self.assertEqual(state, FireResult.UNABLE)
def test_fire_out_of_field(self):
env = Environment(5, 0, 1)
env.add_player(PlayerType.USER, 'user')
state = env.players['user'].field.fire_cell(
0, 6, Player(PlayerType.BOT, env))
self.assertEqual(state, FireResult.UNABLE)
if __name__ == '__main__':
unittest.main()
def test_place_corner_ship_big_field(self):
env = Environment(6, 0, 4)
env.add_player(PlayerType.USER, 'user')
self.assertEqual(
env.players['user'].field.place_ship_on_field([(0, 0)]),
PlacementResult.SUCCESS)
self.assertEqual(
env.players['user'].field.place_ship_on_field([(0, 5)]),
PlacementResult.UNABLE)
def test_should_return_input_grids(self):
expected = [
[0, 1],
[1, 0],
]
environment = Environment(expected)
grids = environment.grids()
self.assertEqual(grids, expected)
def test_place_2_ship(self):
env = Environment(5, 0, 2)
env.add_player(PlayerType.USER, 'user')
env.players['user'].field.field[1][1].state = CellState.SHIP
self.assertNotEqual(
env.players['user'].field.place_ship_on_field([(0, 0), (0, 1)]),
PlacementResult.SUCCESS)
self.assertEqual(
env.players['user'].field.place_ship_on_field([(1, 3), (2, 3)]),
PlacementResult.SUCCESS)
def test_gotIntroduced(self):
"""
When the introduction has been reciprocated, the L{UI} should
start the Environment and create a L{Window} and call
L{Window.go} on it.
"""
starts = []
environment = Environment(3, None)
environment.start = lambda: starts.append(True)
self.ui.gotIntroduced(environment)
self.assertIdentical(self.ui.window.environment, environment)
self.assertIdentical(self.ui.window.clock, self.reactor)
self.assertEqual(self.ui.window.went, [True])
self.assertEqual(starts, [True])
def test_gotIntroducedWithInitialPlayer(self):
"""
The initial L{Player} in the L{Environment} should be passed
to L{UI.gotInitialPlayer}.
"""
player = object()
environment = Environment(10, Clock())
environment.setInitialPlayer(player)
initialEvents = []
def gotInitialPlayer(player):
initialEvents.append(('player', player))
self.ui.gotInitialPlayer = gotInitialPlayer
self.ui.gotIntroduced(environment)
self.assertEquals(initialEvents, [('player', player)]),
def update(self):
owner = self.owner
if owner.distanceToTractor() <= self.r2:
owner.setState(AttackState(owner))
avoidance = Environment.getInstance().staticAvoidanceVector(owner.worldPosition)
randomness = owner.randomDirectionVector()
owner.iterTurn(5*avoidance + randomness)
def test_bound(self):
env = Environment(3, 0, 1)
field = Honeycomb(3, Player(PlayerType.USER, env), env)
self.assertTrue(field.is_in_bound(1, 1))
self.assertFalse(field.is_in_bound(4, 1))
self.assertFalse(field.is_in_bound(-1, 1))
self.assertFalse(field.is_in_bound(4, 6))
def setUp(self):
"""
Create an L{Environment} attached to a L{Clock} so that its behavior is
deterministic.
"""
self.clock = Clock()
self.environment = Environment(1, self.clock)
self.environment.start()
def test_createInitialPlayer(self):
"""
L{NetworkController._createInitialPlayer} should create the player
object for this client.
"""
x, y, z = (3, 2, 12)
speed = 40
granularity = 22
environment = Environment(granularity, self.clock)
observer = PlayerVisibilityObserver()
environment.addObserver(observer)
self.controller.createInitialPlayer(
environment, self.identifier, Vector(x, y, z), speed)
self.assertEqual(len(observer.createdPlayers), 1)
self._assertThingsAboutPlayerCreation(
environment, Vector(x, y, z), speed)
def cbIntroduce(box):
granularity = box['granularity']
position = Vector(box['x'], box['y'], box['z'])
speed = box['speed']
self.environment = Environment(granularity, self.clock)
self.environment.setNetwork(self)
self.createInitialPlayer(
self.environment, box['identifier'], position,
speed)
return self.environment
def update(self):
owner = self.owner
dist = owner.distanceToTractor()
if self.r2/2 < dist < self.r2:
if owner.tractorAimError() > pi/6:
owner.walk()
owner.iterTurn(5*Environment.getInstance().staticAvoidanceVector(owner.worldPosition) + owner.randomDirectionVector() + 10*owner.vectorToTractor())
else:
owner.setAnimation('attack')
owner.setVelocity((0, 0))
owner.turn(0)
elif self.r1 < dist <= self.r2/2:
owner.run()
owner.iterTurn(5*Environment.getInstance().staticAvoidanceVector(owner.worldPosition) + owner.randomDirectionVector() + 10* owner.vectorToTractor())
elif 0 < dist <= self.r1:
owner.setAnimation('attack')
owner.setVelocity((0, 0.07))
owner.turn(0)
else:
owner.setState(WanderState(owner))
def test_removePlayer(self):
"""
L{NetworkController} should respond to L{RemovePlayer}
commands by removing the identified L{Player} object from the
L{Environment} and forgetting the L{Player}'s identifier.
"""
environment = Environment(10, self.clock)
self.controller.environment = environment
observer = PlayerVisibilityObserver()
environment.addObserver(observer)
identifier = 123
self.controller.newPlayer(identifier, 23, 32, 13, 939)
responder = self.controller.lookupFunction(RemovePlayer.commandName)
d = responder({"identifier": str(identifier)})
def gotResult(ignored):
self.assertEqual(observer.removedPlayers, observer.createdPlayers)
self.assertRaises(
KeyError,
self.controller.objectByIdentifier, identifier)
d.addCallback(gotResult)
return d
def create_snake_environment():
""" Create a new Snake environment. """
from game.environment import Environment, Environment2D
global game2D
if game2D:
return Environment2D(level_map=[
"#############", "#...........#", "#...........#", "#...........#",
"#...........#", "#...........#", "#.....S.....#", "#...........#",
"#...........#", "#...........#", "#...........#", "#...........#",
"#############"
])
else:
return Environment()
def avoid(self):
owner = self.owner
avoidance = Vector((0,0))
for sheep in owner.flock:
p1 = Vector((owner.worldPosition.x,owner.worldPosition.y))
p2 = Vector((sheep.worldPosition.x,sheep.worldPosition.y))
dist = (p1 - p2).magnitude
theta = atan2(p1.y - p2.y,p1.x - p2.x)
if .001 < dist < self.r1:
size = 1/dist**2
avoidance.x += size*cos(theta)
avoidance.y += size*sin(theta)
env = Environment.getInstance()
avoidance += env.staticAvoidanceVector(owner.worldPosition)
try:
ramAvoidance = owner.avoidanceVector('ram')
ramDist = owner.distance('ram')
if 0 < ramDist < 1.5*self.r1:
ramAvoidance *= 1.5/ramDist**2
avoidance += ramAvoidance
except:
pass
tractorDist = owner.distance('tractor')
if 0 < tractorDist < 3*self.r1:
avoidance += owner.avoidanceVector('tractor')*(5/tractorDist**2)
if avoidance.magnitude > 0.05:
owner.run()
self.direction += avoidance*10
return
if avoidance.magnitude > 0.04:
owner.flounder()
else:
owner.walk()
avoidance.normalize()
self.direction += avoidance*10
class EnvironmentTestCase(unittest.TestCase):
def setUp(self):
self.environment = Environment()
def test_should_return_default_simple_grids(self):
expected = [
[0, 0, 0, 0, 1],
[0, 1, 0, 0, 1],
[0, 0, 1, 0, 1],
[0, 0, 0, 0, 1],
[0, 0, 1, 0, 1],
]
grids = self.environment.grids()
self.assertEqual(grids, expected)
def test_should_return_input_grids(self):
expected = [
[0, 1],
[1, 0],
]
environment = Environment(expected)
grids = environment.grids()
self.assertEqual(grids, expected)
def test_should_set_and_get_home(self):
home = (1, 1)
self.environment.set_home(home)
self.assertEqual(self.environment.home(), home)
def test_should_set_and_get_grids(self):
grids = [[1, 0], [1, 0]]
self.environment.set_grids(grids)
self.assertEqual(self.environment.grids(), grids)
def cbHs(box):
granularity = box['granularity']
self.environment = Environment(granularity,self.clock)
self.environment.setNetwork(self)
self.storeHandshakeResponse(box['identifier'],granularity)
return self.environment
class NetworkController(AMP):
"""
A controller which responds to AMP commands to make state changes to local
model objects. This is used by the client.
@ivar modelObjects: A C{dict} mapping identifiers to model objects.
@ivar clock: A provider of L{IReactorTime} which will be used to
update the model time.
"""
environment = None
def __init__(self, clock):
self.modelObjects = {}
self.clock = clock
self.lastPoll = None
def addModelObject(self, identifier, modelObject):
"""
Associate a network identifier with a model object.
"""
self.modelObjects[identifier] = modelObject
modelObject.addObserver(self)
def storeHandshakeResponse(self,identifier, modelObject):
print "Got Identifier %s"%(identifier)
#self.addModelObject(identifier, modelObject)
def rod(self,msg):
print "Rod Msg: %s"%msg
j = json.loads(msg)
d = self.callRemote(SetRod, level=j['level'])
def cb(box):
pass
d.addCallback(cb)
return d
def pump(self,msg):
print "Pump Msg: %s"%msg
j = json.loads(msg)
d = self.callRemote(SetPump, pumpid=str(j['pumpid']),level=j['level'])
def cb(box):
print "Pump Protocol Response: %s"%box
return box
d.addCallback(cb)
return d
def repairDamage(self,msg):
j = json.loads(msg)
d = self.callRemote(RepairDamage, damage=int(j['damage']))
def cb(box):
pass
d.addCallback(cb)
return d
def getLastPoll(self):
return {} if self.lastPoll==None else self.lastPoll
def valve(self,msg):
j = json.loads(msg)
print "valve msg",j
self.callRemote(SetValve,valveid=str(j['valveid']),state=j['state'])
def handshake(self):
d = self.callRemote(Handshake)
def cbHs(box):
granularity = box['granularity']
self.environment = Environment(granularity,self.clock)
self.environment.setNetwork(self)
self.storeHandshakeResponse(box['identifier'],granularity)
return self.environment
d.addCallback(cbHs)
return d
def earthquake(self,quake,damage):
#TODO: add objects to the response for damage
#TODO: need to "leak" the flags to the server in the wild.
j = {'quake':quake,'damage':damage}
try:
if len(self.factory.frontEndListeners['earthquake'].connections) > 0:
for conn in self.factory.frontEndListeners['earthquake'].connections:
conn.sendMessage(json.dumps(j))
except KeyError:
pass
return j
Earthquake.responder(earthquake)
def pollPlant(self,updateid,
mwh,
simtime,
reactortemp,
rcshotlegtemp,
rcscoldlegtemp,
afshotlegtemp,
afscoldlegtemp,
genmw,
cshotlegtemp,
cscoldlegtemp,
rcspressure,
boilingtemp,
workers,
risk,
rcs,
hpiTank,
auxTank,
feedwater,
cs,
rods,
hpivalve,
afsvalve,
pressurizervalve,
explosion,
meltdown,
damage,
hpiwater,
pressurizerwater,
afswater,
critflag,
steamvoiding,
totsteamvoiding,
totearthquakes,
totsim,
totexplosions,
totmeltdowns):
'''
('pressurizervalve',Boolean()),
('explosion',Boolean()),
('meltdown',Boolean()),
('damage',Integer()),
('hpiwater',Integer()),
('pressurizerwater',Integer()),
('afswater',Integer())
'''
j = {'mwh':mwh,
'simtime':simtime,
'reactortemp':reactortemp,
'rcshotlegtemp':rcshotlegtemp,
'rcscoldlegtemp':rcscoldlegtemp,
'afshotlegtemp':afshotlegtemp,
'afscoldlegtemp':afscoldlegtemp,
'genmw':genmw,
'cshotlegtemp':cshotlegtemp,
'cscoldlegtemp':cscoldlegtemp,
'rcspressure':rcspressure,
'boilingtemp':boilingtemp,
'workers':workers,
'risk':risk,
'rcs':rcs,
'hpiTank':hpiTank,
'auxTank':auxTank,
'feedwater':feedwater,
'cs':cs,
'rods':rods,
'hpivalve':hpivalve,
'afsvalve':afsvalve,
'pressurizervalve':pressurizervalve,
'explosion':explosion,
'meltdown':meltdown,
'damage':damage,
'hpiwater':hpiwater,
'pressurizerwater':pressurizerwater,
'afswater':afswater,
'critflag':critflag,
'steamvoiding':steamvoiding,
'totsteamvoiding':totsteamvoiding,
'totearthquakes':totearthquakes,
'totsim':totsim,
'totexplosions':totexplosions,
'totmeltdowns':totmeltdowns
}
self.lastPoll = j
try:
if len(self.factory.frontEndListeners['poll'].connections) > 0:
for conn in self.factory.frontEndListeners['poll'].connections:
conn.sendMessage(json.dumps(j))
except KeyError:
pass
return j
PollPlant.responder(pollPlant)
def setUp(self):
self.environment = Environment()
class NetworkController(AMP):
"""
A controller which responds to AMP commands to make state changes to local
model objects.
@ivar modelObjects: A C{dict} mapping identifiers to model objects.
@ivar clock: A provider of L{IReactorTime} which will be used to
update the model time.
"""
environment = None
def __init__(self, clock):
self.modelObjects = {}
self.clock = clock
def addModelObject(self, identifier, modelObject):
"""
Associate a network identifier with a model object.
"""
self.modelObjects[identifier] = modelObject
modelObject.addObserver(self)
def directionChanged(self, modelObject):
"""
Notify the network that a local model object changed direction.
@param modelObject: The L{Player} whose direction has changed.
"""
d = self.callRemote(
SetMyDirection,
direction=modelObject.direction, y=modelObject.orientation.y)
d.addCallback(self._gotNewPosition, modelObject)
# XXX Add an errback
def _gotNewPosition(self, position, player):
"""
Update a L{Player}'s position based on new data from the server.
@param player: The L{Player} whose position to change.
@param position: Dict with C{x} and C{y} keys, whose values should be
integers specifying position.
"""
player.setPosition(Vector(position['x'], position['y'], position['z']))
def createInitialPlayer(self, environment, identifier, position,
speed):
"""
Create this client's player as the initial player in the given
environment and add it to the model object mapping.
"""
player = environment.createPlayer(position, speed)
environment.setInitialPlayer(player)
self.addModelObject(identifier, player)
def introduce(self):
"""
Greet the server and register the player model object which belongs to
this client and remember the identifier with which it responds.
"""
d = self.callRemote(Introduce)
def cbIntroduce(box):
granularity = box['granularity']
position = Vector(box['x'], box['y'], box['z'])
speed = box['speed']
self.environment = Environment(granularity, self.clock)
self.environment.setNetwork(self)
self.createInitialPlayer(
self.environment, box['identifier'], position,
speed)
return self.environment
d.addCallback(cbIntroduce)
return d
def objectByIdentifier(self, identifier):
"""
Look up a pre-existing model object by its network identifier.
@type identifier: C{int}
@raise KeyError: If no existing model object has the given identifier.
"""
return self.modelObjects[identifier]
def identifierByObject(self, modelObject):
"""
Look up the network identifier for a given model object.
@raise ValueError: If no network identifier is associated with the
given model object.
@rtype: L{int}
"""
for identifier, object in self.modelObjects.iteritems():
if object is modelObject:
return identifier
raise ValueError("identifierByObject passed unknown model objects")
def setDirectionOf(self, identifier, direction, x, y, z, orientation):
"""
Set the direction of a local model object.
@type identifier: L{int}
@type direction: One of the L{game.direction} direction constants
@see: L{SetDirectionOf}
"""
player = self.objectByIdentifier(identifier)
player.setDirection(direction)
player.setPosition(Vector(x, y, z))
player.orientation.y = orientation
return {}
SetDirectionOf.responder(setDirectionOf)
def newPlayer(self, identifier, x, y, z, speed):
"""
Add a new L{Player} object to the L{Environment} and start
tracking its identifier on the network.
@param identifier: The network-level identifier of the player.
@param x: The x position of the new L{Player}.
@param y: The y position of the new L{Player}.
@param z: The z position of the new L{Player}.
"""
player = self.environment.createPlayer(Vector(x, y, z), speed)
self.modelObjects[identifier] = player
return {}
NewPlayer.responder(newPlayer)
def removePlayer(self, identifier):
"""
Remove an existing L{Player} object from the L{Environment}
and stop tracking its identifier on the network.
@param identifier: The network-level identifier of the player.
"""
self.environment.removePlayer(self.objectByIdentifier(identifier))
del self.modelObjects[identifier]
return {}
RemovePlayer.responder(removePlayer)
def setTerrain(self, x, y, z, voxels):
"""
Add new terrain information to the environment.
@param x: The x coordinate where the given voxels begin.
@param y: The y coordinate where the given voxels begin.
@param z: The z coordinate where the given voxels begin.
@param voxels: An L{numpy.array} specifying terrain information starting
at the specified location and proceeding in the positive direction
along all axes
"""
self.environment.terrain.set(x, y, z, voxels)
return {}
SetTerrain.responder(setTerrain)
class EnvironmentTests(TestCase, ArrayMixin):
"""
Tests for L{game.environment.Environment}.
"""
def setUp(self):
"""
Create an L{Environment} attached to a L{Clock} so that its behavior is
deterministic.
"""
self.clock = Clock()
self.environment = Environment(1, self.clock)
self.environment.start()
def test_terrain(self):
"""
An L{Environment} should start with an empty terrain array.
"""
self.assertEquals(self.environment.terrain.dict(), {})
def test_createPlayer(self):
"""
L{Environment.createPlayer} should instantiate a L{Player} and
broadcast it to all registered observers.
"""
position = Vector(1, 2, 3)
speed = 20
observer = PlayerVisibilityObserver()
self.environment.addObserver(observer)
player = self.environment.createPlayer(position, speed)
self.assertEqual(observer.createdPlayers, [player])
self.assertEqual(player.getPosition(), position)
self.assertEqual(player.speed, speed)
self.assertEqual(player.seconds, self.environment.seconds)
def test_removePlayer(self):
"""
L{Environment.removePlayer} should broadcast C{playerRemoved}
to all registered observers.
"""
position = Vector(1, 2, 3)
speed = 20
observer = PlayerVisibilityObserver()
self.environment.addObserver(observer)
player = self.environment.createPlayer(position, speed)
self.environment.removePlayer(player)
self.assertEqual(observer.createdPlayers, observer.removedPlayers)
def test_setInitialPlayer(self):
"""
L{Environment.setInitialPlayer} should change the environment's
C{initialPlayer} attribute from C{None} to its argument.
"""
self.assertIdentical(self.environment.initialPlayer, None)
player = object()
self.environment.setInitialPlayer(player)
self.assertIdentical(self.environment.initialPlayer, player)
def test_setNetwork(self):
"""
L{Environment.setNetwork} changes the environment's C{network} attribute
from C{None} to its argument.
"""
self.assertIdentical(self.environment.network, None)
network = object()
self.environment.setNetwork(network)
self.assertIdentical(self.environment.network, network)
def test_fleet_placement(self):
env = Environment(3, 0, 1)
env.add_player(PlayerType.USER, 'user')
self.assertFalse(env.players['user'].is_fleet_placed())
env.players['user'].field.place_ship_on_field([(1, 0)])
self.assertTrue(env.players['user'].is_fleet_placed())
class NetworkController(AMP):
"""
A controller which responds to AMP commands to make state changes to local
model objects. This is used by the client.
@ivar modelObjects: A C{dict} mapping identifiers to model objects.
@ivar clock: A provider of L{IReactorTime} which will be used to
update the model time.
"""
environment = None
def __init__(self, clock):
self.modelObjects = {}
self.clock = clock
def addModelObject(self, identifier, modelObject):
"""
Associate a network identifier with a model object.
"""
self.modelObjects[identifier] = modelObject
modelObject.addObserver(self)
def storeHandshakeResponse(self,identifier, modelObject):
print dir(modelObject)
print "Got Identifier %s"%(identifier)
#self.addModelObject(identifier, modelObject)
def handshake(self):
d = self.callRemote(Handshake)
def cbHs(box):
granularity = box['granularity']
self.environment = Environment(granularity,self.clock)
self.environment.setNetwork(self)
self.storeHandshakeResponse(box['identifier'],granularity)
return self.environment
d.addCallback(cbHs)
return d
def pollPlant(self,id,mwh):
print "Poll Plant Got update: %s %s"%(id,mwh)
return {}
PollPlant.responder(pollPlant)
def objectByIdentifier(self, identifier):
"""
Look up a pre-existing model object by its network identifier.
@type identifier: C{int}
@raise KeyError: If no existing model object has the given identifier.
"""
return self.modelObjects[identifier]
def identifierByObject(self, modelObject):
"""
Look up the network identifier for a given model object.
@raise ValueError: If no network identifier is associated with the
given model object.
@rtype: L{int}
"""
for identifier, object in self.modelObjects.iteritems():
if object is modelObject:
return identifier
raise ValueError("identifierByObject passed unknown model objects")
def test_delete_from_fleet(self):
env = Environment(3, 0, 1)
env.add_player(PlayerType.USER, 'user')
env.players['user'].move_ship_to_fleet(1)
env.players['user'].delete_cell_from_fleet()
self.assertEqual(0, env.players['user'].fleet)
def test_move_to_fleet(self):
env = Environment(3, 0, 1)
env.add_player(PlayerType.USER, 'user')
env.players['user'].move_ship_to_fleet(1)
self.assertEqual(env.players['user'].fleet, 1)
self.assertNotIn(1, env.players['user'].hand)
def test_bot_init_diff_wrong(self):
env = Environment(3, 100, 2)
env.add_player(PlayerType.BOT, 'bot')
self.assertEqual(env.players['bot'].AI.diff, env.diff)
self.assertEqual(env.diff, 0)
return self.environment
def perspective_getTeam(self):
return self.player.team
def perspective_switchTeams(self):
return self.environment.switchTeams(self.player)
#TODO could we add a perspective_getPosition and perspective_getIRTargetStatus here
#TODO otherwise, how do we do remote call on a client?
pygame.init()
pygame.display.set_mode((800, 480), pygame.DOUBLEBUF)
realm = GameRealm()
env = Environment()
view = Window(env)
realm.environment = env
view.start('Server')
LoopingCall(lambda: pygame.event.pump()).start(0.03)
controller = ServerController(realm, view)
controller.go()
portal = portal.Portal(realm, [checkers.AllowAnonymousAccess()])
reactor.listenTCP(8800, pb.PBServerFactory(portal))
from twisted.protocols.basic import LineReceiver
from twisted.internet import protocol
import cPickle
def cbHs(box):
granularity = box['granularity']
self.environment = Environment(granularity, self.clock)
self.environment.setNetwork(self)
self.storeHandshakeResponse(box['identifier'], granularity)
return self.environment
class NetworkController(AMP):
"""
A controller which responds to AMP commands to make state changes to local
model objects. This is used by the client.
@ivar modelObjects: A C{dict} mapping identifiers to model objects.
@ivar clock: A provider of L{IReactorTime} which will be used to
update the model time.
"""
environment = None
def __init__(self, clock):
self.modelObjects = {}
self.clock = clock
def addModelObject(self, identifier, modelObject):
"""
Associate a network identifier with a model object.
"""
self.modelObjects[identifier] = modelObject
modelObject.addObserver(self)
def storeHandshakeResponse(self, identifier, modelObject):
print dir(modelObject)
print "Got Identifier %s" % (identifier)
#self.addModelObject(identifier, modelObject)
def handshake(self):
d = self.callRemote(Handshake)
def cbHs(box):
granularity = box['granularity']
self.environment = Environment(granularity, self.clock)
self.environment.setNetwork(self)
self.storeHandshakeResponse(box['identifier'], granularity)
return self.environment
d.addCallback(cbHs)
return d
def pollPlant(self, id, mwh):
print "Poll Plant Got update: %s %s" % (id, mwh)
return {}
PollPlant.responder(pollPlant)
def objectByIdentifier(self, identifier):
"""
Look up a pre-existing model object by its network identifier.
@type identifier: C{int}
@raise KeyError: If no existing model object has the given identifier.
"""
return self.modelObjects[identifier]
def identifierByObject(self, modelObject):
"""
Look up the network identifier for a given model object.
@raise ValueError: If no network identifier is associated with the
given model object.
@rtype: L{int}
"""
for identifier, object in self.modelObjects.iteritems():
if object is modelObject:
return identifier
raise ValueError("identifierByObject passed unknown model objects")
