Exemple #1
0
    def __init__(self, _parent=None):
        self.parent = _parent

        # Containers
        self.game_objects = {}
        self.game_doors = {}
        self.game_objects_np = render.attachNewNode("Game_Objects")
        self.game_doors_np = render.attachNewNode("Player_Doors")
        self.game_doors_np.setPos(0, 0, 0)
        self.game_counter_node = None
        self.game_collector_nodes = []

        self.redDudesCount = 0
        self.blueDudesCount = 0

        # Physics world
        self.physics_world = None
        self.builder = Builder(self)

        # level lights
        self.directLight = None

        # Dude class
        self.dude = None
        self.spawnPoints = self.builder.spawnPoints

        # HUD
        self.hud = Hud()

        # Lightshow
        self.elapsed = 0.0
Exemple #2
0
    def start_loop(self):
        """Loop for start screen"""
        selected = False
        background = Background(START_BG, [0, 0])
        top_score = Hud(10, 350, 200, 40, "TOP SCORE")

        def launch_game():
            nonlocal selected
            selected = True
            self.game_loop()

        while not selected:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    selected = True

            top_score.prop = self.scores.top_score
            self.clock.tick(20)
            pygame.mouse.set_visible(True)
            self.screen.blit(background.image, background.rect)

            large_text = pygame.font.Font('freesansbold.ttf', 80)
            text_surf, text_rect = text_objects("OMEGA!", large_text,
                                                (210, 208, 224))
            text_rect.center = ((self.screen_width / 2),
                                (self.screen_height / 2.75))
            self.screen.blit(text_surf, text_rect)

            top_score.update(dest=self.screen)
            button('PLAY', ((self.screen_width / 2) - 50), 240, 100, 40,
                   ((37, 31, 71), (108, 100, 153), (210, 208, 224)),
                   self.screen, launch_game)
Exemple #3
0
    def __init__(self, virtual_width, virtual_height, map_height, map_width):


        self.v_rect = pygame.Rect(0, 0, virtual_width, virtual_height-config.hud_size)
        self.map_rect = pygame.Rect(0, 0, map_width, map_height)
        self.hud_rect = pygame.Rect(0, virtual_height-config.hud_size, virtual_width, config.hud_size)

        self.map_layer = []
        self.map_layer_surf= pygame.Surface((self.map_rect.w, self.map_rect.h))

        self.item_layer = []
        self.item_layer_surf= pygame.Surface((self.map_rect.w, self.map_rect.h), flags=pygame.SRCALPHA)

        self.unit_layer = []
        self.unit_layer_surf= pygame.Surface((self.map_rect.w, self.map_rect.h), flags=pygame.SRCALPHA)

        self.unit_action_surf = pygame.Surface((self.map_rect.w, self.map_rect.h), flags=pygame.SRCALPHA)

        self.hud = Hud(0, virtual_height-config.hud_size, virtual_width, config.hud_size, self)
        self.hud_surf = pygame.Surface((self.hud_rect.w, self.hud_rect.h))
        self.hud_surf.fill(pygame.Color("#737373"))
        self.hud_font = pygame.font.Font("assets/bitwise/bitwise.ttf", 25)

        self.dirty = 1

        self.font = pygame.font.Font(None, 20)

        self.mouse_events = []
def run_game():
    pygame.init()
    m_settings = Settings()
    stats = Estadisticas(m_settings)
    fj.cargar_puntuacion(stats)
    screen = pygame.display.set_mode((m_settings.screen_width, m_settings.screen_height)) #dibujar pantalla
    nave = Nave(screen, m_settings) #Dibujar nave
    balas = Group() #Un grupo es una lista con funciones añadidas
    marcianitos = Group()
    fj.crear_flota(m_settings, screen, nave, marcianitos)
    icon = pygame.image.load("images/alien.bmp")
    pygame.display.set_icon(icon)
    pygame.display.set_caption("Marcianitos")
    boton = Boton(m_settings, screen, "Jugar")
    hud = Hud(m_settings, screen, stats)
    m.musica_fondo()


    while True:
        fj.comprobar_eventos(m_settings, screen, nave, balas, stats, marcianitos, boton)
        if stats.jugando:
            nave.actualizar_posicion(m_settings)
            fj.actualizar_balas(m_settings, screen, nave, marcianitos, balas, stats, hud)
            fj.actualizar_flota(m_settings, stats, screen, balas, marcianitos, nave, hud)
        fj.actualizar_pantalla(m_settings, screen, nave, marcianitos, balas, boton, stats, hud)
Exemple #5
0
 def __init__(self,
              dir_sprites,
              dir_sounds,
              dir_fonts,
              lifes=constants['MAX_PLAYER_LIFES'],
              hjump=constants['INITIAL_PLAYER_HJUMP'],
              gravity=constants['INITIAL_PLAYER_GRAVITY'],
              position=list(constants['START_POSITION_PLAYER'])):
     self.hud = Hud(dir_sprites, dir_fonts, lifes=lifes)
     self.sprites = {
         'wait':
         pygame.image.load(dir_sprites['player_wait']).convert_alpha(),
         'run':
         pygame.image.load(dir_sprites['player_run']).convert_alpha(),
         'hurt':
         pygame.image.load(dir_sprites['player_hurt']).convert_alpha()
     }
     #the following attribute will be modified in method _run...
     self.sprite_base = self.sprites['wait']
     self.sounds = {
         'score_plus':
         pygame.mixer.Sound(dir_sounds['sound_player_score_plus'])
     }
     self.attributes = {
         'hjump': hjump,
         'gravity': gravity,
         'position': position
     }
Exemple #6
0
def init_game():
    """ Инициализирует игру и создает объект экрана"""
    pygame.init()
    global screen
    screen = pygame.display.set_mode(
        (game_settings.screen_width, game_settings.screen_height))
    pygame.display.set_caption("Aliens")

    # Создание кнопки Play
    global play_button
    play_button = Button(game_settings, screen, "Play")

    global hud
    hud = Hud(game_settings, screen, stats)

    # Создание корабля
    global ship
    ship = Ship(game_settings, screen)

    # Создание группы для хранения пуль
    global bullets
    bullets = pygame.sprite.Group()

    # Создание пришельцев
    global aliens
    aliens = pygame.sprite.Group()

    # Создание флота пришельцев
    create_fleet()
Exemple #7
0
    def postInit(self):
        #
        # initialize game content
        #
        base.cTrav = CollisionTraverser("base collision traverser")
        base.pusher = CollisionHandlerPusher()
        self.menu = Menu()
        self.credits = Credits()
        self.charSelection = CharacterSelection()
        self.levelSelection = LevelSelection()
        self.koScreen = KoScreen()
        self.hud = Hud()
        self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
        self.menuMusic.setLoop(True)
        self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
        self.fightMusic.setLoop(True)
        base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)

        #
        # Event handling
        #
        self.accept("escape", self.__escape)

        #
        # Start with the menu
        #
        self.request("Menu")
