def __init__(self):
import Driver.ConnectionListUpdater
import CommandEngine
Engine.__init__(self)
attributes = {'roomMap': {}, 'roomList': []}
for key in attributes.keys():
self.attributes[key] = attributes[key]
self.addEventHandlerByNameWithAdjusters(
'Engine.EventHandlers.RoomEngine.PlayerLoginEventHandler', None)
self.addEventHandlerByNameWithAdjusters(
'Engine.EventHandlers.RoomEngine.PlayerLogoutEventHandler', None)
RoomEngine.instance = self
for subscriber in RoomEngine.subscribers:
self.addEventSubscriber(subscriber)
RoomEngine.subscribers = []
self.buildWorld()
Driver.ConnectionListUpdater.addEventSubscriber(self)
CommandEngine.addEventSubscriber(self)
def __init__(self):
from Driver import LoginListener
import threading
import CommandEngine
Engine.__init__(self)
attributes = {
'openConnectionsSemaphore' : threading.BoundedSemaphore(3),
'newConnectionSemaphore' : threading.BoundedSemaphore(1),
'closedConnectionSemaphore' : threading.BoundedSemaphore(1),
'connectionList' : [],
'newConnections' : [],
'closedConnections' : []
}
for key in attributes.keys():
self.attributes[key] = attributes[key]
self.addEventHandlerByNameWithAdjusters('Engine.EventHandlers.ConnectionEngine.PlayerLoginHandler', None)
self.addEventHandlerByNameWithAdjusters('Engine.EventHandlers.ConnectionEngine.PlayerLogoutHandler', None)
ConnectionEngine.instance = self
LoginListener.addEventSubscriber(self)
CommandEngine.addEventSubscriber(self)
def __init__(self):
from Driver import LoginListener
import threading
import CommandEngine
Engine.__init__(self)
attributes = {
'openConnectionsSemaphore': threading.BoundedSemaphore(3),
'newConnectionSemaphore': threading.BoundedSemaphore(1),
'closedConnectionSemaphore': threading.BoundedSemaphore(1),
'connectionList': [],
'newConnections': [],
'closedConnections': []
}
for key in attributes.keys():
self.attributes[key] = attributes[key]
self.addEventHandlerByNameWithAdjusters(
'Engine.EventHandlers.ConnectionEngine.PlayerLoginHandler', None)
self.addEventHandlerByNameWithAdjusters(
'Engine.EventHandlers.ConnectionEngine.PlayerLogoutHandler', None)
ConnectionEngine.instance = self
LoginListener.addEventSubscriber(self)
CommandEngine.addEventSubscriber(self)
def __init__(self):
Engine.__init__(self)
import CommandEngine
import threading
import Driver.ConnectionListUpdater
attributes = {
'playerSetSemaphore' : threading.BoundedSemaphore(1),
'playerMap' : {},
'playerList' : [],
'npcMap' : {}
}
for key in attributes.keys():
self.attributes[key] = attributes[key]
ActorEngine.instance = self
self.addEventHandlerByNameWithAdjusters('Engine.EventHandlers.ActorEngine.PlayerLoginEventHandler', None)
self.addEventHandlerByNameWithAdjusters('Engine.EventHandlers.ActorEngine.PlayerLogoutEventHandler', None)
self.addEventHandlerByNameWithAdjusters('Engine.EventHandlers.ActorEngine.BroadcastEventHandler', None)
for subscriber in ActorEngine.subscribers:
self.addEventSubscriber(subscriber)
ActorEngine.subscribers = []
Driver.ConnectionListUpdater.addEventSubscriber(self)
CommandEngine.addEventSubscriber(self)
def __init__(self):
import Driver.UpdateDriver
import ActorEngine
Engine.__init__(self)
attributes = {
'commandList' : {},
'emoteList': []
}
for key in attributes.keys():
self.attributes[key] = attributes[key]
self.addEventHandlerByNameWithAdjusters('Engine.EventHandlers.CommandEngine.CommandExecutionEventHandler', None)
CommandEngine.instance = self
for subscriber in CommandEngine.subscribers:
self.addEventSubscriber(subscriber)
CommandEngine.subscribers = []
self.buildCommandList()
Driver.UpdateDriver.addEventSubscriber(self)
ActorEngine.addEventSubscriber(self)
def __init__(self, mass, moment, spaceGravity, position,
aiComponent: AIComponent):
self.aiController = AIController(aiComponent)
self.body = pymunk.Body(mass, moment)
self.body.position = position
self.leftEngine = Engine(self.body, spaceGravity,
self.getLeftEnginePosition(),
self.ENGINE_SIZE)
self.rightEngine = Engine(self.body, spaceGravity,
self.getRightEnginePosition(),
self.ENGINE_SIZE)
self.chassis = pymunk.Poly(self.body, self.getChassisVec())
self.chassis.friction = self.FRICTION
self.currentDecision = AIDecision(0, 0)
self.droneBase = pygame.image.load(
self.DRONE_BASE_SPRITE_PATH).convert_alpha()
self.leftRotor = pygame.image.load(
self.DRONE_L_ROTOR_SPRITE_PATH).convert_alpha()
self.rightRotor = pygame.image.load(
self.DRONE_R_ROTOR_SPRITE_PATH).convert_alpha()
DebugScreen.getInstance().addInfo("AIComponent",
aiComponent.__class__.__name__)
def __init__(self):
Engine.__init__(self)
import CommandEngine
import threading
import Driver.ConnectionListUpdater
attributes = {
'playerSetSemaphore': threading.BoundedSemaphore(1),
'playerMap': {},
'playerList': [],
'npcMap': {}
}
for key in attributes.keys():
self.attributes[key] = attributes[key]
ActorEngine.instance = self
self.addEventHandlerByNameWithAdjusters(
'Engine.EventHandlers.ActorEngine.PlayerLoginEventHandler', None)
self.addEventHandlerByNameWithAdjusters(
'Engine.EventHandlers.ActorEngine.PlayerLogoutEventHandler', None)
self.addEventHandlerByNameWithAdjusters(
'Engine.EventHandlers.ActorEngine.BroadcastEventHandler', None)
for subscriber in ActorEngine.subscribers:
self.addEventSubscriber(subscriber)
ActorEngine.subscribers = []
Driver.ConnectionListUpdater.addEventSubscriber(self)
CommandEngine.addEventSubscriber(self)
def __init__(self, btcTrader, apiName, authId, authPass):
Engine.__init__(self, apiName, btcTrader, 1) # refresh rate of 1 second. In the futur with the websockets we will probably put 0 and use some kind of select
self.req = self.CreateRequester(authId, authPass)
self.depth = {}
self.clock = Clock()
self.first = 1
self.account = Account()
def __init__(self):
import Driver.UpdateDriver
import ActorEngine
Engine.__init__(self)
attributes = {'commandList': {}, 'emoteList': []}
for key in attributes.keys():
self.attributes[key] = attributes[key]
self.addEventHandlerByNameWithAdjusters(
'Engine.EventHandlers.CommandEngine.CommandExecutionEventHandler',
None)
CommandEngine.instance = self
for subscriber in CommandEngine.subscribers:
self.addEventSubscriber(subscriber)
CommandEngine.subscribers = []
self.buildCommandList()
Driver.UpdateDriver.addEventSubscriber(self)
ActorEngine.addEventSubscriber(self)
def __init__(self):
import Driver.ConnectionListUpdater
import CommandEngine
Engine.__init__(self)
attributes = {
'roomMap' : {},
'roomList' : []
}
for key in attributes.keys():
self.attributes[key] = attributes[key]
self.addEventHandlerByNameWithAdjusters('Engine.EventHandlers.RoomEngine.PlayerLoginEventHandler', None)
self.addEventHandlerByNameWithAdjusters('Engine.EventHandlers.RoomEngine.PlayerLogoutEventHandler', None)
RoomEngine.instance = self
for subscriber in RoomEngine.subscribers:
self.addEventSubscriber(subscriber)
RoomEngine.subscribers = []
self.buildWorld()
Driver.ConnectionListUpdater.addEventSubscriber(self)
CommandEngine.addEventSubscriber(self)
class Program: """ General program template - init function for program component initialization - main loop * check events -> handle (event) * update """ def __init__(self): """ init function """ self.interface = Interface() self.engine = Engine() self.run() def run(self): """ main loop """ while True: self.check_events() self.update() def check_events(self): """ pygame event handling (edit this for more events) """ for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == pygame.MOUSEBUTTONDOWN: mousex, mousey = event.pos response = self.interface.click(mousex,mousey) self.handle(response) def handle(self,response): """ handle responses to events """ self.engine.send(response) def update(self): """ update state of program components """ self.engine.update() self.interface.update(self.engine.get_updates())
def __init__(self, configuration, input, root):
# Defineste harta, care trebuie sa fie vizibila din toate obiectele
game_map = Map()
self.command_buffer = []
# In functie de parametru, configureaza harta
if configuration == "Default":
Configurers.default_configuration(game_map, None)
elif configuration == "Recommended":
Configurers.recommended_configuration(game_map, None)
elif configuration == "FullyOpen":
Configurers.fully_open_configuration(game_map, None)
else:
raise RuntimeError("Bad configuration parameter")
# Defineste vizualizatorul
if root:
self.display = Display(game_map, root)
for i in game_map.land_hex_list:
i.display = self.display
else:
self.display = Dummy()
# game_map.direct_ref_matrix[7][8].status = Status.CONTAMINATED
# game_map.direct_ref_matrix[7][8].hex_type = HexType.ICE
# UnitManager.add_unit(game_map, [game_map.direct_ref_matrix[7][8], UnitType.SOLDIER, Player.BLUE])
# UnitManager.add_unit(game_map, [game_map.direct_ref_matrix[7][8], UnitType.CIV, Player.BLUE])
# UnitManager.add_unit(game_map, [game_map.direct_ref_matrix[7][8], UnitType.CIV, Player.GREY])
# tiles = [(7, 8)]
# self.display.update(tiles)
# In functie de parametru, configureaza cititorii
if input == "CommandLine":
reader = CommandLineReader()
elif input == "GUI":
reader = GUIReader
elif input == "File":
reader = FileReader()
elif input == "Memory":
reader = MemoryReader()
else:
raise RuntimeError("Bad specification for reader")
# Defineste componentele pentru obiectul Sequencer pentru starvation
starvation_interpreter = StarvationInterpreter(game_map)
starvation_checker = StarvationMachine(game_map)
starvation_executive = StarvationServer()
# Defineste componentele pentru obiectul Sequencer pentru action
action_interpreter = ActionInterpreter(game_map)
action_checker = ActionMachine(game_map)
action_executive = ActionServer()
# Defineste componentele pentru obiectul Sequencer pentru doomsday
doomsday_interpreter = DoomsdayInterpreter(game_map)
doomsday_checker = DoomsdayMachine(game_map)
doomsday_executive = DoomsdayServer()
# Defineste obiectele Sequencer pentru toate fazele
starvation_sequencer = SequenceRunner(reader, starvation_interpreter, starvation_checker, starvation_executive)
action_sequencer = SequenceRunner(reader, action_interpreter, action_checker, action_executive)
doomsday_sequencer = SequenceRunner(reader, doomsday_interpreter, doomsday_checker, doomsday_executive)
# Defineste motorul jocului
self.engine = Engine(starvation_sequencer, action_sequencer, doomsday_sequencer, game_map)
def main(arguments):
if len(arguments) > 4:
print "Sorry, there were too many arguments."
print "You only need to include the number of rows, columns and the required length to win."
print "In that order."
return 0
elif len(arguments) < 4:
print "Sorry, there were not enough arguments"
print "You need to include number of rows, columns and the required length to win the game."
print "In that order."
return 0
try:
num_rows = int(arguments[1])
num_cols = int(arguments[2])
length_to_win = int(arguments[3])
except ValueError:
print "Please input only numbers"
return 0
print "Welcome to Connect 4 in python!"
load_or_save = str(raw_input("Would you like to continue your old game? Yes or no? :"))
if load_or_save.lower() == 'yes':
board = Board(0,0)
board.load_board()
else:
board = Board(num_rows, num_cols)
board.create_board()
engine = Engine(num_rows, num_cols, length_to_win, board)
board.print_board()
while(1):
try:
player_number = int(raw_input("Enter the number of players: "))
if player_number < 1:
print "Please use a number larger than 0!"
else:
break
except ValueError:
print "Please use a number!"
print "If at any time you would like to save your game, simply type save."
while (True):
for player in range(player_number):
column = -1
input = raw_input("Pick a column for your token player %d: " % (player))
if input.lower() == 'save':
board.save_board()
print "Your game has been saved."
return 0
break
try:
column = int(input)
print engine.place_token(column, player)
except ValueError:
print "You didn't save or use an acceptable number. You're turn is over."
board.print_board()
if engine.winner() != -1:
print "Congratulations player %d!!\nYou won conncect 4!" %(player)
return 0
def __init__(self, btcTrader):
Engine.__init__(self, "Interface", btcTrader, 0.0333333) # 1/30 --> 30 frame per seconds
self.currentConsole = 0
self.commandLine = ""
self.cursorPosition = 0
self.printset = set(string.printable)
self.PushMsg("Hola !")
self.PushMsg("PageUp / PageDown to change of market.")
self.PushMsg("Type help to see the list of available commands.")
def __init__(self, depth=2):
"""
:param depth: The depth of the engine
"""
self.whiteEngine: Engine = Engine(depth=depth)
self.blackEngine: Engine = Engine(depth=depth)
self.engines = (self.whiteEngine, self.blackEngine)
def restart(self):
"""Restart the game."""
if not self.restartRequested:
self.restartRequested = True
self.input.broadcastSystemEvent("restartRequested")
else:
# evilynux - With self.audio.close(), calling self.quit() results in
# a crash. Calling the parent directly as a workaround.
Engine.quit(self)
def restart(self):
"""Restart the game."""
if not self.restartRequested:
self.restartRequested = True
self.input.broadcastSystemEvent("restartRequested")
else:
# evilynux - With self.audio.close(), calling self.quit() results in
# a crash. Calling the parent directly as a workaround.
Engine.quit(self)
class ResourceTest(unittest.TestCase):
def testAsynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
self.r.load(self, "result", lambda: loader())
while not self.result:
self.e.run()
assert self.result == 0xdada
def testSynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
assert self.r.load(self, "result2", loader, synch=True) == 0xdada
assert self.result2 == 0xdada
def testAsynchLoadSeries(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
for i in range(10):
self.r.load(self, "result%d" % i, loader)
while not self.result9:
self.e.run()
assert self.result9 == 0xdada
def testCallback(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
self.quux = None
def loaded(r):
self.quux = r
self.r.load(self, "fuuba", loader, onLoad=loaded).join()
while not self.fuuba:
self.e.run()
assert self.fuuba == self.quux
def setUp(self):
Config.load(Version.appName() + ".ini", setAsDefault=True)
# Resource expects game_priority to be an integer,
# Config won't know unless we define it as such.
Config.define("performance", "game_priority", int, 2)
self.e = Engine()
def tearDown(self):
self.e.quit()
def runSimulation(self):
entries = self.__opctionFrame.getStats()
self.__opctionFrame.getFrame().destroy()
#print(entries)
cfg = []
for i in [
'BubbleSort', 'SelectionSort', 'InsertSort', 'MergeSort',
'HeapSort', 'QuickSort', 'QuickSortWithMedianPointer',
'StaticQuickSort', 'StaticQuickSortWithMedianPointer'
]:
if entries[i]:
if entries['random']:
cfg.append(
Config(i, 'random', entries['Start Step'],
entries['Last Step'] + 1, entries['Step'],
entries['MaxTime']))
if entries['sorted']:
cfg.append(
Config(i, 'sorted', entries['Start Step'],
entries['Last Step'] + 1, entries['Step'],
entries['MaxTime']))
if entries['unsorted']:
cfg.append(
Config(i, 'unsorted', entries['Start Step'],
entries['Last Step'] + 1, entries['Step'],
entries['MaxTime']))
engine = Engine(cfg)
engine.mainLab()
dataForPlots = engine.statForPlot()
df = []
frames = self.__plotsFrames
for i in dataForPlots.keys():
for j in dataForPlots[i].keys():
df.append({
'title':
i + " " + j,
'mainColumn':
'n',
'columns':
dataForPlots[i][j].keys(),
'data':
DataFrame(dataForPlots[i][j],
columns=dataForPlots[i][j].keys())
})
for i in range(len(df)):
frames.append(Frame(self.__plotFrame.getFrame()))
figure2 = plt.Figure(figsize=(11, 11), dpi=60)
ax2 = figure2.add_subplot(111)
line2 = FigureCanvasTkAgg(figure2, frames[i])
line2.get_tk_widget().pack(side=LEFT, fill=BOTH)
df2 = df[i]['data'][df[i]['columns']].groupby(
df[i]['mainColumn']).sum()
df2.plot(kind='line', legend=True, ax=ax2, fontsize=10)
ax2.set_title(df[i]['title'])
self.printPlot(self.__actualFrame)
def __init__(self, btcTrader):
Engine.__init__(self, "Interface", btcTrader,
0.0333333) # 1/30 --> 30 frame per seconds
self.currentConsole = 0
self.commandLine = ""
self.cursorPosition = 0
self.printset = set(string.printable)
self.PushMsg("Hola !")
self.PushMsg("PageUp / PageDown to change of market.")
self.PushMsg("Type help to see the list of available commands.")
def main():
global thread
thread = Engine(socketio)
thread.daemon = True
thread.start()
templateData = {
"title": "MSU RMC Control Center",
"controls": make_controls(Motor_Names)
}
return render_template("main.html", **templateData)
def engine(*args):
"""Returns an arbiter object."""
if args == ():
arbiter_instance = Engine()
elif len(args) == 1:
arbiter_instance = Engine(args[0])
else:
arbiter_instance = Engine(args)
return arbiter_instance
def main():
board = Board()
player = Player("w", board)
engine = Engine("b", board)
finished = False
while (finished == False):
player.do()
engine.do()
finished = Board.check()
def mainfunc():
"""The entry point. Note, if you want dont want argument parsing, feel free to directly use Engine class"""
engine = None
skippass2 = False
datadumpdirectory = None
indexgit = None
customindexfile = None
indexentries = None
testentries = None
indexgitbranch = "master"
cmdargs = initparser().parse_args()
# Set up the parameters to Engine, based on argument parsing.
if cmdargs.indexgiturl is not None and cmdargs.customindexfile is not None:
Logger().log(Logger.error,
"indexgiturl and customindexfile are mutually exclusive. So please specify either one")
exit(5)
if cmdargs.indexgiturl is not None:
indexgit = cmdargs.indexgiturl[0]
if cmdargs.indexgitbranch is not None:
indexgitbranch = cmdargs.indexgitbranch[0]
if cmdargs.customindexfile is not None:
customindexfile = cmdargs.customindexfile[0]
if cmdargs.skippass2 is not None:
skippass2 = cmdargs.skippass2
if cmdargs.datadumpdirectory is not None:
datadumpdirectory = cmdargs.datadumpdirectory[0]
if cmdargs.indexentry is not None:
indexentries = []
for item in cmdargs.indexentry:
indexentries.append(int(item[0]))
if cmdargs.testentry is not None:
testentries = cmdargs.testentry
engine = Engine(datadumpdirectory=datadumpdirectory, indexgit=indexgit, customindexfile=customindexfile,
skippass2=skippass2, specificindexentries=indexentries, testindexentries=testentries,
indexgitbranch=indexgitbranch)
status = engine.run()
if not status:
exit(1)
return
class ResourceTest(unittest.TestCase):
def testAsynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.r.load(self, "result", lambda: loader())
while not self.result:
self.e.run()
assert self.result == 0xdada
def testSynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
assert self.r.load(self, "result2", loader, synch = True) == 0xdada
assert self.result2 == 0xdada
def testAsynchLoadSeries(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
for i in range(10):
self.r.load(self, "result%d" % i, loader)
while not self.result9:
self.e.run()
assert self.result9 == 0xdada
def testCallback(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.quux = None
def loaded(r):
self.quux = r
self.r.load(self, "fuuba", loader, onLoad = loaded).join()
while not self.fuuba:
self.e.run()
assert self.fuuba == self.quux
def setUp(self):
Config.load(Version.appName() + ".ini", setAsDefault = True)
# Resource expects game_priority to be an integer,
# Config won't know unless we define it as such.
Config.define("performance", "game_priority", int, 2)
self.e = Engine()
def tearDown(self):
self.e.quit()
def __init__(self):
self.my_Touch_Sensor_Front = Touch_sensor_class(1)
self.my_Touch_Sensor_Wip = Touch_sensor_class(2)
self.my_IR_Sensor = IR_sensor_class()
self.engine_Left = Engine(1)
self.engine_Right = Engine(2)
self.my_Color_Sensor = Color_sensor_class()
self.wheel_bias = 1.05
self.disable_wip = False
self.standard_speed = 20
self.isInSecondQuadrant = False
def __init__(self):
Engine.__init__(self)
attributes = {'affects': {}, 'affectComponents': {}}
for key in attributes.keys():
self.attributes[key] = attributes[key]
AffectEngine.instance = self
self.buildAffectList()
self.buildAffectComponentList()
def on_init(self):
self.camera = Camera(Screen.WIDTH, Screen.HEIGHT, Physics.BLOCKWIDTH, Physics.BLOCKHEIGHT)
enviroment = Enviroment(Physics.MAPWIDTH, Physics.MAPDEPTH, self.seed)
self.world = Engine(pygame.display.set_mode(self.size, pygame.DOUBLEBUF | pygame.HWSURFACE), self.camera, enviroment)
self.player = Player(0, -35)
self.entities = [self.player]
self._running = True
self.visionLines = []
self.font = pygame.font.SysFont('mono', 16)
self.n = 0
self.camera.SetFocusPos(self.entities[self.n])
def main(): masterTbl = MasterTbl() engine = Engine() projectDir = sys.argv[1] del sys.argv[0:2] execDir, execName = engine.split_cmdname(sys.argv[0]) return engine.execute(projectDir, execDir, execName)
def mainfunc():
"""The entry point. Note, if you want dont want argument parsing, feel free to directly use Engine class"""
engine = None
skippass2 = False
datadumpdirectory = None
indexgit = None
customindexfile = None
indexentries = None
testentries = None
cmdargs = initparser().parse_args()
# Set up the parameters to Engine, based on argument parsing.
if cmdargs.indexgiturl is not None and cmdargs.customindexfile is not None:
Logger().log(
Logger.error,
"indexgiturl and customindexfile are mutually exclusive. So please specify either one"
)
exit(5)
if cmdargs.indexgiturl is not None:
indexgit = cmdargs.indexgiturl[0]
if cmdargs.customindexfile is not None:
customindexfile = cmdargs.customindexfile
if cmdargs.skippass2 is not None:
skippass2 = cmdargs.skippass2
if cmdargs.datadumpdirectory is not None:
datadumpdirectory = cmdargs.datadumpdirectory[0]
if cmdargs.indexentry is not None:
indexentries = []
for item in cmdargs.indexentry:
indexentries.append(int(item[0]))
if cmdargs.testentry is not None:
testentries = cmdargs.testentry
engine = Engine(datadumpdirectory=datadumpdirectory,
indexgit=indexgit,
customindexfile=customindexfile,
skippass2=skippass2,
specificindexentries=indexentries,
testindexentries=testentries)
if not engine.run():
exit(1)
return
class ResourceTest(unittest.TestCase):
def testAsynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
self.r.load(self, "result", lambda: loader())
while not self.result:
self.e.run()
assert self.result == 0xdada
def testSynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
assert self.r.load(self, "result2", loader, synch=True) == 0xdada
assert self.result2 == 0xdada
def testAsynchLoadSeries(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
for i in range(10):
self.r.load(self, "result%d" % i, loader)
while not self.result9:
self.e.run()
assert self.result9 == 0xdada
def testCallback(self):
self.r = Resource()
self.e.addTask(self.r, synchronized=False)
self.quux = None
def loaded(r):
self.quux = r
self.r.load(self, "fuuba", loader, onLoad=loaded).join()
while not self.fuuba:
self.e.run()
assert self.fuuba == self.quux
def setUp(self):
self.e = Engine()
def tearDown(self):
self.e.quit()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.Engine = Engine()
self.Engine.register(self)
"""
temas = "656,1240,525,656,1240,525,142,1263,1031,154,1134,426,531,884,74,759,621,756,995,648,315,1146,538,1028,70,390,33,59,819,453,1046,180,880"
for codigotema in temas.split(","):
self.Engine.addTemaSeleccion(codigotema)
"""
self.setupUi(self)
self.postsetupUi()
class ResourceTest(unittest.TestCase):
def testAsynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.r.load(self, "result", lambda: loader())
while not self.result:
self.e.run()
assert self.result == 0xdada
def testSynchLoad(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
assert self.r.load(self, "result2", loader, synch = True) == 0xdada
assert self.result2 == 0xdada
def testAsynchLoadSeries(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
for i in range(10):
self.r.load(self, "result%d" % i, loader)
while not self.result9:
self.e.run()
assert self.result9 == 0xdada
def testCallback(self):
self.r = Resource()
self.e.addTask(self.r, synchronized = False)
self.quux = None
def loaded(r):
self.quux = r
self.r.load(self, "fuuba", loader, onLoad = loaded).join()
while not self.fuuba:
self.e.run()
assert self.fuuba == self.quux
def setUp(self):
self.e = Engine()
def tearDown(self):
self.e.quit()
def create_first_epoch(config_filename): config = Config() config.load_file(config_filename) engine = Engine([]) engine.init_train_from_config(config=config, train_data=None) engine.epoch = 1 engine.save_model(engine.get_epoch_model_filename(), epoch=engine.epoch)
def main(_):
assert len(sys.argv) == 2, "usage: main.py <config>"
config_path = sys.argv[1]
assert os.path.exists(config_path), config_path
try:
config = Config(config_path)
except ValueError as e:
print("Malformed config file: " + str(e))
return -1
init_log(config)
config.initialize()
engine = Engine(config)
engine.run()
def __init__(self, camera, keyboard):
self.camera = camera
self.keyboard = keyboard
self.width = WIDTH // TILE_SIZE
self.height = HEIGHT // TILE_SIZE
self.tile_list = arcade.SpriteList(use_spatial_hash=True, spatial_hash_cell_size=32, is_static=True)
self.entities = arcade.SpriteList(use_spatial_hash=True, spatial_hash_cell_size=64)
self.particles = arcade.SpriteList(is_static=True)
self.tiles = {}
self.reset = False
self.reset_timer = -1
# for i in range(100):
# ball = Ball(Textures.get_texture(2, 5), 128 * random.random(), 128 * random.random())
# ball.change_x = random.randint(-8, 8)
# ball.change_y = random.randint(-8, 8)
# self.add_entity_to_list(ball, self.entities)
self.player = Player(64, 64, self.keyboard)
self.add_entity_to_list(self.player, self.entities)
self.level_gen = LevelGenerator.LevelGen(self)
self.paused = True
self.difficulty = 1
self.engine = Engine(self.entities, self.tile_list, self, GRAVITY)
self.physics_engine = arcade.PhysicsEnginePlatformer(self.player, self.tile_list, GRAVITY)
self.pause_text = Graphics.create_text_list("Paused", 0, 0, True)
self.game_over_text = Graphics.create_text_list("Game Over :<", 0, 0, True)
self.game_over = False
self.game_over_timer = 0
self.curr_health = self.player.health
self.health_bar = arcade.SpriteList()
for i in range(3):
heart = arcade.Sprite()
heart.center_x = self.player.center_x - TILE_SIZE + i * TILE_SIZE
heart.center_y = self.player.center_y - TILE_SIZE * 1.5
heart.texture = Textures.get_texture(4, 9)
self.health_bar.append(heart)
self.setup()
def __init__(self):
Engine.__init__(self)
attributes = {
'affects' : {},
'affectComponents' : {}
}
for key in attributes.keys():
self.attributes[key] = attributes[key]
AffectEngine.instance = self
self.buildAffectList()
self.buildAffectComponentList()
def __init__(self,
ri=0,
ro=0,
l=0,
rt=0,
re=0,
rhop=0,
k=0,
MM=1,
a=0,
n=0,
T=0,
patm=0,
tstepnum=0,
tspan=1):
# Create a dictionary of keys as parameter names and values as parameter values
self.values = dict({
'ri': ri,
"ro": ro,
"l": l,
"rt": rt,
"re": re,
"rhop": rhop,
"k": k,
"MM": MM,
"a": a,
"n": n,
"T": T,
"patm": patm,
"tstepnum": tstepnum,
"tspan": tspan
})
# Create an Engine based off those values
self.engine = Engine(ri, ro, l, rt, re)
# Make a timespan to run the simulation for
self.tspan = linspace(0, tspan, num=int(self.values["tstepnum"]))
# Length units = mm
# Density units = g/cm3
# Pressure units = MPa
# Molar mass units = g/mol
# Temperature units = K
# Force units = N
self.p = []
self.F = []
self.R = 8314 # Gas constant, units J/K kmol
self.R_specific = self.R / self.values["MM"] # Specific gas constant
self.It = 0
self.Isp = 0
self.burn_time = 0
self.burn_time_bool = True
def main(_):
assert len(sys.argv) == 2, "usage: main.py <config>"
config_path = sys.argv[1]
assert os.path.exists(config_path), config_path
try:
config = Config(config_path)
except ValueError as e:
print "Malformed config file:", e
return -1
init_log(config)
config.initialize()
#dump the config into the log
print >> log.v4, open(config_path).read()
engine = Engine(config)
engine.run()
def create_game():
engine = Engine(welcomeMessage)
engine.add_room("Iowa", Iowa(engine))
engine.add_room("Kansas", Kansas(engine))
engine.start_room("Kansas")
#engine.run()
test_start(engine)
def main(args):
# try:
debug_mode = args.debug
firmware = args.inputfile
output = args.outputfile
logger = Logger(output, debug_mode)
processor = GenericAtmel8051Proc(_logger=logger)
logger.print_success("Processor '{:s}' has been created.".format(processor.desc))
engine = Engine(processor, _logger=logger)
engine.flash_rom(firmware)
logger.print_success("Firmware loaded in ROM.")
user_input = ""
while (user_input != "quit"):
user_input = logger.get_input("").rstrip()
execute_cmd(user_input, engine, logger)
logger.print_info("Terminating program...")
class __ProviderManager(QtCore.QObject):
sendError = QtCore.pyqtSignal(str)
def __init__(self):
QtCore.QObject.__init__(self)
self.providers = {}
self.poolManager = PoolManager(timeout=Timeout(10),
headers={'Accept-Encoding': 'gzip,deflate'})
self.engine = Engine()
def loadProviderFromFile(self,path):
try:
providerFile = open(path,mode="r")
provider = json.loads(providerFile.read())
providerFile.close()
self.providers[provider["name"]] = provider
except Exception as e:
self.sendError.emit("cannot load provider at '"+path+"' <br/><b>Reason:</b> "+str(e))
def loadProviderFromUrl(self,url):
try:
req = self.poolManager.request("GET", url)
provider = json.loads(req.data.decode('utf-8'))
self.providers[provider["name"]] = provider
del req
except Exception as e:
self.sendError.emit("cannot load provider at '"+url+"' <br/><b>Reason:</b> "+str(e))
def queryProvider(self,text,category,pages,providerName,perPageCallback=None,whenDoneCallback=None):#Exceptions here should be managed by the caller
return self.engine.makeQuery(self.providers[providerName], text, category, pages,perPageCallback,whenDoneCallback)
def reset(self):
if self.providers:
self.providers.clear()
def __init__(self): """ init function """ self.interface = Interface() self.engine = Engine() self.run()
def iterateEpochs():
start_epoch, start_batch = Engine.get_train_start_epoch_batch(config)
final_epoch = Engine.config_get_final_epoch(config)
print("Starting with epoch %i, batch %i." % (start_epoch, start_batch), file=log.v3)
print("Final epoch is: %i" % final_epoch, file=log.v3)
recurrent_net = "lstm" in config.value("hidden_type", "") # good enough...
batch_size = config.int('batch_size', 1)
max_seqs = config.int('max_seqs', -1)
for epoch in range(start_epoch, final_epoch + 1):
print("Epoch %i." % epoch, file=log.v3)
rnn.train_data.init_seq_order(epoch)
iterateDataset(rnn.train_data, recurrent_net=recurrent_net, batch_size=batch_size, max_seqs=max_seqs)
print("Finished all epochs.", file=log.v3)
def test_interface_get_ready_to_go(self):
"""
GIVEN :engine, gearbox, electronics, status_panel
WHEN :call get_ready_to_go interface
THEN :return true
"""
self.assertTrue(
self.ctrl.get_ready_to_go(Engine(), GearBox(), Electronics(),
StatusPanel()))
def __init__(self):
self.elements = [
Wheel("front left"),
Wheel("front right"),
Wheel("back left"),
Wheel("back right"),
Body(),
Engine()
]
def __init__(self):
Engine.__init__(self)
attributes = {
'itemList' : [],
'itemLoadFunctions' : {
'wieldable' : self.loadWeapon
}
}
for key in attributes.keys():
self.attributes[key] = attributes[key]
ItemEngine.instance = self
for subscriber in ItemEngine.subscribers:
self.addEventSubscriber(subscriber)
ItemEngine.subscribers = []
def initBase(configfile=None, targetMode=None, epoch=None):
"""
:type configfile: str | None
"""
global isInitialized
isInitialized = True
# Run through in any case. Maybe just to set targetMode.
global config
if not config:
if configfile is None:
configfile = DefaultSprintCrnnConfig
assert os.path.exists(configfile)
rnn.initThreadJoinHack()
rnn.initConfig(configfile, [])
config = rnn.config
rnn.initLog()
rnn.initConfigJsonNetwork()
if targetMode:
setTargetMode(targetMode)
initDataset()
if targetMode and targetMode == "forward" and epoch:
model_filename = config.value('model', '')
fns = [Engine.epoch_model_filename(model_filename, epoch, is_pretrain) for is_pretrain in [False, True]]
fns_existing = [fn for fn in fns if os.path.exists(fn)]
assert len(fns_existing) == 1, "%s not found" % fns
model_epoch_filename = fns_existing[0]
config.set('load', model_epoch_filename)
assert Engine.get_epoch_model(config)[1] == model_epoch_filename
global engine
if not engine:
devices = rnn.initDevices()
rnn.printTaskProperties(devices)
rnn.initEngine(devices)
engine = rnn.engine
assert isinstance(engine, Engine)
def saveCrnnNetwork(epoch, layers):
"""
:type epoch: int
:type layers: list[(numpy.ndarray, numpy.ndarray)]
"""
print("Loading Crnn")
from Network import LayerNetwork
from NetworkHiddenLayer import ForwardLayer
from NetworkOutputLayer import OutputLayer
from Pretrain import pretrainFromConfig
from Engine import Engine
pretrain = pretrainFromConfig(config)
is_pretrain_epoch = pretrain and epoch <= pretrain.get_train_num_epochs()
modelFilename = config.value("model", None)
assert modelFilename, "need 'model' in config"
filename = Engine.epoch_model_filename(modelFilename, epoch, is_pretrain_epoch)
assert not os.path.exists(filename), "already exists"
if is_pretrain_epoch:
network = pretrain.get_network_for_epoch(epoch)
else:
network = LayerNetwork.from_config_topology(config)
nHiddenLayers = len(network.hidden)
# print network topology
print "Crnn Network layer topology:"
print "input dim:", network.n_in
print "hidden layer count:", nHiddenLayers
print "output dim:", network.n_out["classes"]
print "net weights #:", network.num_params()
print "net params:", network.train_params_vars
print "net output:", network.output["output"]
assert network.n_in == inputDim
#assert network.n_out == outputDim
assert nHiddenLayers + 1 == layerCount # hidden + output layer
assert len(layers) == layerCount
for i, (layerName, hidden) in enumerate(sorted(network.hidden.items())):
# Some checks whether this is a forward-layer.
assert isinstance(hidden, ForwardLayer)
saveCrnnLayer(hidden, *layers[i])
assert isinstance(network.output["output"], OutputLayer)
saveCrnnLayer(network.output["output"], *layers[len(layers) - 1])
import h5py
print("Save Crnn model under %s" % filename)
model = h5py.File(filename, "w")
network.save_hdf(model, epoch)
model.close()
def loading(self):
"""Loading state loop."""
done = Engine.run(self)
self.clearScreen()
if self.data.essentialResourcesLoaded():
if not self.loadingScreenShown:
self.loadingScreenShown = True
Dialogs.showLoadingScreen(self, self.data.resourcesLoaded)
if self.startupLayer:
self.view.pushLayer(self.startupLayer)
self.mainloop = self.main
self.view.render()
self.video.flip()
return done
def main(self):
"""Main state loop."""
# Tune the scheduler priority so that transitions are as smooth as possible
if self.view.isTransitionInProgress():
self.boostBackgroundThreads(False)
else:
self.boostBackgroundThreads(True)
done = Engine.run(self)
self.clearScreen()
self.view.render()
if self.debugLayer:
self.debugLayer.render(1.0, True)
self.video.flip()
return done
class Game:
def __init__(self):
self.board = ChessBoard()
self.engine = Engine()
pass
def play_game(self, withAI=False, verbose=False):
while not self.is_game_over():
if verbose:
print self.board
if withAI:
if self.board.is_whites_turn():
self.play_move()
else:
self.play_ai_move()
else:
self.play_move()
print str(self.board) + "\n" + "Game Over! {}".format(self.board.outcome)
def auto_play(self):
while not self.is_game_over():
self.play_ai_move()
print str(self.board) + "\n" + "Game Over! {}".format(self.board.outcome)
def is_game_over(self):
return self.board.is_game_over
def play_move(self):
move = raw_input("Enter move: (example: e2e4): ")
if not self.board.attempt_to_make_move(move):
print "\n Invalid Move! \n"
def play_ai_move(self):
origin, destination = self.engine.get_one_ply_materialistic_move(self.board)
self.board.execute_move(origin, destination)
print "Computer plays: {}{}".format(origin, destination)
def testCascadeWithRequiredBackRef(store):
"""See also: Classes.csv Engine & Engine Part
The deal is that deleting an Engine should delete all its EngineParts
via the cascade set on the parts list attribute. Previously, there was
a bug with this if the back ref attr (EnginePart.engine in this case)
was required (isRequired=True).
"""
from Engine import Engine
from EnginePart import EnginePart
e = Engine()
store.addObject(e)
store.saveChanges()
e.addToParts(EnginePart())
e.addToParts(EnginePart())
e.addToParts(EnginePart())
store.saveChanges()
assert e.parts()
store._verboseDelete = 1
store.deleteObject(e)
store.saveChanges()
def __init__(self):
QtCore.QObject.__init__(self)
self.providers = {}
self.poolManager = PoolManager(timeout=Timeout(10),
headers={'Accept-Encoding': 'gzip,deflate'})
self.engine = Engine()
parser.add_argument(
"-c",
"--cleanup",
help="Specify to force cleanup of test bench. If your running multiple times on same system,"
" this is not recommended as it will require downloading of repositories again and again",
action="store_true"
)
return parser
if __name__ == '__main__':
cmd_args = get_parser().parse_args()
clean_up = False
index = cmd_args.index
if cmd_args.cleanup is not None and cmd_args.cleanup:
clean_up = True
e = Engine(index_path=index, cleanup=clean_up)
status, status_list, dependency_graph = e.run()
if cmd_args.list is not None and cmd_args.list:
for item in status_list:
print item
if not status:
exit(1)
def quit(self):
self.audio.close()
Engine.quit(self)
def __init__(self, config = None):
"""
Constructor.
@param config: L{Config} instance for settings
"""
if not config:
config = Config.load()
self.config = config
fps = self.config.get("video", "fps")
tickrate = self.config.get("engine", "tickrate")
Engine.__init__(self, fps = fps, tickrate = tickrate)
pygame.init()
self.title = _("Frets on Fire")
self.restartRequested = False
self.handlingException = False
self.video = Video(self.title)
self.audio = Audio()
Log.debug("Initializing audio.")
frequency = self.config.get("audio", "frequency")
bits = self.config.get("audio", "bits")
stereo = self.config.get("audio", "stereo")
bufferSize = self.config.get("audio", "buffersize")
self.audio.pre_open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
pygame.init()
self.audio.open(frequency = frequency, bits = bits, stereo = stereo, bufferSize = bufferSize)
Log.debug("Initializing video.")
width, height = [int(s) for s in self.config.get("video", "resolution").split("x")]
fullscreen = self.config.get("video", "fullscreen")
multisamples = self.config.get("video", "multisamples")
self.video.setMode((width, height), fullscreen = fullscreen, multisamples = multisamples)
# Enable the high priority timer if configured
if self.config.get("engine", "highpriority"):
Log.debug("Enabling high priority timer.")
self.timer.highPriority = True
viewport = glGetIntegerv(GL_VIEWPORT)
h = viewport[3] - viewport[1]
w = viewport[2] - viewport[0]
geometry = (0, 0, w, h)
self.img = ImgContext(geometry)
glViewport(int(viewport[0]), int(viewport[1]), int(viewport[2]), int(viewport[3]))
self.input = Input()
self.view = View(self, geometry)
self.resizeScreen(w, h)
self.resource = Resource(Version.dataPath())
self.server = None
self.sessions = []
self.mainloop = self.loading
# Load game modifications
Mod.init(self)
theme = Config.load(self.resource.fileName("theme.ini"))
Theme.open(theme)
# Make sure we are using the new upload URL
if self.config.get("game", "uploadurl").startswith("http://kempele.fi"):
self.config.set("game", "uploadurl", "http://fretsonfire.sourceforge.net/play")
self.addTask(self.audio, synchronized = False)
self.addTask(self.input, synchronized = False)
self.addTask(self.view)
self.addTask(self.resource, synchronized = False)
self.data = Data(self.resource, self.img)
self.input.addKeyListener(FullScreenSwitcher(self), priority = True)
self.input.addSystemEventListener(SystemEventHandler(self))
self.debugLayer = None
self.startupLayer = None
self.loadingScreenShown = False
Log.debug("Ready.")
