Esempio n. 1
0
    def __init__(self, manager):
        """manager is required to be a child of GameManager with these functions:
        -kill_player()
        -next_level()
        -add_score(amount)
        -give_energy(amount)
        -spend_energy(amount)
        -give_life()
        """

        GameState.__init__(self, manager)

        self.player = Ship(*opt.player_args)
        self.enemy = EnemyBase(opt.mover_args, opt.spinner_args,
                               opt.shooter_args, self.player)
        self.shield = EnemyShield(self.enemy, opt.shield_filename, formation,
                                  formation_center)
        self.hbullet = HomingBullet(opt.homer_filename, self.player,
                                    opt.homer_speed)
        self.cannon = Cannon(opt.deactivated_cannon_args,
                             opt.standby_cannon_args, opt.firing_cannon_args,
                             self.player)
        self.ion_field = IonField(*opt.ion_field_args)
        self.player_bullets = Group()

        self.reset_positions()
Esempio n. 2
0
    def __init__(self):
        """Initialize the game and create game resources"""
        pygame.init()
        self.settings = Settings()
        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        self.background = self.settings.background_image
        pygame.display.set_caption("Pirate Invasion")

        #Create an instance to store game statistics
        #and create a score
        # board
        self.cannon = Cannon(self)
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        self.cannonballs = pygame.sprite.Group()
        self.pirates = pygame.sprite.Group()

        self._create_fleet()

        #Make the Play button
        self.play_button = Button(self, "Start Fight!")

        #Set the background color
        self.bg_color = (62, 164, 236)

        #Set background song
        mixer.music.load(
            'C:/Users/Khyr/Desktop/CIT228/Sideways_Shooter/music/music.wav')
        mixer.music.play(-1)
        mixer.music.set_volume(0.2)
Esempio n. 3
0
 def create_cannon(self):
     """Creates a digimon to control"""
     sprite_group = pygame.sprite.Group()
     for i in range(0, 10):
         cannon = Cannon(randint(0, 1000) + i * 1000, 50)
         sprite_group.add(cannon)
     return sprite_group
