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
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
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 __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 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)
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()}
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 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 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)
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)
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}
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;
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()
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))
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()
