def __init__(self):
Thread.__init__(self)
self.daemon = True
self.runthread = True
self.idlesleep = 0.01
self.eventpipe = deque()
self.em = EventManager()
def main():
"""..."""
evManager = EventManager()
sharedObjectRegistry = {}
#import random
#rng = random.Random()
#clientID = rng.randrange( 1, 10000 )
#playerName = str( rng.randrange(1,100) )
#player = Player( evManager )
from sjbeasts import AnimationTimerController
keybd = PygameMasterController(evManager)
spinner = CPUSpinnerController(evManager)
animationSpinner = AnimationTimerController(evManager)
pygameView = PygameMasterView(evManager)
phonyModel = PhonyModel(evManager, sharedObjectRegistry)
import gui
gui.playerRef = gui.GlobalPlayer(evManager)
print gui.playerRef
#from twisted.spread.jelly import globalSecurity
#globalSecurity.allowModules( network )
from twisted.internet import reactor
serverController = NetworkServerController(evManager, reactor)
serverView = NetworkServerView(evManager, sharedObjectRegistry,
serverController)
spinner.Run()
def main():
# create the managers
eMngr = EventManager()
gMngr = GraphicManager(eMngr)
iMngr = InputManager(eMngr, gMngr)
uMngr = UpdateManager(eMngr)
sMngr = SoundManager(eMngr)
nMngr = NetworkManager(eMngr)
print "starting game"
# create file with input
playFile = open(sys.argv[1], 'r')
# start the managers
eMngr.start()
gMngr.start()
iMngr.start()
uMngr.start()
sMngr.start()
nMngr.start()
# create game and start it
# FIXME playfile should be passed to the updateManager
game = Game(iMngr, uMngr, gMngr, sMngr, nMngr, playFile)
game.run()
# close the managers
eMngr.stop()
uMngr.stop()
iMngr.stop()
gMngr.stop()
sMngr.stop()
nMngr.stop()
def __init__(self):
self.clock = pygame.time.Clock()
self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
self.event_manager = EventManager()
self.current_page = Page(pygame.Surface((0, 0)), BLACK,
self.event_manager)
self.name_1 = "Batman"
self.name_2 = "Superman"
def __init__(self, port=None, address=None):
Thread.__init__(self)
self.daemon = True
self.runthread = True
self.port = port
self.address = address
self.pluginlist = None
self.clients = {}
self.event_subscriptions = {}
self.em = EventManager()
def Main():
# Sample usage used in a demo... ----
em = EventManager()
recordedEvents = em.Record(10)
em.WriteToFile()
em.Play()
def __init__(self):
Thread.__init__(self)
self.daemon = True
self.host = None
self.port = None
self.user = None
self.password = None
self.runthread = True
self.sendlock = False
self.pluginlist = None
self.em = EventManager()
def Notify(self, event):
HomeButton.Notify(self, event)
if isinstance(event, PlayerExplorationEvent):
print "SWITCHING TO EXPLORE"
from screen_explore import ExploreScreen, \
ExploreScreenController
from eventmanager import EventManager
dummyEvManager = EventManager()
view = ExploreScreen(dummyEvManager, event.player, event.turns)
cont = ExploreScreenController(self.evManager)
ev = GUIChangeScreenRequest(([view], [cont]))
self.evManager.Post(ev)
def __init__(self):
Thread.__init__(self)
self.daemon = True
self.runthread = True
self.idlesleep = 0.01
self.eventpipe = deque()
self.em = EventManager()
self.ami = None
self.queuereadflag = False
self.queuestats = {}
self.extstates = {}
self.channels = {}
self.status_expire = 60
self.status_timeout = 1
def Notify(self, event):
HomeButton.Notify(self, event)
if isinstance(event, GoToStoreEvent):
print "SWITCHING TO STORE"
from screen_store import StoreScreen, \
StoreScreenController
from eventmanager import EventManager
# we don't want the new Gui reacting to events before
# it is active, so give it a dummy event manager that
# won't send it anything
dummyEvManager = EventManager()
view = StoreScreen(dummyEvManager, event.player)
cont = StoreScreenController(self.evManager)
ev = GUIChangeScreenRequest(([view], [cont]))
self.evManager.Post(ev)
def main(srvHost, srvPort):
w = dict()
em = EventManager()
nm = NetworkManager(em, w)
FRAME_TIME = 0.2 # 200 ms
c = Clock(FRAME_TIME)
c.start()
slept_time = 0.0
nm.start(srvHost, srvPort)
counter = 100
exit = False
while not exit:
nm.update(slept_time + c.time_passed())
counter -= 1
if counter <= 0:
exit = True
slept_time = c.time_left()
c.sleep()
print "%s" % (counter * FRAME_TIME)
def main():
"""..."""
from twisted.spread import pb
from twisted.application import service
from twisted.cred.authorizer import DefaultAuthorizer
from twisted.internet import reactor, app
evManager = EventManager()
sharedObjectRegistry = {}
log = TextLogView(evManager)
timer = TimerController(evManager, reactor)
#clientContr = NetworkClientController( evManager, sharedObjectRegistry )
clientView = NetworkClientView(evManager, sharedObjectRegistry)
game = Game(evManager)
#from twisted.spread.jelly import globalSecurity
#globalSecurity.allowModules( network )
application = app.Application("myServer")
auth = DefaultAuthorizer(application)
#create a service, tell it to generate NetworkClientControllers
serv = pb.Service("myService", application, auth)
serv.perspectiveClass = NetworkClientController
#create a Perspective
per1 = serv.createPerspective("perspective1")
per1.PostInit(evManager, sharedObjectRegistry)
#create an Identity
iden1 = auth.createIdentity("user1")
iden1.setPassword("asdf")
#allow it access to the perspective named perspective1
iden1.addKeyByString("myService", "perspective1")
auth.addIdentity(iden1)
#application.listenTCP(8000, pb.BrokerFactory(clientContr) )
application.listenTCP(8000, pb.PBServerFactory(pb.AuthRoot(auth)))
application.run(save=0)
def __init__(self, app, parent=None, background_color=(0, 0, 0)):
MediaNavNode.__init__(self)
self.screen = app.screen #: The screen surface to draw to
self.screen_width = self.screen.get_width()
self.screen_height = self.screen.get_height()
self.background_color = background_color #: The background color to fill the screen with
self.background_image = None
self.parent = parent #: The parent page, used for navigation
self.widgets = [] #: A list of widgets in this page
self.app = app #: The app object under which this page runs
# Load the background
# TODO: Remove hardcoding of background
# Make the page an event dispatcher
self.set_event_manager(EventManager())
self.is_event_dispatcher = True
# Make the page an event listener
self.event_manager.register_listener(self)
self.is_event_listener = True
def main(): """...""" evManager = EventManager() spinner = CPUSpinnerController( evManager ) animationSpinner = AnimationTimerController( evManager ) pygameView = PygameMasterView( evManager ) pygameCont = PygameMasterController( evManager ) game = Game( evManager ) import gui gui.playerRef = gui.GlobalPlayer( evManager ) print gui.playerRef while 1: try: spinner.Run() except NotImplementedError, msg: text = "Not Implemented: "+ str(msg) ev = ExceptionEvent( text ) evManager.Post( ev ) else: break;
def display(self):
del self.texts[2:]
TOP = self.texts[1][1].top + 35
format_string = "{rank:>4d} | {name:20s} | {matches_played:>14d} | {wins:>4d} | {losses:>6d} | {point_diff:>16d} | {win_per:>14.2f}"
for index, leader in enumerate(self.leaderboard.get_top_number(10)):
res = SMALL.render(
format_string.format(**dict(
zip(("rank", "name", "matches_played", "wins", "losses",
"point_diff", "win_per"), leader))), True, BLACK)
res_rect = res.get_rect()
res_rect.top = TOP + 35 * index
res_rect.centerx = HALF_WIDTH
self.texts.append((res, res_rect))
super(LeaderBoardPage, self).display()
if __name__ == '__main__':
from properties import SCREEN_HEIGHT, SCREEN_WIDTH
from eventmanager import EventManager
c = pygame.time.Clock()
s = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
e = EventManager()
l = LeaderBoardPage(s, e)
l.display()
while True:
e.run()
c.tick(30)
def __init__(self):
from optparse import OptionParser
parser = OptionParser(version="%prog 0.1.1")
parser.add_option('-r', '--replay',
dest='infile',
help='uses the recorded input instead of the user input')
parser.add_option('-d', '--dump',
dest='outfile',
help='writes the user input into a file')
(options, args) = parser.parse_args()
self.evm = EventManager()
self.evm.RegisterListener(self)
if options.infile:
self.te = InputPlayer(self.evm, options.infile)
else:
self.te = TickEmitter(self.evm)
self.system = System(self.evm)
self.logic = Logic(self.evm)
if options.outfile:
self.input_recorder = InputRecorder(self.evm, options.outfile)
self.load_map('map2.xml')
#########################################
## create windows
#########################################
self.main_window = Widget(0,0,110,27)
self.window = Widget(84,1,25,25)
self.windows = {}
self.windows['lives'] = Widget(1,1,23,3)
self.windows['money'] = Widget(1,4,23,3)
self.windows['points'] = Widget(1,7,23,3)
for w in self.windows.values():
self.window.add_child(w)
self.main_window.add_child(self.window)
self.wave_window = Widget(58,1,25,25)
self.main_window.add_child(self.wave_window)
wave_label = Widget(1,1,23,1)
wave_label.label = 'Waves'
wave_label.border = False
self.wave_window.add_child(wave_label)
self.wave_windows = []
for i in range(0,4):
w = WaveWidget(1,2 + i * 5, 23, 5)
self.wave_windows.append(w)
self.wave_window.add_child(w)
self.wc = WidgetController(self.evm,self.system)
help_window = Widget(1,22,56,4)
help_window1 = Widget(0,1,56,1)
help_window1.label = "Press space to send next wave. Hit q to quit the game."
help_window1.border = False
help_window.add_child(help_window1)
help_window2 = Widget(0,2,56,1)
help_window2.label = "Click anywhere on the map to place a tower."
help_window2.border = False
help_window.add_child(help_window2)
self.main_window.add_child(help_window)
def __init__(self):
self.verbose = False
self.visual_debug = False
# Llama Stuff
self.llama_controller = LlamaControler()
# Control Stuff
self.want_to_expand = False
self.researched_warpgate = False
# Attack stuff
self.army_manager = ArmyManager(bot=self)
self.attack_target = None
self.units_available_for_attack = {
ZEALOT: 'ZEALOT',
STALKER: 'STALKER'
}
self.minimum_army_size = 15
# Defense stuff
self.threat_proximity = 20
self.defending_units = {}
self.defend_around = [PYLON, NEXUS]
# Threat stuff stuff
self.defending_from = {}
# Scout stuff
self.scouting_units = set()
self.number_of_scouting_units = 3
self.scout_interval = 30 # Seconds
self.scout_timer = 0
self.map_size = None
# Expansion and macro stuff
self.auto_expand_after = 300 # 5 Minutes
self.auto_expand_mineral_threshold = 22 # Should be 2.5 ~ 3 fully saturated bases
self.maximum_workers = 80
self.gateways_per_nexus = 2
# Research stuff
self.start_forge_after = 180 # seconds - 4min
self.forge_research_priority = ['ground_weapons', 'shield']
self.event_manager = EventManager()
self.upgrades = {
'ground_weapons': [
FORGERESEARCH_PROTOSSGROUNDWEAPONSLEVEL1,
FORGERESEARCH_PROTOSSGROUNDWEAPONSLEVEL2,
FORGERESEARCH_PROTOSSGROUNDWEAPONSLEVEL3
],
'ground_armor': [
FORGERESEARCH_PROTOSSGROUNDARMORLEVEL1,
FORGERESEARCH_PROTOSSGROUNDARMORLEVEL2,
FORGERESEARCH_PROTOSSGROUNDARMORLEVEL3
],
'shield': [
FORGERESEARCH_PROTOSSSHIELDSLEVEL1,
FORGERESEARCH_PROTOSSSHIELDSLEVEL2,
FORGERESEARCH_PROTOSSSHIELDSLEVEL3
]
}
self.upgrade_names = {
FORGERESEARCH_PROTOSSGROUNDWEAPONSLEVEL1: 'GROUND WEAPONS 1',
FORGERESEARCH_PROTOSSGROUNDWEAPONSLEVEL2: 'GROUND WEAPONS 2',
FORGERESEARCH_PROTOSSGROUNDWEAPONSLEVEL3: 'GROUND WEAPONS 2',
FORGERESEARCH_PROTOSSGROUNDARMORLEVEL1: 'GROUND ARMOR 2',
FORGERESEARCH_PROTOSSGROUNDARMORLEVEL2: 'GROUND ARMOR 2',
FORGERESEARCH_PROTOSSGROUNDARMORLEVEL3: 'GROUND ARMOR 2',
FORGERESEARCH_PROTOSSSHIELDSLEVEL1: 'SHIELDS 1',
FORGERESEARCH_PROTOSSSHIELDSLEVEL2: 'SHIELDS 2',
FORGERESEARCH_PROTOSSSHIELDSLEVEL3: 'SHIELDS 3'
}
def process_events(cfg_csv_path, cfg_csv_parsing, cfg_open_edx_spec, timestamp_format):
print('****** Processing events *******')
events_processing_duration = time.time()
# MOOCdb storage interface
moocdb = MOOCdb(cfg_csv_path['moocdb_csv_dir'])
# Instanciating the piping architecture
event_formatter = EventFormatter(moocdb, TIMESTAMP_FORMAT=timestamp_format)
resource_manager = ResourceManager(moocdb, HIERARCHY_ROOT='https://')
event_manager = EventManager(moocdb)
submission_manager = SubmissionManager(moocdb)
curation_helper = CurationHelper(cfg_csv_path['moocdb_csv_dir'])
clickevents_manager = ClickEventsManager(moocdb)
print("Processing %s" % cfg_csv_path['edx_track_event_path'])
extract = extractor.CSVExtractor(cfg_csv_path, cfg_csv_parsing)
num_rows = int(
check_output(["wc", "-l", cfg_csv_path['edx_track_event_path']]).split(" ")[0])
event_count = 0
for raw_event in extract:
event_count += 1
if event_count % 500 == 0:
progress = 'Progress: %0.4f%%' % (100.0 * float(event_count) /
float(num_rows))
# A print statement is not used here because
# a newline is automatically appended on each print, whereas
# we want to use the CR character to move the terminal
# pointer back to the beginning of the same line.
print(progress)
sys.stdout.write("\033[F")
# Skip events explicitly not handled by qpipe
if event_formatter.pass_filter(raw_event) is False:
continue
event = event_formatter.polish(raw_event)
resource_id = resource_manager.create_resource(event)
event.set_data_attr('resource_id', resource_id)
submission_manager.update_submission_tables(event)
curation_helper.record_curation_hints(event)
clickevents_manager.record(event, cfg_open_edx_spec)
event_manager.store_event(event)
print('* All events processed')
print('* Writing CSV output to : %s' % cfg_csv_path['moocdb_csv_dir'])
event_formatter.serialize()
event_manager.serialize()
resource_manager.serialize(pretty_print_to=cfg_csv_path['resource_hierarchy_path'])
submission_manager.serialize(pretty_print_to=cfg_csv_path['problem_hierarchy_path'])
curation_helper.serialize()
print('* Writing resource hierarchy to : %s' % cfg_csv_path['resource_hierarchy_path'])
print('* Writing problem hierarchy to : %s' % cfg_csv_path['problem_hierarchy_path'])
metadata_file_path = os.path.join(cfg_csv_path['moocdb_csv_dir'], 'metadata.csv')
try:
os.remove(metadata_file_path)
print('* Removed old metadata file at %s' % metadata_file_path)
except OSError:
pass
print('* Writing metadata row to : %s' % metadata_file_path)
try:
with open(metadata_file_path, 'w') as metafile:
process = Popen(['git', 'describe', '--always'], stdout=PIPE)
commit_hash, err = process.communicate()
commit_hash = commit_hash.rstrip() if err is None else ''
events_processing_duration = (
int(time.time() - events_processing_duration)) / 60 # minutes
metafile.write('%s,%s\n' %
(commit_hash, events_processing_duration))
except OSError:
pass
moocdb.close()
#
# Results generators and caching
#
import json
import gevent
import Database
import Options
import RHUtils
import logging
from monotonic import monotonic
from Language import __
from eventmanager import Evt, EventManager
from RHRace import WinCondition
Events = EventManager()
logger = logging.getLogger(__name__)
class CacheStatus:
INVALID = 'invalid'
VALID = 'valid'
def invalidate_all_caches(DB):
''' Check all caches and invalidate any paused builds '''
for race in Database.SavedRaceMeta.query.all():
race.cacheStatus = CacheStatus.INVALID
for heat in Database.Heat.query.all():
heat.cacheStatus = CacheStatus.INVALID
'time': parse_time('2013-11-10 06:00:00')
}),
Event({
'_id': 3,
'anon_screen_name': 'A',
'time': parse_time('2013-11-10 06:05:00')
}),
Event({
'_id': 4,
'anon_screen_name': 'B',
'time': parse_time('2013-11-10 06:10:00')
}),
Event({
'_id': 5,
'anon_screen_name': 'A',
'time': parse_time('2013-11-10 06:10:00')
})
]
if __name__ == '__main__':
manager = EventManager()
for event in EVENTS:
e = manager.stage_event(event)
if e:
print ','.join([e['_id'], e['anon_screen_name'], str(e.duration)])
# Expected output is:
# 1,A,5
# 2,B,10
# 3,A,5