Esempio n. 4
0
 def __init__(self, screen, angle, x, y, sizey, team, flags, strength,
              play=True, defense=False):
     super().__init__()
     if team == "green":
         file1, file2, fileFlag, fileBall = greenCannon
     elif team == "blue":
         file1, file2, fileFlag, fileBall = blueCannon
     coords = np.array([x, y], dtype=float)
     self.troops = []
     for i in range(sizey):
         """ x displacement from center of Battery based on count
         shiftx increases with count with a period of sizey, creating
         a row of soldiers with a length of sizey
         """
         shifty = C_GAPY * ((i % sizey) - sizey // 2)
         shiftx = 0
         self.troops.append(Cannon(screen, angle, shiftx, shifty, strength,
                                    file1, file2, fileBall, team,
                                    coords, defense))
     self.flag = Flag(screen, (x, y), angle, fileFlag, play)
     flags.append(self.flag)
     # 0,1=click,release to show buttons, 2,3=click,release to select
     self.showOrders = 0
     # self.bayonetButton = Button(screen, "Bayonets")
     self.healthDisp = Button(screen, str(self.health))
     self.play = play
     self.team = team
     self.oldUnits = []
     # used to id object for testing, not meant to be seen/used
     self.id = file1
Esempio n. 5
0
 def prep_cannons(self):
     """Show how many cannons are left"""
     self.cannons = Group()
     for cannon_number in range(self.stats.cannons_left):
         cannon = Cannon(self.ai_game)
         cannon.rect.x = 1000 + cannon_number * cannon.rect.width
         cannon.rect.y = 10
         self.cannons.add(cannon)
Esempio n. 6
0
    def btnNewGameClicked(self):
        # target 위치 지정
        self.targetColumn = random.randint(40, 60)
        self.targetRow = random.randint(18, 21)
        self.target = (self.targetRow, self.targetColumn)

        # 게임 시작시 초기화
        self.cannon = Cannon(self.target)
        self.fire = Fire()
        self.gameOver = False
        self.boulet = ["●", "●", "●", "●"]
        self.turn = -1

        self.txWindow.setText(self.cannon.initialMap())
        self.lnResult.setText('Start!')
        self.lnBoulet.setText(" ".join(self.boulet))
        self.slAngle.setValue(55)
        self.slPower.setValue(40)
Esempio n. 7
0
def init_modules():
    right_eye = Eye(list(range(12)), (100, 0, 0))
    left_eye = Eye(list(range(12, 24)), (100, 0, 0))
    left_eye.eye_time = right_eye.eye_time # Pretty hacky but syncronizes the pulse
    # gills
    gills = Gills([Gill(list(range(24, 69)), color=(0, 0, 20), intensity=1.0)], [Gill(list(range(71, 131)), color=(0, 0, 20), intensity=1.0)])  # treat all as lefties for now...
    cannon = Cannon()

    return {'gills': gills, 'left_eye': left_eye, 'right_eye': right_eye, 'cannon': cannon, 'compass': Compass()}
Esempio n. 8
0
    def btnFireClicked(self):
        self.cannon = Cannon(self.target)

        # 각도 와 파워 설정
        try:
            angle = int(self.slAngle.value())
            power = int(self.slPower.value())
        except:
            self.lnResult.setText('Not integer')
            return

        # 게임 완료 시
        if self.gameOver == True:
            self.lnResult.setText('Game Over')
            return

        # 현재 맵 출력
        for point in self.fire.parabola(angle, power):
            shape = self.cannon.currentMap(point)[0]
            hit = self.cannon.currentMap(point)[1]
            self.txWindow.setText(shape)

            if hit:
                self.lnResult.setText('Hit!')
                self.gameOver = True
                break
            else:
                self.lnResult.setText('Miss!')

            # 에니메이션 효과 구현
            loop = QEventLoop()
            QTimer.singleShot(100, loop.quit)
            loop.exec_()

        if self.boulet[0] == "○":
            self.lnResult.setText('Fail!')
            self.gameOver = True
            return

        del (self.boulet[self.turn])
        self.turn -= 1
        self.boulet.append("○")
        self.lnBoulet.setText(" ".join(self.boulet))
Esempio n. 9
0
def start():
    global score, lives, level, stage, bomb_rate, cannon
    bomb_rate = starting_bomb_rate

    score = 0
    lives = 3
    level = 1
    stage = START

    cannon = Cannon(480, 530)
    setup()
    def generate_cannon(self):
        if self._ground.get_x() < ARENA_W:
            actors = self._arena.actors()
            cannon_available = True
            rand_cannon_x = randint(ARENA_W, ARENA_W*2)

            for a in self._obstacles:
                if isinstance(a, Cannon) or rand_cannon_x == a.get_x():
                    cannon_available = False
                
            if cannon_available:
                self._obstacles.append(Cannon(self._arena, (rand_cannon_x, 570)))
def calculate_percentile(duration, max_qps, cannon: Cannon):
    df = create_dataframe()
    for i in range(100, max_qps, 10):
        latency_list = cannon.start_shoot(max_qps, duration, threads=int(max_qps / 10))
        df.loc[i] = [duration,
                     duration*(i+1),
                     i+1,
                     calc_percentile(.5, latency_list),
                     calc_percentile(.9, latency_list),
                     calc_percentile(.99, latency_list),
                     100*latency_list.count(None)/len(latency_list)]
    return df
Esempio n. 12
0
    def __init__(self, manager):
        """manager is required to be a child of GameManager with these functions:
        -kill_player()
        -next_level()
        -add_score(amount)
        -give_energy(amount)
        -spend_energy(amount)
        -give_life()
        """

        GameState.__init__(self, manager)

        self.player = Ship(*opt.player_args)
        self.enemy = EnemyBase(opt.mover_args, opt.spinner_args, opt.shooter_args, self.player)
        self.shield = EnemyShield(self.enemy, opt.shield_filename, formation, formation_center)
        self.hbullet = HomingBullet(opt.homer_filename, self.player, opt.homer_speed)
        self.cannon = Cannon(opt.deactivated_cannon_args, opt.standby_cannon_args,
                             opt.firing_cannon_args, self.player)
        self.ion_field = IonField(*opt.ion_field_args)
        self.player_bullets = Group()

        self.reset_positions()
Esempio n. 13
0
class PirateInvasion:
    """Class to manage game assets and behavior"""
    def __init__(self):
        """Initialize the game and create game resources"""
        pygame.init()
        self.settings = Settings()
        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        self.background = self.settings.background_image
        pygame.display.set_caption("Pirate Invasion")

        #Create an instance to store game statistics
        #and create a score
        # board
        self.cannon = Cannon(self)
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)
        self.cannonballs = pygame.sprite.Group()
        self.pirates = pygame.sprite.Group()

        self._create_fleet()

        #Make the Play button
        self.play_button = Button(self, "Start Fight!")

        #Set the background color
        self.bg_color = (62, 164, 236)

        #Set background song
        mixer.music.load(
            'C:/Users/Khyr/Desktop/CIT228/Sideways_Shooter/music/music.wav')
        mixer.music.play(-1)
        mixer.music.set_volume(0.2)

    def run_game(self):
        """Start the main loop for game"""
        while True:
            self._check_events()

            if self.stats.game_active:
                self.cannon.update()
                self._update_cannonballs()
                self._update_pirates()
            self._update_screen()

    def _check_events(self):
        """Respond to keypresses & mouse events"""
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN or event.type == ord('s'):
                self._check_keydown_events(event)
            elif event.type == pygame.KEYUP or event.type == ord('w'):
                self._check_keyup_events(event)
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_pos = pygame.mouse.get_pos()
                self._check_play_button(mouse_pos)

    def _check_keydown_events(self, event):
        """Respond to keypresses"""
        #Set the cannonball sound
        cannonballSound = pygame.mixer.Sound(
            'C:/Users/Khyr/Desktop/CIT228/Sideways_Shooter/music/sound.wav')
        mixer.music.set_volume(0.2)

        if event.key == pygame.K_UP or event.key == ord('w'):
            self.cannon.moving_up = True
        elif event.key == pygame.K_DOWN or event.key == ord('s'):
            self.cannon.moving_down = True
        elif event.key == pygame.K_q:
            sys.exit()
        elif event.key == pygame.K_SPACE:
            self._fire_cannonball()
            cannonballSound.play()

    def _check_keyup_events(self, event):
        if event.key == pygame.K_UP or event.key == ord('w'):
            self.cannon.moving_up = False
        elif event.key == pygame.K_DOWN or event.key == ord('s'):
            self.cannon.moving_down = False

    def _check_play_button(self, mouse_pos):
        """Start a new game when the player clicks Play"""
        button_clicked = self.play_button.rect.collidepoint(mouse_pos)
        if button_clicked and not self.stats.game_active:
            #Reset the game settings
            self.settings.intitalize_dynamic_settings()

            #Reset the game statistics
            self.stats.reset_stats()
            self.stats.game_active = True
            self.sb.prep_score()
            self.sb.prep_level()
            self.sb.prep_cannons()

            #Get rid of any remaining pirates and cannonballs
            self.pirates.empty()
            self.cannonballs.empty()

            #Create a new fleet and center the cannon
            self._create_fleet()
            self.cannon.center_cannon()

            #Hide the mouse cursor
            pygame.mouse.set_visible(False)

    def _fire_cannonball(self):
        """Create a new cannonball and add to the cannonball group"""
        if len(self.cannonballs) < self.settings.cannonballs_allowed:
            new_cannonball = Cannonball(self)
            self.cannonballs.add(new_cannonball)

    def _update_cannonballs(self):
        """Update the position of cannonballs and get rid of old cannonballs"""
        #Update cannonball positions
        self.cannonballs.update()

        #Get rid of cannonballs off screen
        for cannonball in self.cannonballs.copy():
            if cannonball.rect.bottom <= 0:
                self.cannonballs.remove(cannonball)
        self._check_cannonball_pirate_collisions()

    def _check_cannonball_pirate_collisions(self):
        """Respond to cannonball-pirate collisions"""
        #Remove any cannonballs and pirates that have collided
        collisions = pygame.sprite.groupcollide(self.cannonballs, self.pirates,
                                                True, True)

        if collisions:
            for pirates in collisions.values():
                self.stats.score += self.settings.pirate_points * len(pirates)
            self.sb.prep_score()
            self.sb.check_high_score()

        if not self.pirates:
            #Destroy existing cannonballs and create new fleet
            self.cannonballs.empty()
            self._create_fleet()
            self.settings.increase_speed()

            #Increase level
            self.stats.level += 1
            self.sb.prep_level()

    def _update_pirates(self):
        """Check if the fleet is at an edge, then update the positions of all the pirates in fleet"""
        self._check_fleet_edges()
        self.pirates.update()

        #Look for pirate-cannon collisions
        if pygame.sprite.spritecollideany(self.cannon, self.pirates):
            self._cannon_hit()

        #Look for pirates hitting the bottom of the screen
        self._check_pirates_bottom()

    def _cannon_hit(self):
        """Respond to cannon being hit by a pirate"""
        if self.stats.cannons_left > 0:
            #Decrement cannons_left, and update scoreboard
            self.stats.cannons_left -= 1
            self.sb.prep_cannons()

            #Get rid of any remaining pirates and cannonballs
            self.pirates.empty()
            self.cannonballs.empty()

            #Create a new fleet and center the cannon
            self._create_fleet()
            self.cannon.center_cannon()

            #Pause
            sleep(0.5)
        else:
            self.stats.game_active = False
            pygame.mouse.set_visible(True)

    def _check_pirates_bottom(self):
        """Check if any pirates have reached the bottom of the screen"""
        screen_rect = self.screen.get_rect()
        for pirate in self.pirates.sprites():
            if pirate.rect.bottom >= screen_rect.bottom:
                #Treat this the same as if teh cannon got hit
                self._cannon_hit()
                break

    def _update_screen(self):
        """Updates images on the screen, flip to the new screen"""
        self.screen.blit(self.background, [0, 0])
        self.cannon.blitme()
        for cannonball in self.cannonballs.sprites():
            cannonball.draw_cannonball()
        self.pirates.draw(self.screen)

        #Draw the score information
        self.sb.show_score()

        #Draw the play button if the game is inactive

        if not self.stats.game_active:
            self.play_button.draw_button()

        #Make the most recent drawn screen visible
        pygame.display.flip()

    def _create_fleet(self):
        """Make a fleet of pirates"""
        #Create a pirate ship and find the number of pirates in a row
        #Spacing between each pirate is equal to one pirate width
        pirate = Pirate(self)
        pirate_width, pirate_height = pirate.rect.size
        available_space_x = self.settings.screen_width - (2 * pirate_width)
        number_pirates_x = available_space_x // (2 * pirate_width)

        #Determine the number of rows of pirates that fit on screen
        cannon_height = self.cannon.rect.height
        available_space_y = (self.settings.screen_height -
                             (3 * pirate_height) - cannon_height)
        number_rows = available_space_y // (2 * pirate_height)

        #Create a full fleet of pirates
        for row_number in range(number_rows):
            for pirate_number in range(number_pirates_x):
                self._create_alien(pirate_number, row_number)

    def _create_alien(self, pirate_number, row_number):
        #Create pirate and place in row
        pirate = Pirate(self)
        pirate_width, pirate_height = pirate.rect.size
        pirate.x = pirate_width + 2 * pirate_width * pirate_number
        pirate.rect.x = pirate.x
        pirate.rect.y = pirate.rect.height + 2 * pirate.rect.height * row_number
        self.pirates.add(pirate)

    def _check_fleet_edges(self):
        """Respond if any pirates have reached an edge"""
        for pirate in self.pirates.sprites():
            if pirate.check_edges():
                self._change_fleet_direction()
                break

    def _change_fleet_direction(self):
        """Drop the entire fleet and change the fleet direction"""
        for pirate in self.pirates.sprites():
            pirate.rect.y += self.settings.fleet_drop_speed
        self.settings.fleet_direction *= -1
