def __init__(self, main):
Screen.__init__(self, main)
self.waves = Waves()
self.inputblock = pygame.Surface((JOIN_BOX_W, JOIN_BOX_H), pygame.SRCALPHA)
self.inputblock.fill((0, 0, 0, 128))
self.textbox = pygame.Surface((JOIN_TEXT_W, JOIN_TEXT_H), pygame.SRCALPHA)
self.textbox.fill((0, 0, 0, 64))
self.font = pygame.font.Font(None, 40)
okbutton = pygame.Surface((JOIN_BUTT_W, JOIN_BUTT_H), pygame.SRCALPHA)
okbutton.fill((0, 0, 0, 64))
oktxt = self.font.render("Join", True, COLORS["white"])
okbutton.blit(oktxt, (10, 8))
backbutton = pygame.Surface((JOIN_BUTT_W, JOIN_BUTT_H), pygame.SRCALPHA)
backbutton.fill((0, 0, 0, 64))
backtxt = self.font.render("Back", True, COLORS["white"])
backbutton.blit(backtxt, (5, 8))
self.inputblock.blit(backbutton, (JOIN_BUTT_BUF_X, JOIN_BUTT_BUF_Y))
self.inputblock.blit(okbutton, (self.inputblock.get_width()-JOIN_BUTT_BUF_X-okbutton.get_width(), JOIN_BUTT_BUF_Y))
instruction = self.font.render("Server Address", True, COLORS["white"])
self.inputblock.blit(instruction, (int(((self.inputblock.get_width()-instruction.get_width())/2.0)), 10))
self.ip = ""
self.countdown = 0
def go_back(mpos):
self.main.change_screen("main")
self.clickbox.append((JOIN_BACK_X, JOIN_BUTT_Y, JOIN_BUTT_W, JOIN_BUTT_H), go_back)
self.clickbox.append((JOIN_OK_X, JOIN_BUTT_Y, JOIN_BUTT_W, JOIN_BUTT_H), self.connect_ip)
def __init__(self, width, height, manager, owner):
Screen.__init__(self, manager, owner, Screens.PRODUCTENTRY)
ProductEntryGUI.__init__(self, width, height, self)
self.states = Enum("BARCODE", "DESCRIPTION", "PRICE", "ADDING",
"WARNING")
self.events = Enum("GUIEVENT", "SCAN", "BADSCAN", "KEYPRESS",
"TIMEOUT")
self.barcode = ""
self.price = 0
self.description = ""
self.sm = SimpleStateMachine(
self.states.BARCODE, #pylint: disable=C0103
[
(self.states.BARCODE, self.events.GUIEVENT,
self._on_gui_event),
(self.states.BARCODE, self.events.SCAN, self._got_barcode),
(self.states.BARCODE, self.events.BADSCAN,
self._got_new_barcode),
(self.states.BARCODE, self.events.KEYPRESS,
lambda: self.states.BARCODE),
(self.states.DESCRIPTION, self.events.GUIEVENT,
self._on_gui_event),
(self.states.DESCRIPTION, self.events.KEYPRESS,
self._got_new_desc_char),
(self.states.DESCRIPTION, self.events.SCAN,
lambda: self.states.DESCRIPTION),
(self.states.DESCRIPTION, self.events.BADSCAN,
lambda: self.states.DESCRIPTION),
(self.states.PRICE, self.events.GUIEVENT, self._on_gui_event),
(self.states.PRICE, self.events.KEYPRESS,
self._got_new_price_char),
(self.states.PRICE, self.events.SCAN,
lambda: self.states.DESCRIPTION),
(self.states.PRICE, self.events.BADSCAN,
lambda: self.states.DESCRIPTION),
(self.states.ADDING, self.events.TIMEOUT, self._exit),
(self.states.ADDING, self.events.GUIEVENT,
lambda: self.states.ADDING),
(self.states.ADDING, self.events.KEYPRESS,
lambda: self.states.ADDING),
(self.states.ADDING, self.events.SCAN,
lambda: self.states.ADDING),
(self.states.ADDING, self.events.BADSCAN,
lambda: self.states.ADDING),
(self.states.WARNING, self.events.TIMEOUT,
lambda: self.states.BARCODE),
(self.states.WARNING, self.events.GUIEVENT,
lambda: self.states.WARNING),
(self.states.WARNING, self.events.KEYPRESS,
lambda: self.states.WARNING),
(self.states.WARNING, self.events.SCAN,
lambda: self.states.WARNING),
(self.states.WARNING, self.events.BADSCAN,
lambda: self.states.WARNING),
])
def die(self):
'''
'''
super().die()
Screen.load_screen(DeathScreen(Screen.get_current_screen()))
sound_manager.play_effect('player_death')
def update(self, delta_time):
'''
'''
super().update(delta_time)
if event_handler.is_key_pressed(pygame.K_RETURN):
Screen.load_screen(GameScreen())
def instantiate(position):
'''
'''
if Blood.total_objects < 40:
Screen.get_current_screen().object_handler.instantiate(
Blood(position))
Blood.total_objects += 1
def update(self, delta_time):
'''
'''
super().update(delta_time)
if event_handler.is_key_pressed(pygame.K_RETURN):
Screen.get_last_screen().load_content()
Screen.load_screen(Screen.get_last_screen())
def display(self, screen):
Screen.display(self, screen)
self.waves.display(screen)
screen.blit(self.inputblock, (JOIN_BOX_X, JOIN_BOX_Y))
screen.blit(self.textbox, (JOIN_TEXT_X, JOIN_TEXT_Y))
if self.countdown > 0:
self.countdown -= 1
if not self.countdown:
self.redraw_textbox(False)
def setup_class(self):
self.d_psr = 1 * u.kpc
self.d_scr = 0.5 * u.kpc
self.pulsar = Source(
vel=CartesianRepresentation(100., 0, 0, unit='km/s'))
self.screen = Screen(CartesianRepresentation([0., 10.], [0., 0.],
[0., 0.],
unit='AU'),
CartesianRepresentation(0., 0., 0., unit='km/s'),
magnification=np.array([1., 0.5j]))
self.telescope = Telescope()
def display(self, screen):
Screen.display(self, screen)
self.waves.display(screen)
if self.highlight_over_loc is not None:
screen.blit(self.highlight_over_box, self.highlight_over_loc)
if self.highlight_click_loc is not None:
screen.blit(self.highlight_click_box, self.highlight_click_loc)
screen.blit(self.disp_area, (40, 160))
screen.blit(self.text_area, (40, 690))
screen.blit(self.save_load_button, (550, 690))
screen.blit(self.back_button, (40, 740))
def display(self, screen):
Screen.display(self, screen)
# I feel like the following code is flipping me off...
self.waves.display(screen, False)
screen.blit(self.players_panel, (26, 38))
screen.blit(self.chat_panel, (545, 38))
screen.blit(self.textbox, (565, 577), (min(self.textbox.get_width()-582, max(0, (self.font.size(self.text_input)[0])-582+10)), 0, 582, 30))
screen.blit(self.base_panel, (26, 681))
screen.blit(self.msgpanel.view, (566, 63))
if self.player_menu_pos != (0, 0):
screen.blit(self.player_menu, (self.player_menu_pos[0], self.player_menu_pos[1]))
def on_shooting(self):
'''
'''
sound_manager.play_effect('shotgun')
self.owner.animator.play('shotgun_shoot')
# spawn bullets
for i in range(35):
Screen.get_current_screen().instantiate(
Bullet(self, self.bullet_speed, self.bullet_max_distance))
super().on_shooting()
def on_shooting(self):
'''
'''
# spawn bullet
Screen.get_current_screen().instantiate(
Bullet(self, self.bullet_speed, self.bullet_max_distance))
if self.bullets != 0 and self.bullets % self.magazine_size == 0:
self.reload()
self.bullets -= 1
elif self.bullets > 0:
self.bullets -= 1
self.can_shoot = False
def update(self, delta_time):
'''
'''
super().update(delta_time)
if self.is_dead:
return
# update current gun
self.current_gun.update(delta_time)
# handle movement
self._movement(delta_time)
# shoot
if event_handler.is_mouse_down(1):
self.attack()
# switch weapons
self._swith_weapons()
# get the camera in current screen
camera = Screen.get_current_screen().camera
# look at mouse
self.transform.look_at(
camera.screen_to_world_point(
Vector2.tuple_to_vector2(pygame.mouse.get_pos())))
# make the camera follow player
self._camera_follow(camera)
def spawn_enemy(self, enemy):
'''
'''
self.current_wave_index += 1
enemy_type = None
position = Vector2(enemy[2], enemy[3])
if enemy[1] == 'normal_zombie':
enemy_type = Zombie(self.player, position)
elif enemy[1] == 'big_zombie':
enemy_type = BigZombie(self.player, position)
Screen.get_current_screen().instantiate(enemy_type)
self.spawned_enemies.append(enemy_type)
class TestSimpleScreen:
def setup_class(self):
self.d_psr = 1 * u.kpc
self.d_scr = 0.5 * u.kpc
self.pulsar = Source(
vel=CartesianRepresentation(100., 0, 0, unit='km/s'))
self.screen = Screen(CartesianRepresentation([0., 10.], [0., 0.],
[0., 0.],
unit='AU'),
CartesianRepresentation(0., 0., 0., unit='km/s'),
magnification=np.array([1., 0.5j]))
self.telescope = Telescope()
def test_observe_pulsar(self):
obs = self.telescope.observe(self.pulsar, distance=self.d_psr)
assert obs.brightness.shape == ()
assert obs.brightness == 1.
assert obs.tau == 0.
assert obs.taudot == 0.
def test_screen_pulsar(self):
d_rel = self.d_psr - self.d_scr
screened = self.screen.observe(self.pulsar, distance=d_rel)
assert screened.brightness.shape == (2, )
assert np.all(screened.brightness == self.screen.magnification)
theta = ([0, -10] * u.AU) / d_rel
tau_expected = theta**2 * 0.5 * d_rel / const.c
assert u.allclose(screened.tau, tau_expected)
taudot_expected = 100 * u.km / u.s * theta / const.c
assert u.allclose(screened.taudot, taudot_expected)
def test_observe_screened_pulsar(self):
d_rel = self.d_psr - self.d_scr
screened = self.screen.observe(self.pulsar, distance=d_rel)
obs = self.telescope.observe(screened, distance=self.d_scr)
assert obs.brightness.shape == (2, )
assert np.all(obs.brightness == self.screen.magnification)
d_eff = self.d_psr * self.d_scr / d_rel
v_eff = self.d_scr / d_rel * 100 * u.km / u.s
theta = ([0, -10] * u.AU) / self.d_scr
tau_expected = theta**2 * 0.5 * d_eff / const.c
assert u.allclose(obs.tau, tau_expected)
taudot_expected = v_eff * theta / const.c
assert u.allclose(obs.taudot, taudot_expected)
# Sanity check on repr
repr(obs)
def __init__(self, main):
Screen.__init__(self, main)
self.waves = Waves()
self.files = None
self.font = pygame.font.Font(None, LINE_HEIGHT)
self.disp_area = pygame.Surface((600, 520), pygame.SRCALPHA)
self.text_area = pygame.Surface((500, LINE_HEIGHT), pygame.SRCALPHA)
self.save_load_button = pygame.Surface((90, LINE_HEIGHT), pygame.SRCALPHA)
self.highlight_over_box = pygame.Surface((600, LINE_HEIGHT), pygame.SRCALPHA)
self.highlight_over_box.fill((0, 0, 0, 64))
self.highlight_over_loc = None
self.highlight_click_box = pygame.Surface((600, LINE_HEIGHT), pygame.SRCALPHA)
self.highlight_click_box.fill((0, 0, 0, 64))
self.highlight_click_loc = None
self.redraw_save_load()
self.return_to = None
self.text_area.fill((0, 0, 0, 64))
self.text_input = ""
self.back_button = pygame.Surface((110, 50), pygame.SRCALPHA)
self.back_button.fill((0, 0, 0, 128))
txt = pygame.font.Font(None, 60).render("Back", True, COLORS["white"])
self.back_button.blit(txt, (5, 5))
def go_back(mpos):
if self.return_to is not None:
self.main.change_screen(self.return_to)
else:
print "I got nowhere to go to."
self.clickbox.append((40, 740, 110, 50), go_back)
self.redraw_files()
def m_click(mpos):
index = mpos[1]//LINE_HEIGHT
if index < len(self.files):
self.highlight_click_loc = (40, index*LINE_HEIGHT + 160)
self.text_input = self.files[index]
self.redraw_text()
def m_over(mpos):
index = mpos[1]//LINE_HEIGHT
if index < len(self.files):
self.highlight_over_loc = (40, index*LINE_HEIGHT + 160)
else:
self.highlight_over_loc = None
def m_out():
self.highlight_over_loc = None
self.overbox.append((40, 160, 600, 520), m_over, off=m_out)
self.clickbox.append((40, 160, 600, 520), m_click)
self.clickbox.append((550, 690, 90, LINE_HEIGHT), self.save_load)
def main() -> None:
''' The main function of the program that contains the gameLoop
'''
# ---------------------- GameLoop
while not utils.quit_game:
# --------------------UPDATE--------------------
event_handler.update()
Screen.get_current_screen().update(
clock.get_time()) # update everything in the current screen
# ---------------------DRAW---------------------
utils.window.fill((20, 20, 20)) # clear screen
Screen.get_current_screen().draw(
utils.window) # draw everything in the current screen
pygame.display.update() # render everything
clock.tick(100) # set the FPS to 100
def __init__(self, width, height, manager, owner):
Screen.__init__(self, manager, owner, Screens.MAINSCREEN)
MainScreenGUI.__init__(self, width, height, self)
self.states = Enum("IDLE", "CHARGING", "PAYMENTMSG", "WARNING")
self.events = Enum("GUIEVENT", "SCAN", "BADSCAN", "RFID", "BADRFID", "CHARGED", "BANNERTIMEOUT")
self.sm = SimpleStateMachine(self.states.IDLE, #pylint: disable=C0103
[
[self.states.IDLE, self.events.GUIEVENT, self._on_idle_gui_event],
[self.states.IDLE, self.events.SCAN, self._on_idle_scan_event],
[self.states.IDLE, self.events.BADSCAN, self._on_idle_bad_scan_event],
[self.states.IDLE, self.events.RFID, self._on_rfid_event],
[self.states.IDLE, self.events.BADRFID, self._on_bad_rfid_event],
[self.states.PAYMENTMSG, self.events.BANNERTIMEOUT, self._return_to_intro],
[self.states.PAYMENTMSG, self.events.GUIEVENT, lambda: self.states.PAYMENTMSG],
[self.states.PAYMENTMSG, self.events.SCAN, lambda: self.states.PAYMENTMSG],
[self.states.PAYMENTMSG, self.events.BADSCAN, lambda: self.states.PAYMENTMSG],
[self.states.PAYMENTMSG, self.events.RFID, lambda: self.states.PAYMENTMSG],
[self.states.PAYMENTMSG, self.events.BADRFID, lambda: self.states.PAYMENTMSG],
[self.states.CHARGING, self.events.CHARGED, lambda: self.states.PAYMENTMSG],
[self.states.CHARGING, self.events.GUIEVENT, lambda: self.states.CHARGING],
[self.states.CHARGING, self.events.SCAN, lambda: self.states.CHARGING],
[self.states.CHARGING, self.events.BADSCAN, lambda: self.states.CHARGING],
[self.states.CHARGING, self.events.RFID, lambda: self.states.CHARGING],
[self.states.CHARGING, self.events.BADRFID, lambda: self.states.CHARGING],
[self.states.WARNING, self.events.BANNERTIMEOUT, self._remove_warning],
[self.states.WARNING, self.events.SCAN, self._on_idle_scan_event],
[self.states.WARNING, self.events.BADSCAN, self._update_barcode_warning],
[self.states.WARNING, self.events.RFID, self._on_rfid_event],
[self.states.WARNING, self.events.BADRFID, self._on_bad_rfid_event],
[self.states.WARNING, self.events.GUIEVENT, self._remove_warning],
])
self.logger = logging.getLogger("MainScreen")
self.new_product = None
self.badcode = ""
def __init__(self, width, height, manager, owner):
Screen.__init__(self, manager, owner, Screens.PRODUCTENTRY)
ProductEntryGUI.__init__(self, width, height, self)
self.states = Enum("BARCODE", "DESCRIPTION", "PRICE", "ADDING", "WARNING")
self.events = Enum("GUIEVENT", "SCAN", "BADSCAN", "KEYPRESS", "TIMEOUT")
self.barcode = ""
self.price = 0
self.description = ""
self.sm = SimpleStateMachine(self.states.BARCODE, #pylint: disable=C0103
[
(self.states.BARCODE, self.events.GUIEVENT, self._on_gui_event),
(self.states.BARCODE, self.events.SCAN, self._got_barcode),
(self.states.BARCODE, self.events.BADSCAN, self._got_new_barcode),
(self.states.BARCODE, self.events.KEYPRESS, lambda: self.states.BARCODE),
(self.states.DESCRIPTION, self.events.GUIEVENT, self._on_gui_event),
(self.states.DESCRIPTION, self.events.KEYPRESS, self._got_new_desc_char),
(self.states.DESCRIPTION, self.events.SCAN, lambda: self.states.DESCRIPTION),
(self.states.DESCRIPTION, self.events.BADSCAN, lambda: self.states.DESCRIPTION),
(self.states.PRICE, self.events.GUIEVENT, self._on_gui_event),
(self.states.PRICE, self.events.KEYPRESS, self._got_new_price_char),
(self.states.PRICE, self.events.SCAN, lambda: self.states.DESCRIPTION),
(self.states.PRICE, self.events.BADSCAN, lambda: self.states.DESCRIPTION),
(self.states.ADDING, self.events.TIMEOUT, self._exit),
(self.states.ADDING, self.events.GUIEVENT, lambda: self.states.ADDING),
(self.states.ADDING, self.events.KEYPRESS, lambda: self.states.ADDING),
(self.states.ADDING, self.events.SCAN, lambda: self.states.ADDING),
(self.states.ADDING, self.events.BADSCAN, lambda: self.states.ADDING),
(self.states.WARNING, self.events.TIMEOUT, lambda: self.states.BARCODE),
(self.states.WARNING, self.events.GUIEVENT, lambda: self.states.WARNING),
(self.states.WARNING, self.events.KEYPRESS, lambda: self.states.WARNING),
(self.states.WARNING, self.events.SCAN, lambda: self.states.WARNING),
(self.states.WARNING, self.events.BADSCAN, lambda: self.states.WARNING),
])
def on_render(self, surface):
super().on_render(surface)
# display weapon name
weapon = self.current_gun
bullets = weapon.bullets % weapon.magazine_size + 1 if not weapon.reloading else 0
magazines = weapon.bullets // weapon.magazine_size * weapon.magazine_size if not weapon.reloading else weapon.bullets // weapon.magazine_size * weapon.magazine_size + weapon.magazine_size
text = f'{self.current_gun.name} | {bullets}/{magazines}'
position = Screen.get_current_screen().camera.world_to_screen_point(
self.transform.position -
Vector2(len(text) * 0.25 * 11, 55)).to_tuple()
utils.draw_font(surface,
text, (255, 255, 255),
position,
size=11,
bold=True)
def __init__(self, width, height, manager, owner):
Screen.__init__(self, manager, owner, Screens.NUMERICENTRY)
NumericEntryGUI.__init__(self, width, height, self)
self.amountinpence = 0
self.preset_amount = False
def __init__(self, main, host=True):
Screen.__init__(self, main)
self.my_index = 0
self.player_colors = [(0xFF, 0, 0), (0, 0xFF, 0), (0xFF, 0, 0xFF), (0xFF, 0xFF, 0),
(0, 0xFF, 0xFF), (0xFF, 180, 0), (180, 0, 0xFF),
(0, 0xFF, 100), (0xFF, 0xCC, 0xCC), (0xCC, 0xCC, 0xFF)]
self.color_pick = 0
self.largefont = pygame.font.Font(None, 70)
self.font = pygame.font.Font(None, 30)
self.waves = Waves()
self.player_menu = pygame.Surface((415, 120), pygame.SRCALPHA)
self.player_menu_pos = (0, 0)
self.players_panel = pygame.Surface((496, 578), pygame.SRCALPHA)
self.players_panel.fill((0, 0, 0, 128))
self.players = []
self.start_timeout = time.time()
self.players.append(["Host", pygame.Surface((474, 48), pygame.SRCALPHA), False])
for _ in xrange(1, 10):
self.players.append([CLOSED, pygame.Surface((474, 48), pygame.SRCALPHA), False])
self.redraw_players()
self.chat_panel = pygame.Surface((696, 578), pygame.SRCALPHA)
self.chat_panel.fill((0, 0, 0, 128))
send_button = pygame.Surface((67, 30), pygame.SRCALPHA)
send_button.fill((0, 0, 0, 64))
txt = self.font.render("Send", True, (0xCC, )*3) # TODO: nope
send_button.blit(txt, (10, 7))
self.chat_panel.blit(send_button, (20+582+5, 577-38))
self.textbox = pygame.Surface((1820, 30), pygame.SRCALPHA)
self.textbox.fill((0, 0, 0, 64))
self.base_panel = pygame.Surface((1215, 96), pygame.SRCALPHA)
self.base_panel.fill((0, 0, 0, 128))
txt_leave_lobby = self.largefont.render("Leave Lobby", True, COLORS["white"])
self.button_leave_lobby = pygame.Surface((331, 76), pygame.SRCALPHA)
self.button_leave_lobby.fill((0, 0, 0, 64))
self.button_leave_lobby.blit(txt_leave_lobby, (15, 15))
self.base_panel.blit(self.button_leave_lobby, (10, 10))
if host:
def get_ip():
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('google.com', 80))
ip = s.getsockname()[0]
s.close()
txt_ip = self.largefont.render(ip, True, COLORS["white"])
self.base_panel.blit(txt_ip, (450, 25))
def copy_ip(mpos):
try:
pygame.scrap.init()
pygame.scrap.put(pygame.SCRAP_TEXT, ip)
except:
pass # fixes!
self.clickbox.append((476, 706, txt_ip.get_width(), txt_ip.get_height()), copy_ip)
except (urllib2.URLError, urllib2.HTTPError, IOError):
print "Error fetching IP"
threading.Thread(target=get_ip).start()
self.button_start = pygame.Surface((331, 76), pygame.SRCALPHA)
self.button_start.fill((0, 0, 0, 64))
txt_start_game = self.largefont.render("Start Game", True, COLORS["white"])
self.button_start.blit(txt_start_game, (30, 15))
self.base_panel.blit(self.button_start, (870, 10))
def start_game(mpos):
if time.time() - self.start_timeout > 3:
self.main.client.start_game()
self.start_timeout = time.time()
self.clickbox.append((900, 690, 331, 76), start_game)
self.text_input = ""
self.msgpanel = MessagePanel((652, 509), 23, self.font)
self.startable = False
def to_main(mpos):
self.main.change_screen("main")
self.clickbox.append((37, 692, 329, 74), to_main)
def ready_button_click(i):
def anon(mpos):
if i == self.my_index:
self.main.client.set_ready(int(not self.players[i][2]))
else:
print "ready button clicked!!"
return anon
for x in xrange(10):
self.clickbox.append((37, 75+54*x, 48, 48), ready_button_click(x))
def player_panel_click(i):
def anon(mpos):
if self.my_index == 0: # only the host can kick
if i == self.my_index:
pass
elif isinstance(self.players[i][0], int):
self.player_menu_pos = (95, 75+54*i+48)
options = ["Closed", "Open", "AI"]
self.player_menu.fill((0, 0, 0, 128))
def clearworking(mpos):
self.player_menu_pos = (0, 0)
for k in xrange(3):
self.clickbox.remove((95, 75+54*i+48+k*40+5))
self.clickbox.remove((0, 0))
self.clickbox.append((0, 0, 1280, 800), clearworking, z=2)
for j, option in enumerate(options):
def wrapper(toWhat):
def changeto(mpos):
self.main.client.set_slot(i, toWhat+1)
self.player_menu_pos = (0, 0)
for k in xrange(3):
self.clickbox.remove((95, 75+54*i+48+k*40+5))
self.clickbox.remove((0, 0))
return changeto
self.clickbox.append((95, 75+54*i+48+j*40+5, 415, 40), wrapper(j), z=3)
text = self.font.render(option, True, COLORS["white"])
self.player_menu.blit(text, (5, 5+j*40))
else: # it's a person
self.player_menu_pos = (95, 75+54*i+48)
self.player_menu.fill((0, 0, 0, 0))
pygame.draw.rect(self.player_menu, (0, 0, 0, 128), (0, 0, 415, 30))
def clearworking(mpos):
self.player_menu_pos = (0, 0)
self.clickbox.remove((95, 75+54*i+48+5))
self.clickbox.remove((0, 0))
self.clickbox.append((0, 0, 1280, 800), clearworking, z=2)
def kickhim(mpos):
self.main.client.kick_player(str(i))
self.player_menu_pos = (0, 0)
self.clickbox.remove((95, 75+54*i+48+5))
self.clickbox.remove((0, 0))
self.clickbox.append((95, 75+54*i+48, 415, 40), kickhim, z=3)
text = self.font.render("Kick", True, COLORS["white"])
self.player_menu.blit(text, (5, 5))
return anon
for x in xrange(10):
self.clickbox.append((95, 75+54*x, 415, 48), player_panel_click(x))
def wrapper(mpos):
self.message()
self.textbox.fill((0, 0, 0, 64))
txt = self.font.render(self.text_input, True, COLORS["white"])
self.textbox.blit(txt, (5, 5))
self.clickbox.append((1154, 580, 64, 25), wrapper)
def __init__(self, width, height, manager, owner):
Screen.__init__(self, manager, owner, Screens.MAINSCREEN)
MainScreenGUI.__init__(self, width, height, self)
self.states = Enum("IDLE", "CHARGING", "PAYMENTMSG", "WARNING")
self.events = Enum("GUIEVENT", "SCAN", "BADSCAN", "RFID", "BADRFID",
"CHARGED", "BANNERTIMEOUT")
self.sm = SimpleStateMachine(
self.states.IDLE, #pylint: disable=C0103
[
[
self.states.IDLE, self.events.GUIEVENT,
self._on_idle_gui_event
],
[self.states.IDLE, self.events.SCAN, self._on_idle_scan_event],
[
self.states.IDLE, self.events.BADSCAN,
self._on_idle_bad_scan_event
],
[self.states.IDLE, self.events.RFID, self._on_rfid_event],
[
self.states.IDLE, self.events.BADRFID,
self._on_bad_rfid_event
],
[
self.states.PAYMENTMSG, self.events.BANNERTIMEOUT,
self._return_to_intro
],
[
self.states.PAYMENTMSG, self.events.GUIEVENT,
lambda: self.states.PAYMENTMSG
],
[
self.states.PAYMENTMSG, self.events.SCAN,
lambda: self.states.PAYMENTMSG
],
[
self.states.PAYMENTMSG, self.events.BADSCAN,
lambda: self.states.PAYMENTMSG
],
[
self.states.PAYMENTMSG, self.events.RFID,
lambda: self.states.PAYMENTMSG
],
[
self.states.PAYMENTMSG, self.events.BADRFID,
lambda: self.states.PAYMENTMSG
],
[
self.states.CHARGING, self.events.CHARGED,
lambda: self.states.PAYMENTMSG
],
[
self.states.CHARGING, self.events.GUIEVENT,
lambda: self.states.CHARGING
],
[
self.states.CHARGING, self.events.SCAN,
lambda: self.states.CHARGING
],
[
self.states.CHARGING, self.events.BADSCAN,
lambda: self.states.CHARGING
],
[
self.states.CHARGING, self.events.RFID,
lambda: self.states.CHARGING
],
[
self.states.CHARGING, self.events.BADRFID,
lambda: self.states.CHARGING
],
[
self.states.WARNING, self.events.BANNERTIMEOUT,
self._remove_warning
],
[
self.states.WARNING, self.events.SCAN,
self._on_idle_scan_event
],
[
self.states.WARNING, self.events.BADSCAN,
self._update_barcode_warning
],
[self.states.WARNING, self.events.RFID, self._on_rfid_event],
[
self.states.WARNING, self.events.BADRFID,
self._on_bad_rfid_event
],
[
self.states.WARNING, self.events.GUIEVENT,
self._remove_warning
],
])
self.logger = logging.getLogger("MainScreen")
self.new_product = None
self.badcode = ""
pygame.init()
# Initialize the game window
utils.window = pygame.display.set_mode(
(utils.window_size[0], utils.window_size[1]))
pygame.display.set_caption('Zombie Shooter 3000')
# Icon
#icon = pygame.image.load('content/sprites/icon.png')
#pygame.display.set_icon(icon)
# Used font for txt
#config.font = pygame.font.SysFont('Tahoma',18, True, False)
# set the current screen to
Screen.load_screen(LoadScreen())
Screen.load_screen(MenuScreen())
# clock is used to get a framerate of 60fps
clock = pygame.time.Clock()
def main() -> None:
''' The main function of the program that contains the gameLoop
'''
# ---------------------- GameLoop
while not utils.quit_game:
# --------------------UPDATE--------------------
event_handler.update()