Exemple #8
0
    def __init__(self) -> None:
        self.game_objects = {
            "check": [],
            "switch": [],
            "robot": [],
            "platform": [],
            "laser": [],
            "shot": [],
            "gate": [],
            "plr": [self.plr],
            "hud": [Hud(self)]
        }
        self.game_data = {}

        pyxel.init(SCREEN_WIDTH, SCREEN_HEIGHT, caption="Jumpstick robo")
        pyxel.load(
            os.path.join(os.path.dirname(__file__), 'assets',
                         'jumpy_robot.pyxres'), )

        self.load_objects()

        first_check = self.game_objects["check"][0]
        first_check.activate()
        self.plr.current_checkpoint = first_check
        self.plr.kill(True)
        self.plr.current_checkpoint.restore()

        self.game_data = json.loads(game_data)

        self.update_gate_status()
        self.draw_state = self.draw_title

        self.update_state = self.update_title

        pyxel.run(self.update, self.draw)
Exemple #9
0
    def __init__(self):
        ShowBase.__init__(self)
        pman.shim.init(self)
        #props = WindowProperties()
        #props.setCursorHidden(True)
        #props.setMouseMode(WindowProperties.M_relative)
        #base.win.requestProperties(props)
        base.disableMouse()
        self.mouse = [0, 0]
        self.setFrameRateMeter(True)
        self.win.setClearColor((0, 0, 0, 1))
        self.cTrav = CollisionTraverser()
        self.cTrav.setRespectPrevTransform(True)
        self.delay = [0, 5]
        base.win.display_regions[1].dimensions = (0, 1, 0.25, 1)
        render.setShaderAuto()
        self.music = None
        self.shuffleSong()

        self.mode = "edit"
        self.defineKeys()
        self.hud = Hud(self)
        self.road = RoadMan(self)
        self.road.enableEditing()
        self.spawn()
        self.taskMgr.add(self.update)
 def start_game(self):
     self.logger.info("STARTGAME")
     self.tank = tanks[self.cl_id]
     self.hud = Hud()
     self.camera = Camera()
     self.camera.init_gl(Game.WIDTH, Game.HEIGHT)
     self.on_resize = self.camera.on_resize
     self.bg_player.play()
     self.running = True
     self.gui.remove(self.stack)
Exemple #11
0
def get_new_game():
    scene = Scene()
    game = Game()
    hud = Hud()
    end_game = EndGame()
    game_ctrl = GameCtrl(game, hud, end_game)
    scene.add(game, z=0, name="game layer")
    scene.add(game_ctrl, z=1, name="game control layer")
    scene.add(hud, z=2, name="hud layer")
    scene.add(end_game, z=3, name="end game layer")
    return scene
Exemple #12
0
    def initAttr(self):
        self.turn = True
        self.hudWidth = HUD["HUD_WIDTH"]
        self.edgeWidth = GAME["EDGE_WIDTH"]

        # 先获取 board 部分的大小,再自适应自己的大小
        self.board = Board((self.hudWidth, self.edgeWidth))
        Div.__init__(self, (self.board.width + self.hudWidth,
                            self.board.height + self.edgeWidth * 2))
        # 根据窗口高度设置 HUD 高度
        self.hud = Hud((0, self.height), (0, 0))
        self.hud.setMark(self.turn)
        self.board.setTurn(self.turn)
        self.gameID = 0
        self.order = None
Exemple #13
0
    def __init__(self):
        GameBase.__init__(self, debug=False)
        FSM.__init__(self, "GUI FSM")
        base.disableMouse()

        self.menu = Menu()
        self.missionScreen = MissionScreen()
        self.debrief = Debrief()
        self.hud = Hud()
        self.missionSelect = MissionSelect()

        base.camLens.setFov(90)

        self.setMusic("audio/music.mp3", volume=0.5)
        self.setMusic("audio/engine1.wav", volume=0.3)

        self.request("Menu")
        base.taskMgr.add(self.missionOverTask, "is mission over")
Exemple #14
0
    def load(self):
        super().load()

        blockWidth = blocks.Block.width
        blockHeight = blocks.Block.height
        self.gameArea = Rect(Game.curGame.width - blockWidth,
                             Game.curGame.height - Hud.height, 0, 0)

        if (self.len() == 0):
            self.generateMap()

        playerStartX = blockWidth
        playerStartY = blockHeight

        self.player = characters.EditCursor(playerStartX, playerStartY)
        # Add player
        self.addGameObject(self.player, 1)

        self.addGameObject(Hud(blockWidth, self.gameArea.height + blockHeight))
Exemple #15
0
    def restart(self, game_data):
        """Start a new game with the current game_data"""
        self.game_data = game_data

        self.state = MonorailGame.STATE_INTRO

        self.scenario = self.game_data.get_quest().create_scenario(
            self.game_data.skill_level.value)
        self.playfield = self.scenario.playfield
        self.controller = ctrl.GroundControl(self.playfield)
        self.init_goldcars()

        self.hud = Hud(self.scenario, self.controller, self.game_data)
        self.hud.start_intro_screen()

        self.begin_timeout = 25 * 3

        self.ingame_menu = None
        self.gui_state = GuiState()

        self.mouse_timeout = MonorailGame.MOUSE_TIMEOUT
        self.is_paused = False
Exemple #16
0
    def load(self):
        super().load()

        blockWidth = blocks.Block.width
        blockHeight = blocks.Block.height
        self.gameArea = Rect(Game.curGame.width - blockWidth,
                             Game.curGame.height - Hud.height, 0, 0)

        playerStartX = blockWidth
        playerStartY = blockHeight

        # If there are playerSpawn blocks
        if (self.hasAny(blocks.PlayerSpawn)):
            # Get the location of the block
            playerSpawn = self.getGameObjectsByType(blocks.PlayerSpawn)
            # Create a player if there is not one already
            if not (self.player):
                self.player = characters.Player(playerStartX, playerStartY)
            # Spawn the player on the block
            self.player.x = playerSpawn[0].x
            self.player.y = playerSpawn[0].y
            self.removeGameObjectsByType(blocks.PlayerSpawn)
            self.addGameObject(self.player)
        # If there are not Player Objects create one
        elif (not self.hasAny(characters.Player)):
            if not (self.player):
                self.player = characters.Player(0, 0)
            self.player.x = playerStartX
            self.player.y = playerStartY
            self.addGameObject(self.player)
        # If there are Player Objects
        elif (self.hasAny(characters.Player)):
            self.player = self.getGameObjectsByType(characters.Player)[0]

        self.addGameObject(Hud(blockWidth, self.gameArea.height + blockHeight))

        self.originalGos = self.gameObjects