Esempio n. 14
0
def main():

    fps = 30
    clock = pygame.time.Clock()

    screen = pygame.display.set_mode((config.WIDTH, config.HEIGHT))

    pygame.font.init()
    font = pygame.font.Font("DejaVuSans.ttf", 24)

    if TYPE == 'HOST':
        s, game_map, conn = hostOptions(screen, font)
    elif TYPE == 'JOIN':
        s, game_map = joinOptions(screen, font)
    else:
        textOnMiddle(screen, 'Generating map...', font)
        pygame.display.flip()
        game_map = GameMap().generate(config.WIDTH, config.HEIGHT, 2500)

    #icon = pygame.image.load("pygame-icon.png")
    #icon = icon.convert_alpha()
    #icon_w, icon_h = icon.get_size()

    shooting_force = -1

    bullets = []

    cannon1 = Cannon(screen, game_map, 100, (0, 255, 0), 0)
    cannon2 = Cannon(screen, game_map, config.WIDTH - 100, (255, 0, 0), 180)

    gameEnded = False

    while True:

        msg = {"cannon": {}}
        recv_msg = {}

        shooting_force, quitGame = getInputEvents(screen, cannon1, cannon2,
                                                  bullets, game_map,
                                                  shooting_force, msg)

        if quitGame:
            if TYPE == 'HOST':
                conn.close()

            if TYPE == 'JOIN' or TYPE == 'HOST':
                print('Closing Server...')
                return s

            return

        ping = time.time()
        if TYPE == 'HOST':
            try:
                conn.send(encodeDict(msg))
                recv_msg = conn.recv(1024)
                recv_msg = decodeDict(recv_msg)
            except ConnectionResetError:
                print('Connection closed by client')
                conn.close()
                return s
            except json.decoder.JSONDecodeError:
                print('Connection closed by client')
                conn.close()
                return s

        elif TYPE == 'JOIN':
            try:
                recv_msg = s.recv(1024)
                s.send(encodeDict(msg))
                recv_msg = decodeDict(recv_msg)
            except json.decoder.JSONDecodeError:
                print('Connection closed by host')
                return s
            except ConnectionResetError:
                print('Connection closed by host')
                return s

        if 'shoot' in recv_msg:
            if TYPE == 'JOIN':
                rot = cannon1.rot
                center = cannon1.base.rect.center
            else:
                rot = cannon2.rot
                center = cannon2.base.rect.center

            bullets.append(
                Bullet(screen, game_map, center[0], center[1],
                       recv_msg['shoot']['shooting_force'], rot))

        if 'cannon' in recv_msg:
            if 'rotation' in recv_msg['cannon']:
                rotation = recv_msg['cannon']['rotation']
                if TYPE == 'JOIN':
                    cannon1.rotating = rotation
                if TYPE == 'HOST':
                    cannon2.rotating = rotation

        ping = time.time() - ping

        #reset drawing
        screen.fill((0, 0, 0))

        #draw background
        game_map.printBackground(screen)

        #draw top info
        text = font.render('10uv >>', True, (255, 255, 255))
        fps_text = font.render(
            str(round(clock.get_fps(), 2)) + ' fps', True, (255, 255, 255))
        ping_text = font.render('ping ' + str(int(ping * 1000)) + 'ms', True,
                                (255, 255, 255))
        text_w, text_h = fps_text.get_size()
        ping_text_w, _ = ping_text.get_size()
        screen.blit(text, (0, 0))
        screen.blit(fps_text, (config.WIDTH - text_w, 0))
        screen.blit(ping_text, (config.WIDTH - ping_text_w, text_h))

        #draw map ground
        game_map.printGround(screen)

        #draw shoot bar
        if shooting_force != -1:
            if shooting_force < 50:
                shooting_force += 1

            hud.drawShootForce(screen, shooting_force)

        #draw shoot bar ruler
        hud.drawShootForceRuler(screen)

        #update and draw bullets
        for bullet in bullets[:]:
            if not bullet.update():
                if bullet.collide:
                    x = int(bullet.x)
                    collision_range = range(x - 15, x + 15)
                    for i in collision_range:  #TODO: send this to game map
                        if len(game_map.map_curve) > i >= 0:
                            game_map.map_curve[i] += 10

                    if not cannon1.isAlive(collision_range):
                        winnerText = font.render('Cannon 2 won.', True,
                                                 (255, 255, 255))
                        gameEnded = True
                        break
                    if not cannon2.isAlive(collision_range):
                        winnerText = font.render('Cannon 1 won.', True,
                                                 (255, 255, 255))
                        gameEnded = True
                        break

                bullets.remove(bullet)
                del bullet
            else:
                bullet.draw()

        #update and draw cannons
        cannon1.update()
        cannon1.draw(screen)
        cannon2.update()
        cannon2.draw(screen)

        if gameEnded:
            while len(bullets) > 0:
                bullets.pop()
            winnerText_w, winnerText_h = winnerText.get_size()
            screen.blit(winnerText, (config.WIDTH / 2 - winnerText_w / 2,
                                     config.HEIGHT / 2 - winnerText_h / 2))

        #end drawing
        pygame.display.flip()

        clock.tick(fps)
