def relearn_ports(self, event, log):
"""
Throws either a port_up or port_down event to listening
classes.
"""
e = Event()
e.dpid = event.dpid
e.port = event.port
if event.added:
# Maybe ARP should be the only reason to acknowledge
# a port_up. Else if you swap devices, they'll be
# stale until ARP.
for h in core.db.find_hosts({
'dpid': str(event.dpid),
'port_no': str(event.port)
}):
h['active'] = True
core.db.update_host(h)
self.handle_event("port_up", e)
elif event.deleted:
for h in core.db.find_hosts({
'dpid': str(event.dpid),
'port_no': str(event.port)
}):
h['active'] = False
core.db.update_host(h)
self.handle_event("port_down", e)
def next_lvl(self):
if self.curLevelC + 1 < len(self.levelPathList):
self.loadLevel(self.curLevelC + 1)
else:
#TODO: show screen | and move maybe to game class
print "Game finished You Win!:)"
#Event().raiseCstmEvent(pygame.QUIT, {})
from game import StateManager
Event().raiseCstmEvent(Event().SWITCHSTATE,
{"state": StateManager.MENUSTATE})
def learn(self, event):
"""
Intercept and inspect ARP messages.
"""
pkt = event.parse()
if pkt.type != 2054: return
arp = pkt.next
host_a = core.db.find_host({"mac": str(arp.hwsrc)})
h = {"_parent": str(event.dpid),
"port_no": str(event.port),
"ip": str(arp.protosrc),
"mac": str(arp.hwsrc),
"group_no": "-1", "active": True}
# Is the DB out of sync
if host_a is None:
print("Host %s is new. Recording and adding to null group" % str(arp.hwsrc))
self.hosts[str(arp.hwsrc)] = h
core.db.update_host(h)
return
# Is Local out of sync
if not str(arp.hwsrc) in self.hosts:
print("Host %s is new to local db. Syncing with remote db." % str(arp.hwsrc))
h["group_no"] = host_a["group_no"]
self.hosts[str(arp.hwsrc)] = h
core.db.update_host(h)
e = Event()
e.host = host_a
self.handle_event("host-update", e)
# Is Local out of sync
h["group_no"] = host_a["group_no"]
if host_a["ip"] != h["ip"] or host_a["port_no"] != h["port_no"] \
or host_a["_parent"] != h["_parent"] or host_a["active"] != h["active"]:
print("Saving host %s changes to db and installing new flows." % str(arp.hwsrc))
self.hosts[str(arp.hwsrc)] = h
core.db.update_host(h)
e = Event()
e.host = host_a
self.handle_event("host-update", e)
if host_a["group_no"] is "-1":
print("Not broadcasting ARP from Host %s" % str(arp.hwsrc))
return
else:
host_b = core.db.find_host({"ip": str(arp.protodst)})
if host_b is None or host_b["group_no"] is -1: return
self.send_arp(host_a, host_b)
def setDead(self):
pygame.time.wait(500)
print 'TooooooooooooooooooooooooooooT'
self.alive = False
self.renderer.fades.renderDeathAnimation()
from game import StateManager
Event().raiseCstmEvent(Event.SWITCHSTATE,
argDict={"state": StateManager.MENUSTATE})
def add_event(self, rule, callback):
"""Adds an event to the algorithm's EventManager.
Parameters
----------
rule : EventRule
The rule for when the callback should be triggered.
callback : callable[(context, data) -> None]
The function to execute when the rule is triggered.
"""
self.event_manager.add_event(Event(rule, callback), )
def relearn_ports(self, event, log):
"""
Throws either a port_up or port_down event to listening
classes.
"""
e = Event()
e.dpid = event.dpid
e.port = event.port
if event.added:
# Maybe ARP should be the only reason to acknowledge
# a port_up. Else if you swap devices, they'll be
# stale until ARP.
for h in core.db.find_hosts({'dpid': str(event.dpid), 'port_no': str(event.port)}):
h['active'] = True
core.db.update_host(h)
self.handle_event("port_up", e)
elif event.deleted:
for h in core.db.find_hosts({'dpid': str(event.dpid), 'port_no': str(event.port)}):
h['active'] = False
core.db.update_host(h)
self.handle_event("port_down", e)
def handleInput(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.stateManager.endGame()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.stateManager.endGame()
elif event.key == pygame.K_SPACE:
if not self.levelManager.curLevel.cutSceneState:
self.levelManager.curLevel.player.jump()
elif event.key == pygame.K_LEFT:
if not self.levelManager.curLevel.cutSceneState:
self.levelManager.curLevel.player.walkLeft()
elif event.key == pygame.K_RIGHT:
if not self.levelManager.curLevel.cutSceneState:
self.levelManager.curLevel.player.walkRight()
elif event.key == pygame.K_p:
Event().raiseCstmEvent(
Event.SWITCHSTATE,
argDict={"state": StateManager.PAUSESTATE})
elif event.key == pygame.K_m:
Event().raiseCstmEvent(
Event.SWITCHSTATE,
argDict={"state": StateManager.MENUSTATE})
elif event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
if not self.levelManager.curLevel.cutSceneState:
self.levelManager.curLevel.player.walkStop(dir=-1)
elif event.key == pygame.K_RIGHT:
if not self.levelManager.curLevel.cutSceneState:
self.levelManager.curLevel.player.walkStop(dir=1)
elif event.type == pygame.MOUSEBUTTONDOWN:
if Options.getOption("ISDEBUG"):
print "The current cursor position is: ", Vector(
event.pos[0],
event.pos[1]) + self.gameRenderer.getCamera()
#custom events:
elif event.type == Event().ACTIVATETRIGGER:
self.levelManager.curLevel.triggerManager.addTrigger(
event.tObject)
elif event.type == Event().NEWDIALOG:
self.interface.dialogManager.addDialog(event.msg, self)
elif event.type == Event().LEVELFINISHED:
self.levelManager.curLevel.setFinished()
elif event.type == Event().SWITCHSTATE:
self.stateManager.switchState(event.state)
#Trigger input:
if self.levelManager.curLevel.triggerManager.isNewEvents():
self.levelManager.curLevel.triggerManager.next().action()
def learn(self, event):
"""
Intercept and inspect ARP messages.
"""
pkt = event.parse()
if pkt.type != 2054: return
arp = pkt.next
host_a = core.db.find_host({"mac": str(arp.hwsrc)})
h = {
"_parent": str(event.dpid),
"port_no": str(event.port),
"ip": str(arp.protosrc),
"mac": str(arp.hwsrc),
"group_no": "-1",
"active": True
}
# Is the DB out of sync
if host_a is None:
print("Host %s is new. Recording and adding to null group" %
str(arp.hwsrc))
self.hosts[str(arp.hwsrc)] = h
core.db.update_host(h)
return
# Is Local out of sync
if not str(arp.hwsrc) in self.hosts:
print("Host %s is new to local db. Syncing with remote db." %
str(arp.hwsrc))
h["group_no"] = host_a["group_no"]
self.hosts[str(arp.hwsrc)] = h
core.db.update_host(h)
e = Event()
e.host = host_a
self.handle_event("host-update", e)
# Is Local out of sync
h["group_no"] = host_a["group_no"]
if host_a["ip"] != h["ip"] or host_a["port_no"] != h["port_no"] \
or host_a["_parent"] != h["_parent"] or host_a["active"] != h["active"]:
print("Saving host %s changes to db and installing new flows." %
str(arp.hwsrc))
self.hosts[str(arp.hwsrc)] = h
core.db.update_host(h)
e = Event()
e.host = host_a
self.handle_event("host-update", e)
if host_a["group_no"] is "-1":
print("Not broadcasting ARP from Host %s" % str(arp.hwsrc))
return
else:
host_b = core.db.find_host({"ip": str(arp.protodst)})
if host_b is None or host_b["group_no"] is -1: return
self.send_arp(host_a, host_b)
def __init__(
self,
sim_params,
on_error='log',
# finance module
slippage_model=None,
commission_model=None,
restrictions=None,
execution_style=None,
trading_controls=None,
account_controls=None,
ledger=None,
# pd
underneath_model=None,
broker=None,
# pipe API
pipelines=None,
final=None,
disallow_righted=True,
disallowed_violation=True,
engine=None,
# risk
risk_fuse=None,
risk_models=None,
risk_allocation=None,
# metric
_analyze=None,
metrics_set=None,
metrics_tracker=None,
# extra
namespace=None,
initialize=None,
platform='px_trader',
_handle_data=None,
logger=None,
before_trading_start=None,
create_event_context=None,
analyse=None,
**initialize_kwargs):
self.sim_params = sim_params
self.benchmark_returns = self._calculate_benchmark_returns()
# set finance module
self.slippage = slippage_model or NoSlippage()
self.commission = commission_model or NoCommission()
self.execution_style = execution_style or MarketOrder()
self.restrictions = restrictions or NoRestrictions()
self.account_controls = account_controls or []
self.trading_controls = trading_controls or [NoControl()]
self.ledger = ledger
# set engine module
self.violated = disallowed_violation
self.righted = disallow_righted
self.final = final or Final()
self.pipelines = pipelines or []
self.pipeline_engine = engine
# set risk module
self.risk_allocation = risk_allocation or Equal()
self.risk_models = risk_models or NoRisk()
self.risk_fuse = risk_fuse or NoFuse()
# set pd module
self.underneath_module = underneath_model or SimpleUncover()
self.broker = broker
# set metrics module
if metrics_set is not None:
self._metrics_set = metrics_set
else:
self._metrics_set = default_metrics()
if metrics_tracker is not None:
self.tracker = metrics_tracker
else:
self.tracker = self._create_metrics_tracker()
# analyse
self._analyze = _ClassicRiskMetrics()
# set event manager
self.event_manager = EventManager(create_event_context)
self.event_manager.add_event(
Event(Always(), _handle_data),
prepend=True,
)
self.initialized = False
self.logger = logger
self._platform = platform
self.on_error = on_error
self.initialize_kwargs = initialize_kwargs or {}
self._recorded_vars = {}
self.namespace = namespace or {}
def noop(*args, **kwargs):
pass
self._initialize = initialize or noop
self._before_trading_start = before_trading_start or noop
def handleInput(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.stateManager.endGame()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.stateManager.endGame()
elif event.key == pygame.K_UP:
self.menuManager.curMenu.moveUp()
elif event.key == pygame.K_DOWN:
self.menuManager.curMenu.moveDown()
elif event.key == pygame.K_RETURN:
self.menuManager.curMenu.execute()
elif event.key == pygame.K_m:
# only change if there is a level loaded
if self.stateManager.stateList[
StateManager.
GAMESTATE].levelManager.curLevel != None:
Event().raiseCstmEvent(
Event.SWITCHSTATE,
argDict={"state": StateManager.GAMESTATE})
#custom events
elif event.type == Event().NEWGAME:
self.stateManager.switchState(self.stateManager.GAMESTATE)
gameState = self.stateManager.getGameState()
gameState.levelManager.loadLevel(
gameState.levelManager.FIRSTLEVEL)
elif event.type == Event().SWITCHMENU:
self.menuManager.loadMenu(event.mIndex)
elif event.type == Event().SWITCHSTATE:
self.stateManager.switchState(event.state)
elif event.type == Event().SWITCHLEVEL:
self.stateManager.getGameState().levelManager.loadLevel(
event.levelIndex)
Event().raiseCstmEvent(Event().SWITCHSTATE, {"state": 0})
elif event.type == Event().OPTIONSWITCH:
itemChanged = False
if event.option == "ISFULLSCR" or event.option == "ISDEBUG" or event.option == "ISSOUND":
if Options.getOption(event.option) == False:
Options.setOption(event.option, True)
itemChanged = True
elif Options.getOption(event.option) == True:
Options.setOption(event.option, False)
itemChanged = True
elif event.option == "VOLUME" or event.option == "RESOLUTION":
list = []
if event.option == "VOLUME": list = Options.volumeList
elif event.option == "RESOLUTION":
list = Options.resolutionList
valFound = False
for i in range(0, len(list) - 1):
if list[i] == Options.getOption(event.option):
valFound = True
Options.setOption(event.option,
list[i + 1 % len(list)])
itemChanged = True
break
if not valFound:
Options.setOption(event.option, list[0])
itemChanged = True
if itemChanged:
if event.option == "ISFULLSCR" or event.option == "RESOLUTION":
if Options.getOption("ISFULLSCR"):
self.screen = pygame.display.set_mode(
Options.getOption("RESOLUTION"),
pygame.FULLSCREEN)
else:
self.screen = pygame.display.set_mode(
Options.getOption("RESOLUTION"))
elif event.option == "VOLUME":
SoundManager.updateVolumes()
def onClick(self):
Event().raiseCstmEvent(self.eventType, argDict=self.eventArgs)