Exemple #17
0
 def setup_hud(self):
     self.hud = Hud(entities=self.entities)
     self.hud.add_counter('clock', 'hud/clock.png')
     self.hud.add_counter('pigeons', 'hud/pigeon.png')
     self.hud.add_counter('sticks', 'hud/stick.png')
     self.hud.hide()
Exemple #18
0
def main():
    """ Main Program """
    pygame.init()

    # Set the height and width of the screen
    size = [SCREEN_WIDTH, SCREEN_HEIGHT]
    screen = pygame.display.set_mode(size)

    pygame.display.set_caption("Dungeon Dreams Demo")

    # Create the player
    map_pix_size = 30

    # Create all the levels
    level_list = []
    #    level_list.append( Level_01(player) )

    # Set the current level
    current_level_no = 0
    current_level = 0
    #    current_level = level_list[current_level_no]

    active_sprite_list = pygame.sprite.Group()

    # Loop until the user clicks the close button.
    done = False

    # Used to manage how fast the screen updates
    clock = pygame.time.Clock()
    all_sprites_list = pygame.sprite.LayeredDirty()
    collid_list = pygame.sprite.LayeredDirty()
    mobiles_list = pygame.sprite.Group()
    m_attacks = pygame.sprite.Group()
    area = None
    image_files = glob.glob('HumanMage.PNG')
    hud = Hud(screen)
    player = Player(100, 100, image_files, hud)
    hud.display_player_stats(player.stats)
    player.set_all_sprites(all_sprites_list)
    screen_size = (screen.get_width(), screen.get_height())
    m_fact = Monster_Factory(area, collid_list, 50, screen_size,
                             all_sprites_list, player)
    map_tool = Map_Handler(screen, all_sprites_list, collid_list, player,
                           mobiles_list, m_fact, hud)
    map_tool.build_area()
    item_fact = map_tool.get_item_fact()

    shift_x = 0
    shift_y = 0

    all_mobiles = m_fact.get_mobiles_group()
    dam_mod = 1
    #init path finding...
    path_finder = a_star(collid_list, 50)
    player.group_add(all_mobiles)

    image_files = glob.glob('*.PNG')

    #init events for following and monsters, start at 3 seconds because
    #player needs a second or two catch bearings
    FOLLOW_EVENT = USEREVENT + 1
    M_ATTACK_EVENT = USEREVENT + 2
    pygame.time.set_timer(FOLLOW_EVENT, 3000)
    pygame.time.set_timer(M_ATTACK_EVENT, 3000)
    game_start = False
    #-------- Main Program Loop -----------
    while not done:

        #Probably would make a class just to handle
        #client events.
        #These handle the movements
        keys = pygame.key.get_pressed()
        if keys[pygame.K_h]:
            player.changespeed(-1, 0)
        if keys[pygame.K_l]:
            player.changespeed(1, 0)
        if keys[pygame.K_k]:
            player.changespeed(0, -1)
        if keys[pygame.K_j]:
            player.changespeed(0, 1)
        if keys[pygame.K_n]:
            player.changespeed(1, 1)
        if keys[pygame.K_b]:
            player.changespeed(-1, 1)
        if keys[pygame.K_y]:
            player.changespeed(-1, -1)
        if keys[pygame.K_u]:
            player.changespeed(1, -1)

        #More events, quit and attacks and stopping the player
        #when the button goes up.
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                done = True

            player.check_events(event)

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    r_attack = player.ranged_attack(all_sprites_list, None,
                                                    player.r_attack_images,
                                                    dam_mod)
                    m_fact.set_check_attack(r_attack)

            if event.type == pygame.KEYUP:
                if event.key == pygame.K_h:
                    player.stop()
                if event.key == pygame.K_y:
                    player.stop()
                if event.key == pygame.K_k:
                    player.stop()
                if event.key == pygame.K_u:
                    player.stop()
                if event.key == pygame.K_l:
                    player.stop()
                if event.key == pygame.K_n:
                    player.stop()
                if event.key == pygame.K_j:
                    player.stop()
                if event.key == pygame.K_b:
                    player.stop()

            #Really for testing pathfinding, pathfinding is really for monsters.
            if event.type == pygame.MOUSEBUTTONUP:
                pos = pygame.mouse.get_pos()
                player.follow_path(path_finder.get_path(player.get_pos(), pos),
                                   map_pix_size, pos)

            #Monsters follow every two seconds to cut down on pathfinding
            #Calculations
            if event.type == FOLLOW_EVENT:
                m_fact.monster_group_follow(player.get_pos())
                pygame.time.set_timer(FOLLOW_EVENT, 2000)

            #Attack every second which is kind of a lot still
            #Otherwise player would get hurt too fast or too slow.
            if event.type == M_ATTACK_EVENT:
                m_attacks = m_fact.monsters_attack(player.get_pos())
                player.set_check_attack(m_attacks)
                pygame.time.set_timer(M_ATTACK_EVENT, 1000)

        #Move the player and then check for game end or picked up item.
        player_pos = player.move(collid_list, all_mobiles)
        lost = player.damaged()
        m_fact.move_monsters(all_mobiles)
        got_item = item_fact.is_picked_up()
        #For now just one item and if it is picked up the player wins.
        if got_item:
            end_text = []
            end_text.append(
                'You Found the Scepter of Yendor and Won the Game!')
            end_text.append('To replay press r!')
            end_text.append('To quit press q!')
            end_text.append('To continue press Space Bar!')
            done = game_end(True, end_text, screen, map_tool)
            map_tool.map_move(0, 0)
            player.stop()
            player.ranged_item = 3
            player.speed = 8
            player.dam_mod = 10
        elif (lost):
            end_text = []
            end_text.append('You perished!')
            end_text.append('To replay press r!')
            end_text.append('To quit press q!')
            done = game_end(False, end_text, screen, map_tool)

        if (map_tool.map_section_change(player_pos)):
            area = map_tool.get_area()
            m_fact.gen_monsters(area)

        player.is_moving(map_pix_size)
        all_mobiles.update(None, None)
        if m_attacks:
            m_attacks.update()
        all_sprites_list.draw(screen)

        clock.tick(25)
        pygame.display.flip()

    pygame.quit()