Esempio n. 15
0
    def __init__(self):
        """
        This constructor instantiates a game board, instantiates and adds the game piece objects to the board,
        initializes the game state to "unfinished",  initializes the current turn as the red players,
        and initializes the in-check status of the players.
        """
        self._board = self._board = {
            "a1": None,
            "b1": None,
            "c1": None,
            "d1": None,
            "e1": None,
            "f1": None,
            "g1": None,
            "h1": None,
            "i1": None,
            # row 2
            "a2": None,
            "b2": None,
            "c2": None,
            "d2": None,
            "e2": None,
            "f2": None,
            "g2": None,
            "h2": None,
            "i2": None,
            # row 3
            "a3": None,
            "b3": None,
            "c3": None,
            "d3": None,
            "e3": None,
            "f3": None,
            "g3": None,
            "h3": None,
            "i3": None,
            # row 4
            "a4": None,
            "b4": None,
            "c4": None,
            "d4": None,
            "e4": None,
            "f4": None,
            "g4": None,
            "h4": None,
            "i4": None,
            # row 5
            "a5": None,
            "b5": None,
            "c5": None,
            "d5": None,
            "e5": None,
            "f5": None,
            "g5": None,
            "h5": None,
            "i5": None,
            # row 6
            "a6": None,
            "b6": None,
            "c6": None,
            "d6": None,
            "e6": None,
            "f6": None,
            "g6": None,
            "h6": None,
            "i6": None,
            # row 7
            "a7": None,
            "b7": None,
            "c7": None,
            "d7": None,
            "e7": None,
            "f7": None,
            "g7": None,
            "h7": None,
            "i7": None,
            # row 8
            "a8": None,
            "b8": None,
            "c8": None,
            "d8": None,
            "e8": None,
            "f8": None,
            "g8": None,
            "h8": None,
            "i8": None,
            # row 9
            "a9": None,
            "b9": None,
            "c9": None,
            "d9": None,
            "e9": None,
            "f9": None,
            "g9": None,
            "h9": None,
            "i9": None,
            # row 10
            "a10": None,
            "b10": None,
            "c10": None,
            "d10": None,
            "e10": None,
            "f10": None,
            "g10": None,
            "h10": None,
            "i10": None,
        }
        self._red_pieces = []
        self._black_pieces = []

        red_char_1 = Chariot("red", "a1")
        self.update_board("a1", red_char_1)
        self._red_pieces.append(red_char_1)

        black_char_1 = Chariot("Black", "a10")
        self.update_board("a10", black_char_1)
        self._black_pieces.append(black_char_1)

        red_horse_1 = Horse("red", "b1")
        self.update_board("b1", red_horse_1)
        self._red_pieces.append(red_horse_1)

        black_horse_1 = Horse("black", "b10")
        self.update_board("b10", black_horse_1)
        self._black_pieces.append(black_horse_1)

        red_ele_1 = Elephant("red", "c1")
        self.update_board("c1", red_ele_1)
        self._red_pieces.append(red_ele_1)

        black_ele_1 = Elephant("black", "c10")
        self.update_board("c10", black_ele_1)
        self._black_pieces.append(black_ele_1)

        red_adv_1 = Advisor("red", "d1")
        self.update_board("d1", red_adv_1)
        self._red_pieces.append(red_adv_1)

        black_adv_1 = Advisor("black", "d10")
        self.update_board("d10", black_adv_1)
        self._black_pieces.append(black_adv_1)

        red_gen = General("red", "e1")
        self.update_board("e1", red_gen)
        self._red_pieces.append(red_gen)

        black_gen = General("Black", "e10")
        self.update_board("e10", black_gen)
        self._black_pieces.append(black_gen)

        red_adv_2 = Advisor("Red", "f1")
        self.update_board("f1", red_adv_2)
        self._red_pieces.append(red_adv_2)

        black_adv_2 = Advisor("black", "f10")
        self.update_board("f10", black_adv_2)
        self._black_pieces.append(black_adv_2)

        red_ele_2 = Elephant("red", "g1")
        self.update_board("g1", red_ele_2)
        self._red_pieces.append(red_ele_2)

        black_ele_2 = Elephant("black", "g10")
        self.update_board("g10", black_ele_2)
        self._black_pieces.append(black_ele_2)

        red_horse_2 = Horse("red", "h1")
        self.update_board("h1", red_horse_2)
        self._red_pieces.append(red_horse_2)

        black_horse_2 = Horse("black", "h10")
        self.update_board("h10", black_horse_2)
        self._black_pieces.append(black_horse_2)

        red_char_2 = Chariot("red", "i1")
        self.update_board("i1", red_char_2)
        self._red_pieces.append(red_char_2)

        black_char_2 = Chariot("black", "i10")
        self.update_board("i10", black_char_2)
        self._black_pieces.append(black_char_2)

        red_can_1 = Cannon("red", "b3")
        self.update_board("b3", red_can_1)
        self._red_pieces.append(red_can_1)

        black_can_1 = Cannon("black", "b8")
        self.update_board("b8", black_can_1)
        self._black_pieces.append(black_can_1)

        red_can_2 = Cannon("red", "h3")
        self.update_board("h3", red_can_2)
        self._red_pieces.append(red_can_2)

        black_can_2 = Cannon("black", "h8")
        self.update_board("h8", black_can_2)
        self._black_pieces.append(black_can_2)

        red_sol_1 = Soldier("red", "a4")
        self.update_board("a4", red_sol_1)
        self._red_pieces.append(red_sol_1)

        red_sol_2 = Soldier("red", "c4")
        self.update_board("c4", red_sol_2)
        self._red_pieces.append(red_sol_2)

        red_sol_3 = Soldier("red", "e4")
        self.update_board("e4", red_sol_3)
        self._red_pieces.append(red_sol_3)

        red_sol_4 = Soldier("red", "g4")
        self.update_board("g4", red_sol_4)
        self._red_pieces.append(red_sol_4)

        red_sol_5 = Soldier("red", "i4")
        self.update_board("i4", red_sol_5)
        self._red_pieces.append(red_sol_5)

        black_sol_1 = Soldier("black", "a7")
        self.update_board("a7", black_sol_1)
        self._black_pieces.append(black_sol_1)

        black_sol_2 = Soldier("black", "c7")
        self.update_board("c7", black_sol_2)
        self._black_pieces.append(black_sol_2)

        black_sol_3 = Soldier("black", "e7")
        self.update_board("e7", black_sol_3)
        self._black_pieces.append(black_sol_3)

        black_sol_4 = Soldier("black", "g7")
        self.update_board("g7", black_sol_4)
        self._black_pieces.append(black_sol_4)

        black_sol_5 = Soldier("black", "i7")
        self.update_board("i7", black_sol_5)
        self._black_pieces.append(black_sol_5)

        self._game_state = "UNFINISHED"
        self._turn = True

        self.generate_moves()

        self._red_in_check = {"red": False}
        self._black_in_check = {"black": False}
