class SvgTest(unittest.TestCase):
def testRendering(self):
self.svg.transform.translate(256, 256)
self.svg.transform.rotate(3.141592)
self.svg.draw()
self.e.video.flip()
def testRenderToTexture(self):
scale = 4
fullwidth, fullheight = 512, 512
width, height = int(fullwidth / scale), int(fullheight / scale)
t = Texture()
self.e.svg.setProjection((0, 0, fullwidth, fullheight))
glViewport(0, 0, width, height)
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT
| GL_DEPTH_BUFFER_BIT)
self.svg.transform.translate(width * scale / 2, height * scale / 2)
self.svg.transform.rotate(3.141592)
self.svg.draw()
glViewport(0, 0, fullwidth, fullheight)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluOrtho2D(0.0, 1.0, 0.0, 1.0)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
t.bind()
glEnable(GL_TEXTURE_2D)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(1.0, 1.0, 1.0)
glBegin(GL_TRIANGLE_STRIP)
glTexCoord2f(0.0, 0.0)
glVertex2f(0.0, 0.0)
glTexCoord2f(1.0, 0.0)
glVertex2f(1.0, 0.0)
glTexCoord2f(0.0, 1.0)
glVertex2f(0.0, 1.0)
glTexCoord2f(1.0, 1.0)
glVertex2f(1.0, 1.0)
glEnd()
self.e.video.flip()
import time
time.sleep(2)
def setUp(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini",
setAsDefault=True)
self.e = GameEngine(config)
self.e.loadImgDrawing(self, "svg", "mfhlogo.png")
while not self.svg:
self.e.run()
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT
| GL_DEPTH_BUFFER_BIT)
class ViewTest(unittest.TestCase):
def testTransition(self):
l1 = TestLayer()
l2 = TestLayer()
l3 = TestLayer()
v = self.e.view
v.pushLayer(l1)
v.pushLayer(l2)
v.pushLayer(l3)
while l3.visibility < 1.0:
self.e.run()
v.popLayer(l3)
v.popLayer(l2)
v.popLayer(l1)
while l1 in v.layers or l2 in v.layers or l3 in v.layers:
self.e.run()
assert not v.layers
def setUp(self):
self.e = GameEngine()
def tearDown(self):
self.e.quit()
class ViewTest(unittest.TestCase):
def testTransition(self):
l1 = TestLayer()
l2 = TestLayer()
l3 = TestLayer()
v = self.e.view
v.pushLayer(l1)
v.pushLayer(l2)
v.pushLayer(l3)
while l3.visibility < 1.0:
self.e.run()
v.popLayer(l3)
v.popLayer(l2)
v.popLayer(l1)
while l1 in v.layers or l2 in v.layers or l3 in v.layers:
self.e.run()
assert not v.layers
def setUp(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
self.e = GameEngine(config)
def tearDown(self):
self.e.quit()
def __init__(self, config):
super().__init__(config)
# initialize the Yaniv game
players = []
# if player_config not specified in config, we initialize with two random player
if not ('player_config' in config):
players = [RandomPlayer("RandomPlayer1"), RandomPlayer("RandomPlayer2")]
# otherwise we will find the player_config to generate players
else:
for i in range(len(config['player_config'])):
player_type = config['player_config'][i]
if player_type == 'DQN':
players.append(RandomPlayer('RDQNPlayer' + str(i)))
elif player_type == 'Random':
players.append(RandomPlayer('RandomPlayer' + str(i)))
elif player_type == 'HC':
players.append(HillClimbPlayer('HC' + str(i)))
elif player_type == 'Minimax':
players.append(MinimaxPlayer('Minimax' + str(i)))
elif player_type == 'SA':
players.append(SimulatedAnnealingPlayer('SA' + str(i)))
self.game = GameEngine(players)
self.state_shape = [4, 54]
class ViewTest(unittest.TestCase):
def testTransition(self):
l1 = TestLayer()
l2 = TestLayer()
l3 = TestLayer()
v = self.e.view
v.pushLayer(l1)
v.pushLayer(l2)
v.pushLayer(l3)
while l3.visibility < 1.0:
self.e.run()
v.popLayer(l3)
v.popLayer(l2)
v.popLayer(l1)
while l1 in v.layers or l2 in v.layers or l3 in v.layers:
self.e.run()
assert not v.layers
def setUp(self):
config = Config.load(Version.appName() + ".ini", setAsDefault=True)
self.e = GameEngine(config)
def tearDown(self):
self.e.quit()
class ViewTest(unittest.TestCase):
def testTransition(self):
l1 = TestLayer()
l2 = TestLayer()
l3 = TestLayer()
v = self.e.view
v.pushLayer(l1)
v.pushLayer(l2)
v.pushLayer(l3)
while l3.visibility < 1.0:
self.e.run()
v.popLayer(l3)
v.popLayer(l2)
v.popLayer(l1)
while l1 in v.layers or l2 in v.layers or l3 in v.layers:
self.e.run()
assert not v.layers
def setUp(self):
self.e = GameEngine()
def tearDown(self):
self.e.quit()
def __init__(self):
# initialize game, ball, and player
self.game = GameEngine()
self.ball = Ball(self.game, 500, 300, 0)
self.game.new_ball(self.ball)
self.player1 = Player(self.game, 400, 300, 1, (0, 0, 255))
self.game.new_player(self.player1)
self.player2 = Player(self.game, 400, 300, 1, (0, 0, 255))
self.game.new_player(self.player2)
# movement options
# 0 = v(-1,-1) # 1 = v( 0,-1) # 2 = v( 1, 1)
# 3 = v(-1, 0) # 4 = v( 1, 0)
# 5 = v(-1, 1) # 6 = v( 0, 1) # 7 = v( 1, 1)
self.states_translation_array = [None] * 8
self.states_translation_array[0] = pygame.math.Vector2(-1,-1).normalize()
self.states_translation_array[1] = pygame.math.Vector2(0,-1).normalize()
self.states_translation_array[2] = pygame.math.Vector2(1, 1).normalize()
self.states_translation_array[3] = pygame.math.Vector2(-1, 0).normalize()
self.states_translation_array[4] = pygame.math.Vector2(1, 0).normalize()
self.states_translation_array[5] = pygame.math.Vector2(-1, 1).normalize()
self.states_translation_array[6] = pygame.math.Vector2(0, 1).normalize()
self.states_translation_array[7] = pygame.math.Vector2(1, 1).normalize()
def setUp(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
self.e = GameEngine(config)
self.e.loadImgDrawing(self, "svg", "mfhlogo.png")
while not self.svg:
self.e.run()
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def setUp(self):
self.e = GameEngine()
self.e.loadSvgDrawing(self, "svg", "koopa.svg")
while not self.svg:
self.e.run()
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT
| GL_DEPTH_BUFFER_BIT)
class SvgTest(unittest.TestCase):
def testRendering(self):
self.svg.transform.translate(256, 256)
self.svg.transform.rotate(3.141592)
self.svg.draw()
self.e.video.flip()
def testRenderToTexture(self):
scale = 4
fullwidth, fullheight = 512, 512
width, height = int(fullwidth / scale), int(fullheight / scale)
t = Texture()
self.e.svg.setProjection((0, 0, fullwidth, fullheight))
glViewport(0, 0, width, height)
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
self.svg.transform.translate(width * scale / 2, height * scale / 2)
self.svg.transform.rotate(3.141592)
self.svg.draw()
glViewport(0, 0, fullwidth, fullheight)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluOrtho2D(0.0, 1.0, 0.0, 1.0)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
t.bind()
glEnable(GL_TEXTURE_2D)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(1.0, 1.0, 1.0)
glBegin(GL_TRIANGLE_STRIP)
glTexCoord2f(0.0, 0.0)
glVertex2f(0.0, 0.0)
glTexCoord2f(1.0, 0.0)
glVertex2f(1.0, 0.0)
glTexCoord2f(0.0, 1.0)
glVertex2f(0.0, 1.0)
glTexCoord2f(1.0, 1.0)
glVertex2f(1.0, 1.0)
glEnd()
self.e.video.flip()
import time
time.sleep(2)
def setUp(self):
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
self.e = GameEngine(config)
self.e.loadImgDrawing(self, "svg", "mfhlogo.png")
while not self.svg:
self.e.run()
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
class DialogTestInteractive(unittest.TestCase):
def testGetTest(self):
text = getText(self.e, "Please enter your name:", "Wario")
def setUp(self):
self.e = GameEngine()
def tearDown(self):
self.e.quit()
class DialogTestInteractive(unittest.TestCase):
def testGetTest(self):
text = getText(self.e, "Please enter your name:", "Wario")
def setUp(self):
self.e = GameEngine()
def tearDown(self):
self.e.quit()
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.PROGRAM_UNIXSTYLE_NAME + ".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 = GameEngine()
def tearDown(self):
self.e.quit()
class DialogTestInteractive(unittest.TestCase):
def testGetTest(self):
text = getText(self.e, "Please enter your name:", "Wario")
def setUp(self):
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
self.e = GameEngine(config)
def tearDown(self):
self.e.quit()
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.PROGRAM_UNIXSTYLE_NAME + ".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 = GameEngine()
def tearDown(self):
self.e.quit()
class MenuTest(unittest.TestCase):
def testMenuNavigation(self):
m = Menu(self.e, rootMenu)
self.e.view.pushLayer(m)
def setUp(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
self.e = GameEngine(config)
def tearDown(self):
self.e.quit()
class MenuTest(unittest.TestCase):
def testMenuNavigation(self):
m = Menu(self.e, rootMenu)
self.e.view.pushLayer(m)
def setUp(self):
config = Config.load(Version.appName() + ".ini", setAsDefault=True)
self.e = GameEngine(config)
def tearDown(self):
self.e.quit()
def testVideoPlayerLayer(self):
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
self.e = GameEngine(config)
winWidth, winHeight = (self.e.view.geometry[2], self.e.view.geometry[3])
vidPlayer = VideoPlayer(framerate, self.src, (winWidth, winHeight),
loop = False)
self.e.view.pushLayer(vidPlayer)
while not vidPlayer.finished:
self.e.run()
self.e.view.popLayer(vidPlayer)
self.e.audio.close()
self.e.quit()
class MenuTestInteractive(unittest.TestCase):
def testMenuNavigation(self):
m = Menu(self.e, rootMenu)
self.e.view.pushLayer(m)
while self.e.view.layers:
rootMenu[0][0] = "%.1f FPS" % self.e.fpsEstimate
self.e.run()
def setUp(self):
self.e = GameEngine()
def tearDown(self):
self.e.quit()
def simulateGamesForCol(game: GameData):
win = game.board.add_to_col(game.col, game.color)
if win:
return game.N
p1 = MachineRandomPlayer(Color.RED if game.color ==
Color.YELLOW else Color.YELLOW)
p2 = MachineRandomPlayer(game.color)
eng = GameEngine()
wins = 0
for i in range(game.N):
winner = eng.play_game(copy.deepcopy(game.board), p1, p2, False, False)
if winner == game.color:
wins += 1
return wins
class MenuTestInteractive(unittest.TestCase):
def testMenuNavigation(self):
m = Menu(self.e, rootMenu)
self.e.view.pushLayer(m)
while self.e.view.layers:
rootMenu[0][0] = "%.1f FPS" % self.e.timer.fpsEstimate
self.e.run()
def setUp(self):
self.e = GameEngine()
def tearDown(self):
self.e.quit()
class MenuTestInteractive(unittest.TestCase):
def testMenuNavigation(self):
m = Menu(self.e, rootMenu)
self.e.view.pushLayer(m)
while self.e.view.layers:
self.e.run()
def setUp(self):
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
self.e = GameEngine(config)
def tearDown(self):
self.e.quit()
def __init__(self, parent, controller):
Frame.__init__(self, parent)
self.controller = controller
label = Label(self, text="Game", font=LARGE_FONT)
label.pack(pady=10, padx=10)
#self.round = casino.getGameTable()
#flag for human as last capturer
#self.lastCapturer = "None"
#set true as deafault
#NewGameReference = self.controller.get_page(NewGame)
self.LoadGameReference = self.controller.get_page(LoadGame)
self.NewGameReference = self.controller.get_page(NewGame)
#required to prevent reloading the game when clicking the update button
self.flag = -1
self.casino = GameEngine()
self.moveInfo = []
self.buttonUpdate = Button(self,
text="Update Board",
command=lambda: self.updateBoard())
self.buttonUpdate.pack()
self.buttonSave = Button(
self,
text="Save",
bg="blue",
command=lambda: self.controller.show_frame(SaveGame))
self.buttonSave.pack(side=TOP)
#updateable varibales
self.listHumanHand = []
self.listComputerHand = []
self.listTableCard = []
self.prompt = Label(self)
self.labelHuman = Label(self)
self.labelComputer = Label(self)
self.labelHumanPile = Label(self)
self.labelComputerPile = Label(self)
self.labelTable = Label(self)
self.status = Label(self)
self.buttonTrail = Button(self)
self.buttonCapture = Button(self)
self.buttonBuild = Button(self)
self.buttonHelp = Button(self)
self.buttonComputer = Button(self)
class MenuTest(unittest.TestCase):
def testMenuNavigation(self):
m = Menu(self.e, rootMenu)
self.e.view.pushLayer(m)
while self.e.view.layers and 0:
rootMenu[0][0] = "%.1f FPS" % self.e.timer.fpsEstimate
self.e.run()
# FIXME: keyboard event injection for testing
def setUp(self):
self.e = GameEngine()
def tearDown(self):
self.e.quit()
class MenuTest(unittest.TestCase):
def testMenuNavigation(self):
m = Menu(self.e, rootMenu)
self.e.view.pushLayer(m)
while self.e.view.layers and 0:
rootMenu[0][0] = "%.1f FPS" % self.e.fpsEstimate
self.e.run()
# FIXME: keyboard event injection for testing
def setUp(self):
self.e = GameEngine()
def tearDown(self):
self.e.quit()
class MenuTestInteractive(unittest.TestCase):
def testMenuNavigation(self):
m = Menu(self.e, rootMenu)
self.e.view.pushLayer(m)
while self.e.view.layers:
self.e.run()
def setUp(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini",
setAsDefault=True)
self.e = GameEngine(config)
def tearDown(self):
self.e.quit()
def playersQtyInputScreen(self):
qty = -1
while qty == -1:
try:
qty = int(input("Informe a quantidade de jogadores: "))
if (qty < 2) or (qty > 4):
print("Número de jogadores:")
print("Máximo: 4")
print("Mínimo: 2")
qty = -1
else:
self.__gameEngine = GameEngine(qty)
except:
print("Digite apenas números!")
qty = -1
def testVideoPlayerLayer(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini",
setAsDefault=True)
self.e = GameEngine(config)
winWidth, winHeight = (self.e.view.geometry[2],
self.e.view.geometry[3])
vidPlayer = VideoPlayer(framerate,
self.src, (winWidth, winHeight),
loop=False,
startTime=10000,
endTime=14000)
self.e.view.pushLayer(vidPlayer)
while not vidPlayer.finished:
self.e.run()
self.e.view.popLayer(vidPlayer)
self.e.audio.close()
self.e.quit()
def setUp(self):
self.e = GameEngine()
self.e.loadSvgDrawing(self, "svg", "koopa.svg")
while not self.svg:
self.e.run()
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def setUp(self):
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
self.e = GameEngine(config)
self.e.loadImgDrawing(self, "svg", "mfhlogo.png")
while not self.svg:
self.e.run()
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def testLoading(self):
e = GameEngine()
infoFile = e.resource.fileName("songs", "defy", "song.ini")
guitarFile = e.resource.fileName("songs", "defy", "guitar.ogg")
songFile = e.resource.fileName("songs", "defy", "song.ogg")
noteFile = e.resource.fileName("songs", "defy", "notes.mid")
song = Song(e, infoFile, guitarFile, songFile, None, noteFile)
assert int(song.bpm) == 122
def testLoading(self):
config = Config.load(Version.appName() + ".ini", setAsDefault=True)
e = GameEngine(config)
infoFile = e.resource.fileName("tutorials", "bangbang", "song.ini")
guitarFile = e.resource.fileName("tutorials", "bangbang", "guitar.ogg")
songFile = e.resource.fileName("tutorials", "bangbang", "song.ogg")
noteFile = e.resource.fileName("tutorials", "bangbang", "notes.mid")
song = Song(e, infoFile, guitarFile, songFile, None, noteFile)
assert int(song.bpm) == 120
def testVideoPlayerLayer(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
self.e = GameEngine(config)
winWidth, winHeight = (self.e.view.geometry[2], self.e.view.geometry[3])
vidPlayer = VideoPlayer(framerate, self.src, (winWidth, winHeight),
loop = False, startTime = 10000, endTime = 14000)
self.e.view.pushLayer(vidPlayer)
while not vidPlayer.finished:
self.e.run()
self.e.view.popLayer(vidPlayer)
self.e.audio.close()
self.e.quit()
def testAnimationPlayerLayer(self):
loop = 10
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini",
setAsDefault=True)
self.e = GameEngine(config)
animPlayer = AnimationPlayer(
framerate,
self.path,
self.basename, (self.e.view.geometry[2], self.e.view.geometry[3]),
loop=loop)
print "Rendering as a GameEngine Layer for %d loops." % loop
self.e.view.pushLayer(animPlayer)
startTime = pygame.time.get_ticks()
while not animPlayer.finished:
self.e.run()
stopTime = pygame.time.get_ticks()
totalTime = stopTime - startTime
print "nbrFrames: %d, nbrLoops: %d, Total time: %.02f s, Average fps: %.02f" % \
(animPlayer.nbrFrames, loop, totalTime/1000.0, \
(float(1000.0*animPlayer.nbrFrames*(loop+1)) / float(totalTime)))
self.e.view.popLayer(animPlayer)
self.e.quit()
class firstCase(unittest.TestCase):
def setUp(self):
self.GameEngine = GameEngine()
self.ai = _AI('hard')
def testIsFinished1(self):
board = [[None,None,None],[None,None,None],[None,None,None]]
assert self.GameEngine.isFinished(board) == False,\
"Wrong with empty board."
def testIsFinished2(self):
board = [['X','X','X'], [None, None, None],[None, None, None]]
assert self.GameEngine.isFinished(board) == True, \
"Wrong with win in a row."
def testIsFinished3(self):
board = [['X', None, None], [None,'X',None],[None, None, 'X']]
assert self.GameEngine.isFinished(board) == True, \
"Wrong with diagonal win."
def testIsFinished4(self):
board = [['X','O','X'], [None, None, None], [None, None, None]]
assert self.GameEngine.isFinished(board) == False,\
"Three values in a row, but theyre not from the same player."
def testChangePlayer(self):
currentPlayer = 'X' #Game always starts with player X.
self.GameEngine.changePlayer()
differentPlayer = self.GameEngine.getPlayer()
assert differentPlayer == 'O', \
"Doesn't switch players properly."
def testUpdateBoard1(self):
currentPlayer = 'X'
self.GameEngine.updateBoard(currentPlayer, (0,1))
board = self.GameEngine.getBoard()
assert board == [[None, 'X', None], [None, None, None], [None, None, None]], "Wrong when updating board"
def testSaving(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini",
setAsDefault=True)
e = GameEngine(config)
# Make a temp copy
tmp = "songtest_tmp"
files = ["song.ini", "guitar.ogg", "song.ogg", "notes.mid"]
try:
os.mkdir(tmp)
for f in files:
shutil.copy(e.resource.fileName("tutorials", "bangbang", f),
tmp)
infoFile = os.path.join(tmp, "song.ini")
guitarFile = os.path.join(tmp, "guitar.ogg")
songFile = os.path.join(tmp, "song.ogg")
noteFile = os.path.join(tmp, "notes.mid")
song = Song(e, infoFile, guitarFile, songFile, None, noteFile)
events1 = song.track[0].getAllEvents()
song.save()
song = Song(e, infoFile, guitarFile, songFile, None, noteFile)
events2 = song.track[0].getAllEvents()
notes1 = [(time, event) for time, event in events1
if isinstance(event, Note)]
notes2 = [(time, event) for time, event in events2
if isinstance(event, Note)]
for i, event in enumerate(zip(notes1, notes2)):
t1, n1 = event[0]
t2, n2 = event[1]
if "-v" in sys.argv:
print "%8d. %.3f + %.3f\t%2d\t %.3f + %.3f\t%2d" % (
i, t1, n1.length, n1.number, t2, n2.length, n2.number)
# Allow 2ms of rounding error
assert abs(t1 - t2) < 2
assert abs(n1.length - n2.length) < 2
assert n1.number == n2.number
finally:
# Load another song to free the copy
pygame.mixer.music.load(
e.resource.fileName("tutorials", "bangbang", "guitar.ogg"))
shutil.rmtree(tmp)
def runMultiGames(num_of_play, run_name=""):
r_wins = 0
y_wins = 0
print()
print('============ {0} start ================'.format(run_name))
print("Player 1 (RED) = Heuristic VS Player 2 (Yellow) MonteCarlo")
for i in range(num_of_play):
b = Board()
p1 = MachineLogicPlayer(b, Color.RED)
p2 = MonteCarloPlayer(b, Color.YELLOW)
# p2 = MachineRandomPlayer(Color.YELLOW)
eng = GameEngine()
eng.play_game(b, p1, p2, False, False)
# b.print_board()
if b.winner == Color.YELLOW:
y_wins += 1
elif b.winner == Color.RED:
r_wins += 1
print(str(i + 1) + " " + str(b.winner) + " wins - " + str(datetime.datetime.now().time()))
# print('red wins: {0} yellow wins: {1} games: {2}'.format(r_wins, y_wins, i + 1))
print('============ {0} complete ================'.format(run_name))
print('red wins: {0} total games: {1} ratio: {2}'.format(r_wins, num_of_play, r_wins / num_of_play))
return r_wins
def __init__(self, engine=None, home_team=None, away_team=None):
self.state = GameState()
if home_team is None:
home_team = Team()
if away_team is None:
away_team = Team()
self.state.homeTeam = home_team
self.state.awayTeam = away_team
self.event_callbacks = []
self.game_end_callbacks = []
if engine is None:
self.engine = GameEngine()
else:
self.engine = engine
def testAnimationPlayerLayer(self):
loop = 10
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
self.e = GameEngine(config)
animPlayer = AnimationPlayer(framerate, self.path, self.basename,
(self.e.view.geometry[2],
self.e.view.geometry[3]), loop = loop)
print "Rendering as a GameEngine Layer for %d loops." % loop
self.e.view.pushLayer(animPlayer)
startTime = pygame.time.get_ticks()
while not animPlayer.finished:
self.e.run()
stopTime = pygame.time.get_ticks()
totalTime = stopTime - startTime
print "nbrFrames: %d, nbrLoops: %d, Total time: %.02f s, Average fps: %.02f" % \
(animPlayer.nbrFrames, loop, totalTime/1000.0, \
(float(1000.0*animPlayer.nbrFrames*(loop+1)) / float(totalTime)))
self.e.view.popLayer(animPlayer)
self.e.quit()
class Solver:
def __init__(self, game, bots):
self.game = game
self.bots = bots
self.engine = GameEngine()
def solve(self):
self.engine.load_configuration(self.game, self.bots)
game_statistics = self.__game_loop()
return game_statistics
def __game_loop(self):
while self.engine.is_game_playing():
self.engine.update()
return self.engine.get_statistics()
class SvgTest(unittest.TestCase):
def testRendering(self):
self.svg.transform.translate(256, 256)
self.svg.transform.rotate(3.141592)
self.svg.draw()
self.e.video.flip()
def testRenderToTexture(self):
scale = 4
fullwidth, fullheight = 512, 512
width, height = int(fullwidth / scale), int(fullheight / scale)
t = Texture()
self.e.svg.setProjection((0, 0, fullwidth, fullheight))
t.prepareRenderTarget(width, height)
t.setAsRenderTarget()
glViewport(0, 0, width, height)
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
self.svg.transform.translate(width * scale / 2, height * scale / 2)
self.svg.transform.rotate(3.141592)
self.svg.draw()
t.resetDefaultRenderTarget()
glViewport(0, 0, fullwidth, fullheight)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluOrtho2D(0.0, 1.0, 0.0, 1.0)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
t.bind()
glEnable(GL_TEXTURE_2D)
if not t.framebuffer.emulated:
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(1.0, 1.0, 1.0)
glBegin(GL_TRIANGLE_STRIP)
glTexCoord2f(0.0, 0.0)
glVertex2f(0.0, 0.0)
glTexCoord2f(1.0, 0.0)
glVertex2f(1.0, 0.0)
glTexCoord2f(0.0, 1.0)
glVertex2f(0.0, 1.0)
glTexCoord2f(1.0, 1.0)
glVertex2f(1.0, 1.0)
glEnd()
self.e.video.flip()
import time
time.sleep(2)
def setUp(self):
self.e = GameEngine()
self.e.loadSvgDrawing(self, "svg", "koopa.svg")
while not self.svg:
self.e.run()
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def main():
playing = None
configFile = None
fullscreen = None
resolution = None
theme = None
#debug = False
difficulty = None
part = None
mode = 0
nbrplayers = 1
for opt, arg in opts:
if opt in ["--verbose", "-v"]:
Log.quiet = False
if opt in ["--config", "-c"]:
configFile = arg
if opt in ["--fullscreen", "-f"]:
fullscreen = arg
if opt in ["--resolution", "-r"]:
resolution = arg
if opt in ["--theme", "-t"]:
theme = arg
if opt in ["--song", "-s"]:
playing = arg
if opt in ["--part", "-p"]:
part = arg
if opt in ["--diff", "-d", "-l"]:
difficulty = arg
#evilynux - Multiplayer and mode selection support
if opt in ["--mode", "-m"]:
mode = int(arg)
if opt in ["--nbrplayers", "-n"]:
nbrplayers = int(arg)
# Load the configuration file.
if configFile is not None:
if configFile.lower() == "reset":
fileName = os.path.join(Resource.getWritableResourcePath(), Version.PROGRAM_UNIXSTYLE_NAME + ".ini")
os.remove(fileName)
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
else:
config = Config.load(configFile, setAsDefault = True)
else:
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
#Lysdestic - Allow support for manipulating fullscreen via CLI
if fullscreen is not None:
Config.set("video", "fullscreen", fullscreen)
#Lysdestic - Change resolution from CLI
if resolution is not None:
Config.set("video", "resolution", resolution)
#Lysdestic - Alter theme from CLI
if theme is not None:
Config.set("coffee", "themename", theme)
engine = GameEngine(config)
engine.cmdPlay = 0
# Check for a valid invocation of one-shot mode.
if playing is not None:
Log.debug('Validating song directory for one-shot mode.')
library = Config.get("game","base_library")
basefolder = os.path.join(Version.dataPath(),library,"songs",playing)
if not (os.path.exists(os.path.join(basefolder, "song.ini")) and (os.path.exists(os.path.join(basefolder, "notes.mid")) or os.path.exists(os.path.join(basefolder, "notes-unedited.mid"))) and (os.path.exists(os.path.join(basefolder, "song.ogg")) or os.path.exists(os.path.join(basefolder, "guitar.ogg")))):
Log.warn("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode." % playing)
engine.startupMessages.append(_("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode.") % playing)
playing = None
# Set up one-shot mode if the invocation is valid for it.
if playing is not None:
Log.debug('Entering one-shot mode.')
Config.set("game", "selected_library", "songs")
Config.set("game", "selected_song", playing)
engine.cmdPlay = 1
if difficulty is not None:
engine.cmdDiff = int(difficulty)
if part is not None:
engine.cmdPart = int(part)
#evilynux - Multiplayer and mode selection support
if nbrplayers == 1:
engine.cmdMode = nbrplayers, mode, 0
else:
engine.cmdMode = nbrplayers, 0, mode
encoding = Config.get("game", "encoding")
if encoding is not None:
#stump: XXX: Everything I have seen indicates that this is a
# horrible, horrible hack. Is there another way? Do we even need this?
reload(sys)
sys.setdefaultencoding(encoding)
# Play the intro video if it is present, we have the capability, and
# we are not in one-shot mode.
videoLayer = False
if videoAvailable and not engine.cmdPlay:
# TODO: Parameters to add to theme.ini:
# - intro_video_file
# - intro_video_start_time
# - intro_video_end_time
themename = Config.get("coffee", "themename")
vidSource = os.path.join(Version.dataPath(), 'themes', themename, \
'menu', 'intro.mp4')
if os.path.isfile(vidSource):
winWidth, winHeight = engine.view.geometry[2:4]
songVideoStartTime = 0
songVideoEndTime = None
vidPlayer = VideoPlayer(-1, vidSource, (winWidth, winHeight),
startTime = songVideoStartTime,
endTime = songVideoEndTime)
if vidPlayer.validFile:
engine.view.pushLayer(vidPlayer)
videoLayer = True
try:
engine.ticksAtStart = pygame.time.get_ticks()
while not vidPlayer.finished:
engine.run()
engine.view.popLayer(vidPlayer)
engine.view.pushLayer(MainMenu(engine))
except KeyboardInterrupt:
engine.view.popLayer(vidPlayer)
engine.view.pushLayer(MainMenu(engine))
if not videoLayer:
engine.setStartupLayer(MainMenu(engine))
#stump: make psyco optional
if Config.get("performance", "use_psyco"):
try:
import psyco
psyco.profile()
except:
Log.error("Unable to enable psyco as requested: ")
# Run the main game loop.
try:
engine.ticksAtStart = pygame.time.get_ticks()
while engine.run():
pass
except KeyboardInterrupt:
Log.notice("Left mainloop due to KeyboardInterrupt.")
# don't reraise
# Restart the program if the engine is asking that we do so.
if engine.restartRequested:
Log.notice("Restarting.")
engine.audio.close()
try:
# Extra arguments to insert between the executable we call and our
# command line arguments.
args = []
# Figure out what executable to call.
if hasattr(sys, "frozen"):
if os.name == "nt":
# When py2exe'd, sys.executable is the name of the EXE.
exe = os.path.abspath(unicode(sys.executable, sys.getfilesystemencoding()))
elif sys.frozen == "macosx_app":
# When py2app'd, sys.executable is a Python interpreter copied
# into the same dir where we live.
exe = os.path.join(os.path.dirname(sys.executable), 'FoFiX') # FIXME: don't hard-code "FoFiX" here
else:
raise RuntimeError, "Don't know how to restart when sys.frozen is %s" % repr(sys.frozen)
else:
# When running from source, sys.executable is the Python interpreter
# being used to run the program.
exe = sys.executable
# Pass the optimization level on iif python version >= 2.6.0 as
# sys.flags has been introduced in 2.6.0.
if sys.version_info[:3] >= (2,6,0) and sys.flags.optimize > 0:
args.append('-%s' % ('O' * sys.flags.optimize))
args.append(sys.argv[0])
os.execv(exe, [sys.executable] + args + sys.argv[1:])
except:
Log.error("Restart failed: ")
raise
# evilynux - MainMenu class already calls this - useless?
engine.quit()
try:
opts, args = getopt.getopt(sys.argv[1:], "vp:", ["verbose", "play="])
except getopt.GetoptError:
print usage
sys.exit(1)
songName = None
for opt, arg in opts:
if opt in ["--verbose", "-v"]:
Log.quiet = False
elif opt in ["--play", "-p"]:
songName = arg
while True:
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
engine = GameEngine(config)
menu = MainMenu(engine, songName = songName)
engine.setStartupLayer(menu)
try:
import psyco
psyco.profile()
except:
Log.warn("Unable to enable psyco.")
try:
while engine.run():
pass
except KeyboardInterrupt:
pass
class VideoPlayerTest(unittest.TestCase):
# Simplest way to use the video player, use it as a Layer
def testVideoPlayerLayer(self):
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
self.e = GameEngine(config)
winWidth, winHeight = (self.e.view.geometry[2], self.e.view.geometry[3])
vidPlayer = VideoPlayer(framerate, self.src, (winWidth, winHeight),
loop = False)
self.e.view.pushLayer(vidPlayer)
while not vidPlayer.finished:
self.e.run()
self.e.view.popLayer(vidPlayer)
self.e.audio.close()
self.e.quit()
# Keep tight control over the video player
def testVideoPlayerSlave(self):
winWidth, winHeight = 800, 600
pygame.init()
flags = DOUBLEBUF|OPENGL|HWPALETTE|HWSURFACE
pygame.display.set_mode((winWidth, winHeight), flags)
vidPlayer = VideoPlayer(framerate, self.src, (winWidth, winHeight))
glViewport(0, 0, winWidth, winHeight) # Both required as...
glScissor(0, 0, winWidth, winHeight) # ...GameEngine changes it
glClearColor(0, 0, 0, 1.)
while not vidPlayer.finished:
vidPlayer.run()
vidPlayer.render()
pygame.display.flip()
pygame.quit()
# Grab the texture, use the CallList and do whatever we want with it;
# We could also _just_ use the texture and take care of the polygons ourselves
def testVideoPlayerSlaveShowOff(self):
winWidth, winHeight = 500, 500
pygame.init()
flags = DOUBLEBUF|OPENGL|HWPALETTE|HWSURFACE
pygame.display.set_mode((winWidth, winHeight), flags)
vidPlayer = VideoPlayer(-1, self.src, (winWidth, winHeight))
glViewport(0, 0, winWidth, winHeight) # Both required as...
glScissor(0, 0, winWidth, winHeight) # ...GameEngine changes it
glClearColor(0, 0, 0, 1.)
x, y = 0.0, 1.0
fx, fy, ftheta = 1, 1, 1
theta = 0.0
time = 0.0
clock = pygame.time.Clock()
while not vidPlayer.finished:
vidPlayer.run()
vidPlayer.textureUpdate()
# Save and clear both transformation matrices
glMatrixMode(GL_PROJECTION)
glPushMatrix()
glLoadIdentity()
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glLoadIdentity()
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(1., 1., 1.)
glBindTexture(GL_TEXTURE_2D, vidPlayer.videoTex)
glTranslatef(x, y, 0)
glRotatef(theta, 0, 0, 1.)
glScalef(.5, .5, 1.)
glCallList(vidPlayer.videoList)
# Restore both transformation matrices
glPopMatrix()
glMatrixMode(GL_PROJECTION)
glPopMatrix()
pygame.display.flip()
x = (x + fx*time)
y = (y + fy*time)
theta = theta + ftheta
if x > 1.0 or x < -1.0:
fx = fx * -1
if y > 1.0 or y < -1.0:
fy = fy * -1
if theta > 90 or theta < -90:
ftheta = ftheta * -1
time = time + 0.00001
clock.tick(60)
pygame.quit()
def setUp(self):
self.src = os.path.join(Version.dataPath(), vidSource)
self.assert_(os.path.exists(self.src), "File %s does not exist!" % self.src)
def tearDown(self):
pass
def main():
"""Main thread"""
try:
opts, args = getopt.getopt(sys.argv[1:], "vdc:p:D:P:m:N:", ["verbose", "debug", "config=", "play=", "diff=", "part=", "mode=", "nbrplayers="])
except getopt.GetoptError:
print usage
sys.exit(1)
playing = None
configFile = None
debug = False
difficulty = 0
part = 0
mode = 0
nbrplayers = 1
for opt, arg in opts:
if opt in ["--verbose", "-v"]:
Log.quiet = False
if opt in ["--debug", "-d"]:
debug = True
if opt in ["--config", "-c"]:
configFile = arg
if opt in ["--play", "-p"]:
playing = arg
if opt in ["--diff", "-D"]:
difficulty = arg
if opt in ["--part", "-P"]:
part = arg
#evilynux - Multiplayer and mode selection support
if opt in ["--mode", "-m"]:
mode = int(arg)
if opt in ["--nbrplayers", "-N"]:
nbrplayers = int(arg)
while True:
if configFile != None:
if configFile.lower() == "reset":
fileName = os.path.join(Resource.getWritableResourcePath(), Version.appName() + ".ini")
os.remove(fileName)
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
else:
config = Config.load(configFile, setAsDefault = True)
else:
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
engine = GameEngine(config)
engine.cmdPlay = 0
if playing != None:
Config.set("game", "selected_library", "songs")
Config.set("game", "selected_song", playing)
engine.cmdPlay = 1
engine.cmdDiff = int(difficulty)
engine.cmdPart = int(part)
#evilynux - Multiplayer and mode selection support
Config.set("game", "players", nbrplayers)
Config.set("player0","mode_1p", mode)
Config.set("player1","mode_2p", mode)
if debug == True:
engine.setDebugModeEnabled(not engine.isDebugModeEnabled())
engine.debugLayer.debugOut(engine)
engine.quit()
break
encoding = Config.get("game", "encoding")
if encoding != None:
reload(sys)
sys.setdefaultencoding(encoding)
engine.setStartupLayer(MainMenu(engine))
try:
import psyco
psyco.profile()
except:
Log.warn("Unable to enable psyco.")
try:
while engine.run():
pass
except KeyboardInterrupt:
pass
if engine.restartRequested:
Log.notice("Restarting.")
engine.audio.close()
try:
# Determine whether were running from an exe or not
if hasattr(sys, "frozen"):
if os.name == "nt":
os.execl("FretsOnFire.exe", "FretsOnFire.exe", *sys.argv[1:])
elif sys.frozen == "macosx_app":
import string
import subprocess
appname = string.join(string.split(sys.executable, '/')[:-1], '/')
appname = appname+"/Frets on Fire"
subprocess.Popen(`appname`, shell=True)
else:
os.execl("./FretsOnFire", "./FretsOnFire", *sys.argv[1:])
else:
if os.name == "nt":
bin = "c:/python24/python"
else:
bin = "/usr/bin/python2.4"
os.execl(bin, bin, "FretsOnFire.py", *sys.argv[1:])
except:
Log.warn("Restart failed.")
raise
break
else:
break
engine.quit()
class AnimationPlayerTest(unittest.TestCase):
# Simplest way to use the Animation player, use it as a Layer
def testAnimationPlayerLayer(self):
loop = 10
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini",
setAsDefault=True)
self.e = GameEngine(config)
animPlayer = AnimationPlayer(
framerate,
self.path,
self.basename, (self.e.view.geometry[2], self.e.view.geometry[3]),
loop=loop)
print "Rendering as a GameEngine Layer for %d loops." % loop
self.e.view.pushLayer(animPlayer)
startTime = pygame.time.get_ticks()
while not animPlayer.finished:
self.e.run()
stopTime = pygame.time.get_ticks()
totalTime = stopTime - startTime
print "nbrFrames: %d, nbrLoops: %d, Total time: %.02f s, Average fps: %.02f" % \
(animPlayer.nbrFrames, loop, totalTime/1000.0, \
(float(1000.0*animPlayer.nbrFrames*(loop+1)) / float(totalTime)))
self.e.view.popLayer(animPlayer)
self.e.quit()
# Keep tight control over the Animation player
def testAnimationPlayerSlave(self):
loop = 5
winWidth, winHeight = 800, 600
pygame.init()
flags = DOUBLEBUF | OPENGL | HWPALETTE | HWSURFACE
pygame.display.set_mode((winWidth, winHeight), flags)
animPlayer = AnimationPlayer(framerate,
self.path,
self.basename, (winWidth, winHeight),
loop=loop)
glViewport(0, 0, winWidth, winHeight) # Both required as...
glScissor(0, 0, winWidth, winHeight) # ...GameEngine changes it
glClearColor(0, 0, 0, 1.)
print "Rendering independently and fullscreen for %d loops." % loop
clock = pygame.time.Clock()
startTime = pygame.time.get_ticks()
while not animPlayer.finished:
ticks = clock.get_time()
animPlayer.run(ticks)
animPlayer.render()
pygame.display.flip()
clock.tick()
stopTime = pygame.time.get_ticks()
totalTime = stopTime - startTime
print "nbrFrames: %d, nbrLoops: %d, Total time: %.02f s, Average fps: %.02f" % \
(animPlayer.nbrFrames, loop, totalTime/1000.0,
1000.0*animPlayer.nbrFrames*(loop+1) / float(totalTime))
# Testing animation change
# FIXME: another set of files would be more relevant (e.g. diff. resolution)
loop = 5
print "Let's go for another ride of %d loops." % loop
animPlayer.loop = loop
animPlayer.loadAnimation(self.path, self.basename)
startTime = pygame.time.get_ticks()
while not animPlayer.finished:
ticks = clock.get_time()
animPlayer.run(ticks)
animPlayer.render()
pygame.display.flip()
clock.tick()
stopTime = pygame.time.get_ticks()
totalTime = stopTime - startTime
print "nbrFrames: %d, nbrLoops: %d, Total time: %.02f s, Average fps: %.02f" % \
(animPlayer.nbrFrames, loop, totalTime/1000.0,
1000.0*animPlayer.nbrFrames*(loop+1) / float(totalTime))
pygame.quit()
# Grab the texture, use the CallList and do whatever we want with it;
# We could also _just_ use the texture and take care of the polygons ourselves
def testAnimationPlayerSlaveShowOff(self):
winWidth, winHeight = 500, 500
loop = 4
pygame.init()
flags = DOUBLEBUF | OPENGL | HWPALETTE | HWSURFACE
pygame.display.set_mode((winWidth, winHeight), flags)
animPlayer = AnimationPlayer(framerate,
self.path,
self.basename, (winWidth, winHeight),
loop=loop)
print "Rendering ourselves, doing what we want with the texture, for %d loops." % loop
glViewport(0, 0, winWidth, winHeight) # Both required as...
glScissor(0, 0, winWidth, winHeight) # ...GameEngine changes it
glClearColor(0, 0, 0, 1.)
x, y = 0.0, 1.0
fx, fy, ftheta = 1, 1, 1
theta = 0.0
time = 0.0
clock = pygame.time.Clock()
startTime = pygame.time.get_ticks()
while not animPlayer.finished:
ticks = clock.get_time()
animPlayer.run(ticks)
texture = animPlayer.getTexture()
# Save and clear both transformation matrices
glMatrixMode(GL_PROJECTION)
glPushMatrix()
glLoadIdentity()
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glLoadIdentity()
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(1., 1., 1.)
glBindTexture(GL_TEXTURE_2D, texture)
glTranslatef(x, y, 0)
glRotatef(theta, 0, 0, 1.)
glScalef(.5, .5, 1.)
glCallList(animPlayer.animList)
# Restore both transformation matrices
glPopMatrix()
glMatrixMode(GL_PROJECTION)
glPopMatrix()
pygame.display.flip()
x = (x + fx * time)
y = (y + fy * time)
theta = theta + ftheta
if x > 1.0 or x < -1.0:
fx = fx * -1
if y > 1.0 or y < -1.0:
fy = fy * -1
if theta > 90 or theta < -90:
ftheta = ftheta * -1
time = time + 0.00001
clock.tick(60)
stopTime = pygame.time.get_ticks()
totalTime = stopTime - startTime
print "nbrFrames: %d, nbrLoops %d, Total time: %.02f s, Average fps: %.02f" % \
(animPlayer.nbrFrames, loop, totalTime/1000.0, \
(float(1000.0*animPlayer.nbrFrames*(loop+1)) / float(totalTime)))
pygame.quit()
def setUp(self):
self.path = os.path.join(Version.dataPath(), animPath)
self.basename = animBasename
print "Initializing..."
def tearDown(self):
pass
def setUp(self):
config = Config.load(Version.appName() + ".ini", setAsDefault=True)
self.e = GameEngine(config)
self.src = os.path.join(Version.dataPath(), vidSource)
class Game():
"""
The game to be played. Contains game logic.
"""
def __init__(self, engine=None, home_team=None, away_team=None):
self.state = GameState()
if home_team is None:
home_team = Team()
if away_team is None:
away_team = Team()
self.state.homeTeam = home_team
self.state.awayTeam = away_team
self.event_callbacks = []
self.game_end_callbacks = []
if engine is None:
self.engine = GameEngine()
else:
self.engine = engine
def register_event_callback(self, callback):
self.event_callbacks.append(callback)
def fire_event_callbacks(self, pre_state, post_state, event):
for callback in self.event_callbacks:
callback(pre_state, post_state, event)
def register_game_end_callback(self, callback):
self.game_end_callbacks.append(callback)
def fire_game_end_callbacks(self, state):
for callback in self.game_end_callbacks:
callback(state)
def play(self):
for pre_state, post_state, event in self._play_inning():
self.fire_event_callbacks(pre_state, post_state, event)
self.fire_game_end_callbacks(self.state)
def _play_inning(self):
while not self.state.completed and (self.state.inning <= 9 or self.state.homeRuns == self.state.awayRuns):
# play top half of inning
for preState, postState, event in self._play_half_inning():
yield preState, postState, event
# play bottom half of inning
if self.state.inning < 9 or self.state.homeRuns <= self.state.awayRuns:
for preState, postState, event in self._play_half_inning():
yield preState, postState, event
else:
self.state.completed = True
def _play_half_inning(self):
self.state.outs = 0
self.state.clear_bases()
while self.state.outs < 3 and self._continue_playing():
event = self.engine.next_event(self.state)
prestate = self.state
if isinstance(event, GameEvent.Play):
poststate = self.state.add_event(event)
elif isinstance(event, GameEvent.Substitution):
# TODO - move this to a function (add_substitution)
team = self.state.homeTeam if event.team == 1 else self.state.awayTeam
if event.offensiveLineupIndex > 0:
team.offensiveLineup[event.offensiveLineupIndex - 1] = event.player
if 0 < event.defensiveLineupIndex <= 9:
team.defensiveLineup[event.defensiveLineupIndex - 1] = event.player
poststate = prestate
elif isinstance(event, GameEvent.Comment):
poststate = prestate
else:
raise Exception("Unsupported event type")
yield prestate, poststate, event
self.state = poststate
if self.state.inningBottom:
self.state.inning += 1
self.state.inningBottom = not self.state.inningBottom
def _continue_playing(self):
return not (self.state.inningBottom and
self.state.homeRuns > self.state.awayRuns and
self.state.inning >= 9)
def testNetworking(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
e1 = GameEngine(config)
e1.startServer()
session1 = e1.connect("localhost")
session2 = e1.connect("localhost")
while not session1.isConnected() or not session2.isConnected():
e1.run()
session1.world.createPlayer("mario")
session2.world.createPlayer("luigi")
for i in range(10):
e1.run()
assert len(e1.server.world.players) == 2
assert len(session1.world.players) == 2
assert len(session2.world.players) == 2
session3 = e1.connect("localhost")
for i in range(10):
e1.run()
assert len(session3.world.players) == 2
session1.disconnect()
for i in range(10):
e1.run()
assert len(e1.server.world.players) == 1
assert len(session2.world.players) == 1
e1.quit()
def setUp(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
self.e = GameEngine(config)
else:
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
#Lysdestic - Allow support for manipulating fullscreen via CLI
if fullscreen is not None:
Config.set("video", "fullscreen", fullscreen)
#Lysdestic - Change resolution from CLI
if resolution is not None:
Config.set("video", "resolution", resolution)
#Lysdestic - Alter theme from CLI
if theme is not None:
Config.set("coffee", "themename", theme)
engine = GameEngine(config)
engine.cmdPlay = 0
# Check for a valid invocation of one-shot mode.
if playing is not None:
Log.debug('Validating song directory for one-shot mode.')
library = Config.get("setlist","base_library")
basefolder = os.path.join(Version.dataPath(),library,"songs",playing)
if not (os.path.exists(os.path.join(basefolder, "song.ini")) and (os.path.exists(os.path.join(basefolder, "notes.mid")) or os.path.exists(os.path.join(basefolder, "notes-unedited.mid"))) and (os.path.exists(os.path.join(basefolder, "song.ogg")) or os.path.exists(os.path.join(basefolder, "guitar.ogg")))):
Log.warn("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode." % playing)
engine.startupMessages.append(_("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode.") % playing)
playing = None
# Set up one-shot mode if the invocation is valid for it.
if playing is not None:
Log.debug('Entering one-shot mode.')
def main():
"""Main thread"""
try:
opts, args = getopt.getopt(sys.argv[1:], "vdc:f:r:t:s:l:p:m:n:", ["verbose", "debug", "config=", "fullscreen=", "resolution=", "theme=", "song=", "diff=", "part=", "mode=", "nbrplayers="])
except getopt.GetoptError:
print usage
sys.exit(1)
playing = None
configFile = None
fullscreen = None
resolution = None
theme = None
debug = False
difficulty = None
part = None
mode = 0
nbrplayers = 1
for opt, arg in opts:
if opt in ["--verbose", "-v"]:
Log.quiet = False
if opt in ["--debug", "-d"]:
debug = True
if opt in ["--config", "-c"]:
configFile = arg
if opt in ["--fullscreen", "-f"]:
fullscreen = arg
if opt in ["--resolution", "-r"]:
resolution = arg
if opt in ["--theme", "-t"]:
theme = arg
if opt in ["--song", "-s"]:
playing = arg
if opt in ["--diff", "-l"]:
difficulty = arg
if opt in ["--part", "-p"]:
part = arg
#evilynux - Multiplayer and mode selection support
if opt in ["--mode", "-m"]:
mode = int(arg)
if opt in ["--nbrplayers", "-n"]:
nbrplayers = int(arg)
while 1:
if configFile != None:
if configFile.lower() == "reset":
fileName = os.path.join(Resource.getWritableResourcePath(), Version.appName() + ".ini")
os.remove(fileName)
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
else:
config = Config.load(configFile, setAsDefault = True)
else:
config = Config.load(Version.appName() + ".ini", setAsDefault = True)
#Lysdestic - Allow support for manipulating fullscreen via CLI
if fullscreen != None:
Config.set("video", "fullscreen", fullscreen)
#Lysdestic - Change resolution from CLI
if resolution != None:
Config.set("video", "resolution", resolution)
#Lysdestic - Alter theme from CLI
if theme != None:
Config.set("coffee", "themename", theme)
if playing != None:
library = Config.get("game","base_library")
basefolder = os.path.join(Version.dataPath(),library,"songs",playing)
if not (os.path.exists(os.path.join(basefolder, "song.ini")) and (os.path.exists(os.path.join(basefolder, "notes.mid")) or os.path.exists(os.path.join(basefolder, "notes-unedited.mid"))) and (os.path.exists(os.path.join(basefolder, "song.ogg")) or os.path.exists(os.path.join(basefolder, "guitar.ogg")))):
Log.warn("Song directory provided ('%s') is not a valid song directory. Starting up FoFiX in standard mode." % playing)
playing = None
engine = GameEngine(config)
engine.cmdPlay = 0
if playing != None:
Config.set("game", "selected_library", "songs")
Config.set("game", "selected_song", playing)
engine.cmdPlay = 1
if difficulty is not None:
engine.cmdDiff = int(difficulty)
if part is not None:
engine.cmdPart = int(part)
#evilynux - Multiplayer and mode selection support
Config.set("game", "players", nbrplayers)
if nbrplayers == 1:
Config.set("game", "game_mode", mode)
else:
Config.set("game", "game_mode", 0)
Config.set("game", "multiplayer_mode", mode)
if debug == True:
engine.setDebugModeEnabled(not engine.isDebugModeEnabled())
engine.debugLayer.debugOut(engine)
engine.quit()
break
encoding = Config.get("game", "encoding")
if encoding != None:
reload(sys)
sys.setdefaultencoding(encoding)
engine.setStartupLayer(MainMenu(engine))
#stump: make psyco optional
if Config.get("performance", "use_psyco"):
try:
import psyco
psyco.profile()
except:
Log.warn("Unable to enable psyco.")
try:
engine.ticksAtStart = pygame.time.get_ticks()
while engine.run():
pass
except KeyboardInterrupt:
pass
if engine.restartRequested:
Log.notice("Restarting.")
engine.audio.close()
try:
# Determine whether were running from an exe or not
if hasattr(sys, "frozen"):
if os.name == "nt":
os.execl("FoFiX.exe", "FoFiX.exe", *sys.argv[1:])
elif sys.frozen == "macosx_app":
import string
import subprocess
appname = string.join(string.split(sys.executable, '/')[:-1], '/')
appname = appname+"/FoFiX"
subprocess.Popen(`appname`, shell=True)
else:
os.execl("./FoFiX", "./FoFiX", *sys.argv[1:])
else:
# stump: sys.executable points to the active python interpreter
os.execl(sys.executable, sys.executable, "FoFiX.py", *sys.argv[1:])
except:
Log.warn("Restart failed.")
raise
break
else:
break
# evilynux - MainMenu class already calls this - useless?
engine.quit()
class VideoPlayerTest(unittest.TestCase):
# Simplest way to use the video player, use it as a Layer
def testVideoPlayerLayer(self):
vidPlayer = VideoPlayer(self.e, framerate, self.src, loop=False)
self.e.view.pushLayer(vidPlayer)
while not vidPlayer.finished:
self.e.run()
# Keep tight control over the video player
def testVideoPlayerSlave(self):
winWidth, winHeight = 800, 600
pygame.init()
flags = DOUBLEBUF | OPENGL | HWPALETTE | HWSURFACE
pygame.display.set_mode((winWidth, winHeight), flags)
vidPlayer = VideoPlayer(self.e, framerate, self.src,
(winWidth, winHeight))
glViewport(0, 0, winWidth,
winHeight) # Required as GameEngine changes it
font = self.e.data.font
while not vidPlayer.finished:
vidPlayer.run()
vidPlayer.render()
pygame.display.flip()
# Grab the texture, use the CallList and do whatever we want with it;
# We could also _just_ use the texture and take care of the polygons ourselves
def testVideoPlayerSlaveShowOff(self):
winWidth, winHeight = 500, 500
pygame.init()
flags = DOUBLEBUF | OPENGL | HWPALETTE | HWSURFACE
pygame.display.set_mode((winWidth, winHeight), flags)
vidPlayer = VideoPlayer(self.e, -1, self.src, (winWidth, winHeight))
glViewport(0, 0, winWidth,
winHeight) # Required as GameEngine changes it
glClearColor(0, 0, 0, 1.)
x, y = 0.0, 1.0
fx, fy, ftheta = 1, 1, 1
theta = 0.0
time = 0.0
clock = pygame.time.Clock()
while not vidPlayer.finished:
vidPlayer.run()
vidPlayer.textureUpdate()
# Save and clear both transformation matrices
glMatrixMode(GL_PROJECTION)
glPushMatrix()
glLoadIdentity()
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glLoadIdentity()
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(1., 1., 1.)
glBindTexture(GL_TEXTURE_2D, vidPlayer.videoTex)
glTranslatef(x, y, 0)
glRotatef(theta, 0, 0, 1.)
glScalef(.5, .5, 1.)
glCallList(vidPlayer.videoList)
# Restore both transformation matrices
glPopMatrix()
glMatrixMode(GL_PROJECTION)
glPopMatrix()
pygame.display.flip()
x = (x + fx * time)
y = (y + fy * time)
theta = theta + ftheta
if x > 1.0 or x < -1.0:
fx = fx * -1
if y > 1.0 or y < -1.0:
fy = fy * -1
if theta > 90 or theta < -90:
ftheta = ftheta * -1
time = time + 0.00001
clock.tick(60)
def setUp(self):
config = Config.load(Version.appName() + ".ini", setAsDefault=True)
self.e = GameEngine(config)
self.src = os.path.join(Version.dataPath(), vidSource)
def tearDown(self):
self.e.quit()
def setUp(self):
self.e = GameEngine()
if opt in ["--mode", "-m"]:
mode = int(arg)
if opt in ["--nbrplayers", "-N"]:
nbrplayers = int(arg)
while True:
if configFile != None:
if configFile.lower() == "reset":
fileName = os.path.join(Resource.getWritableResourcePath(), Version.appName() + ".ini")
os.remove(fileName)
config = Config.load(Version.appName() + ".ini", setAsDefault=True)
else:
config = Config.load(configFile, setAsDefault=True)
else:
config = Config.load(Version.appName() + ".ini", setAsDefault=True)
engine = GameEngine(config)
engine.cmdPlay = 0
if playing != None:
Config.set("game", "selected_library", "songs")
Config.set("game", "selected_song", playing)
engine.cmdPlay = 1
engine.cmdDiff = int(difficulty)
engine.cmdPart = int(part)
# evilynux - Multiplayer and mode selection support
Config.set("game", "players", nbrplayers)
Config.set("player0", "mode_1p", mode)
Config.set("player1", "mode_2p", mode)
if debug == True:
engine.setDebugModeEnabled(not engine.isDebugModeEnabled())
'''
Created on 9 Sep 2012
@author: Callum
'''
from GameEngine import GameEngine
import pygame
from pygame.locals import *
if __name__ == '__main__':
### Start!
pygameDisplay=pygame.display.set_mode((800,800),RESIZABLE)
pygame.display.set_caption("PiCore")
engine = GameEngine(pygameDisplay) #Create engine
engine.run() #Get going....
pass
def __init__(self, game, bots):
self.game = game
self.bots = bots
self.engine = GameEngine()
def setUp(self): config = Config.load(Version.appName() + ".ini", setAsDefault = True) self.e = GameEngine(config)