Exemple #19
0
    def __init__(self, app, screen):
        # tock started out random, but now is an important variable.
        # It is a frames count, used for periodic updates on certain
        # frames.
        self.p_max_health = 5
        self.won = False
        self.won_msg = "WINNER!"
        self.particle_ban = False
        self.wait_stop_count = -1  # -1 means do not count
        self.wait_stop_max = 120  # wait this many frames after decay
                                  # before showing menu
        self.tock = 0
        self.stage_e_bullet_odds = 15
        self.mouse_rect = None
        self.temp_rect = None
        self.app = app
        self.screen = screen
        self.app.music_name = "intro.ogg"
        # self.app.continue_music()
        if self.app.settings['music']:
            # self.app.music_loaded = self.app.music_name
            # pygame.mixer.music.load(self.app.resource_find(
            #     self.music_name))
            # pygame.mixer.music.play()  # plays once PLUS repeats param
            pass
        left_border = 50
        right_border = 50
        w, h = screen.get_size()
        self.world_rect = pygame.Rect(left_border, 0,
                                      w-right_border-left_border, h)
        self.bg = BackgroundManager(self.world_rect)

        # Yay spritegroups! They make the world go round, and iterate.
        # Basically each visible game object resides in its own special
        # spritegroup & then all one needs to do is go through these &
        # call functions & stuff.
        # It makes sense in here *points to brain*
        self.p_swarm = Swarm(self.world_rect)
        self.particles = Swarm(self.world_rect)

        self.explosion_images = self.app.load_seq('ex-medium')
        self.shield_hit_images = self.app.load_seq('shield_hit-tiny')
        self.damage_images = self.app.load_seq('ex-tiny')

        # Load player sprite as image list.
        self.p_unit_images = self.app.load_seq('pship')
        # self.p_unit_images = []
        # self.p_unit_images.append(self.load_file('pship.png'))
        # self.p_unit_images.append(self.load_file('pship1.png'))
        # self.p_unit_images.append(self.load_file('pship2.png'))
        # self.p_unit_images.append(self.load_file('pship3.png'))

        # Load enemy ship image.
        self.e_ship_image = self.load_file('eship.png')
        if self.app.settings['sounds']:
            self.p_shoot_sound = self.app.load_file('p-weapon0.wav',
                                                    file_type='sound')
            self.p_shoot_sound.set_volume(.3)
            self.e_ex_sound = self.app.load_file('e-ex.wav',
                                                 file_type='sound')
            self.p_ex_sound = self.app.load_file('p-ex.wav',
                                                 file_type='sound')
            self.e_damage_sound = self.app.load_file('e-damage.wav',
                                                     file_type='sound')
            self.e_shield_sound = self.app.load_file('e-shield.wav',
                                                     file_type='sound')
            self.p_shield_sound = self.app.load_file('p-shield.wav',
                                                     file_type='sound')
            self.p_damage_sound = self.app.load_file('p-damage.wav',
                                                     file_type='sound')
            print("loaded sounds...")
        self.menus = None
        self.tock = 0
        self.lagcount = 0
        self.leftkeydown = 0
        self.rightkeydown = 0
        # self.enemylist = []  # list of dirty rects
        self.swarm = Swarm(self.world_rect,
                           shoot_odds=self.stage_e_bullet_odds)
        self.stage = Stage(self.swarm, self.p_swarm)

        self.p_shot_image = self.load_file('p-laser.png')
        self.e_shot_image = self.load_file('e-laser.png')

        self.p_bullet_swarm = Swarm(self.world_rect)
        self.e_bullet_swarm = Swarm(self.world_rect)
        # self.bullet_width = 10
        self.hud_rect = pygame.Rect(0, 0, 5, 150)
        self.hud = Hud()
        self.hud.generate_blip('player.score', 100,
                               fg_color=(255,243,207),
                               text_color=(192,180,180),
                               caption="SCORE")
        self.hud.generate_blip('player.health', self.p_max_health,
                               fg_color=(0,255,42),
                               text_color=(192,180,180),
                               caption="SHIELD")
        self.statcounter = self.hud.get_blip('player.score')
Exemple #20
0
from hud import Hud
from scene import Scene
from window import Window
from character import Character

# Create a grid with a specific atlas.
g = Grid(10, 10, 50, 50, "terrain_atlas.json")

# Create a character.
goo = Character("goo", "../images/goo_hl.gif", 7, 7, "animation")
g.add_character(goo, 5, 5)
goo.scale(.10)

# Create a few HUDs.
meter_hud = Hud(x_offset=15,
                y_offset=80,
                hud_image_loc="../images/ui/hud-test.png")
heart_hud0 = Hud(x_offset=120,
                 y_offset=40,
                 hud_image_loc="../images/ui/heart.png")
heart_hud0.image.scale = 0.55
heart_hud1 = Hud(x_offset=140,
                 y_offset=40,
                 hud_image_loc="../images/ui/heart.png")
heart_hud1.image.scale = 0.55
huds = [meter_hud, heart_hud0, heart_hud1]

# Create a scene with a grid and some huds attached.
s = Scene(g, huds)

# Create the window.
Exemple #21
0
 def __init__(self, player):
     self.level_type = "none"
     self.background = None
     self.player = player
     self.hud = Hud()
Exemple #22
0
pygame.display.set_caption('TETRIS')
pygame.key.set_repeat(75)

while 1:
    area = Area(width - 100, height)

    tetrino_queue = []

    for i in range(5):
        tetrino_queue.append(randint(0, 6))

    tetrino_color = (randint(1, 255), randint(1, 255), randint(1, 255))

    tetrino = Tetrino(tetrino_color, tetrino_queue[0])

    hud = Hud(width, height)
    gameOver = Gameover(width, height, area.score)

    screen.fill((0, 0, 0))
    hud.draw_hud(screen)
    menu = Menu(width, height, (255, 255, 255), (0, 0, 0))
    menu.draw_menu(screen)
    menu.update_menu(screen)
    pygame.display.flip()
    core = Core(tetrino, area, menu, screen)
    core.menu_input()

    init = 1000
    start_time = pygame.time.get_ticks()

    while menu.singlePlayer and tetrino.game_state:
