def __init__(self):
self.debug = False
ShowBase.__init__(self)
self.accept("escape",sys.exit)
# the dt should depend on the framerate
self.dt = 0.25
"""try:
self.database = Database()
self.ranking = self.database.getRankingFromDatabase()
except:
pass"""
self.musicManager.setConcurrentSoundLimit(2)
#initiate game state
self.state = 'Menu'
self.terrain = Terrain(1024)
"""try:
self.classement = Classement(self.ranking)
self.classement.hideMenu()
except:
pass"""
self.menu = Menu()
self.loadStartMenu()
if(self.debug == False):
self.disableMouse()
def main():
con, panel, mouse, key = Initializer.init_game()
newgame = Menu.main_menu(con, key, mouse)
if not newgame:
sys.exit(0)
race, prof = Menu.starting_menu(con, key, mouse)
world = World(race, prof)
# world.debug = True
mapmaker = MapMaker()
mapmaker.new_dungeon(world)
world.fov_map = Initializer.init_fov_map(world.tilemap)
DeathFunctions.world = world
while not libtcod.console_is_window_closed():
RenderFunctions.render_all(con, panel, world)
libtcod.console_flush()
libtcod.sys_check_for_event(
libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, key, mouse)
action = Controls.handle_keys(key, world)
world.update(action)
def update(self, input):
"""
@param input: The user input
@summary: updates the inventory status based on the user input
"""
Menu.update(self, input)
if(not None == self.selectedItemIndex):
self.visible = False
returnWeapon = self.weapons[self.selectedItemIndex]
self.selectedItemIndex = None
return returnWeapon
else:
return None
def __init__(self):
self.current_difficulty = 1
self.max_difficulty = 10
self.levels = [Level1, Level2, Level3, Level4, Level5]
self.max_level = len(self.levels)
self.current_level = Level1
adapter.init()
adapter.set_screen(rgb=theme.BACKGROUND)
screen_size = adapter.get_screen_size()
self.menu = Menu(
screen_size.current_w, screen_size.current_h,
self.new_game, self.change_level, self.change_difficulty, self.exit
)
self.countdown_event = None
self.countdown_surf = None
def __init__(self, title):
"""
@param title: The title of the inventory
@summary: Initializes an inventory
"""
Menu.__init__(self)
self.max_weapons = 20
self.weapons = []
self.visible = True
self.selectedItemIndex = None
size = []
size.append(Settings.SCREEN_WIDTH/4)
size.append(Settings.SCREEN_HEIGHT/4)
location = []
location.append(Settings.SCREEN_WIDTH/2 - size[0]/2)
location.append(Settings.SCREEN_HEIGHT/2 - size[1]/2)
self.rect = Rect(location[0], location[1], size[0], size[1])
self.title = title
myTitleLable = Label(title)
self.addWidget(myTitleLable)
self.addWidget(Label(" "))
def __init__(self):
"""
@summary: Initializes a main menu
"""
Scene.__init__(self)
self.helpMenu = HelpMenu(self)
self.menu = Menu()
self.menu.addWidget(Button("Start", self.runGame))
self.menu.addWidget(Button("Settings", self.runSettingsMenu))
self.menu.addWidget(Button("Help", self.runHelpMenu))
self.menu.addWidget(Button("Quit", self.quitGame))
def __init__(self, parentScene):
"""
Initialize the Settingsmenu
@param parentScene: The scene he should go back to when the settings are adjusted
"""
Scene.__init__(self)
self.parentScene = parentScene
self.frame = Menu()
self.sliderPlayers = Slider(2, 4, Settings.GAME_PLAYERS, "Players: ")
self.sliderSnails = Slider(2, 10, Settings.GAME_SNAILS, "Snails: ")
self.sliderSnailsHp = Slider(1, 150, Settings.GAME_SNAILS_HP, "Hitpoints: ", 10)
self.sliderStartTime = Slider(10, 90, Settings.TIMER_STARTTIME, "Turntime: ", 10)
self.sliderBreakTime = Slider(1,10, Settings.TIMER_BREAKTIME, "Breaktime: ")
self.frame.addWidget(self.sliderPlayers)
self.frame.addWidget(self.sliderSnails)
self.frame.addWidget(self.sliderSnailsHp)
self.frame.addWidget(self.sliderStartTime)
self.frame.addWidget(self.sliderBreakTime)
self.frame.addWidget(Button("Ok",self.applySettings))
class World:
def __init__(self):
self.current_difficulty = 1
self.max_difficulty = 10
self.levels = [Level1, Level2, Level3, Level4, Level5]
self.max_level = len(self.levels)
self.current_level = Level1
adapter.init()
adapter.set_screen(rgb=theme.BACKGROUND)
screen_size = adapter.get_screen_size()
self.menu = Menu(
screen_size.current_w, screen_size.current_h,
self.new_game, self.change_level, self.change_difficulty, self.exit
)
self.countdown_event = None
self.countdown_surf = None
def new_game(self, *args, **kwargs):
level = self.current_level(self.current_difficulty)
level.reset()
self.countdown_event, self.countdown_surf = self.set_countdown()
self.run(level)
def end_game(self):
adapter.clean_event()
self.next_level()
self.show_menu()
def exit(self):
adapter.exit()
def change_level(self, value, level):
if level > self.max_level or level < 1:
return
self.current_level = self.levels[level-1]
def change_difficulty(self, value, difficulty):
if difficulty > self.max_difficulty or difficulty < 1:
return
self.current_difficulty = difficulty
def next_level(self):
pass
def show_menu(self):
self.menu.launch_menu(adapter.get_screen())
def set_countdown(self):
countdown_event = adapter.create_time_event(1000, 4)
countdown_surf = [
CountNumber(img.COUNTDOWN_3),
CountNumber(img.COUNTDOWN_2),
CountNumber(img.COUNTDOWN_1),
CountNumber(None),
]
return countdown_event, countdown_surf
def run(self, level: LevelBase):
running = True
countdown_index = 0
while running:
level.hint()
if countdown_index == 0:
adapter.allow(self.countdown_event)
for event in adapter.get_event():
running = adapter.exit_game(event)
if event.type == self.countdown_event:
level.exclude_boss_sprites.add(self.countdown_surf[countdown_index])
if countdown_index != 0:
level.exclude_boss_sprites.remove(self.countdown_surf[countdown_index - 1])
adapter.update_display()
if countdown_index == 3:
adapter.allow(None)
countdown_index += 1
if countdown_index >= 4:
level.boss_move(event, level.player)
level.player_move(event, level.boss)
level.update()
for sprite in level.exclude_boss_sprites:
adapter.bind_screen(sprite.surf, sprite.rect)
adapter.update_display()
level.spark_sprites.update()
adapter.update_screen()
if level.is_end():
end_background = level.end_event()
adapter.bind_screen(end_background, (0, 0))
adapter.update_display()
adapter.delay(2000)
adapter.wait()
running = False
self.end_game()
if pos_y > map_height:
pos_y = map_height
try:
# init window
pygame.init()
font = pygame.font.SysFont("consolas", 10)
clock = pygame.time.Clock()
window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
window.fill((255, 255, 255))
window.blit(font.render("Loading...", 1, (0, 0, 0)), (WINDOW_WIDTH / 2 - 10, WINDOW_HEIGHT / 2))
rank = Rank(window, WINDOW_WIDTH - 150, 0)
# Menu rendering
menu = Menu(window, WINDOW_WIDTH, WINDOW_HEIGHT)
nick_name, element, ip, port = menu.display()
port = int(port)
# connect and get fits data
conn = client.Client(ip, port)
# data taking from start screen later
map_width, map_height, player_id, pos_x, pos_y = conn.connect(nick_name, element)
player_id = str(player_id)
real_r = 0
SCALE = WINDOW_HEIGHT / map_height
end_game = EndGame(window, WINDOW_WIDTH, WINDOW_HEIGHT)
play_flag = True
while True:
clock.tick(FPS)
class SettingsMenu(Scene):
def __init__(self, parentScene):
"""
Initialize the Settingsmenu
@param parentScene: The scene he should go back to when the settings are adjusted
"""
Scene.__init__(self)
self.parentScene = parentScene
self.frame = Menu()
self.sliderPlayers = Slider(2, 4, Settings.GAME_PLAYERS, "Players: ")
self.sliderSnails = Slider(2, 10, Settings.GAME_SNAILS, "Snails: ")
self.sliderSnailsHp = Slider(1, 150, Settings.GAME_SNAILS_HP, "Hitpoints: ", 10)
self.sliderStartTime = Slider(10, 90, Settings.TIMER_STARTTIME, "Turntime: ", 10)
self.sliderBreakTime = Slider(1,10, Settings.TIMER_BREAKTIME, "Breaktime: ")
self.frame.addWidget(self.sliderPlayers)
self.frame.addWidget(self.sliderSnails)
self.frame.addWidget(self.sliderSnailsHp)
self.frame.addWidget(self.sliderStartTime)
self.frame.addWidget(self.sliderBreakTime)
self.frame.addWidget(Button("Ok",self.applySettings))
def update(self, input):
"""
Update the settingsmenu
@param input: The input class
"""
self.frame.update(input)
def draw(self, surface):
"""
Draw the settingsmenu on a surface
@param surface: The surface the settingsmenu should be drawed on
"""
self.frame.draw(surface)
def applySettings(self):
"""
Adjust the game settings
"""
Settings.GAME_PLAYERS = self.sliderPlayers.value
Settings.GAME_SNAILS = self.sliderSnails.value
Settings.GAME_SNAILS_HP = self.sliderSnailsHp.value
Settings.TIMER_STARTTIME = self.sliderStartTime.value
Settings.TIMER_BREAKTIME = self.sliderBreakTime.value
SceneManager().setScene(self.parentScene)
class MyApp(ShowBase):
def __init__(self):
self.debug = False
ShowBase.__init__(self)
self.accept("escape",sys.exit)
# the dt should depend on the framerate
self.dt = 0.25
"""try:
self.database = Database()
self.ranking = self.database.getRankingFromDatabase()
except:
pass"""
self.musicManager.setConcurrentSoundLimit(2)
#initiate game state
self.state = 'Menu'
self.terrain = Terrain(1024)
"""try:
self.classement = Classement(self.ranking)
self.classement.hideMenu()
except:
pass"""
self.menu = Menu()
self.loadStartMenu()
if(self.debug == False):
self.disableMouse()
def loadStartMenu(self):
self.accept("Menu-Start-Parkour", self.loadGame)
self.accept("Menu-Start-World", self.loadGame)
self.accept("Menu-Start-Ranking", self.loadRankingMenu)
self.menu.showStartMenu()
self.show_cursor()
def exitStartMenu(self):
self.ignore("Menu-Start-Ranking")
self.ignore("Menu-Start-World")
self.ignore("Menu-Start-Parkour")
self.menu.hideStartMenu()
def loadGameOverMenu(self,score):
self.gameover = Gameover(score)
taskMgr.doMethodLater(5, self.restartGame,'timer')
self.show_cursor()
def loadRankingMenu(self):
self.accept("Menu-Ranking-Return", self.exitRankingMenu)
self.exitStartMenu()
self.classement.showMenu()
self.show_cursor()
def exitRankingMenu(self):
print("hidding ranking menu")
self.ignore("Menu-Ranking-Return")
self.classement.hideMenu()
self.loadStartMenu()
def loadGame(self):
self.exitStartMenu()
print("Loading game")
self.state = 'Loading'
if(self.debug == False):
self.hide_cursor
self.setLights()
self.terrain.load()
self.hud = Hud()
self.hud.show()
self.loadEntities()
#positionate the camera
if(self.debug == False):
self.camera.lookAt(self.slime.model)
# Load Skybox
Skybox(self.render)
#register events
self.ydelta = 300
self.zdelta = 60
self.accept("wheel_up", self.camzoom,[True])
self.accept("wheel_down", self.camzoom,[False])
#register tasks
self.task_mgr.add(self.mainLoop, "MainTask")
if(self.debug == False):
self.task_mgr.add(self.updateCamera, "CameraTask")
self.startGame()
def startGame(self):
print("Starting game")
#Load music
self.music = base.loader.loadMusic("assets/sounds/hytale-ost-kweebec-village.mp3")
self.music.play()
self.music.setVolume(0.1)
self.setFrameRateMeter(True)
self.state = 'Game'
#init console
"""
self.userConsole = pc.Console()
commands = {"restart":self.__init__,
"teleport": self.slime.teleport,
"color": self.slime.setColor,
"stop": self.endGame
}
self.userConsole.create(commands,app=self)
"""
def endGame(self):
self.state = 'Finished'
print("SCORE : "+str(Monster.score))
self.music.stop()
self.loadGameOverMenu(Monster.score)
today = date.today()
name = getpass.getuser()
"""try:
self.database.insertValues(name.capitalize(),Monster.score,today.strftime("%d/%m/%Y"))
except:
pass"""
def restartGame(self,task):
os.execl(sys.executable, sys.executable, *sys.argv)
def loadEntities(self):
startingPoint = (100, 0, 10)
self.AIworld = AIWorld(render)
self.collision = Collision(Monster.monster)
#terrain, initialPos, slimeModelPath, floorPos, scale, lifePoint, volumicMass, movingSpeed, dt
self.slime = Slime(self.terrain, startingPoint, "assets/models/slime.egg", 10, 10, 100, 0.01, 5, self.dt, "slime", self.collision)
self.spawn = Spawn([self.slime]+Monster.monster, self.terrain, self.AIworld, self.collision)
self.spawn.spawn()
def setLights(self):
sun = DirectionalLight("sun")
sun.setColor((1, 1, 0.9, 1))
sun.setScene(render)
self.sunNp = render.attachNewNode(sun)
self.sunNp.setPos(-10, -10, 30)
self.sunNp.lookAt(0,0,0)
render.setLight(self.sunNp)
alight = AmbientLight('alight')
alight.setColor((0.35, 0.35, 0.35, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
def mainLoop(self,task):
if(self.state == "Finished"):
return
if(self.slime.lifePoint <= 0 or self.slime.scale >= 1000):
self.endGame()
self.AIworld.update()
self.spawn.spawn()
for e in [self.slime]+Monster.monster:
e.update()
self.hud.setLifeBarValue(self.slime.lifePoint)
self.hud.setScore(Monster.score)
return task.cont
def camzoom(self,decrease):
if(decrease):
self.ydelta-=5
self.zdelta-=1
else:
self.ydelta+=5
self.zdelta+=1
def updateCamera(self,task):
if(self.state != 'Game'):
return
self.cam.setPos(self.slime.pos.getX(),self.slime.pos.getY()-self.ydelta,self.slime.pos.getZ()+self.zdelta)
#print("x:"+str(self.camera.getX()-self.slime.pos.getX())+" y:"+str(self.camera.getY()-self.slime.pos.getY())+" z:"+str(self.camera.getZ()))
#print(self.cam.getHpr())
self.cam.lookAt(self.slime.model)
return task.cont
def hide_cursor(self):
props = WindowProperties()
props.setCursorHidden(True)
self.win.requestProperties(props)
def show_cursor(self):
"""set the Cursor visible again"""
props = WindowProperties()
props.setCursorHidden(False)
self.win.requestProperties(props)
import tkinter as tk
from pathlib import Path
import utils
from config import Config
from gui.analysis import Analysis
from gui.menu import Menu
from gui.styles import configure_styles
if __name__ == "__main__":
root = tk.Tk()
root.title("Spotify Analyzer")
root.iconbitmap(Path("resources") / "icon.ico")
configure_styles(root)
config = Config.load("config.toml")
if config.enable_logs:
utils.configure_logger("analyzer", "logs.txt")
analysis = Analysis(root, config=config)
analysis.gui.pack(expand=True, fill=tk.BOTH, padx=10, pady=10)
menu = Menu(root, on_load=analysis.on_load)
root.config(menu=menu)
root.mainloop()
def __init__(self):
ShowBase.__init__(self)
from gui.menu import Menu
self.m = Menu()
class MainMenu(Scene):
def __init__(self):
"""
@summary: Initializes a main menu
"""
Scene.__init__(self)
self.helpMenu = HelpMenu(self)
self.menu = Menu()
self.menu.addWidget(Button("Start", self.runGame))
self.menu.addWidget(Button("Settings", self.runSettingsMenu))
self.menu.addWidget(Button("Help", self.runHelpMenu))
self.menu.addWidget(Button("Quit", self.quitGame))
def draw(self, surface):
"""
@param surface: The surface which the main menu should be drawed on
@summary: draws the main menu on a specified surface
"""
self.menu.draw(surface)
def update(self, input):
"""
@param input: The user input
@summary: updates the status of the main menu based on the user input
"""
self.menu.update(input)
def runGame(self):
"""
@summary: runs a new game
"""
game = Game()
game.mainmenu = self
SceneManager().setScene(game)
def runSettingsMenu(self):
"""
@summary: shows the settings menu
"""
SceneManager().setScene(SettingsMenu(self))
def runHelpMenu(self):
"""
@summary: shows the help screen
"""
SceneManager().setScene(self.helpMenu)
def quitGame(self):
"""
@summary: quits the game
"""
SceneManager().setScene(None) #No scene, means quit game!