Esempio n. 16
0
class Level(GameState):
    """Level is a GameState with behavior for one full game level.

    Contains Sprites player, enemy, shield, hbullet, cannon, and Group player_bullets
    """
    def __init__(self, manager):
        """manager is required to be a child of GameManager with these functions:
        -kill_player()
        -next_level()
        -add_score(amount)
        -give_energy(amount)
        -spend_energy(amount)
        -give_life()
        """

        GameState.__init__(self, manager)

        self.player = Ship(*opt.player_args)
        self.enemy = EnemyBase(opt.mover_args, opt.spinner_args,
                               opt.shooter_args, self.player)
        self.shield = EnemyShield(self.enemy, opt.shield_filename, formation,
                                  formation_center)
        self.hbullet = HomingBullet(opt.homer_filename, self.player,
                                    opt.homer_speed)
        self.cannon = Cannon(opt.deactivated_cannon_args,
                             opt.standby_cannon_args, opt.firing_cannon_args,
                             self.player)
        self.ion_field = IonField(*opt.ion_field_args)
        self.player_bullets = Group()

        self.reset_positions()

    def update(self):
        self.player.update()
        self.enemy.update()
        self.shield.update()
        self.hbullet.update()
        self.cannon.update()
        self.player_bullets.update()
        self.ion_field.update()

        self.collisions()

    def handle_events(self, events, keys):
        return (event_handlers.check_quit(events, keys)
                and event_handlers.check_shoot_button(events, keys, self.shoot)
                and event_handlers.move_player(events, keys, self.player))

    def draw(self, screen):
        self.ion_field.draw(screen)
        self.enemy.draw(screen)
        self.shield.draw(screen)
        self.player.draw(screen)
        self.hbullet.draw(screen)
        self.cannon.draw(screen)
        self.player_bullets.draw(screen)

    def collisions(self):
        """Handles collisions
        """

        player = self.player
        enemy = self.enemy
        shield = self.shield
        hbullet = self.hbullet
        cannon = self.cannon
        ion_field = self.ion_field
        player_bullets = self.player_bullets

        #player with homing bullet
        if collide_mask(player,
                        hbullet) and not collide_mask(player, ion_field):
            self.kill_player()

        #player with enemy base
        if collide_mask(player, enemy):
            #if base in moving phase, give player energy
            if enemy.get_state_number() == EnemyBase.MOVING:
                self.manager.give_energy(opt.energy_from_enemy)
            #if base in spinning or shooting phase, kill player
            elif enemy.get_state_number() == EnemyBase.SPINNING:
                self.kill_player()
            elif enemy.get_state_number() == EnemyBase.SHOOTING:
                self.kill_player()

        #player with cell
        #-hitting a cell will bounce the player a bit to the left
        #-if the player hit the cell twice in a short enough span,
        # the cell is eaten and the player gets energy
        #-in case of multiple collisions, deal with cell closest to player's center
        #
        #TODO: This still isn't quite right.
        #Should be able to eat top/bottom rows with diagonal movement.
        #(vertical movement should still move player all the way left)
        pc_collides = spritecollide(player, shield, False, collide_mask)
        center_cell = self.find_centermost_cell(pc_collides)
        if center_cell is not None:
            player.rect.right = center_cell.rect.left - opt.cell_bounceback

            if not center_cell.marked:
                center_cell.mark()
            elif shield.can_eat():
                center_cell.kill()
                self.manager.give_energy(opt.energy_from_cell)
                self.manager.add_score(opt.score_cell_eat)
                shield.start_delay(opt.frames_to_eat_cell)

        #player with cannon
        if collide_mask(player, cannon):
            #if in deactivated phase, try spending required energy to activate
            if (cannon.get_state_number() == Cannon.DEACTIVATED
                    and self.manager.spend_energy(opt.cannon_energy_cost)):
                cannon.start_standby()
            #if in firing phase, kill player
            if cannon.get_state_number() == Cannon.FIRING:
                self.kill_player()
            #if in returning phase, give energy and deactivate cannon
            if cannon.get_state_number() == Cannon.RETURNING:
                cannon.start_transition(Cannon.DEACTIVATED)
                self.manager.give_energy(opt.energy_from_cannon)

        #cannon with cell
        #kill one cell and reverse cannon direction
        #assuming this is only possible if cannon in firing state
        if cannon.get_state_number() == Cannon.FIRING:
            cannon_collides = spritecollide(cannon, shield, False,
                                            collide_mask)
            if len(cannon_collides) > 0:
                cannon_collides[0].kill()
                self.manager.add_score(opt.score_cell_shoot)
                cannon.start_transition(Cannon.RETURNING)

        #cannon with enemy base -- only if cannon in firing state
        #give points corresponding to enemy state and end level
        #if enemy base is in shooting state, player also gets a life
        if cannon.get_state_number() == Cannon.FIRING and collide_mask(
                cannon, enemy):
            if enemy.get_state_number() == EnemyBase.MOVING:
                self.manager.add_score(opt.score_mover_destroy)
            elif enemy.get_state_number() == EnemyBase.SPINNING:
                self.manager.add_score(opt.score_spinner_destroy)
            elif enemy.get_state_number() == EnemyBase.SHOOTING:
                self.manager.add_score(opt.score_shooter_destroy)
                self.manager.give_life()
            self.end_level()

        #player's bullet with cell
        #kill player bullet but remove cells in a cross pattern
        #if somehow one bullet hits multiple cells one is arbitrarily selected
        bc_collides = groupcollide(player_bullets, shield, True, False,
                                   collide_mask)
        for current_bullet in bc_collides.keys():
            self.manager.add_score(opt.score_cell_shoot)
            shield.remove_cross(bc_collides[current_bullet][0])

    def find_centermost_cell(self, cells):
        """Given a list of Cell sprites, 
        returns the one whose rect.centery is closest to the player's rect.centery
        
        Returns None if list is empty
        """

        closest_cell = None

        for current_cell in cells:
            current_dist = abs(current_cell.rect.centery -
                               self.player.rect.centery)
            if closest_cell is None or current_dist < closest_dist:
                closest_cell = current_cell
                closest_dist = current_dist

        return closest_cell

    def shoot(self):
        """If cannon can be fired, fires cannon.
        
        Otherwise creates bullet moving from player's center along player's direction
        as long as options.max_player_bullets won't be exeeded
        """

        if collide_mask(self.player, self.ion_field):
            return

        if self.cannon.start_transition(Cannon.FIRING):
            return

        if len(self.player_bullets) < opt.max_player_bullets:
            new_bullet = Bullet(opt.bullet_filename, opt.bullet_speed,
                                self.player.get_rect().center,
                                self.player.get_direction())
            self.player_bullets.add(new_bullet)

    def reset_positions(self):
        """Moves sprites to their initial locations:
        player starts in left center facing south and with 0 energy
        player bullets are removed
        enemy bullet starts on enemy base
        enemy base is in moving state
        cannon is in deactivated state

        Note: shield configuration is not reset
        """

        self.player.rect.midleft = (20, int(opt.height / 2))
        self.player.set_direction(vector.SOUTH)
        self.player_bullets.empty()
        self.enemy.resume_mover_state()
        self.cannon.start_deactivated()
        self.hbullet.rect.center = self.enemy.rect.center

    def kill_player(self):
        death_animation = DeathAnimation(self.manager, self.player,
                                         (self.enemy, self.shield), self,
                                         opt.death_animation_delay,
                                         opt.death_animation_total_runtime)
        self.manager.change_state(death_animation)

    def end_level(self):
        win_animation = WinAnimation(self.manager, self.player,
                                     opt.win_animation_total_runtime,
                                     opt.exp_field_args)
        self.manager.change_state(win_animation)
