class Game:
def __init__(self):
pygame.init()
self.size = self.width, self.height = 640, 640
self.screen = pygame.display.set_mode(self.size)
pygame.display.set_caption('Traveling Salesman Problem')
self.clock = pygame.time.Clock()
self.renderer = Renderer(self)
self.calculator = Calculator(self)
self.saved_points = []
self.screenshot_requested = False
while True:
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
sys.exit()
self.update(events)
self.renderer.draw(self.screen)
if self.screenshot_requested:
util.save_screenshot(self)
self.screenshot_requested = False
pygame.display.flip()
def update(self, events):
for event in events:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
self.calculator.thread_stop = True
self.calculator.thread_finished = False
self.calculator.reset_points = True
if event.key == pygame.K_s:
self.screenshot_requested = True
if event.key == pygame.K_1:
self.calculator.thread_stop = True
self.calculator.thread_finished = False
self.calculator.selected_algorithm = RANDOM
self.calculator.reset_points = False
if event.key == pygame.K_2:
self.calculator.thread_stop = True
self.calculator.thread_finished = False
self.calculator.selected_algorithm = PERMUTATION
self.calculator.reset_points = False
if event.key == pygame.K_3:
self.calculator.thread_stop = True
self.calculator.thread_finished = False
self.calculator.selected_algorithm = GENETIC
self.calculator.reset_points = False
if not self.calculator.thread_running and not self.calculator.thread_finished:
self.calculator.algorithm = self.calculator.selected_algorithm
self.calculator.start_thread()
def draw(self, uProjection, uView, uModel):
"""
Set uniforms in the shader and render the object
:param uProjection:
:param uView:
:param uModel:
:return:
"""
self.material.bind()
self.material.shader.set_uniform_mat4f("uProjection", glm.transpose(uProjection))
self.material.shader.set_uniform_mat4f("uView", glm.transpose(uView))
self.material.shader.set_uniform_mat4f("uModel", glm.transpose(uModel))
Renderer.draw(self.vao, self.ibo if self.ibo is not None else self.vbo, self.material.shader)
class Game:
def __init__(self, gamemap, pacman):
self.gamemap, self.pacman = gamemap, pacman
self.r = Renderer()
def start(self):
while True:
self.r.draw(self.gamemap)
key = getch()
if key is 'q':
exit(0)
elif key is '\033':
key = getch()
if key is '[':
key = getch()
if key is 'A':
self.pacman.move(self.gamemap, Y=-1)
elif key is 'B':
self.pacman.move(self.gamemap, Y=1)
elif key is 'C':
self.pacman.move(self.gamemap, X=1)
elif key is 'D':
self.pacman.move(self.gamemap, X=-1)
class Application:
def __init__(self, name: str):
pygame.init()
self.__title = name
self.__gameover = False
self.__renderer = None
def create_window(self, width: int, height: int, name="default"):
self.__renderer = Renderer(width, height, name)
def exit(self):
self.__gameover = True
def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.exit()
else:
Director().get_current_scene().handle_event(event)
def run(self):
if self.__renderer is None:
print("[Fatal Error] No screen initialized")
sys.exit(1)
director = Director()
Director().set_scene(MainGameScene())
previous_time = time()
delta_t = time()
while not self.__gameover:
delta_t = (time() - previous_time)
scene = director.get_current_scene()
scene.update(delta_t)
self.handle_events()
self.__renderer.draw(scene)
previous_time = time()
return 0
return mod
# Main
if __name__ == "__main__":
envName = "SnakeGame"
if len(sys.argv) > 1:
envName = sys.argv[1]
agentName = "HumanAgent"
if len(sys.argv) > 2:
agentName = sys.argv[2]
# Create env
print (f"Creating env {envName}")
Environment = importModule(f'Environments.{envName}').Environment
env = Environment()
# Load agent
print(f"Starting agent {agentName}")
Agent = importModule(f'Agents.{agentName}').Agent
agent = Agent()
# Create renderer
renderer = Renderer(512, 384)
while True:
renderer.clock.tick(10)
agent.step(env, renderer)
renderer.pollEvents()
renderer.draw(env.render)
class Game:
def __init__(self,arguments):
self.debug = False
self.capturing = False
self.captureFPSWait = 0
self.running = True
self.fullscreen = False
self.paused = False
self.cachedScenes = {}
self.currentScene = None
self.currentElement = None
self.currentWindow = None
self.currentWidget = None
self.values = {}
self.Loader = Loader(self)
self.setupScreen()
self.setupAudio()
self.displayTitle()
self.Loader.preload()
self.TitleManager = TitleManager(self)
self.Cursor = Cursor(self)
self.Renderer = Renderer(self)
self.AudioController = AudioController(self)
self.Inventory = Inventory(self)
self.TopicMenu = TopicMenu(self)
self.ScriptManager = ScriptManager(self)
self.Player = Player(self)
self.EventManager = EventManager(self)
self.parseArguments(arguments)
self.loadScene("blacksmith")
self.run()
def setupScreen(self,fullscreen=False):
#There seems to be no way to make this work right other than doing this:
pygame.display.set_icon(pygame.image.load(os.path.join('Resources','Icons','gameicon.png')))
if fullscreen:
self.window = pygame.display.set_mode((0,0),pygame.FULLSCREEN)
else:
self.window = pygame.display.set_mode((1024,768))
pygame.display.set_caption('Subterranean')
def displayTitle(self):
#Temporary but neat
logo = pygame.image.load(os.path.join('Resources','Graphics','Misc','logo.png'))
self.window.blit(logo,(self.window.get_rect().centerx - logo.get_width()/2,self.window.get_rect().centery - logo.get_height()/2))
pygame.display.flip()
def setupAudio(self):
pygame.mixer.init(44100)
def parseArguments(self,arguments):
avalibleArguments = {
'--fullscreen':self.toggleFullscreen,
'--nomusic':self.AudioController.disableMusic,
'--nosound':self.AudioController.disableSound,
'--debug':self.activateDebug
}
for argument in avalibleArguments.keys():
if argument in arguments:
argumentMethod = avalibleArguments.get(argument)
argumentMethod()
def pause(self):
self.paused = True
def unpause(self):
self.paused = False
def loop(self):
while self.running:
self.EventManager.checkEvents()
self.Renderer.draw()
self.Renderer.Timer.tick()
def loadScene(self,sceneName):
if sceneName in self.cachedScenes:
self.log("Got",sceneName,"from cache")
self.currentScene = self.cachedScenes.get(sceneName)
#Run the enter method if it is not the first time we do
self.currentScene.enter()
else:
self.log("Loaded",sceneName,"from file")
scene = imp.load_source(sceneName,os.path.join('Assets','Scenes',sceneName+'.py'))
sceneClass = getattr(scene,'Room');
self.currentScene = sceneClass(self)
self.cacheScene(self.currentScene,sceneName)
def loadAsset(self,assetType,assetName):
try:
module = imp.load_source(assetName,os.path.join('Assets',assetType,assetName+'.py'))
assetClass = getattr(module,assetName);
asset = assetClass(self)
return asset
except IOError:
print "Fatal error: Could not load",assetName,"from",assetType
exit()
def cacheScene(self,sceneObject,sceneName):
self.cachedScenes[sceneName] = sceneObject
def quit(self,event=None):
self.running = False
sys.exit()
def run(self):
self.loop()
def toggleFullscreen(self):
if self.fullscreen == False:
self.fullscreen = True
self.setupScreen(True)
else:
self.fullscreen = False
self.setupScreen(False)
def activateDebug(self):
self.debug = True
def log(self,*values):
if self.debug:
logValues = []
for value in values:
logValues.append(str(value)+" ")
print "".join(logValues)
def setValue(self,key,value):
self.values[key] = value
def getValue(self,key):
return self.values.get(key)
def dump(self):
if self.debug:
self.debug = False
else:
self.debug = True
def get(self,key):
return self.Loader.get(key)