Exemple #23
0
    def __init__(self):
        """initialise the engine"""
        ShowBase.__init__(self)
        base.notify.info("Version {}".format(versionstring))
        FSM.__init__(self, "FSM-Game")

        #
        # BASIC APPLICATION CONFIGURATIONS
        #
        # disable pandas default camera driver
        self.disableMouse()
        # set antialias for the complete sceen to automatic
        self.render.setAntialias(AntialiasAttrib.MAuto)
        # shader generator
        render.setShaderAuto()
        # Enhance font readability
        DGG.getDefaultFont().setPixelsPerUnit(100)
        # get the displays width and height for later usage
        self.dispWidth = self.pipe.getDisplayWidth()
        self.dispHeight = self.pipe.getDisplayHeight()

        #
        # CONFIGURATION LOADING
        #
        # load given variables or set defaults
        # check if particles should be enabled
        # NOTE: If you use the internal physics engine, this always has
        #       to be enabled!
        particles = ConfigVariableBool("particles-enabled", True).getValue()
        if particles:
            self.enableParticles()

        def setFullscreen():
            """Helper function to set the window fullscreen
            with width and height set to the screens size"""
            # set window properties
            # clear all properties not previously set
            base.win.clearRejectedProperties()
            # setup new window properties
            props = WindowProperties()
            # Fullscreen
            props.setFullscreen(True)
            # set the window size to the screen resolution
            props.setSize(self.dispWidth, self.dispHeight)
            # request the new properties
            base.win.requestProperties(props)
            # Set the config variables so we correctly store the
            # new size and fullscreen setting later
            winSize = ConfigVariableString("win-size")
            winSize.setValue("{} {}".format(self.dispWidth, self.dispHeight))
            fullscreen = ConfigVariableBool("fullscreen")
            fullscreen.setValue(True)
            # Render a frame to make sure the fullscreen is applied
            # before we do anything else
            self.taskMgr.step()
            # make sure to propagate the new aspect ratio properly so
            # the GUI and other things will be scaled appropriately
            aspectRatio = self.dispWidth / self.dispHeight
            self.adjustWindowAspectRatio(aspectRatio)

        # check if the config file hasn't been created
        if not os.path.exists(prcFile):
            setFullscreen()
        # automatically safe configuration at application exit
        #base.exitFunc = self.__writeConfig

        #
        # INITIALIZE GAME CONTENT
        #
        base.cTrav = CollisionTraverser("base collision traverser")
        base.pusher = CollisionHandlerPusher()
        self.menu = Menu()
        self.credits = Credits()
        self.charSelection = CharacterSelection()
        self.levelSelection = LevelSelection()
        self.koScreen = KoScreen()
        self.hud = Hud()
        self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
        self.menuMusic.setLoop(True)
        self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
        self.fightMusic.setLoop(True)
        base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)

        #
        # EVENT HANDLING
        #
        # By default we accept the escape key
        self.accept("escape", self.__escape)

        #
        # ENTER GAMES INITIAL FSM STATE
        #
        self.request("Menu")
Exemple #24
0
 def create(self, package):
     self.map_package = MapPackage(package)
     self.world = self.map_package.current()
     self.hud = Hud()
     self.menu = Menu()
Exemple #25
0
 def __init__(self, master, skin: str, size: tuple):
     super(Application, self).__init__(master)
     self.snake = Snake(self, skin, size)
     self.hud = Hud(self)
Exemple #26
0
def main():
    logg.info('Starting the main function')

    #Instancing, etc.

    main_view = View().from_rect(
        FloatRect(0, 0, PP_WIDTH, PP_HEIGHT + BAR_HEIGHT))
    window = RenderWindow(
        VideoMode(PP_WIDTH * SCALE, (PP_HEIGHT + BAR_HEIGHT) * SCALE),
        GAME_TITLE + ' v.' + GAME_VERSION)
    window.framerate_limit = 61
    window.view = main_view

    # INITIALIZE TEXTURES HERE OR AFTER \o/
    TEXTURE_WALL = Texture.load_from_file('main/walls.png')
    TEXTURE_BAR = Texture.load_from_file('main/bar.png')
    TEXTURE_HUDWEAPONS = Texture.load_from_file('main/hud_weapons.png')
    TEXTURE_FACES = Texture.load_from_file('main/faces.png')
    TEXTURE_NUMBERS = Texture.load_from_file('main/numbers.png')
    TEXTURE_WEAPONS = Texture.load_from_file('main/weapons.png')
    TEXTURE_ENEMIES = Texture.load_from_file('main/test.png')

    #Create an instance for all game variables and loop functions
    # and set the level to TESTLEVEL
    game = Gameworld(TEXTURE_ENEMIES)
    game.create_dict_map()
    game.player.gamemap = game.current_level
    game.init_physics()
    game.physics.mob_bodies(game.entities)

    #prepare the hud

    hud = Hud(player=game.player,
              background=TEXTURE_BAR,
              faces=TEXTURE_FACES,
              hudweapons=TEXTURE_HUDWEAPONS,
              weapons=TEXTURE_WEAPONS,
              numbers=TEXTURE_NUMBERS)

    #prepare the wall textures

    wall_sprites = game.create_wall_sprite_list(TEXTURE_WALL)

    rays = Raycaster(player=game.player,
                     sprites=wall_sprites,
                     gamemap=game.current_level)

    #prepare other stuff

    player_action = ''

    running = True
    nofocus = False

    ##
    # MAIN LOOP
    ##

    logg.info('Main loop starting...')
    while running:

        #iterate events

        for event in window.iter_events():
            if event.type == Event.CLOSED or player_action == 'quit':
                running = False

            if event.type == Event.LOST_FOCUS:
                nofocus = True
            elif event.type == Event.GAINED_FOCUS:
                nofocus = False

            if event.type == Event.KEY_RELEASED:
                if game.player.bob > 0:  #level the headbobbing
                    game.player.bob -= .5
                elif game.player.bob < 0:
                    game.player.bob += .5

                game.player.strafing = False
                #disable speed limiter for moving in 2 axii

        window.clear(Color(235, 235, 235,
                           255))  #clear the window of everything

        for sprite in wall_sprites:  #draw walls
            window.draw(sprite)

        #draw entities here
        for entity in game.entities:
            if entity.visible == True:
                for sprite_slice in entity.sprite:
                    window.draw(sprite_slice)

        hud.display(window)  #draw the hud

        debug_txt = text('[' + str(draw_fps(frame)) + '] ' +
                         str("{0:.2f}".format(game.player.ux)) + '(' +
                         str(game.player.x) + '),' +
                         str("{0:.2f}".format(game.player.uy)) + '(' +
                         str(game.player.y) + '):' + str(game.player.heading),
                         style=1)
        window.draw(debug_txt)

        wall_sprites = rays.texture_slices(
            rays.cast_rays(), wall_sprites,
            game.player.bob)  #determine which walls to display

        #determine wich entities to display and prepare
        for entity in game.entities:  #calculate the distance of entities to the player
            entity.distance_to_player(game.player)
            # print(str(round(entity.distance, 2)) + " " + str(entity.x) + "," + str(entity.y))

        game.entities.sort(key=lambda x: x.distance,
                           reverse=True)  #sort entities based on the distance

        for entity in game.entities:
            entity.set_sprite_for_display(game.player, rays.distances)

        ###
        # TIMERS
        ###

        if game.player.attack_delay > 0 and game.player.attack == True:
            game.player.attack_delay -= 1
        elif game.player.attack == True and game.player.attack_delay == 0:
            game.player.attack = False
            game.player.attack_delay = 2
        elif game.player.attack == False and game.player.attack_delay > 0:
            game.player.attack_delay -= 1

        if len(game.doors) != 0:
            # print('lol doors')
            for door in game.doors:
                # print(door.openess)
                state = door.open_close()
                # print(state)
                if state == 'done':
                    # print('removing doors')
                    game.doors.remove(door)

        game.physics.world.ClearForces()

        if not nofocus:
            player_action = game.handle_keys()  #player input

        game.physics.world.Step(1.0 / 60.0, 10, 8)

        game.player.update_position()
        for entity in game.entities:
            entity.update_position()

        window.display()  #blit to window

    window.close()

    logg.info('Terminating. Have a nice day.')
    logg.info('Average FPS: %s', round(average_fps / all_frames, 2))