Esempio n. 17
0
class Level(GameState):
    """Level is a GameState with behavior for one full game level.

    Contains Sprites player, enemy, shield, hbullet, cannon, and Group player_bullets
    """
    
    def __init__(self, manager):
        """manager is required to be a child of GameManager with these functions:
        -kill_player()
        -next_level()
        -add_score(amount)
        -give_energy(amount)
        -spend_energy(amount)
        -give_life()
        """

        GameState.__init__(self, manager)

        self.player = Ship(*opt.player_args)
        self.enemy = EnemyBase(opt.mover_args, opt.spinner_args, opt.shooter_args, self.player)
        self.shield = EnemyShield(self.enemy, opt.shield_filename, formation, formation_center)
        self.hbullet = HomingBullet(opt.homer_filename, self.player, opt.homer_speed)
        self.cannon = Cannon(opt.deactivated_cannon_args, opt.standby_cannon_args,
                             opt.firing_cannon_args, self.player)
        self.ion_field = IonField(*opt.ion_field_args)
        self.player_bullets = Group()

        self.reset_positions()
        

    def update(self):
        self.player.update()
        self.enemy.update()
        self.shield.update()
        self.hbullet.update()
        self.cannon.update()
        self.player_bullets.update()
        self.ion_field.update()
        
        self.collisions()


    def handle_events(self, events, keys):
        return (event_handlers.check_quit(events, keys) and
                event_handlers.check_shoot_button(events, keys, self.shoot) and
                event_handlers.move_player(events, keys, self.player))


    def draw(self, screen):
        self.ion_field.draw(screen)
        self.enemy.draw(screen)
        self.shield.draw(screen)
        self.player.draw(screen)
        self.hbullet.draw(screen)
        self.cannon.draw(screen)
        self.player_bullets.draw(screen)


    def collisions(self):
        """Handles collisions
        """

        player = self.player
        enemy = self.enemy
        shield = self.shield
        hbullet = self.hbullet
        cannon = self.cannon
        ion_field = self.ion_field
        player_bullets = self.player_bullets
        
        #player with homing bullet
        if collide_mask(player, hbullet) and not collide_mask(player, ion_field):
            self.kill_player()
        
        #player with enemy base
        if collide_mask(player, enemy):
            #if base in moving phase, give player energy
            if enemy.get_state_number() == EnemyBase.MOVING:
                self.manager.give_energy(opt.energy_from_enemy)
            #if base in spinning or shooting phase, kill player
            elif enemy.get_state_number() == EnemyBase.SPINNING:
                self.kill_player()
            elif enemy.get_state_number() == EnemyBase.SHOOTING:
                self.kill_player()
                
        #player with cell
        #-hitting a cell will bounce the player a bit to the left
        #-if the player hit the cell twice in a short enough span,
        # the cell is eaten and the player gets energy
        #-in case of multiple collisions, deal with cell closest to player's center
        #
        #TODO: This still isn't quite right.
        #Should be able to eat top/bottom rows with diagonal movement.
        #(vertical movement should still move player all the way left)
        pc_collides = spritecollide(player, shield, False, collide_mask)
        center_cell = self.find_centermost_cell(pc_collides)
        if center_cell is not None:
            player.rect.right = center_cell.rect.left - opt.cell_bounceback
            
            if not center_cell.marked:
                center_cell.mark()
            elif shield.can_eat():
                center_cell.kill()
                self.manager.give_energy(opt.energy_from_cell)
                self.manager.add_score(opt.score_cell_eat)
                shield.start_delay(opt.frames_to_eat_cell)
            
        #player with cannon
        if collide_mask(player, cannon):
            #if in deactivated phase, try spending required energy to activate
            if (cannon.get_state_number() == Cannon.DEACTIVATED and 
                self.manager.spend_energy(opt.cannon_energy_cost)):
                cannon.start_standby()
            #if in firing phase, kill player
            if cannon.get_state_number() == Cannon.FIRING:
                self.kill_player()
            #if in returning phase, give energy and deactivate cannon
            if cannon.get_state_number() == Cannon.RETURNING:
                cannon.start_transition(Cannon.DEACTIVATED)
                self.manager.give_energy(opt.energy_from_cannon)
                
        #cannon with cell
        #kill one cell and reverse cannon direction
        #assuming this is only possible if cannon in firing state
        if cannon.get_state_number() == Cannon.FIRING:
            cannon_collides = spritecollide(cannon, shield, False, collide_mask)
            if len(cannon_collides) > 0:
                cannon_collides[0].kill()
                self.manager.add_score(opt.score_cell_shoot)
                cannon.start_transition(Cannon.RETURNING)
            
        #cannon with enemy base -- only if cannon in firing state
        #give points corresponding to enemy state and end level
        #if enemy base is in shooting state, player also gets a life
        if cannon.get_state_number() == Cannon.FIRING and collide_mask(cannon, enemy):
            if enemy.get_state_number() == EnemyBase.MOVING:
                self.manager.add_score(opt.score_mover_destroy)
            elif enemy.get_state_number() == EnemyBase.SPINNING:
                self.manager.add_score(opt.score_spinner_destroy)
            elif enemy.get_state_number() == EnemyBase.SHOOTING:
                self.manager.add_score(opt.score_shooter_destroy)
                self.manager.give_life()
            self.end_level()
        
        #player's bullet with cell
        #kill player bullet but remove cells in a cross pattern
        #if somehow one bullet hits multiple cells one is arbitrarily selected
        bc_collides = groupcollide(player_bullets, shield, True, False, collide_mask)
        for current_bullet in bc_collides.keys():
            self.manager.add_score(opt.score_cell_shoot)
            shield.remove_cross(bc_collides[current_bullet][0])


    def find_centermost_cell(self, cells):
        """Given a list of Cell sprites, 
        returns the one whose rect.centery is closest to the player's rect.centery
        
        Returns None if list is empty
        """
        
        closest_cell = None
        
        for current_cell in cells:
            current_dist = abs(current_cell.rect.centery - self.player.rect.centery)
            if closest_cell is None or current_dist < closest_dist:
                closest_cell = current_cell
                closest_dist = current_dist

        return closest_cell


    def shoot(self):
        """If cannon can be fired, fires cannon.
        
        Otherwise creates bullet moving from player's center along player's direction
        as long as options.max_player_bullets won't be exeeded
        """
        
        if collide_mask(self.player, self.ion_field):
            return

        if self.cannon.start_transition(Cannon.FIRING):
            return        
        
        if len(self.player_bullets) < opt.max_player_bullets:
            new_bullet = Bullet(opt.bullet_filename, opt.bullet_speed, 
                                self.player.get_rect().center, self.player.get_direction())
            self.player_bullets.add(new_bullet)


    def reset_positions(self):
        """Moves sprites to their initial locations:
        player starts in left center facing south and with 0 energy
        player bullets are removed
        enemy bullet starts on enemy base
        enemy base is in moving state
        cannon is in deactivated state

        Note: shield configuration is not reset
        """

        self.player.rect.midleft = (20, int(opt.height/2))
        self.player.set_direction(vector.SOUTH)
        self.player_bullets.empty()
        self.enemy.resume_mover_state()
        self.cannon.start_deactivated()
        self.hbullet.rect.center = self.enemy.rect.center


    def kill_player(self):
        death_animation = DeathAnimation(self.manager, self.player, (self.enemy, self.shield), self,
                opt.death_animation_delay, opt.death_animation_total_runtime)
        self.manager.change_state(death_animation)


    def end_level(self):
        win_animation = WinAnimation(self.manager, self.player, opt.win_animation_total_runtime, opt.exp_field_args)
        self.manager.change_state(win_animation)
