def __init__(self, evManager, objects, container=None):
WidgetAndContainer.__init__(self, evManager, container)
EventManager.__init__(self)
self.image = pygame.Surface((400, 130), SRCALPHA)
self.image.fill((90, 90, 90))
self.rect = self.image.get_rect()
#copy the rect
self.scrollState = self.rect.move(0, 0)
leftEvent = GUIScrollRequest(self, -5)
rightEvent = GUIScrollRequest(self, 5)
self.leftButton = ScrollButton(self, self, leftEvent)
self.widgets.append(self.leftButton)
self.rightButton = ScrollButton(self, self, rightEvent)
self.widgets.append(self.rightButton)
self.xPadding = 4
maxWidth = len(objects) * (IconSprite.maxWidth + self.xPadding)
maxHeight = IconSprite.maxHeight
self.scrollSurface = pygame.Surface((maxWidth, maxHeight), SRCALPHA)
for obj in objects:
newSprite = IconSprite(self, obj, self)
self.widgets.append(newSprite)
self.ArrangeWidgets()
self.update()
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 test_listen(self):
listen_port = 8000
test_message = pickle.dumps('test_message')
event_manager = EventManager([], listen_port);
# Wait for thread to be ready
while not event_manager.is_listening():
time.sleep(0)
# Mock the event_received method
m = mox.Mox()
mock_event_received = m.CreateMockAnything()
event_manager.event_received = new.instancemethod(mock_event_received,
event_manager)
mock_event_received(event_manager, 'test_message')
m.ReplayAll()
s = socket.create_connection((socket.gethostname(), listen_port))
s.sendall(test_message)
s.shutdown(socket.SHUT_RDWR)
s.close()
event_manager.shutdown()
# Make sure event_received was called on the EventManager
m.VerifyAll()
def __init__(self):
Thread.__init__(self)
self.daemon = True
self.runthread = True
self.idlesleep = 0.01
self.eventpipe = deque()
self.em = EventManager()
def test_subscribe_same(self):
event_type = 'test_event_type'
controller = 'dummy_controller'
event_manager = EventManager([]);
event_manager.subscribe(event_type, controller)
event_manager.subscribe(event_type, controller)
self.assertEqual(len(event_manager.subscriptions[event_type]), 1)
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 test_serialize_deserialize_event(self):
event_type = EventType.DOOR_SENSOR_EVENT
timestamp = datetime.utcnow()
event = Event(event_type, timestamp)
event_manager = EventManager([]);
serialized = event_manager.serialize_event(event)
deserialized = event_manager.deserialize_event(serialized)
self.assertIsInstance(deserialized, Event)
self.assertEqual(deserialized.get_event_type(), event_type)
self.assertEqual(deserialized.get_timestamp(), timestamp)
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 test_broadcast_event(self):
test_message = 'test_message'
peers = [('localhost', 8000)]
event_manager = EventManager(peers);
event = 'test_event'
# Create a mock EventManager to verify it receives the test event
mock_event_manager = mox.MockObject(EventManager)
thread = ListenerThread(mock_event_manager, 8000)
thread.start()
event_manager.broadcast_event(event)
thread.stop()
thread.join()
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 __init__(self):
logutils.setup_logging("mustikkabot")
self.log = logging.getLogger("mustikkabot")
self.basepath = tools.find_basepath()
self.confdir = os.path.join(self.basepath, "config")
self.datadir = os.path.join(self.basepath, "data")
self.srcdir = os.path.join(self.basepath, "src")
setup.setup(self)
setup.do_migrations(self)
self.ircsock = None
self.lastReceived = None
self.user = None
self.channel = None
self.eventmanager = EventManager()
""" :type: EventManager"""
self.modulemanager = ModuleManager()
""" :type: ModuleManager"""
self.accessmanager = AccessManager()
""" :type: AccessManager"""
self.timemanager = TimeManager()
""" :type: TimeManager"""
self.run = True
def __init__(self): Thread.__init__(self) self.daemon = True self.runthread = True self.idlesleep = 0.01 self.eventpipe = deque() self.em = EventManager()
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 __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()
class ChannelEventLogger(Thread):
def __init__(self):
Thread.__init__(self)
self.daemon = True
self.runthread = True
self.idlesleep = 0.01
self.eventpipe = deque()
self.em = EventManager()
def config(self, conf):
return True
def plugins(self, plugins):
self.pluginlist = plugins
self.em.plugins(plugins)
def add_event(self, event):
self.eventpipe.appendleft(event)
def send(self, send_string):
return True
def run(self):
ret = self.em.add_event_handler('ChannelEventLogger', 1)
ldebug('starting CEL thread')
while self.runthread:
if (self.eventpipe):
event = self.eventpipe.pop()
else:
event = False
sleep(self.idlesleep)
continue
ldebug('CEL: %s' % event)
ldebug('closing CEL thread')
def stop(self):
self.runthread = False
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()
class ChannelEventLogger(Thread):
def __init__(self):
Thread.__init__(self)
self.daemon = True
self.runthread = True
self.idlesleep = 0.01
self.eventpipe = deque()
self.em = EventManager()
def config(self, conf):
return True
def plugins(self, plugins):
self.pluginlist = plugins
self.em.plugins(plugins)
def add_event(self, event):
self.eventpipe.appendleft(event)
def send(self, send_string):
return True
def run(self):
ret = self.em.add_event_handler('ChannelEventLogger', 1)
ldebug('starting CEL thread')
while self.runthread:
if (self.eventpipe):
event = self.eventpipe.pop()
else:
event = False
sleep(self.idlesleep)
continue
ldebug('CEL: %s' % event)
ldebug('closing CEL thread')
def stop(self):
self.runthread = False
class Browser(object):
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 get_shower(self, klass, *args):
def shower():
self.current_page.clean()
self.current_page = klass(self.screen, self.event_manager, *args)
self.current_page.display()
return shower
def run(self):
self.get_shower(SplashScreen)()
def cb1(value):
self.name_1 = value
self.get_shower(TextInput, "Enter Player 2's name", cb2)()
def finish_cb():
self.get_shower(LeaderBoardPage)()
def cb2(value):
self.name_2 = value
self.get_shower(BoardPage, (self.name_1, self.name_2), finish_cb)()
self.event_manager.add_timer(
2, self.get_shower(TextInput, "Enter Player 1's name", cb1))
while True:
self.event_manager.run()
self.clock.tick(FPS)
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 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 __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):
WidgetAndContainer.Notify(self, event)
if isinstance( event, GUIScrollRequest ) \
and event.target is self:
self.Scroll(event.amount)
#determine what icons are accessible, and send events through
#to them.
if isinstance( event, GUIClickEvent ) \
or isinstance( event, GUIMouseMoveEvent ):
if self.rect.collidepoint(event.pos):
from copy import copy
modifiedEvent = copy(event)
pos = list(event.pos)
pos[0] = pos[0] - self.rect.x
pos[1] = pos[1] - self.rect.y
if pos[1] < self.leftButton.rect.top:
pos[0] = pos[0] + self.scrollState.x
pos[1] = pos[1] + self.scrollState.y
modifiedEvent.pos = (pos)
EventManager.Post(self, modifiedEvent)
else:
EventManager.Post(self, event)
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 test_event_received_multiple_events(self):
door_event = Event(EventType.DOOR_SENSOR_EVENT)
window_event = Event(EventType.WINDOW_SENSOR_EVENT)
# Set up controller mocks
door_controller = mox.MockObject(Controller)
door_controller.handle_event(door_event)
mox.Replay(door_controller)
window_controller = mox.MockObject(Controller)
mox.Replay(window_controller)
event_manager = EventManager([]);
event_manager.subscribe(EventType.DOOR_SENSOR_EVENT, door_controller)
event_manager.subscribe(EventType.WINDOW_SENSOR_EVENT, window_controller)
# Send event
event_manager.event_received(door_event)
event_manager.process_events()
mox.Verify(door_controller)
mox.Verify(window_controller)
def test_event_received(self):
event_type = EventType.DOOR_SENSOR_EVENT
event = Event(event_type)
# Set up controller mock
controller = mox.MockObject(Controller)
controller.handle_event(event)
mox.Replay(controller)
event_manager = EventManager([]);
event_manager.subscribe(event_type, controller)
event_manager.event_received(event)
event_manager.process_events()
mox.Verify(controller)
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 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
class SpatialLlama(sc2.BotAI):
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 on_start(self):
if self.verbose:
print('%6.2f Rise and shine' % (0))
self.map_size = self.game_info.map_size
self.army_manager.init()
# TODO Tweak these values
self.event_manager.add_event(self.distribute_workers, 10)
self.event_manager.add_event(self.manage_upgrades, 5.3)
self.event_manager.add_event(self.build_workers, 2.25)
self.event_manager.add_event(self.manage_supply, 1)
self.event_manager.add_event(self.build_assimilator, 2.5)
self.event_manager.add_event(self.build_structures, 2.4)
self.event_manager.add_event(self.build_nexus, 5)
self.event_manager.add_event(self.build_army, 0.9)
self.event_manager.add_event(self.scout_controller, 7)
self.event_manager.add_event(self.army_controller, 1.1)
self.event_manager.add_event(self.defend, 2)
self.event_manager.add_event(self.attack, 3)
self.event_manager.add_event(self.expansion_controller, 5)
async def on_step(self, iteration):
sys.stdout.flush()
if iteration == 0: # Do nothing on the first iteration to avoid
# everything being done at the same time
await self.chat_send(self.llama_controller.get_random_llama_fact())
return
events = self.event_manager.get_current_events(self.time)
for event in events:
await event()
await self.debug()
async def expansion_controller(self):
if self.time > self.auto_expand_after:
number_of_minerals = sum([
self.state.mineral_field.closer_than(10, x).amount
for x in self.townhalls
])
if number_of_minerals <= self.auto_expand_mineral_threshold:
self.want_to_expand = True
async def army_controller(self):
await self.army_manager.step()
async def scout_controller(self):
current_time = self.time
if current_time - self.scout_timer > self.scout_interval:
self.scout_timer = self.time
n_scouting_units_assigned = len(self.scouting_units)
missing_scouting_units = self.number_of_scouting_units - n_scouting_units_assigned
# Uses the previous assigned scouting units to keep scouting
for scouting_unit_tag in list(self.scouting_units):
unit = self.units.find_by_tag(scouting_unit_tag)
if unit.exists:
target = random.sample(list(self.expansion_locations),
k=1)[0]
await self.do(unit.attack(target))
else:
# If a scouting unit isnt found then it is (most likely) dead
# and we need another to replace it
self.scouting_units.remove(unit)
missing_scouting_units += 1
if missing_scouting_units > 0:
idle_stalkers = self.units(STALKER).idle
if idle_stalkers.exists:
if self.verbose:
print('%6.2f Scouting' % (self.time))
# If there is no unit assigned to scouting
# the the idle unit furthest from the base
for i in range(missing_scouting_units):
stalker = idle_stalkers.furthest_to(
self.units(NEXUS).first)
if stalker:
target = random.sample(list(
self.expansion_locations),
k=1)[0]
await self.do(stalker.attack(target))
self.scouting_units
idle_stalkers = self.units(STALKER).idle
if not idle_stalkers.exists:
break
else:
pass
#print(' - no units to scout')
async def defend(self):
# Attacks units that get too close to import units
for structure_type in self.defend_around:
for structure in self.units(structure_type):
threats = self.known_enemy_units.closer_than(
self.threat_proximity, structure.position)
if threats.exists:
target_threat = None
new_threat_count = 0
for threat in threats:
if threat.tag not in self.defending_from:
self.defending_from[threat.tag] = None
target_threat = threat
new_threat_count += 1
if new_threat_count > 0:
if self.verbose:
print('%6.2f found %d threats' %
(self.time, new_threat_count))
await self.target_enemy_unit(target_threat)
break
async def target_enemy_unit(self, target):
# sends all idle units to attack an enemy unit
zealots = self.units(ZEALOT).idle
stalkers = self.units(STALKER).idle
total_units = zealots.amount + stalkers.amount
# Only sends 1 unit to attack a worker
is_worker = target.type_id in [PROBE, SCV, DRONE]
if self.verbose:
print('%6.2f defending with %d units' % (self.time, total_units))
for unit_group in [zealots, stalkers]:
for unit in unit_group:
if is_worker:
await self.do(unit.attack(target))
if self.verbose:
print(
' - target is a probe, sending a single unit')
return
else:
await self.do(unit.attack(target.position))
async def attack(self):
total_units = 0
for unit_type in self.units_available_for_attack.keys():
total_units += self.units(unit_type).idle.amount
if total_units >= self.minimum_army_size:
if self.army_manager.army_size() == 0:
for unit_type in self.units_available_for_attack.keys():
for unit in self.units(unit_type).idle:
self.army_manager.add(unit.tag)
await self.army_manager.group_at_map_center(
wait_for_n_units=total_units - 1,
timeout=30,
move_towards_position=self.enemy_start_locations[0])
if self.verbose:
print('%6.2f Attacking with %d units' %
(self.time, total_units))
else:
for unit_type in self.units_available_for_attack.keys():
for unit in self.units(unit_type).idle:
self.army_manager.add(unit.tag,
options={'reinforcement': True})
if self.verbose:
print('%6.2f reinforcing with %d units' %
(self.time, total_units))
async def build_army(self):
if not self.can('build_army'):
return
# Iterates over all gateways
for gateway in self.units(GATEWAY).ready.noqueue:
abilities = await self.get_available_abilities(gateway)
# Checks if the gateway can morph into a warpgate
if AbilityId.MORPH_WARPGATE in abilities and self.can_afford(
AbilityId.MORPH_WARPGATE):
await self.do(gateway(MORPH_WARPGATE))
# Else, tries to build a stalker
elif AbilityId.GATEWAYTRAIN_STALKER in abilities:
if self.can_afford(STALKER) and self.supply_left > 2:
await self.do(gateway.train(STALKER))
# Else, tries to build a zealot
elif AbilityId.GATEWAYTRAIN_ZEALOT in abilities:
if self.can_afford(ZEALOT) and self.supply_left > 2:
await self.do(gateway.train(ZEALOT))
# Iterates over all warpgates and warp in stalkers
for warpgate in self.units(WARPGATE).ready:
abilities = await self.get_available_abilities(warpgate)
if AbilityId.WARPGATETRAIN_STALKER in abilities:
if self.can_afford(STALKER) and self.supply_left > 2:
# Smartly find a good pylon boy to warp in units next to it
pylon = self.pylon_with_less_units()
#pos = pylon.position.to2.random_on_distance(4)
pos = pylon.position.to2
placement = await self.find_placement(PYLON,
pos,
placement_step=1,
max_distance=4)
if placement is not None:
await self.do(warpgate.warp_in(STALKER, placement))
else:
# otherwise just brute force it
for _ in range(5): # TODO tweak this
pylon = self.units(PYLON).ready.random
#pos = pylon.position.to2.random_on_distance(4)
pos = pylon.position.to2
placement = await self.find_placement(
PYLON, pos, placement_step=1, max_distance=4)
if placement is not None:
await self.do(
warpgate.warp_in(STALKER, placement))
break
async def build_structures(self):
if not self.can('build_structures'):
return
# Only start building main structures if there is
# at least one pylon
if not self.units(PYLON).ready.exists:
return
else:
pylon = self.units(PYLON).ready.random
number_of_gateways = self.units(WARPGATE).amount + self.units(
GATEWAY).amount
# Build the first gateway
if self.can_afford(GATEWAY) and number_of_gateways == 0:
if self.verbose:
print('%6.2f starting first gateway' % (self.time))
await self.build(GATEWAY, near=pylon)
# Build the cybernetics core after the first gateway is ready
if self.can_afford(CYBERNETICSCORE) and self.units(
CYBERNETICSCORE).amount == 0 and self.units(GATEWAY).ready:
if self.verbose:
print('%6.2f starting cybernetics' % (self.time))
await self.build(CYBERNETICSCORE, near=pylon)
self.want_to_expand = True
# Build more gateways after the cybernetics core is ready
if self.can_afford(GATEWAY) and self.units(CYBERNETICSCORE).ready and (
(number_of_gateways < 4 and self.units(NEXUS).amount <= 2) or
(number_of_gateways <=
self.units(NEXUS).amount * self.gateways_per_nexus)):
if self.verbose:
print('%6.2f starting more gateways' % (self.time))
await self.build(GATEWAY, near=pylon)
# Build 2 forges
if self.time > self.start_forge_after and self.units(FORGE).amount < 2:
if self.can_afford(FORGE) and not self.already_pending(FORGE):
if self.verbose:
print('%6.2f building forge' % (self.time))
await self.build(FORGE, near=pylon)
# Build twilight council
if self.units(FORGE).ready.amount >= 2 and self.units(
TWILIGHTCOUNCIL).amount == 0:
if self.can_afford(TWILIGHTCOUNCIL
) and not self.already_pending(TWILIGHTCOUNCIL):
if self.verbose:
print('%6.2f building twilight council' % (self.time))
await self.build(TWILIGHTCOUNCIL, near=pylon)
async def build_nexus(self):
if not self.can('expand'):
return
if not self.already_pending(NEXUS) and self.can_afford(NEXUS) and \
self.bot.units(UnitTypeId.NEXUS).ready.amount >= 1:
if self.verbose:
print('%6.2f expanding' % (self.time))
await self.expand_now()
self.want_to_expand = False
async def manage_upgrades(self):
await self.manage_cyberbetics_upgrades()
await self.manage_forge_upgrades()
async def manage_cyberbetics_upgrades(self):
if self.units(CYBERNETICSCORE).ready.exists and self.can_afford(
RESEARCH_WARPGATE) and not self.researched_warpgate:
ccore = self.units(CYBERNETICSCORE).ready.first
await self.do(ccore(RESEARCH_WARPGATE))
self.researched_warpgate = True
if self.verbose:
print('%6.2f researching warpgate' % (self.time))
async def manage_forge_upgrades(self):
for forge in self.units(FORGE).ready.noqueue:
abilities = await self.get_available_abilities(forge)
for upgrade_type in self.forge_research_priority:
for upgrade in self.upgrades[upgrade_type]:
sys.stdout.flush()
if upgrade in abilities and self.can_afford(upgrade):
if self.verbose:
print('%6.2f researching %s' %
(self.time, self.upgrade_names[upgrade]))
await self.do(forge(upgrade))
break
async def build_workers(self):
nexus = self.units(NEXUS).ready.noqueue
if nexus and self.units(
PROBE
).amount < self.maximum_workers and self.workers.amount < self.units(
NEXUS).amount * 22:
if self.can_afford(PROBE) and self.supply_left > 2:
await self.do(nexus.random.train(PROBE))
async def manage_supply(self):
for tries in range(5): # Only tries 5 different placements
nexus = self.units(NEXUS).ready
if not nexus:
return
nexus = nexus.random
if self.supply_left < 8 and not self.already_pending(PYLON):
if self.can_afford(PYLON):
pos = await self.find_placement(PYLON,
nexus.position,
placement_step=2)
mineral_fields = self.state.mineral_field.closer_than(
8, nexus).closer_than(4, pos)
if mineral_fields:
continue
else:
await self.build(PYLON, near=pos)
break
async def build_assimilator(self):
if not self.can('build_assimilator'):
return
if self.workers.amount < 16:
return
for nexus in self.units(NEXUS).ready:
vgs = self.state.vespene_geyser.closer_than(20, nexus)
for vg in vgs:
if not self.can_afford(ASSIMILATOR):
break
worker = self.select_build_worker(vg.position)
if worker is None:
break
if not self.units(ASSIMILATOR).closer_than(1.0, vg).exists:
if self.verbose:
print('%6.2f building assimilator' % (self.time))
await self.do(worker.build(ASSIMILATOR, vg))
async def debug(self):
if not self.visual_debug:
return
# Setup and info
font_size = 18
total_units = 0
for unit_type in self.units_available_for_attack.keys():
total_units += self.units(unit_type).idle.amount
number_of_minerals = sum([
self.state.mineral_field.closer_than(10, x).amount
for x in self.townhalls
])
# Text
messages = [
' n_workers: %3d' % self.units(PROBE).amount,
' n_zealots: %3d' % self.units(ZEALOT).amount,
' n_stalkers: %3d' % self.units(STALKER).amount,
' idle_army: %3d' % total_units,
' army_size: %3d' % self.army_manager.army_size(),
' ememy_units: %3d' % self.known_enemy_units.amount,
'ememy_structures: %3d' % self.known_enemy_structures.amount,
' minerals_left: %3d' % number_of_minerals,
]
if self.army_manager.leader is not None:
messages.append(' leader: %3d' % self.army_manager.leader)
y = 0
inc = 0.025
for message in messages:
self._client.debug_text_screen(message,
pos=(0.001, y),
size=font_size)
y += inc
# Spheres
leader_tag = self.army_manager.leader
for soldier_tag in self.army_manager.soldiers:
soldier_unit = self.units.find_by_tag(soldier_tag)
if soldier_unit is not None:
if soldier_tag == leader_tag:
self._client.debug_sphere_out(soldier_unit,
r=1,
color=(255, 0, 0))
else:
self._client.debug_sphere_out(soldier_unit,
r=1,
color=(0, 0, 255))
# Lines
if self.army_manager.army_size() > 0:
leader_tag = self.army_manager.leader
leader_unit = self.units.find_by_tag(leader_tag)
for soldier_tag in self.army_manager.soldiers:
if soldier_tag == leader_tag:
continue
soldier_unit = self.units.find_by_tag(soldier_tag)
if soldier_unit is not None:
leader_tag = self.army_manager.leader
leader_unit = self.units.find_by_tag(leader_tag)
if leader_unit is not None:
self._client.debug_line_out(leader_unit,
soldier_unit,
color=(0, 255, 255))
# pylon
pylon = self.pylon_with_less_units()
if pylon is not None:
pos = pylon.position3d
self._client.debug_sphere_out(pos, r=1, color=(0, 255, 0))
self._client.debug_sphere_out(pos, r=2, color=(0, 255, 0))
self._client.debug_sphere_out(pos, r=3, color=(0, 255, 0))
self._client.debug_sphere_out(pos, r=4, color=(0, 255, 0))
# Sens the debug info to the game
await self._client.send_debug()
def select_target(self, state):
if self.known_enemy_structures.exists:
return random.choice(self.known_enemy_structures)
return self.enemy_start_locations[0]
# Finds the pylon with more "space" next to it
# Where more space == Less units
# TODO consider "warpable" space
def pylon_with_less_units(self, distance=4):
pylons = self.units(PYLON).ready
good_boy_pylon = None
units_next_to_good_boy_pylon = float('inf')
for pylon in pylons:
units_next_to_candidate_pylon = self.units.closer_than(
distance, pylon).amount
if units_next_to_candidate_pylon < units_next_to_good_boy_pylon:
good_boy_pylon = pylon
units_next_to_good_boy_pylon = units_next_to_candidate_pylon
return good_boy_pylon
def can(self, what):
if what == 'build_army':
return not self.want_to_expand
if what == 'build_structures':
return not self.want_to_expand
if what == 'build_assimilator':
return not self.want_to_expand
if what == 'expand':
return self.want_to_expand
self.console()
def console(self):
from IPython.terminal.embed import InteractiveShellEmbed
ipshell = InteractiveShellEmbed.instance()
ipshell()
def get_unit_info(self, unit, field="food_required"):
assert isinstance(unit, (Unit, UnitTypeId))
if isinstance(unit, Unit):
unit = unit._type_data._proto
else:
unit = self._game_data.units[unit.value]._proto
if hasattr(unit, field):
return getattr(unit, field)
else:
return None
class NetServer(Thread):
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 config(self, conf):
if (not conf.has_key('netserver')):
return False
if (not conf['netserver'].has_key('address')):
return False
if (not conf['netserver'].has_key('port')):
return False
if (not conf['netserver'].has_key('accept')):
conf['netserver']['accept'] = '0.0.0.0/0'
if (not conf['netserver'].has_key('reject')):
conf['netserver']['reject'] = '0.0.0.0/32'
if (not conf['netserver'].has_key('allow')):
conf['netserver']['allow'] = '0.0.0.0/32'
self.address = conf['netserver']['address']
self.port = conf['netserver']['port']
self.net_accept = {}
self.net_reject = {}
self.net_allow = {}
ipcalc = IPCalc()
for network_str in conf['netserver']['accept'].split(','):
network, bitmask = ipcalc.netsplit(network_str)
self.net_accept[network] = bitmask
for network_str in conf['netserver']['reject'].split(','):
network, bitmask = ipcalc.netsplit(network_str)
self.net_reject[network] = bitmask
for network_str in conf['netserver']['allow'].split(','):
network, bitmask = ipcalc.netsplit(network_str)
self.net_allow[network] = bitmask
return True
def plugins(self, plugins):
self.pluginlist = plugins
self.em.plugins(plugins)
def add_event(self, event):
if (not self.event_subscriptions.has_key(event['type'])):
return False
for client in self.event_subscriptions[event['type']]:
try:
self.clients[client]['thread'].add_event(event)
except:
lerror('unable to pass event to client thread')
def run(self):
listen = NetSocket(self.port, self.address)
serversocket = listen.listen()
if (not serversocket):
lerror('cannot start server process')
return 1
ret = self.em.add_event_handler('NetServer', 2)
ipcalc = IPCalc()
while (self.runthread):
try:
clientsocket, address = serversocket.accept()
except socket.error, serror:
lerror('socket error (%d): %s ' % (serror[0], serror[1]))
continue
except:
class AsteriskHandler(Thread):
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 config(self, conf):
return True
def plugins(self, plugins):
self.pluginlist = plugins
self.em.plugins(plugins)
self.ami = array_value(plugins, ('AsteriskManager', 'object'),
self.ami)
def push_event(self, event):
return self.em.add_handler_event(event, 2)
def add_event(self, event):
return self.eventpipe.appendleft(event)
def send(self, send_string):
return self.ami.send(send_string)
def extension_status(self, exten):
if (not exten):
return None
idlesleep = 0.1
timeout = int(self.status_timeout / idlesleep)
if (self.extstates.has_key(exten) and
((time() - self.extstates[exten]['time']) < self.status_expire)):
state = int(self.extstates[exten]['status'])
else:
ldebug('retrieving status of extension %s' % exten)
message = "Action: ExtensionState\r\nExten: %s\r\n\r\n" % exten
try:
self.send(message)
except:
return None
wait = 0
while (wait < timeout):
if (self.extstates.has_key(exten)):
state = int(self.extstates[exten]['status'])
break
else:
sleep(idlesleep)
state = None
wait += 1
return state
def queue_status(self, queue):
if (not queue):
return None
idlesleep = 0.1
timeout = int(self.status_timeout / idlesleep)
if (self.queuestats.has_key(queue) and
((time() - self.queuestats[queue]['time']) < self.status_expire)):
status = self.queuestats[queue]
else:
if (self.queuereadflag == False):
ldebug('retrieving status of queue %s' % queue)
message = "Action: QueueStatus\r\nQueue: %s\r\n\r\n" % queue
try:
self.send(message)
except:
return None
wait = 0
while (wait < timeout):
if (self.queuestats.has_key(queue)):
status = self.queuestats[queue]
ldebug('got new status of queue %s' % queue)
break
else:
ldebug('waiting for update of queue %s' % queue)
sleep(idlesleep)
status = None
wait += 1
if (status == None):
lwarn('updating of queue %s failed after timeout' % queue)
return status
def get_channels(self):
return self.channels
def run(self):
ret = self.em.add_event_handler('AsteriskHandler', 1)
while self.runthread:
if (self.eventpipe):
event = self.eventpipe.pop()
else:
event = False
sleep(self.idlesleep)
continue
push_event = {}
if (array_value(event, 'Message') == "Extension Status"):
exinfo = {}
exten = array_value(event, 'Exten')
exinfo['status'] = array_value(event, 'Status', 255, int)
exinfo['time'] = array_value(event, '_time', 0, int)
if (exten):
self.extstates[exten] = exinfo
push_event['type'] = 1
push_event['status'] = exinfo['status']
push_event['time'] = exinfo['time']
push_event['ext'] = exten
elif (array_value(event, "Message") == "Queue status will follow"):
queue_stats_time = int(event['_time'])
self.queuereadflag = queue_stats_time
continue
if (not event.has_key("Event")):
continue
if (event["Event"] == "ExtensionStatus"):
exinfo = {}
exten = array_value(event, 'Exten')
exinfo['status'] = array_value(event, 'Status', 255, int)
exinfo['time'] = array_value(event, '_time', 0, int)
if (exten):
self.extstates[exten] = exinfo
push_event['type'] = 1
push_event['status'] = exinfo['status']
push_event['time'] = exinfo['time']
push_event['ext'] = exten
elif (event["Event"] == "QueueStatusComplete"):
queue_stats_time = int(event['_time'])
self.queuereadflag = False
elif (event["Event"] == "QueueParams"):
queue = array_value(event, 'Queue')
if (not queue):
continue
queue_entry = {}
queue_stat = {}
queue_stat['calls'] = array_value(event, 'Calls', None, int)
queue_stat['completed'] = array_value(event, 'Completed', None,
int)
queue_stat['abandoned'] = array_value(event, 'Abandoned', None,
int)
queue_stat['maxlen'] = array_value(event, 'Max', None, int)
queue_stat['holdtime'] = array_value(event, 'Holdtime', None,
int)
queue_stat['weight'] = array_value(event, 'Weight', None, int)
queue_stat['servicelevel'] = array_value(
event, 'ServiceLevel', None, int)
queue_stat['serviceperf'] = array_value(
event, 'ServicelevelPerf', None, float)
queue_entry['time'] = int(event['_time'])
queue_entry['status'] = queue_stat
queue_entry['members'] = []
self.queuestats[queue] = queue_entry
elif (event["Event"] == "QueueMember"):
queue = array_value(event, 'Queue')
if (not queue):
continue
queue_member = {}
queue_member['status'] = array_value(event, 'Status', None,
int)
queue_member['penalty'] = array_value(event, 'Penalty', None,
int)
queue_member['name'] = array_value(event, 'Name', None, int)
queue_member['membership'] = array_value(
event, 'Membership', None, str)
queue_member['location'] = array_value(event, 'Location', None,
int)
queue_member['lastcall'] = array_value(event, 'LastCall', None,
int)
queue_member['paused'] = array_value(event, 'Paused', None,
int)
queue_member['callstaken'] = array_value(
event, 'CallsTaken', None, int)
self.queuestats[queue]['members'].append(queue_member)
elif (event["Event"] == "Join" or event["Event"] == "Leave"):
queue = array_value(event, 'Queue', None, str)
count = array_value(event, 'Count', None, int)
if (queue == None):
continue
if (count == None):
continue
if (self.queuestats.has_key(queue)):
self.queuestats[queue]['status']['calls'] = count
elif (event["Event"] == "Newchannel"):
channelinfo = {}
chan_id = array_value(event, 'Uniqueid')
channelinfo['channel'] = array_value(event, 'Channel')
channelinfo['status'] = array_value(event, 'ChannelState', 255,
int)
channelinfo['time'] = time()
channelinfo['starttime'] = channelinfo['time']
channelinfo['ext'] = array_value(event, 'Exten')
channelinfo['cidnum'] = array_value(event, 'CallerIDNum')
channelinfo['cidname'] = array_value(event, 'CallerIDName')
if (chan_id):
self.channels[chan_id] = channelinfo
elif (event["Event"] == "ChannelUpdate"):
chan_id = array_value(event, 'Uniqueid')
if (chan_id):
if (not self.channels.has_key(chan_id)):
self.channels[chan_id] = {}
self.channels[chan_id]['channel'] = array_value(
event, 'Channel')
self.channels[chan_id]['time'] = time()
self.channels[chan_id]['channeltype'] = array_value(
event, 'Channeltype')
elif (event["Event"] == "Newstate"):
chan_id = array_value(event, 'Uniqueid')
if (chan_id):
if (not self.channels.has_key(chan_id)):
self.channels[chan_id] = {}
self.channels[chan_id]['channel'] = array_value(
event, 'Channel')
self.channels[chan_id]['time'] = time()
self.channels[chan_id]['cidnum'] = array_value(
event, 'CallerIDNum')
self.channels[chan_id]['cidname'] = array_value(
event, 'CallerIDName')
self.channels[chan_id]['status'] = array_value(
event, 'ChannelState', 255, int)
elif (event["Event"] == "NewCallerid"):
chan_id = array_value(event, 'Uniqueid')
if (chan_id):
if (not self.channels.has_key(chan_id)):
self.channels[chan_id] = {}
self.channels[chan_id]['channel'] = array_value(
event, 'Channel')
self.channels[chan_id]['time'] = time()
self.channels[chan_id]['cidnum'] = array_value(
event, 'CallerIDNum')
self.channels[chan_id]['cidname'] = array_value(
event, 'CallerIDName')
elif (event["Event"] == "Bridge"):
chan_id1 = array_value(event, 'Uniqueid1')
chan_id2 = array_value(event, 'Uniqueid2')
if (chan_id1 and chan_id2):
if (not self.channels.has_key(chan_id1)):
self.channels[chan_id1] = {}
self.channels[chan_id1]['channel'] = array_value(
event, 'Channel1')
self.channels[chan_id1]['time'] = time()
self.channels[chan_id1]['cidnum'] = array_value(
event, 'CallerID1')
self.channels[chan_id1]['bridgestate'] = array_value(
event, 'Bridgestate')
self.channels[chan_id1]['bridgetype'] = array_value(
event, 'Bridgetype')
self.channels[chan_id1]['bridgechannel'] = array_value(
event, 'Channel2')
self.channels[chan_id1]['bridgechanid'] = chan_id2
if (not self.channels.has_key(chan_id2)):
self.channels[chan_id2] = {}
self.channels[chan_id2]['channel'] = array_value(
event, 'Channel2')
self.channels[chan_id2]['time'] = time()
self.channels[chan_id2]['cidnum'] = array_value(
event, 'CallerID2')
self.channels[chan_id2]['bridgestate'] = array_value(
event, 'Bridgestate')
self.channels[chan_id2]['bridgetype'] = array_value(
event, 'Bridgetype')
self.channels[chan_id2]['bridgechannel'] = array_value(
event, 'Channel1')
self.channels[chan_id2]['bridgechanid'] = chan_id1
elif (event["Event"] == "Hangup"):
channelinfo = {}
chan_id = array_value(event, 'Uniqueid')
channelinfo['channel'] = array_value(event, 'Channel')
channelinfo['status'] = array_value(event, 'ChannelState', 255,
int)
channelinfo['time'] = time()
channelinfo['cidnum'] = array_value(event, 'CallerIDNum')
channelinfo['cidname'] = array_value(event, 'CallerIDName')
channelinfo['cause'] = array_value(event, 'Cause', 255, int)
if (chan_id):
self.channels[chan_id] = channelinfo
try:
del (self.channels[chan_id])
except:
lwarn('channel id "%s" not in list' % chan_id)
if (push_event):
self.push_event(push_event)
ldebug('closing asterisk handler thread')
def stop(self):
self.runthread = False
def Notify(self, event): EventManager.Post( self, event )
class AsteriskHandler(Thread):
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 config(self, conf):
return True
def plugins(self, plugins):
self.pluginlist = plugins
self.em.plugins(plugins)
self.ami = array_value(plugins, ('AsteriskManager', 'object'), self.ami)
def push_event(self, event):
return self.em.add_handler_event(event, 2)
def add_event(self, event):
return self.eventpipe.appendleft(event)
def send(self, send_string):
return self.ami.send(send_string)
def extension_status(self, exten):
if (not exten):
return None
idlesleep = 0.1
timeout = int(self.status_timeout / idlesleep)
if (self.extstates.has_key(exten) and ((time() - self.extstates[exten]['time']) < self.status_expire)):
state = int(self.extstates[exten]['status'])
else:
ldebug('retrieving status of extension %s' % exten)
message = "Action: ExtensionState\r\nExten: %s\r\n\r\n" % exten
try:
self.send(message)
except:
return None
wait = 0
while (wait < timeout):
if (self.extstates.has_key(exten)):
state = int(self.extstates[exten]['status'])
break
else:
sleep(idlesleep)
state = None
wait += 1
return state
def queue_status(self, queue):
if (not queue):
return None
idlesleep = 0.1
timeout = int(self.status_timeout / idlesleep)
if (self.queuestats.has_key(queue) and ((time() - self.queuestats[queue]['time']) < self.status_expire)):
status = self.queuestats[queue]
else:
if (self.queuereadflag == False):
ldebug('retrieving status of queue %s' % queue)
message = "Action: QueueStatus\r\nQueue: %s\r\n\r\n" % queue
try:
self.send(message)
except:
return None
wait = 0
while (wait < timeout):
if (self.queuestats.has_key(queue)):
status = self.queuestats[queue]
ldebug('got new status of queue %s' % queue)
break
else:
ldebug('waiting for update of queue %s' % queue)
sleep(idlesleep)
status = None
wait += 1
if (status == None):
lwarn('updating of queue %s failed after timeout' % queue)
return status
def get_channels(self):
return self.channels
def run(self):
ret = self.em.add_event_handler('AsteriskHandler', 1)
while self.runthread:
if (self.eventpipe):
event = self.eventpipe.pop()
else:
event = False
sleep(self.idlesleep)
continue
push_event = {}
if (array_value(event, 'Message') == "Extension Status"):
exinfo = {}
exten = array_value(event, 'Exten')
exinfo['status'] = array_value(event, 'Status', 255, int)
exinfo['time'] = array_value(event, '_time', 0, int)
if (exten):
self.extstates[exten]=exinfo
push_event['type'] = 1
push_event['status'] = exinfo['status']
push_event['time'] = exinfo['time']
push_event['ext'] = exten
elif (array_value(event,"Message") == "Queue status will follow"):
queue_stats_time = int(event['_time'])
self.queuereadflag = queue_stats_time
continue
if (not event.has_key("Event")):
continue
if (event["Event"] == "ExtensionStatus"):
exinfo = {}
exten = array_value(event, 'Exten')
exinfo['status'] = array_value(event, 'Status', 255, int)
exinfo['time'] = array_value(event, '_time', 0, int)
if (exten):
self.extstates[exten]=exinfo
push_event['type'] = 1
push_event['status'] = exinfo['status']
push_event['time'] = exinfo['time']
push_event['ext'] = exten
elif (event["Event"] == "QueueStatusComplete"):
queue_stats_time = int(event['_time'])
self.queuereadflag = False
elif (event["Event"] == "QueueParams"):
queue = array_value(event, 'Queue')
if (not queue):
continue
queue_entry = {}
queue_stat = {}
queue_stat['calls'] = array_value(event, 'Calls', None, int)
queue_stat['completed'] = array_value(event, 'Completed', None, int)
queue_stat['abandoned'] = array_value(event, 'Abandoned', None, int)
queue_stat['maxlen'] = array_value(event, 'Max', None, int)
queue_stat['holdtime'] = array_value(event, 'Holdtime', None, int)
queue_stat['weight'] = array_value(event, 'Weight', None, int)
queue_stat['servicelevel'] = array_value(event, 'ServiceLevel', None, int)
queue_stat['serviceperf'] = array_value(event, 'ServicelevelPerf', None, float)
queue_entry['time'] = int(event['_time'])
queue_entry['status'] = queue_stat
queue_entry['members'] = []
self.queuestats[queue] = queue_entry
elif (event["Event"] == "QueueMember"):
queue = array_value(event, 'Queue')
if (not queue):
continue
queue_member = {}
queue_member['status'] = array_value(event, 'Status', None, int)
queue_member['penalty'] = array_value(event, 'Penalty', None, int)
queue_member['name'] = array_value(event, 'Name', None, int)
queue_member['membership'] = array_value(event, 'Membership', None, str)
queue_member['location'] = array_value(event, 'Location', None, int)
queue_member['lastcall'] = array_value(event, 'LastCall', None, int)
queue_member['paused'] = array_value(event, 'Paused', None, int)
queue_member['callstaken'] = array_value(event, 'CallsTaken', None, int)
self.queuestats[queue]['members'].append(queue_member)
elif (event["Event"] == "Join" or event["Event"] == "Leave"):
queue = array_value(event, 'Queue', None, str)
count = array_value(event, 'Count', None, int)
if (queue == None):
continue
if (count == None):
continue
if (self.queuestats.has_key(queue)):
self.queuestats[queue]['status']['calls'] = count
elif (event["Event"] == "Newchannel"):
channelinfo = {}
chan_id = array_value(event, 'Uniqueid')
channelinfo['channel'] = array_value(event, 'Channel')
channelinfo['status'] = array_value(event, 'ChannelState', 255, int)
channelinfo['time'] = time()
channelinfo['starttime'] = channelinfo['time']
channelinfo['ext'] = array_value(event, 'Exten')
channelinfo['cidnum'] = array_value(event, 'CallerIDNum')
channelinfo['cidname'] = array_value(event, 'CallerIDName')
if (chan_id):
self.channels[chan_id]=channelinfo
elif (event["Event"] == "ChannelUpdate"):
chan_id = array_value(event, 'Uniqueid')
if (chan_id):
if (not self.channels.has_key(chan_id)):
self.channels[chan_id]={}
self.channels[chan_id]['channel'] = array_value(event, 'Channel')
self.channels[chan_id]['time'] = time()
self.channels[chan_id]['channeltype'] = array_value(event, 'Channeltype')
elif (event["Event"] == "Newstate"):
chan_id = array_value(event, 'Uniqueid')
if (chan_id):
if (not self.channels.has_key(chan_id)):
self.channels[chan_id]={}
self.channels[chan_id]['channel'] = array_value(event, 'Channel')
self.channels[chan_id]['time'] = time()
self.channels[chan_id]['cidnum'] = array_value(event, 'CallerIDNum')
self.channels[chan_id]['cidname'] = array_value(event, 'CallerIDName')
self.channels[chan_id]['status'] = array_value(event, 'ChannelState', 255, int)
elif (event["Event"] == "NewCallerid"):
chan_id = array_value(event, 'Uniqueid')
if (chan_id):
if (not self.channels.has_key(chan_id)):
self.channels[chan_id]={}
self.channels[chan_id]['channel'] = array_value(event, 'Channel')
self.channels[chan_id]['time'] = time()
self.channels[chan_id]['cidnum'] = array_value(event, 'CallerIDNum')
self.channels[chan_id]['cidname'] = array_value(event, 'CallerIDName')
elif (event["Event"] == "Bridge"):
chan_id1 = array_value(event, 'Uniqueid1')
chan_id2 = array_value(event, 'Uniqueid2')
if (chan_id1 and chan_id2):
if (not self.channels.has_key(chan_id1)):
self.channels[chan_id1]={}
self.channels[chan_id1]['channel'] = array_value(event, 'Channel1')
self.channels[chan_id1]['time'] = time()
self.channels[chan_id1]['cidnum'] = array_value(event, 'CallerID1')
self.channels[chan_id1]['bridgestate'] = array_value(event, 'Bridgestate')
self.channels[chan_id1]['bridgetype'] = array_value(event, 'Bridgetype')
self.channels[chan_id1]['bridgechannel'] = array_value(event, 'Channel2')
self.channels[chan_id1]['bridgechanid'] = chan_id2
if (not self.channels.has_key(chan_id2)):
self.channels[chan_id2]={}
self.channels[chan_id2]['channel'] = array_value(event, 'Channel2')
self.channels[chan_id2]['time'] = time()
self.channels[chan_id2]['cidnum'] = array_value(event, 'CallerID2')
self.channels[chan_id2]['bridgestate'] = array_value(event, 'Bridgestate')
self.channels[chan_id2]['bridgetype'] = array_value(event, 'Bridgetype')
self.channels[chan_id2]['bridgechannel'] = array_value(event, 'Channel1')
self.channels[chan_id2]['bridgechanid'] = chan_id1
elif (event["Event"] == "Hangup"):
channelinfo = {}
chan_id = array_value(event, 'Uniqueid')
channelinfo['channel'] = array_value(event, 'Channel')
channelinfo['status'] = array_value(event, 'ChannelState', 255, int)
channelinfo['time'] = time()
channelinfo['cidnum'] = array_value(event, 'CallerIDNum')
channelinfo['cidname'] = array_value(event, 'CallerIDName')
channelinfo['cause'] = array_value(event, 'Cause', 255, int)
if (chan_id):
self.channels[chan_id]=channelinfo
try:
del(self.channels[chan_id])
except:
lwarn('channel id "%s" not in list' % chan_id);
if (push_event):
self.push_event(push_event)
ldebug('closing asterisk handler thread')
def stop(self):
self.runthread = False
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)
import sys
import datetime
sys.path.insert(0, os.path.join(os.getcwd(), os.pardir) )
from eventmanager import EventManager
from events import Event
def parse_time(s):
return datetime.datetime.strptime(s,'%Y-%m-%d %H:%M:%S')
EVENTS = [ Event({'_id':1, 'anon_screen_name':'A', 'time':parse_time('2013-11-10 06:00:00')}),
Event({'_id':2, 'anon_screen_name':'B', '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
class AsteriskManager(Thread):
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 config(self, conf):
self.host = array_value(conf, ('asterisk', 'address'), '127.0.0.1')
self.port = array_value(conf, ('asterisk', 'port'), 5038, int)
self.user = array_value(conf, ('asterisk', 'user'), '')
self.password = array_value(conf, ('asterisk', 'password'), '')
return True
def plugins(self, plugins):
self.pluginlist = plugins
self.em.plugins(plugins)
def addevent(self, event):
return self.em.add_handler_event(event, 1)
def to_array(self, event):
event_array = {}
for line in event:
keyword, delimeter, value = line.partition(": ")
if (keyword):
event_array[keyword] = value
return event_array
def send(self, send_string, blocking=True):
if (blocking):
while self.sendlock:
sleep(0.1)
self.sendlock = True
try:
self.mgsocket.send(send_string)
self.sendlock = False
return True
except:
self.sendlock = False
return False
def login(self, host, port, user, password):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((host, port))
except:
return False
send_string = "Action: Login\r\nUsername: %s\r\nSecret: %s\r\nEvents: on\r\n\r\n" % (
user, password)
s.settimeout(1)
try:
s.send(send_string)
except:
return False
return s
def run(self):
ldebug('starting asterisk manager thread')
while self.runthread:
self.mgsocket = self.login(self.host, self.port, self.user,
self.password)
if (self.mgsocket == False):
lerror('failed to open asterisk manager connection to %s:%d' %
(self.host, self.port))
if (self.runthread):
sleep(1)
continue
ldebug('opening asterisk manager connection to %s:%d' %
(self.host, self.port))
while self.runthread:
try:
data = self.mgsocket.recv(65634)
timeout = False
except:
timeout = True
if (timeout):
continue
events = data.split("\r\n\r\n")
for event_line in events:
if (not event_line):
continue
event = event_line.splitlines()
event_array = self.to_array(event)
self.addevent(event_array)
if not data:
break
if (self.runthread):
ldebug('lost connection to manager')
sleep(1)
if (self.mgsocket):
self.mgsocket.close()
ldebug('closing asterisk manager thread')
def stop(self):
self.runthread = False
class Middle:
"""It handles the input, keeps track of time and draws objects to
the screen.
"""
@staticmethod
def restore():
"""things to before shutdown"""
System.restorescreen()
def draw_minions(self):
"""Draws minions to screen."""
for minion in self.logic.minions:
self.system.draw_at(minion.pos.to_int(), 'o',
self.system.COLOR_BLACK, self.system.COLOR_YELLOW)
def draw_bullets(self):
"""Draws bullets to screen."""
for bullet in self.logic.bullets:
if self.logic.current_level.tiles[int(bullet.pos.x), int(bullet.pos.y)] == 0:
self.system.draw_at(bullet.pos.to_int(), '*',
self.system.COLOR_BLACK, self.system.COLOR_GREEN)
else:
self.system.draw_at(bullet.pos.to_int(), '*',
self.system.COLOR_BLACK, self.system.COLOR_YELLOW)
def draw_towers(self):
"""Draws towers to screen."""
for tower in self.logic.towers:
self.system.draw_at(tower.pos.to_int(), '#',
self.system.COLOR_BLACK, self.system.COLOR_GREEN)
def draw_map(self):
"""Draws map to screen."""
for x in range(1, self.logic.current_level.max_x + 1):
for y in range(1, self.logic.current_level.max_y + 1):
if self.logic.current_level.tiles[x, y] == 0:
self.system.draw_at(Vector(x, y), ' ',
self.system.COLOR_GREEN, self.system.COLOR_GREEN)
else:
self.system.draw_at(Vector(x, y), ' ',
self.system.COLOR_YELLOW, self.system.COLOR_YELLOW)
def draw_hud(self):
"""draws hud to screen"""
self.windows['lives'].label = "lives: %03d" % self.logic.lives
self.windows['points'].label = "points: %03d" % self.logic.points
self.windows['money'].label = "money: %03d" % self.logic.money
def load_map(self, file_name):
"""Loads map from xml file"""
map_xml = minidom.parse(file_name)
map_tag = map_xml.getElementsByTagName('map')[0]
def get_data(elem, tag):
return elem.getElementsByTagName(tag)[0].firstChild.data
level = Level()
level.max_y = int(get_data(map_tag, 'rows'))
level.max_x = int(get_data(map_tag,'columns'))
row_tag = map_xml.getElementsByTagName('row')
for row in row_tag:
row_data = row.firstChild.data
y = int(row.attributes['pos'].value)
for x in range(1, len(row_data)+1):
level.tiles[x, y] = int(row_data[x-1])
for waypoint in map_xml.getElementsByTagName('waypoint'):
number = int( waypoint.attributes['nr'].value )
x = int( get_data(waypoint,'x'))
y = int( get_data(waypoint,'y'))
level.waypoints[number] = Vector(x, y)
for wave in map_xml.getElementsByTagName('wave'):
w = Wave()
w.offset_wave = int( get_data(wave, 'offset_wave'))
w.offset_minion = int( get_data(wave, 'offset_minion'))
w.hp_minion = int( get_data(wave, 'hp_minion'))
w.nr_minion = int( get_data(wave, 'nr_minion'))
level.waves.append(w)
level.next_wave = level.waves[0]
level.waves.remove(level.next_wave)
self.logic.current_level = level
def Notify(self, event):
if isinstance( event, KeyPressEvent ):
if event.key == 'q':
self.evm.Post(QuitEvent())
if event.key == 'a':
self.logic.add_minion()
if event.key == ' ':
self.logic.current_level.send_next_wave()
elif isinstance( event, MouseClickEvent ):
self.logic.add_tower(event.pos.x, event.pos.y)
elif isinstance( event, TickEvent ):
self.evm.Send(ClearScreenEvent())
self.draw_map()
self.draw_minions()
self.draw_towers()
self.draw_bullets()
self.draw_hud()
self.wc.draw_widgets(self.main_window)
if self.logic.current_level.next_wave and len(self.logic.current_level.active_waves) < len(self.wave_windows):
self.wave_windows[len(self.logic.current_level.active_waves)].set_time(self.logic.current_level.next_wave.offset_wave)
elif isinstance( event, WaveChangeEvent ):
wavelist = []
wavelist.extend(self.logic.current_level.active_waves)
if self.logic.current_level.next_wave:
wavelist.append(self.logic.current_level.next_wave)
wavelist.extend(self.logic.current_level.waves)
for i in range(0, min(len(self.wave_windows), len(wavelist))):
wave = wavelist[i]
window = self.wave_windows[i]
window.set_nr(wave.nr_minion)
window.border_bold = False
window.show_time(False)
for i in range(min(len(self.wave_windows), len(wavelist)),len(self.wave_windows)):
self.wave_windows[i].show = False
if self.logic.current_level.next_wave and len(self.logic.current_level.active_waves) < len(self.wave_windows):
self.wave_windows[len(self.logic.current_level.active_waves)].border_bold = True
self.wave_windows[len(self.logic.current_level.active_waves)].show_time(True)
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 run(self):
"""The main game loop"""
self.te.Run()
# restore original settings
self.system.restorescreen()
class NetServer(Thread):
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 config(self, conf):
if (not conf.has_key('netserver')):
return False
if (not conf['netserver'].has_key('address')):
return False
if (not conf['netserver'].has_key('port')):
return False
if (not conf['netserver'].has_key('accept')):
conf['netserver']['accept'] = '0.0.0.0/0'
if (not conf['netserver'].has_key('reject')):
conf['netserver']['reject'] = '0.0.0.0/32'
if (not conf['netserver'].has_key('allow')):
conf['netserver']['allow'] = '0.0.0.0/32'
self.address = conf['netserver']['address']
self.port = conf['netserver']['port']
self.net_accept = {}
self.net_reject = {}
self.net_allow = {}
ipcalc = IPCalc()
for network_str in conf['netserver']['accept'].split(','):
network, bitmask = ipcalc.netsplit(network_str)
self.net_accept[network] = bitmask;
for network_str in conf['netserver']['reject'].split(','):
network, bitmask = ipcalc.netsplit(network_str)
self.net_reject[network] = bitmask;
for network_str in conf['netserver']['allow'].split(','):
network, bitmask = ipcalc.netsplit(network_str)
self.net_allow[network] = bitmask;
return True
def plugins(self, plugins):
self.pluginlist = plugins
self.em.plugins(plugins)
def add_event(self, event):
if (not self.event_subscriptions.has_key(event['type'])):
return False
for client in self.event_subscriptions[event['type']]:
try:
self.clients[client]['thread'].add_event(event)
except:
lerror('unable to pass event to client thread')
def run(self):
listen = NetSocket(self.port, self.address)
serversocket = listen.listen()
if (not serversocket):
lerror('cannot start server process')
return 1
ret = self.em.add_event_handler('NetServer', 2)
ipcalc = IPCalc()
while (self.runthread):
try:
clientsocket, address = serversocket.accept()
except socket.error, serror:
lerror('socket error (%d): %s ' % (serror[0], serror[1]))
continue
except:
class Bot:
"""
Mainclass for the application, everything goes through here
"""
def __init__(self):
logutils.setup_logging("mustikkabot")
self.log = logging.getLogger("mustikkabot")
self.basepath = tools.find_basepath()
self.confdir = os.path.join(self.basepath, "config")
self.datadir = os.path.join(self.basepath, "data")
self.srcdir = os.path.join(self.basepath, "src")
setup.setup(self)
setup.do_migrations(self)
self.ircsock = None
self.lastReceived = None
self.user = None
self.channel = None
self.eventmanager = EventManager()
""" :type: EventManager"""
self.modulemanager = ModuleManager()
""" :type: ModuleManager"""
self.accessmanager = AccessManager()
""" :type: AccessManager"""
self.timemanager = TimeManager()
""" :type: TimeManager"""
self.run = True
def parse_config(self):
"""
:return: list of strings describing parameters
:rtype: list(string, string, string, string)
Parse the config file, and read the different defined parameters. Return them as a list
"""
try:
settings_f = open(os.path.join(self.confdir, "config.txt"))
except IOError:
self.log.error("Config not found, please make a copy of"
" \"config/config.txt.template\" as \"config/config.txt\"")
sys.exit()
host = None
username = None
password = None
channel = None
try:
for line in settings_f:
line = line.strip("\n\r")
if line.find('host') != -1:
host = line.split(":")[1]
if line.find('user') != -1:
username = line.split(":")[1]
if line.find('pass') != -1:
password = '******'.join(line.split(":")[1:])
if line.find('chnl') != -1:
channel = line.split(":")[1]
except IndexError:
self.log.error("Malformed config file, please fix")
sys.exit()
settings_f.close()
passwd_hidden = ""
for c in password: # Hide auth token/password from log messages
passwd_hidden += '*'
self.log.info("PARAMETERS: Host: %s, username: %s, password: %s, channel: %s" %
(host, username, passwd_hidden, channel))
return host, username, password, channel
def connect(self, params):
"""
:param params: A list of the params to be used to connect
:type params: list(string, string, string, string)
Try to connect to the IRC server using the provided parameters
"""
try:
self.ircsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.ircsock.settimeout(30)
self.ircsock.connect((params[0], 6667))
self.ircsock.setblocking(0)
self.send_data("PASS %s" % (params[2]), dontLog=True)
self.send_data("NICK %s" % (params[1]))
self.send_data("USER %s mustikkaBot 127.0.0.1 :mustikkaBot" % (params[1]))
self.send_data("JOIN %s" % (params[3]))
except Exception as e:
traceback.print_exc()
self.log.error("\n\nError connecting: %s" % e)
sys.exit()
def get_data(self):
"""
:return: Data received from the socket
:rtype: str
Return any data that has been received
"""
try:
data = self.ircsock.recv(1024)
data = data.decode("utf-8", "replace").strip('\r\n')
if not len(data) == 0:
self.log.debug("RECV: <>" + data + "<>")
return data
except socket.error as e:
err = e.args[0]
if err == errno.EAGAIN or err == errno.EWOULDBLOCK:
return "" # no data
def send_data(self, data, dontLog=False):
"""
:param data: String to be sent
:type data: str
:param dontLog: Will the string be logged?
:type dontLog: bool
Send data appended with a newline
"""
if not (data is "" or data is None):
if not dontLog:
self.log.debug("SEND: " + data)
self.ircsock.send(bytes(data + "\n", "UTF-8"))
def send_message(self, msg):
"""
:param msg: Message to be sent
:type msg: str
Send a message to the channel
"""
self.send_data("PRIVMSG " + self.channel + " :" + msg)
def sigint(self, signal, frame):
"""
:param signal: Signal received
:param frame: ...
A signal handler to trap ^C
"""
self.log.info("^C received, stopping")
self.run = False
def main(self):
"""
The startpoint of the bot
"""
settings = self.parse_config()
self.user = settings[1]
self.channel = settings[3]
self.accessmanager.init(self)
self.modulemanager.init(self)
try:
self.connect(settings)
self.lastReceived = datetime.datetime.now()
except:
self.log.error("Error connecting to IRC")
sleep(3)
signal.signal(signal.SIGINT, self.sigint)
sleep(1)
while self.run:
# Get new data
ircmsg = self.get_data()
# Process CLI
if platform.system() != "Windows":
cli = select.select([sys.stdin], [], [], 0)[0]
else:
cli = False # No cli on windows because you can't select stdin
if cli:
data = sys.stdin.readline().strip()
if len(data) > 0:
self.eventmanager.handle_message(":cli!cli@localhost PRIVMSG " + self.channel + " :" + data)
# Handle data if received
if not (ircmsg is None or len(ircmsg) == 0):
for line in ircmsg.split('\n'):
self.lastReceived = datetime.datetime.now()
if line.find(' PRIVMSG ') != -1:
self.eventmanager.handle_message(line)
else:
self.eventmanager.handle_special(line)
# Provied timed events to timemanager
self.timemanager.handle_events()
# Check "watchdog"
if self.lastReceived and datetime.datetime.now() - self.lastReceived > datetime.timedelta(minutes=15):
self.log.warning("No messages received within 15 minutesr, trying to reconnect")
try:
self.connect(settings) # Reconnect
self.lastReceived = datetime.datetime.now()
except:
self.log.error("Error connecting to IRC")
sleep(3)
sleep(0.01)
# Shut down
self.modulemanager.dispose()
self.accessmanager.dispose()
class AsteriskManager(Thread):
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 config(self, conf):
self.host = array_value(conf, ('asterisk','address'), '127.0.0.1')
self.port = array_value(conf, ('asterisk','port'), 5038, int)
self.user = array_value(conf, ('asterisk','user'), '')
self.password = array_value(conf, ('asterisk','password'), '')
return True
def plugins(self, plugins):
self.pluginlist = plugins
self.em.plugins(plugins)
def addevent(self, event):
return self.em.add_handler_event(event, 1)
def to_array(self, event):
event_array = {}
for line in event:
keyword, delimeter, value = line.partition(": ")
if (keyword):
event_array[keyword] = value
return event_array
def send(self, send_string, blocking = True):
if (blocking):
while self.sendlock:
sleep(0.1)
self.sendlock = True
try:
self.mgsocket.send(send_string)
self.sendlock = False
return True
except:
self.sendlock = False
return False
def login(self, host, port, user, password):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((host, port))
except:
return False
send_string = "Action: Login\r\nUsername: %s\r\nSecret: %s\r\nEvents: on\r\n\r\n" % (user, password)
s.settimeout(1)
try:
s.send(send_string)
except:
return False
return s
def run (self):
ldebug('starting asterisk manager thread')
while self.runthread:
self.mgsocket = self.login(self.host, self.port, self.user, self.password)
if (self.mgsocket == False):
lerror('failed to open asterisk manager connection to %s:%d' % (self.host, self.port))
if (self.runthread):
sleep(1)
continue
ldebug('opening asterisk manager connection to %s:%d' % (self.host, self.port))
while self.runthread:
try:
data = self.mgsocket.recv(65634)
timeout = False
except:
timeout = True
if (timeout):
continue
events = data.split("\r\n\r\n")
for event_line in events:
if (not event_line):
continue
event = event_line.splitlines()
event_array = self.to_array(event)
self.addevent(event_array)
if not data:
break
if (self.runthread):
ldebug('lost connection to manager')
sleep(1)
if (self.mgsocket):
self.mgsocket.close()
ldebug('closing asterisk manager thread')
def stop(self):
self.runthread = False
def test_empty_event_queue(self):
event_manager = EventManager([]);
# No exception should be raised here
event_manager.process_events()
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'
}
'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
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)