def game_loop():
    """The main game loop"""

    # This is for the in-game background music
    pygame.mixer.music.stop()
    pygame.mixer.music.load("assets/audio/electric_jazz.wav")
    pygame.mixer.music.set_volume(0.5)
    pygame.mixer.music.play(-1)

    all_sprites_list = pygame.sprite.Group()
    missile_list = pygame.sprite.Group()
    projectile_list = pygame.sprite.Group()
    power_up_list = pygame.sprite.Group()

    random.seed()
    missiles_to_spawn = random.choices([1, 2, 3],
                                       weights=[1, 2, 3],
                                       k=(fib(G.DIFFICULTY + 5)))

    power_ups_to_spawn = random.choices(
        sprites.Power_Up.power_up_list,
        weights=[1, 1, 1, 1],
        k=random.randrange(2, 7),
    )

    player = Player()
    gun = sprites.Gun((G.DISPLAY_WIDTH * 0.5, G.DISPLAY_HEIGHT * 0.875))
    all_sprites_list.add(gun)

    hud = Hud(player.health, player.score, player.ammo)

    delta_t = 0
    game_time = 0

    while True:

        # Add last iteration's time to running game_time
        game_time += delta_t

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                exit_game()

            # Fire a projectile if the player presses and releases space
            if event.type == pygame.KEYUP:
                if event.key == pygame.K_SPACE and player.ammo > 0:
                    player.update_ammo(-1)
                    if player.ammo == 0:
                        player.reload_start_time = game_time
                    pygame.mixer.Sound.play(G.SHOOT_FX)
                    projectile = sprites.Projectile(
                        gun.rect.center,
                        gun.angle,
                        gun.image.get_height() * 0.5,
                    )
                    all_sprites_list.add(projectile)
                    projectile_list.add(projectile)
                    if player.fan_of_projectiles:
                        left_projectile = sprites.Projectile(
                            gun.rect.center,
                            gun.angle + 15,
                            gun.image.get_height() * 0.5,
                        )
                        right_projectile = sprites.Projectile(
                            gun.rect.center,
                            gun.angle - 15,
                            gun.image.get_height() * 0.5,
                        )
                        all_sprites_list.add(left_projectile, right_projectile)
                        projectile_list.add(left_projectile, right_projectile)

                if event.key == pygame.K_ESCAPE:
                    G.PAUSE = True
                    paused.paused()

        # Reload
        if player.time_to_reload(game_time):
            player.reload()

        if player.time_to_piercing_rounds_expire(game_time):
            player.piercing_rounds = False

        if player.time_to_fan_expire(game_time):
            player.fan_of_projectiles = False

        if (random.randrange(700 // (5 + G.DIFFICULTY)) == 0
                and missiles_to_spawn):
            missile_type = missiles_to_spawn.pop(0)
            new_missile = sprites.Missile(
                (
                    random.randrange(0.1 * G.DISPLAY_WIDTH,
                                     0.9 * G.DISPLAY_WIDTH),
                    -600,
                ),
                missile_type,
            )
            all_sprites_list.add(new_missile)
            missile_list.add(new_missile)

        if random.randrange(500) == 0 and power_ups_to_spawn:
            power_up = power_ups_to_spawn.pop(0)
            new_power_up_sprite = sprites.Power_Up(
                (
                    random.randrange(G.DISPLAY_WIDTH * 0.125,
                                     G.DISPLAY_WIDTH * 0.875),
                    random.randrange(G.DISPLAY_WIDTH * 0.125,
                                     G.DISPLAY_HEIGHT * 0.625),
                ),
                power_up,
            )
            all_sprites_list.add(new_power_up_sprite)
            power_up_list.add(new_power_up_sprite)

        all_sprites_list.update()

        for projectile in projectile_list:
            hit_missile_list = pygame.sprite.spritecollide(
                projectile, missile_list, True)
            for hit_missile in hit_missile_list:
                all_sprites_list.add(
                    sprites.Missile_Explosion(hit_missile.rect.center,
                                              hit_missile.missile_type))
                pygame.mixer.Sound.play(G.EXPLOSION_FX)
                if not player.piercing_rounds:
                    projectile.kill()
                G.SCORE += hit_missile.stats["points"]

            hit_power_up_list = pygame.sprite.spritecollide(
                projectile, power_up_list, True)
            for hit_power_up in hit_power_up_list:
                pygame.mixer.Sound.play(random.choice(G.POWER_UP_FX_LIST))
                if not hit_power_up.power_up["temporary"]:
                    G.PERMANENT_POWER_UPS[hit_power_up.power_up["type"]] += 1
                if hit_power_up.power_up["type"] == "higher_max_health":
                    player.update_health(1)
                elif hit_power_up.power_up["type"] == "higher_max_ammo":
                    if player.ammo >= 1:
                        player.update_ammo(1)
                    player.max_ammo += 1
                elif hit_power_up.power_up["type"] == "piercing_rounds":
                    player.piercing_rounds = True
                    player.piercing_rounds_start_time = game_time
                elif hit_power_up.power_up["type"] == "fan_of_projectiles":
                    player.fan_of_projectiles = True
                    player.fan_of_projectiles_start_time = game_time

            if projectile.off_screen():
                projectile.kill()

        for missile in missile_list:
            if missile.off_screen():
                missile.kill()
                all_sprites_list.add(
                    sprites.Missile_Explosion(missile.rect.center,
                                              missile.missile_type))
                pygame.mixer.Sound.play(G.EXPLOSION_FX)
                player.update_health(missile.stats["damage"])
                if player.health <= 0:
                    game_over.game_over()

        # Paint the background G.WHITE
        G.SCREEN.fill(G.WHITE)
        G.SCREEN.blit(G.BACKGROUND_1.image, G.BACKGROUND_1.rect)
        hud.draw_hud(G.SCORE, player.ammo, player.health)

        # Draw all sprites
        all_sprites_list.draw(G.SCREEN)

        # Move all background changes to the foreground
        pygame.display.update()

        # Store time since last tick in seconds
        delta_t = G.CLOCK.tick(60) / 1000

        if not missiles_to_spawn and not missile_list:
            G.DIFFICULTY += 1
            new_round.new_round()
Exemple #28
0
def main():
    # create queues in shared memory so each process can access it
    mainQueue = Queue(maxsize=70)
    xyDoneQueue = Queue(maxsize=70)
    hudDoneQueue = Queue(maxsize=70)
    resizeDoneQueue = Queue(maxsize=70)

    # start VideoStream process
    vs = PiVideoStream(mainQueue, file1)
    time.sleep(1)  # allow pi camera to "warm up"
    vsP1 = Process(target=vs.update,
                   name='videoStreamProcess',
                   args=(resolution, framerate,
                         awb_mode))  # passing these parameters here because
    time.sleep(
        0.5
    )  # put some frames into mainQueue to stop other processes from throwing errors
    # passing to PiVideoStream instantiation causes pi camera to be accessed by two different processes which breaks it
    vsP1.daemon = True
    vsP1.start()

    # start ColorTracker process
    tracker = ColorTracker(mainQueue, xyDoneQueue, file2)  # pass shared queues
    trackerP1 = Process(target=tracker.update, name='trackerProcess', args=())
    trackerP1.daemon = True
    trackerP1.start()

    # start Hud process
    hud = Hud(resolution, xyDoneQueue, hudDoneQueue, file3, hud_done)
    hudP1 = Process(target=hud.draw, name='hudProcess', args=())
    hudP1.daemon = True
    hudP1.start()

    # start ResizeFrame process 1
    resize = ResizeFrame(hudDoneQueue,
                         resizeDoneQueue,
                         file4,
                         hud_done,
                         instance_name='resizer1')
    resizeP1 = Process(target=resize.resize, name='resizeProcess', args=())
    resizeP1.daemon = True
    resizeP1.start()

    # start ResizeFrame process 2
    resize2 = ResizeFrame(hudDoneQueue,
                          resizeDoneQueue,
                          file4B,
                          hud_done,
                          instance_name='resizer2')
    resizeP2 = Process(target=resize2.resize, name='resizeProcess2', args=())
    resizeP2.daemon = True
    resizeP2.start()

    # start DisplayFrame process
    display = DisplayFrame(resizeDoneQueue, file5, done)
    displayP1 = Process(target=display.show, name='displayProcess', args=())
    displayP1.daemon = True
    displayP1.start()

    while not done.is_set():
        continue

    else:
        print('Terminating processes')
        file1.close()
        file2.close()
        file3.close()
        file4.close()
        file4B.close()
        vsP1.terminate()
        trackerP1.terminate()
        hudP1.terminate()
        resizeP1.terminate()
        resizeP2.terminate()
        displayP1.terminate()
Exemple #29
0
    def __init__(self, AGREE_TIME, WIN_TIME, COOLDOWN_TIME, STALE_TIME,
                 TOTAL_TIME, FAILURE_TIME, NUM_WINS, keys, p_list_rect,
                 scoreboard_rect, top_rect, top_rect_left, top_rect_right,
                 game_rect, bottom_rect, shadow_dist, sys_font):
        # -- IMPORTS --
        self.keys = keys
        self.top_rect_left = top_rect_left
        self.top_rect_right = top_rect_right
        self.bottom_rect = bottom_rect
        self.AGREE_TIME = AGREE_TIME
        self.NUM_WINS = NUM_WINS
        self.shadow_dist = shadow_dist

        # -- MATCH INFO --
        self.match_num = 0
        self.big_f_agree = self.big_j_agree = 0
        self.f_wins = self.j_wins = 0
        self.score_streak = 0

        # -- NECESSARY CLASSES --
        self.p_list = PlayerList(p_list_rect, shadow_dist, sys_font)
        self.game = Game(WIN_TIME, COOLDOWN_TIME, STALE_TIME, TOTAL_TIME,
                         FAILURE_TIME, self.keys, game_rect, shadow_dist,
                         sys_font)
        self.wheel = Wheel(game_rect, shadow_dist, sys_font)
        self.hud = Hud(top_rect, bottom_rect, shadow_dist, sys_font)
        self.scoreboard = Scoreboard(scoreboard_rect, shadow_dist, sys_font,
                                     self.p_list)
        self.menu = Menu(p_list_rect, self.keys, shadow_dist, sys_font)
        self.match_state = MatchState(MatchState.PLAYER_LIST,
                                      self.state_response)

        # -- MENU ACTIONS --
        self.menu.add_item(
            "[2]", "PRACTICE MODE", 0.5,
            lambda: self.match_state.set_state(MatchState.PRACTICE_MODE))
        self.menu.add_item(
            "[3]", "RESET MATCHUP", 0.5,
            lambda: self.match_state.set_state(MatchState.NEW_OPPONENT,
                                               same_match=True))
        self.menu.add_item(
            "[4]", "NEXT OPPONENT", 0.5,
            lambda: self.match_state.set_state(MatchState.NEW_OPPONENT,
                                               next=True))
        self.menu.add_item(
            "[5]", "CHANGE PLAYERS", 0.5,
            lambda: self.match_state.set_state(MatchState.PLAYER_LIST))

        # -- RENDERING --
        # bottom bar
        self.f_name_text = TextRenderer(
            sys_font, 2, (top_rect_left.centerx, bottom_rect.centery),
            shadow_dist)
        self.j_name_text = TextRenderer(
            sys_font, 2, (top_rect_right.centerx, bottom_rect.centery),
            shadow_dist)
        self.streak_text = TextRenderer(
            sys_font, 1, (bottom_rect.width * 0.08,
                          bottom_rect.centery + bottom_rect.height * 0.25),
            shadow_dist)

        self.practice_mode_text = TextRenderer(sys_font, 2, bottom_rect.center,
                                               0)
        self.practice_inst_rect = Rect(
            (game_rect.left + game_rect.height * 0.05,
             game_rect.top + game_rect.height * 0.05),
            (game_rect.width, game_rect.height * 0.25))
        self.practice_inst_0 = ShadowedPressable.make_pressable_key(
            "1. Hold your key to build your bar.", sys_font, 1,
            GameColor.Pink)[0].convert_alpha()
        self.practice_inst_1 = ShadowedPressable.make_pressable_key(
            "2. Press [SPACE] to reset moving bars.", sys_font, 1,
            GameColor.Cyan)[0].convert_alpha()
        self.practice_inst_2 = ShadowedPressable.make_pressable_key(
            "3. Build the biggest bar to win!", sys_font, 1,
            GameColor.Yellow)[0].convert_alpha()

        # vs
        self.new_match_text = TextRenderer(
            sys_font, 4,
            (game_rect.centerx, game_rect.top + game_rect.height / 6),
            shadow_dist, GameColor.White)

        self.vs_left_bar = Rect((0, game_rect.y + game_rect.height / 3),
                                (top_rect_left.width, game_rect.height / 5))
        self.vs_right_bar = Rect(
            (game_rect.centerx, self.vs_left_bar.bottom),
            (self.vs_left_bar.width, self.vs_left_bar.height))
        vs_par_width = game_rect.height / 7
        self.vs_parallelogram = ((game_rect.centerx, self.vs_left_bar.top),
                                 (game_rect.centerx - vs_par_width,
                                  self.vs_right_bar.bottom),
                                 (game_rect.centerx, self.vs_right_bar.bottom),
                                 (game_rect.centerx + vs_par_width,
                                  self.vs_left_bar.top))
        self.f_name_big_text = TextRenderer(
            sys_font, 4, (top_rect_left.centerx + shadow_dist,
                          self.vs_left_bar.centery + shadow_dist), shadow_dist,
            GameColor.F.Dark)
        self.j_name_big_text = TextRenderer(
            sys_font, 4, (top_rect_right.centerx + shadow_dist,
                          self.vs_right_bar.centery + shadow_dist),
            shadow_dist, GameColor.J.Dark)
        self.vs_text = TextRenderer(sys_font, 2,
                                    (game_rect.centerx + shadow_dist,
                                     self.vs_left_bar.bottom + shadow_dist),
                                    shadow_dist)
        self.vs_left_bar.move_ip((top_rect_left.width, 0))

        big_f, big_f_shadow = ShadowedPressable.make_pressable_key(
            "[F]", sys_font, 4)
        self.big_f = ShadowedPressable(
            big_f.convert_alpha(), big_f_shadow,
            (top_rect_left.centerx, game_rect.top + game_rect.height * 0.85),
            shadow_dist)
        big_j, big_j_shadow = ShadowedPressable.make_pressable_key(
            "[J]", sys_font, 4)
        self.big_j = ShadowedPressable(
            big_j.convert_alpha(), big_j_shadow,
            (top_rect_right.centerx, game_rect.top + game_rect.height * 0.85),
            shadow_dist)

        # counter
        self.counter = TextRenderer(sys_font, 4, game_rect.center, shadow_dist)
        self.ready_text = TextRenderer(
            sys_font, 2,
            (game_rect.centerx, game_rect.top + game_rect.height * 0.35),
            shadow_dist)

        # win rects
        win_rect_size = top_rect.height * 0.15
        self.win_rect = Rect(top_rect.centerx - win_rect_size / 2,
                             win_rect_size, win_rect_size, win_rect_size)
        self.win_rect_shadows = [
            self.win_rect.move(self.win_rect.width * 2 * idx, 0)
            for idx in [-3, -2, -1, 1, 2, 3]
        ]
        self.f_win_rects = []
        self.j_win_rects = []

        # win text
        self.f_win_loss_text = TextRenderer(
            sys_font, 4,
            (top_rect_left.centerx, game_rect.top + game_rect.height * 0.35),
            shadow_dist)
        self.j_win_loss_text = TextRenderer(
            sys_font, 4,
            (top_rect_right.centerx, game_rect.top + game_rect.height * 0.35),
            shadow_dist)
        self.f_plus_minus_text = TextRenderer(
            sys_font, 4,
            (top_rect_left.centerx, game_rect.top + game_rect.height * 0.65),
            shadow_dist)
        self.j_plus_minus_text = TextRenderer(
            sys_font, 4,
            (top_rect_right.centerx, game_rect.top + game_rect.height * 0.65),
            shadow_dist)
        self.f_enc_cons_text = TextRenderer(
            sys_font, 1,
            (top_rect_left.centerx, game_rect.top + game_rect.height * 0.5),
            shadow_dist / 8)
        self.j_enc_cons_text = TextRenderer(
            sys_font, 1,
            (top_rect_right.centerx, game_rect.top + game_rect.height * 0.5),
            shadow_dist / 8)

        # tweens
        self.vs_bar_w = Tweener(
            {
                "retracted": 0,
                "extended": top_rect_left.width
            }, "retracted")
        self.f_name_big_x = Tweener(
            {
                "out": 0,
                "in": self.f_name_big_text.center[0]
            }, "out")
        self.j_name_big_x = Tweener(
            {
                "out": game_rect.right,
                "in": self.j_name_big_text.center[0]
            }, "out")

        # -- SOUND --
        self.vs_sound = pygame.mixer.Sound("SFX/VS.wav")
        self.timer_sound = pygame.mixer.Sound("SFX/beep.wav")
        self.begin_sound = pygame.mixer.Sound("SFX/begin_game.wav")
        self.climax_sound = pygame.mixer.Sound("SFX/climax.wav")
        self.victory_sounds = [
            pygame.mixer.Sound("SFX/vic{0}.wav".format(i)) for i in range(3)
        ]
        self.win_sound = pygame.mixer.Sound("SFX/win.wav")

        self.reset()
Exemple #30
0
pygame.init()

fps_clock = pygame.time.Clock()

# Game window setup
window_size = DEFAULT_WINDOW_SIZE
pygame.display.set_caption("Type Fight!")
app_icon = pygame.image.load(os.path.join('graphics', 'app_icon_256.png'))
pygame.display.set_icon(app_icon)
# Set flags to FULLSCREEN | DOUBLEBUF | HWSURFACE if we add fullscreen support later
flags = HWSURFACE|DOUBLEBUF|RESIZABLE
screen = pygame.display.set_mode(window_size, flags)
screen.set_alpha(None)
game_surface = pygame.Surface((screen.get_width(), screen.get_height()))
hud = Hud(screen)
player = Player(screen)
fight_bkg = pygame.image.load(os.path.join('graphics', 'fight_bkg.png')).convert()
win_fg = pygame.image.load(os.path.join('graphics', 'win_fg.png')).convert_alpha()
lose_fg = pygame.image.load(os.path.join('graphics', 'lose_fg.png')).convert_alpha()
pause_fg = pygame.image.load(os.path.join('graphics', 'pause_menu.png')).convert_alpha()
gamelog.log_display_info()

pygame.key.set_repeat(500, 50)

# Mouse setup
mouse_list = [MOUSEMOTION, MOUSEBUTTONDOWN, MOUSEBUTTONUP]
mouse_button_list = [MOUSEBUTTONDOWN, MOUSEBUTTONUP]
pygame.event.set_allowed([QUIT, VIDEORESIZE, MOUSEMOTION, MOUSEBUTTONDOWN, MOUSEBUTTONUP])

# Pygame mixer setup for sounds