Esempio n. 18
0
import matplotlib.pyplot as plt
from calc_percentile import calculate_percentile
import logging

from cannon import Cannon
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
URL = "http://localhost:8080"

if __name__ == '__main__':
    cannon = Cannon(URL)

    duration = 30
    max_qps = 300

    df = calculate_percentile(duration, max_qps, cannon)

    df.plot(x="QPS(queries per second)", y="Latency, 50%", kind='line')
    df.plot(x="QPS(queries per second)", y="Latency, 90%", kind='line')
    df.plot(x="QPS(queries per second)", y="Latency, 99%", kind='line')
    df.plot(x="QPS(queries per second)", y="Error rate", kind='line')
    plt.show()
Esempio n. 19
0
    def run_game_loop(self):
        player_mouse_pos = [0, 0]
        button_clicked = False
        dragging = False
        game_over = False
        waves_allowed = True
        button = Button(15, 540, 50, 50)
        drag_cannon = Cannon([25, 552])
        cannon_display = Cannon_Display(self.scoreboard)
        cannon_sprite = pygame.sprite.Group(cannon_display)
        zombie_health = 110
        delta = 0.9
        zombies_sprite = self.make_zombie_herd(self.herd_size, zombie_health, delta)
        cannons = pygame.sprite.Group()
        score_sprite = pygame.sprite.Group(self.scoreboard)
        button_sprite = pygame.sprite.Group(button)
        wave_count = 0 
        kills_per_cannon = 50


        # Game loop
        while self.running:

            # Event detection
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    button_clicked = True
                elif event.type == pygame.MOUSEBUTTONUP:
                    player_mouse_pos[0] = event.pos[0]
                    player_mouse_pos[1] = event.pos[1]
                    if button_clicked and dragging and self.scoreboard.cannons > 0:
                        self.scoreboard.cannons -= 1
                        cannon = Cannon([player_mouse_pos[0]-45, player_mouse_pos[1]-45])
                        cannons.add(cannon)
                    button_clicked = False
                    dragging = False

            cannons.update()
            cannon_sprite.update()
            score_sprite.update()
            button_sprite.update("null")

            self.game_display.blit(self.background_img, (0, 0))

            # Get mouse position
            cannon_pos = pygame.mouse.get_pos()

            if 10 <= cannon_pos[0] <= 60 and 540 <= cannon_pos[1] <= 590 and button_clicked:
                button_sprite.update("shrink")
                dragging = True
            elif dragging:
                button_sprite.update("shrink")

            if button_clicked and dragging and self.scoreboard.cannons > 0:
                drag_cannon.display(self.game_display, cannon_pos[0]-45, cannon_pos[1]-45)

            # Check if the wave of zombies is empty, start the timer, don't allow waves
            # increment size of herd, and create a new herd to send as next wave
            if not zombies_sprite:
                waves_allowed = False
                self.herd_size += random.randint(9, 13)
                self.scoreboard.increment_wave()
                wave_count += 1
                if wave_count != 0 and wave_count % 5 == 0:
                    zombie_health += 60
                    delta += 0.1
                    kills_per_cannon = kills_per_cannon + 25
                else:
                    zombie_health += 20
                zombies_sprite = self.make_zombie_herd(self.herd_size, zombie_health, delta)

            if not game_over:
                cannons.draw(self.game_display)
                score_sprite.draw(self.game_display)
                button_sprite.draw(self.game_display)
                cannon_sprite.draw(self.game_display)

            # If 10 secs passed since last wave, then release the next zombie wave
            if not waves_allowed:
                if self.tick_count == 300:
                    self.scoreboard.cannons += (self.scoreboard.cannon_cash // kills_per_cannon)
                    self.scoreboard.cannon_cash = (self.scoreboard.cannon_cash % kills_per_cannon)
                self.display_warning(self.tick_count)
                self.tick_count -= 1
                if self.tick_count == 0:
                    waves_allowed = True
                    self.tick_count = 300

            # If zombie waves are allowed to attack AND the game is not over,
            # then move the zombie wave across the screen
            if waves_allowed and not game_over:
                self.move_zombie_herd(zombies_sprite)

            if self.scoreboard.score >= self.ZOMBIE_THRESH:
                game_over = True

            # If game over is true, draw Game Over and display player's stats
            if game_over:
                self.display_game_over()

            # Check if zombie is within radius of any cannon
            if not game_over and waves_allowed:
                for cannon in cannons:
                    zombies_in_radius = pygame.sprite.spritecollide(cannon, zombies_sprite, False, collided=pygame.sprite.collide_circle)
                    if zombies_in_radius:
                        for zombie in zombies_in_radius:
                            cannon.shoot(zombie.rect.centerx, zombie.rect.centery, self.game_display)

                            # Now check for bullet - zombie collisions
                            hit_list = pygame.sprite.spritecollide(zombie, cannon.bullets, False)
                            if hit_list:
                                for bullet in hit_list:
                                    if zombie.health <= 0:
                                        self.scoreboard.zombies_killed += 1
                                        self.scoreboard.cannon_cash += 1
                                        zombies_sprite.remove(zombie)
                                    else:
                                        zombie.health -= 10
                                    cannon.bullets.remove(bullet)
                                cannon.bullets.empty()

            pygame.display.update()
            self.clock.tick(self.FRAMES_PER_SEC)
Esempio n. 20
0
class CannonGame(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)

        # Button Widget
        self.btnNewGame = QToolButton()
        self.btnNewGame.setText('New Game!')
        self.btnNewGame.clicked.connect(self.btnNewGameClicked)

        self.btnFire = QToolButton()
        self.btnFire.setText('Fire!')
        self.btnFire.clicked.connect(self.btnFireClicked)

        # Label Widget
        self.lbResult = QLabel('Status:')
        self.lbAngle = QLabel('Angle(40 ~ 70):')
        self.lbPower = QLabel('Power(30 ~ 50):')
        self.lbBoulet = QLabel('Boulet: ')

        # LineEdit Widget
        self.lnResult = QLineEdit()
        self.lnResult.setReadOnly(True)
        self.lnResult.setAlignment(Qt.AlignCenter)

        self.lnBoulet = QLineEdit()
        self.lnBoulet.setReadOnly(True)
        self.lnBoulet.setAlignment(Qt.AlignCenter)

        # QSlider Widget
        self.slAngle = QSlider(Qt.Horizontal)
        self.slAngle.setMinimum(40)
        self.slAngle.setMaximum(70)
        self.slAngle.setValue(55)
        self.slAngle.setTickPosition(QSlider.TicksBelow)
        self.slAngle.setTickInterval(5)
        self.slAngle.setFixedWidth(250)

        self.slPower = QSlider(Qt.Horizontal)
        self.slPower.setMinimum(30)
        self.slPower.setMaximum(50)
        self.slPower.setValue(55)
        self.slPower.setTickPosition(QSlider.TicksBelow)
        self.slPower.setTickInterval(5)
        self.slPower.setFixedWidth(250)

        # TextEdit Widget
        self.txWindow = QTextEdit()
        self.txWindow.setFixedSize(850, 670)
        self.txWindow.setReadOnly(True)
        self.txWindow.setAlignment(Qt.AlignLeft)
        font = self.txWindow.font()
        font.setPointSize(font.pointSize() + 4)
        font.setFamily('Courier New')
        self.txWindow.setFont(font)

        # Layout
        hLayout1 = QHBoxLayout()
        hLayout2 = QHBoxLayout()
        hLayout1.addWidget(self.btnNewGame)
        hLayout1.addStretch(1)
        hLayout1.addWidget(self.lbBoulet)
        hLayout1.addWidget(self.lnBoulet)
        hLayout1.addWidget(self.lbResult)
        hLayout1.addWidget(self.lnResult)
        hLayout2.addWidget(self.lbAngle)
        hLayout2.addWidget(self.slAngle)
        hLayout2.addWidget(self.lbPower)
        hLayout2.addWidget(self.slPower)
        hLayout2.addStretch(1)
        hLayout2.addWidget(self.btnFire)

        mainLayout = QVBoxLayout()
        mainLayout.setSizeConstraint(QLayout.SetFixedSize)
        mainLayout.addLayout(hLayout1)
        mainLayout.addWidget(self.txWindow)
        mainLayout.addLayout(hLayout2)

        self.setLayout(mainLayout)
        self.setWindowTitle('Cannon Game')

        # Start Game
        self.btnNewGameClicked()

    def btnNewGameClicked(self):
        # target 위치 지정
        self.targetColumn = random.randint(40, 60)
        self.targetRow = random.randint(18, 21)
        self.target = (self.targetRow, self.targetColumn)

        # 게임 시작시 초기화
        self.cannon = Cannon(self.target)
        self.fire = Fire()
        self.gameOver = False
        self.boulet = ["●", "●", "●", "●"]
        self.turn = -1

        self.txWindow.setText(self.cannon.initialMap())
        self.lnResult.setText('Start!')
        self.lnBoulet.setText(" ".join(self.boulet))
        self.slAngle.setValue(55)
        self.slPower.setValue(40)

    def btnFireClicked(self):
        self.cannon = Cannon(self.target)

        # 각도 와 파워 설정
        try:
            angle = int(self.slAngle.value())
            power = int(self.slPower.value())
        except:
            self.lnResult.setText('Not integer')
            return

        # 게임 완료 시
        if self.gameOver == True:
            self.lnResult.setText('Game Over')
            return

        # 현재 맵 출력
        for point in self.fire.parabola(angle, power):
            shape = self.cannon.currentMap(point)[0]
            hit = self.cannon.currentMap(point)[1]
            self.txWindow.setText(shape)

            if hit:
                self.lnResult.setText('Hit!')
                self.gameOver = True
                break
            else:
                self.lnResult.setText('Miss!')

            # 에니메이션 효과 구현
            loop = QEventLoop()
            QTimer.singleShot(100, loop.quit)
            loop.exec_()

        if self.boulet[0] == "○":
            self.lnResult.setText('Fail!')
            self.gameOver = True
            return

        del (self.boulet[self.turn])
        self.turn -= 1
        self.boulet.append("○")
        self.lnBoulet.setText(" ".join(self.boulet))

    # 단축키 설정
    def keyPressEvent(self, e):
        if e.key() == Qt.Key_Escape:
            self.close()
        elif e.key() == Qt.Key_N:
            self.btnNewGameClicked()
        elif e.key() == Qt.Key_Enter or Qt.Key_Return:
            self.btnFireClicked()
Esempio n. 21
0
import logging

from cannon import Cannon

logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
URL = "http://localhost:8080"

if __name__ == '__main__':
    cannon = Cannon(URL)
    latencies = cannon.start_shoot(qps=100, duration=15, threads=80)
    print(latencies)
Esempio n. 22
0
import pygame
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

from cannon import Cannon;
from objects import *;

screen_size = (800, 600);
clock = pygame.time.Clock();
delta_time = clock.tick() / 1000;

goal = Goal(screen_size);
obstacle_list = [];
cannon = Cannon(20, 0, obstacle_list, goal);

player_points = 0;


def init_game():
    pygame.display.init();
    pygame.display.set_mode((screen_size[0], screen_size[1]), DOUBLEBUF | OPENGL);

    glClearColor(1.0, 1.0, 1.0, 1.0);


def update():
    global delta_time;
    delta_time = clock.tick() / 1000;
Esempio n. 23
0
from cannon import Cannon

# Build some cannons
cannon_1 = Cannon(25)
cannon_2 = Cannon(10)
cannon_3 = Cannon(1)

# Start firing
cannon_1.fire_ball()
cannon_2.fire_multiple(4)
cannon_3.fire_multiple(6)

# Keep firing
cannon_1.fire_multiple(cannon_2.ammunition + cannon_3.ammunition)

# Quiz
print("Cannon1: {}".format(cannon_1.ammunition))
print("Cannon2: {}".format(cannon_2.ammunition))
print("Cannon3: {}".format(cannon_3.ammunition))
Esempio n. 24
0
    win = window.Window(width=500, height=500, vsync=True, resizable=True)
    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
    # needed so that egi knows where to draw
    egi.InitWithPyglet(win)
    # prep the fps display
    fps_display = clock.ClockDisplay()
    # register key and mouse event handlers
    win.push_handlers(on_key_press)
    win.push_handlers(on_mouse_press)
    win.push_handlers(on_resize)

    # create a world for agents
    world = World(500, 500)
    world.hunter = Hunter(world)
    world.cannon = Cannon(Vector2D(250, 20), world)
    # unpause the world ready for movement
    world.paused = False

    while not win.has_exit:
        win.dispatch_events()
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        # show nice FPS bottom right (default)
        delta = clock.tick()
        world.update(delta)
        world.render()
        fps_display.draw()
        # swap the double buffer
        win.flip()