def main():
""" Starting function for the application. Initialize pygame and quidditas and start
the game.
"""
pygame.init()
pygame.display.set_caption("Tower defense example using Quidditas")
screen = pygame.display.set_mode((640, 480))
clock = Clock()
running = 1
images = {}
images["soldier"] = load("res/soldier.png")
q = init_quidditas(screen, images)
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = 0
q.update(clock.get_time())
update(clock.get_time())
render(clock.get_time())
pygame.display.flip()
clock.tick(60)
def main():
"""Main program loop"""
pygame.init()
screen = pygame.display.set_mode(opt.window_size)
sys_font = Font(get_default_font(), opt.font_size)
clock = Clock()
manager = YarsManager()
running = True
while running:
#limit framerate and prepare FPS display text
clock.tick(opt.max_framerate)
fps = clock.get_fps()
fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, opt.white)
if event.get(pygame.QUIT):
sys.exit()
running = manager.handle_events(event.get(), key.get_pressed())
manager.update()
screen.fill(opt.black)
manager.draw(screen)
screen.blit(fps_text, fps_text.get_rect(top = 0, right = opt.width))
pygame.display.update()
sys.exit()
def run():
clock = Clock()
initialize()
while(True):
dt = clock.tick(60)
update()
render()
def main():
pygame.init()
size = width, height = 1280, 720
speed = [2,2]
black = 0, 0, 0
pos = posx, posy = width/2, height/2
radius = 20
color = THECOLORS["red"]
clock = Clock()
screen = pygame.display.set_mode(size)
surface = pygame.display.get_surface()
rmanager = RingManager( width, height, center = pos)
r = 0
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT: pygame.quit(); sys.exit()
elif event.type == KEYDOWN:
if pygame.key.get_pressed()[K_1]:
r = 0
if pygame.key.get_pressed()[K_2]:
r = 1
if pygame.key.get_pressed()[K_3]:
r = 2
if pygame.key.get_pressed()[K_4]:
r = 3
if pygame.key.get_pressed()[K_LEFT]:
rmanager.rings[r] << 1
elif pygame.key.get_pressed()[K_RIGHT]:
rmanager.rings[r] >> 1
rmanager.checkCollide()
rmanager.paintAll(surface)
pygame.display.flip()
clock.tick(60)
def update(self, deps, callback, max_fps):
c = Clock()
while self.running:
env = self.compose(deps)
callback(*env)
c.tick(max_fps)
self.logger.debug("Thread with deps %s ending" % (str(deps)))
class Asteroids(object):
""" Class definition for the asteroids game. """
def __init__(self):
""" Create a new instance of the asteroids game. """
pygame.init()
pygame.display.set_caption("Asteroids example using Quidditas")
screen = pygame.display.set_mode((640, 480))
self.clock = Clock()
self.to_update = []
self.to_render= []
self.event_bus = cyrusbus.Bus()
self.event_bus.subscribe("event.exit", self.on_exit)
images = {}
images["asteroid"] = load("res/asteroid.png")
images["spaceship"] = load("res/player.png")
self.q = self.init_quidditas(screen, images)
def on_exit(self, event):
""" Handle an exit event that comes via the event bus. """
self.running = 0
def start(self):
""" Start the game loop. """
self.running = 1
while self.running:
for event in pygame.event.get(pygame.QUIT):
self.running = 0
time = self.clock.get_time()
self.q.update(time)
self.update(time)
self.render(time)
self.clock.tick(60)
pygame.quit()
def update(self, time):
""" Iterate over all processors that update game logic and call their update. """
[processor.update(time) for processor in self.to_update]
def render(self, time):
""" Iterate over all processors that render the game and call their update. """
[processor.update(time) for processor in self.to_render]
pygame.display.flip()
def init_quidditas(self, screen, images):
""" Initialize the quidditas instance and create the processors. """
q = quidditas.Quidditas()
q.add_type_definitions(type_definitions.definitions)
self.to_update.append(q.add_processor(processors.RenderProcessor(screen, images)))
self.to_update.append(q.add_processor(processors.AsteroidSpawner()))
self.to_update.append(q.add_processor(processors.ControlsProcessor(self.event_bus)))
self.to_render.append(q.add_processor(processors.MovementProcessor((640, 480))))
return q
class CpuSpinner:
def __init__(self, directory, ttl=False, gameticks=Parameters.GAMETICKS, gamespeed=Parameters.GAMESPEED):
self.clock = GameClock(gameticks)
self.clock.set_speed(gamespeed)
self.clock.start()
self.limitclock = Clock()
self._running = True
self.__ttl = ttl * Parameters.GAMETICKS
self._directory = directory
self.__aupdatecounter = 0
def __gettick(self):
return self.clock.game_tick
def __getbetweenframe(self):
return self.clock.get_between_frame()
def start(self):
self.__loop()
def __loop(self):
while self._running:
for i in self.clock.update():
self.__update()
self._draw()
def __update(self):
if self.__ttl:
self.__ttl -= 1
if self.__ttl == 0:
self._running = False
# regular update done x times by seconds
for updatable in self._directory.get(Tags.UPDATABLE):
updatable.update(self.__gettick())
self.__aupdatecounter += 1
if self.__aupdatecounter == Parameters.AGAMETICKS:
self.__aupdatecounter = 0
self._aupdate()
def _aupdate(self):
# alternative (heavy update) every x updates
self._directory.update()
# print self.clock.average_fps
def _draw(self):
self._directory.get_single(Tags.RENDERER).draw(self.__getbetweenframe())
if Parameters.FPSLIMIT:
self.limitclock.tick(Parameters.FPSLIMIT)
def run(self):
clock = Clock()
while True:
clock.tick(50)
for event in pygame.event.get():
if event.type == QUIT:
return
if event.type == KEYDOWN:
return
self.draw(self.screen)
def __init__(self):
self.input = InputHandler()
self.state_manager = GameStateManager()
self.hiscores = Hiscores(resources.get_hiscores(HISCORES_FILENAME))
self.logic_clock = Clock()
self.render_clock = Clock()
self.renderer = Thread(target=self.render_loop, args=())
self.renderer.daemon = True
self.rendering = Lock()
self.running = False
self.screen = None
self.canvas = None
class TaltosGame():
def __init__(self):
pygame.init()
self.clock = Clock()
MusicPlayer.MusicPlayer().playContinously()
self.gameMode = GameMode.GameMode(GameModes.RPG)
self.gameScreen = MainScreen.MainScreen()
self.gameScreen.setScreenMode(self.gameMode.getGameMode())
self.language = Menu.Menu(self.gameScreen.getScreen()).languageChooser()
"""
self.gameModules = {
GameModes.RPG : None,
GameModes.CYBERSPACE : None }
"""
self.changeGameMode(GameModes.RPG)
def changeGameMode(self, newGameMode):
self.gameMode.setGameMode(newGameMode)
self.gameScreen.setScreenMode(self.gameMode.getGameMode())
if self.gameMode.getGameMode() == GameModes.RPG:
self.currentGameModule = Rpg.Rpg(self.gameScreen, self.language)
if self.gameMode.getGameMode() == GameModes.CYBERSPACE:
self.currentGameModule = Cyberspace.Cyberspace(self.gameScreen, self.language)
"""
if self.gameMode.getGameMode() == GameModes.RPG:
if self.gameModules[GameModes.RPG] is None:
self.gameModules[GameModes.RPG] = Rpg.Rpg(self.gameScreen, self.language)
if self.gameMode.getGameMode() == GameModes.CYBERSPACE:
if self.gameModules[GameModes.CYBERSPACE] is None:
self.gameModules[GameModes.CYBERSPACE] = Cyberspace.Cyberspace(self.gameScreen, self.language)
self.currentGameModule = self.gameModules[self.gameMode.getGameMode()]
"""
def gameLoop(self):
while True:
try:
self.clock.tick(30)
self.currentGameModule.handleKeyEvents()
self.currentGameModule.gameLoop()
except MainExceptions.Exit:
exit()
except MainExceptions.ChangeGameMode as gameModeChange:
self.changeGameMode(gameModeChange.newGameMode)
if self.gameMode.getGameMode() == GameModes.RPG:
pygame.display.update()
if self.gameMode.getGameMode() == GameModes.CYBERSPACE:
pygame.display.flip()
def main():
pygame.init()
# pygame.mixer.init()
pygame.mixer.init(frequency=22050, size=8, channels=2, buffer=2048)
from all_notes import AllNotes
allnotes = AllNotes()
from plingpling import Glaspling
pling = Glaspling()
from random_sounds import Random
random = Random()
from beats import Trummor
beats = Trummor()
sounds = {"random": random, "all": allnotes, "pling": pling, "trummor": beats}
if len(sys.argv) < 4:
print "Usage: python sequences.py midi_file track1 sound1 track2 sound2 ..."
print " available sounds: " + str(sounds.keys())
sys.exit(1)
midi_file = sys.argv[1]
tempo = float(sys.argv[2])
our_tracks = sys.argv[3::2]
our_sounds = sys.argv[4::2]
song = midi.read_midifile(midi_file)
clk = Clock()
all_we_need = []
for (tid, soundname) in zip(our_tracks, our_sounds):
track = song[int(tid)]
event = track[0]
tick = event.tick
sound = sounds.get(soundname, pling)
all_we_need.append({"track": track, "event_idx": 0, "event": event, "ticks_left": tick, "play": sound.play})
while True:
ticks_passed = clk.tick() * tempo
if len(all_we_need) == 0:
break
for index, track in enumerate(all_we_need):
advance(track, ticks_passed)
print "Bye bye"
class GameClock(Observable):
"""Keeps track of how fast the game clock runs"""
# Fires when game time advances
# :param dt: Amount of game time that elapsed
@EventType
def REAL_TIME_ADVANCE(dt):
"""Game time has advanced
:param dt: Amount of game time that elapsed, in "seconds"
"""
@EventType
def GAME_TIME_ADVANCE(dt):
"""Real time has passed
:param dt: Amount of real time that elapsed, in milliseconds
"""
def __init__(self, framerate, multiplier=1.0):
super(GameClock, self).__init__()
self.clock = Clock()
self._multiplier = multiplier
self.framerate = framerate
self.isPaused = False
@property
def multiplier(self):
"""Get the real/game time ratio"""
if self.isPaused:
return 0
else:
return self._multiplier
@multiplier.setter
def multiplier(self, multiplier):
"""Get the real/game time ratio"""
self._multiplier = multiplier
def toggle(self):
self.isPaused ^= True
def update(self):
# pygame.time.Clock::tick() returns milliseconds
real_dt = self.clock.tick(self.framerate)
# self.notify(GameClock.REAL_TIME_ADVANCE, real_dt)
game_dt = real_dt * self.multiplier / 1000.0
self.notify(GameClock.GAME_TIME_ADVANCE, game_dt)
def zero(self):
"""Drain any time off the internal clock without calling any updaters"""
real_dt = self.clock.tick(self.framerate)
def main():
"""The main function of the game.
Initializes PyGame objects and then enters the game loop
"""
pygame.init()
screen = pygame.display.set_mode(window_size)
sys_font = Font(get_default_font(), font_size)
clock = Clock()
#now that pygame is initialized, initialize inherited classes properly
global enemy_wave, player
enemy_wave = EnemyGroup(evil_bullets)
player = Player(window_size, ship_filename, ship_speed)
while 1:
#limit framerate and prepare FPS display text
clock.tick(max_framerate)
fps = clock.get_fps()
fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, white)
score_text = sys_font.render("SCORE: {}".format(score), False, white)
lives_text = sys_font.render("MANS: {}".format(lives), False, white)
#check for QUIT event to prevent endless loopage
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
#call the game's thinking functions
check_gameover()
keyboard()
evil_bullets.update()
good_bullets.update()
enemy_wave.update()
collisions()
#draw the stuff
screen.fill(black)
good_bullets.draw(screen)
evil_bullets.draw(screen)
enemy_wave.draw(screen)
screen.blit(player.image, player.rect)
screen.blit(score_text, score_text.get_rect(top = 0, left = 0))
screen.blit(lives_text, lives_text.get_rect(top = 0, centerx = width / 2))
screen.blit(fps_text, fps_text.get_rect(top = 0, right = width))
pygame.display.update()
def __init__(self, framerate, multiplier=1.0):
super(GameClock, self).__init__()
self.clock = Clock()
self._multiplier = multiplier
self.framerate = framerate
self.isPaused = False
def __init__(self, evManager):
self.evManager = evManager
self.evManager.RegisterListener( self )
self.clock = Clock()
self.keepGoing = 1
def start_display_output(self):
""" Start thread for graphical VU meter """
pygame.event.clear()
clock = Clock()
self.meter.start()
while 1:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.exit()
elif event.type == pygame.KEYDOWN or event.type == pygame.KEYUP:
keys = pygame.key.get_pressed()
if (keys[pygame.K_LCTRL] or keys[pygame.K_RCTRL]) and event.key == pygame.K_c:
self.exit()
self.refresh()
clock.tick(1)
def __init__(self):
if Time._instance is None:
Time._instance = self
else:
pass
self._delta_time = 0
self._time_scale = 1
self._clock = Clock()
class Time(object):
"""
A helper class for dealing with time.
"""
_instance = None
def __init__(self):
if Time._instance is None:
Time._instance = self
else:
pass
self._delta_time = 0
self._time_scale = 1
self._clock = Clock()
def update(self):
self._delta_time = self._clock.tick(Configuration.instance().frame_cap )
@property
def delta_time(self):
return self._delta_time / self.time_scale
@property
def time_scale(self):
return self._time_scale
@time_scale.setter
def time_scale(self, time_scale):
self._time_scale = time_scale
@property
def clock(self):
return self._clock
@property
def frame_rate(self):
"""
:return: The frame rate which the game is current running.
"""
return self._clock.get_fps()
@staticmethod
def instance():
if Time._instance is None:
Time._instance = Time()
return Time._instance
def __init__(self, *args, **kargs):
super(TimeLockedState, self).__init__(*args, **kargs)
self._lock = True
self._waited = 0
if not "lock" in kargs.keys():
raise Exception("you must provide an argument named 'lock'.")
self._time_to_wait = kargs["lock"]
self._clock = Clock()
class GetIP:
def __init__(self, height, width):
self._height = height
self._width = width
self.IPtext = ""
self.clock = Clock()
def get_key(self):
while True:
event = pygame.event.poll()
if event.type == KEYDOWN:
return event.key
elif event.type == pygame.QUIT:
exit()
else:
pass
def draw(self, view):
tfont = pygame.font.Font(None, 20)
pygame.draw.rect(view, (0,0,0), ((self._width/2)-100, (self._height/2)-10, 200,20), 0)
pygame.draw.rect(view, (255,255,255), ((self._width/2)-102, (self._height/2)-12, 204,24), 1)
view.blit(tfont.render("IP address: "+ self.IPtext, 1, (255,0,0)), ((self._width/ 2) - 100, (self._height/ 2) - 10))
pygame.display.update()
def get_ip(self,view):
IP = []
self.IPtext = ""
self.draw(view)
while True:
inputkey = self.get_key()
if inputkey == K_BACKSPACE:
IP = IP[0:-1]
elif inputkey == K_RETURN:
break
elif inputkey <=127:
IP.append(chr(inputkey))
self.IPtext = (string.join(IP,""))
self.draw(view)
self.clock.tick(40)
return self.IPtext
def __init__(self):
self.world = World(1024, 768, 0, 0)
self.world.sprites = []
self.clock = Clock()
self.key_binds = {}
self.launchers = []
self.n_launchers = 5
self.world.update()
self.update()
self.create_launchers()
class PygameView():
def __init__(self, model):
init_pygame()
self.screen = set_mode((400, 300))
self.clock = Clock()
self.model = model
def display(self):
self.screen.fill((0, 0, 64)) # dark blue
[draw_rect(self.screen, (0, 191, 255), b) for b in model.borders] # deep sky blue
[draw_rect(self.screen, (255, 192, 203), p) for p in model.pellets] # shrimp
for name, p in model.players.items():
if name != model.myname:
draw_rect(self.screen, (255, 0, 0), p) # red
if model.myname:
draw_rect(self.screen, (0, 191, 255), model.players[model.myname]) # deep sky blue
update_pygame_display()
self.clock.tick(50) # frames per second, independent of server frame rate
def __init__(self, game):
OverlayedState.__init__(self, game)
self.game = game
self.minigame = self.game.minigame(self.game)
self.elapsed_ms = 0
self.duration = self.minigame.get_duration()
self.timer = Clock()
self.minigame.init()
print('In minigame!')
class Game:
#Constants
#Properties
world = None
player = None
display = None
controls = None
clock = None
is_running = False
fps = -1
def __init__(self):
self.world = World()
self.display = Display()
self.controls = Controls()
self.clock = Clock()
self.fps = -1
#self.is_running = False ?
def init(self):
self.display.initWindow()
self.world.loadTextWorld('sample')
self.display.initMinimap(self.world)
self.player = Player(Vector(self.world.starting_point)+0.5)
def startLoop(self):
time_to_exit = False
while not time_to_exit:
self.clock.tick(30)
self.fps = self.clock.get_fps()
keys = self.controls.getInput()
self.player.move(self.world, keys)
self.display.draw(self)
time_to_exit = keys[self.controls.ESCAPE]
def close(self):
self.display.close()
def __init__(self):
global main_window
global surfaces
self.SCREEN_UPDATE = generate_next_event_id()
self.surfaces = []
self.main_window = pygame.display.set_mode((800, 600), pygame.HWSURFACE)
pygame.time.set_timer(self.SCREEN_UPDATE, 1000 / FIX_FPS)
event_handler(self.SCREEN_UPDATE, self.redraw)
event_handler(pygame.QUIT, lambda (event): sys.exit(0))
self.clock = Clock()
class App(object):
def __init__(self):
self.world = World(1024, 768, 0, -0.1)
self.clock = Clock()
self.update()
self.waterfall = WaterFall(self.world, self.world.size_x/2, self.world.size_y/2, angle=0)
def run(self):
while True:
self.dispatch_events()
self.waterfall.update()
self.update()
def update(self):
pygame.display.update()
self.clock.tick(30)
self.world.update()
def dispatch_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
def poll(self):
clock = Clock()
poll()
p = self.m.pellets[0] # always target the first pellet
b = self.m.mybox
if p[0] > b[0]:
cmd = 'right'
elif p[0] + p[2] - 1< b[0]: # p[2] to avoid stuttering left-right movement
cmd = 'left'
elif p[1] > b[1]:
cmd = 'down'
else:
cmd = 'up'
msg = {'input': cmd}
self.client.do_send(msg)
# removes jittery movement
clock.tick(30)
def __init__(self, game, player, prefs):
self.game = game
player.history.setcrier(self._eventcrier)
self._prefs = prefs
self.sprites = LayeredDirty()
self.scale(self._prefs.font)
self.clock = Clock()
self.lasttime = None
self.fps = deque()
def start():
pygame.init()
pygame.display.set_caption("Monkey fever")
pygame.mouse.set_visible(0)
screen = pygame.display.set_mode((468, 60))
clock = Clock()
sounds = {"punch": load_sound("res/punch.wav"),
"whiff": load_sound("res/whiff.wav")
}
q = quidditas.Quidditas()
q.add_type_definitions(type_definitions.get_definitions())
fist_proc = q.add_processor(processors.FistControlProcessor())
punch_proc = q.add_processor(processors.PunchProcessor(sounds))
chimp_proc = q.add_processor(processors.ChimpMovementProcessor())
text_proc = q.add_processor(processors.DrawTextProcessor(screen))
render_proc = q.add_processor(processors.RenderProcessor(screen))
q.create_entity("chimp")
q.create_entity("fist")
running = 1
while running:
for event in pygame.event.get(pygame.QUIT):
running = 0
time = clock.get_time()
q.update(time)
fist_proc.update(time)
punch_proc.update(time)
chimp_proc.update(time)
text_proc.update(time)
render_proc.update(time)
pygame.display.flip()
clock.tick(60)
pygame.quit()
sys.exit()
def main():
bloques = []
world = World(800,600)
clock = Clock()
for n in xrange(0, 240):
x = 20 + (n%20) * 40
y = 20 + (n/20) * 20
bloques.append(Bloque(x, y, world))
barrita = Barrita(400, 500, world)
pelota = Pelota(400, 300, world)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
key = pygame.key.get_pressed()
if key[pygame.K_LEFT]: barrita.mover_izq()
if key[pygame.K_RIGHT]: barrita.mover_der()
if key[pygame.K_UP]: pelota.collide()
world.screen.fill((0,0,0))
barrita.draw()
pelota.draw()
collided = True
if collided and barrita.rect.colliderect(pelota.rect):
pelota.collide()
collided = False
for c in bloques:
if c.drawme:
if collided and c.rect.colliderect(pelota.rect):
pelota.collide()
c.drawme = False
collided = False
c.draw()
collided = True
pygame.display.update()
clock.tick(50)
class Gameloop:
def __init__(self, display_size: Tuple[int, int], display_caption: str):
self.call_update: Optional[Callable[[float], None]] = None
self.call_draw: Optional[Callable[[None], None]] = None
self.level: Optional['Level'] = None
self.keyboard: Optional[Keyboard] = None
pygame.init()
self.display = pygame.display.set_mode(display_size)
self.clock = Clock()
pygame.display.set_caption(display_caption)
def run(self):
self.keyboard = Keyboard()
while True:
pygame.event.pump()
self.keyboard.update()
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
return
self.display.fill((0, 0, 0))
dtms = self.clock.tick()
dt = dtms / 1000.0
self.call_update(dt)
self.call_draw()
pygame.display.update()
def set_level(self, level: 'Level'):
# hook callbacks
self.call_update = level.update
self.call_draw = level.draw
# update static references
level.game = self
self.level = level
# update static references for all components
for ename, entity in level.entities.items():
for comp in entity.components:
comp.level = self.level
comp.game = self
# one time callback
level.start()
def main():
window = create_window()
# create game
clock = Clock()
small_color = 'red'
small_radius = 30
small_center = [50, 75]
small_velocity = [1, 2]
big_color = 'blue'
big_radius = 40
big_center = [200, 100]
big_velocity = [2, 1]
play_game(window, small_color, small_center, small_radius, small_velocity, big_color, big_center, big_radius,
big_velocity, clock)
window.close()
def __init__(self, name, current_theme, field=None):
"""
Make game window
"""
theme.set_theme_module(current_theme)
if field:
theme.FIELD_WIDTH, theme.FIELD_HEIGHT = field
UserInterface.sprites_all = pygame.sprite.LayeredUpdates()
UserInterface.sprites_by_layer = [
pygame.sprite.LayeredUpdates(layer=i)
for i in range(theme.MAX_LAYERS + 1)
]
pygame.init()
screenrect = Rect((0, 0), (theme.FIELD_WIDTH, theme.FIELD_HEIGHT))
self.screen = set_mode(screenrect.size)
set_caption(name)
self.background = pygame.Surface(self.screen.get_size()) # и ее размер
self.background = self.background.convert()
try:
image = load_image(theme.BACKGROUND_IMAGE, -1)
self.background.blit(image, (0, 0))
except (SystemExit, AttributeError):
self.background.fill(theme.BACKGROUND_COLOR) # заполняем цветом
self.clear_screen()
global clock
clock = Clock()
self.fps_meter = Fps(color=(255, 255, 0))
self.game_over_indicator = GameOver()
self._step = 0
self.debug = False
self.game_objects = {}
self.ui_state = UserInput()
self._debug = False
self.child_conn = None
self._game_over = False
def main():
global fire_grp, all_sprites
pygame.init()
screen = pygame.display.set_mode([screen_w, screen_h])
all_sprites = pygame.sprite.Group()
asteroids_grp = pygame.sprite.Group()
fire_grp = pygame.sprite.Group()
player_ship = StarShip()
all_sprites.add(player_ship)
all_sprites.add(fire_grp)
all_sprites.add(asteroids_grp)
all_sprites.add(player_ship)
for i in range(5):
ast = Astroid([screen_w, screen_h])
asteroids_grp.add(ast)
all_sprites.add(ast)
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
running = False
if len(asteroids_grp) < 1:
running = False
screen.fill((0, 0, 0))
move(all_sprites)
draw(all_sprites, screen)
if checkCollid(player_ship, asteroids_grp, fire_grp):
running = False
handle_keys(player_ship)
pygame.display.update()
Clock().tick(FPS)
pygame.quit()
def __init__(self):
self.clock: Clock = Clock()
self.context: Context = Context()
self.context.bar_keeper = BarKeeper(8, 4)
bar_room = BarRoom()
bar_room.sprites.append(
self.context.bar_keeper
)
self.context.rooms[Context.BAR_ROOM] = bar_room
store_room = StoreRoom()
store_room.sprites.append(
self.context.bar_keeper
)
self.context.rooms[Context.STORE_ROOM] = store_room
self.context.set_room(Context.BAR_ROOM)
self.context.sidebar = SideBar()
self.render_context = RenderContext((1920, 1080))
self.running = True
def on_bootstrap(
self,
window_size=None,
display_mode_flags=None,
fps=None,
title=None,
):
self.state.clock = Clock()
self.state.is_running = False
self.state.window_size = tuple(window_size or GAME_DEFAULTS.WINDOW_SIZE)
self.state.fps = fps or GAME_DEFAULTS.FPS
self.state.title = title or GAME_DEFAULTS.TITLE
self.state.delta_t = None
self.state.display_mode_flags = (
reduce(lambda x, y: x | y, display_mode_flags)
if display_mode_flags and len(display_mode_flags) > 1
else (display_mode_flags or pg.DOUBLEBUF)
)
pg.init()
def main():
# Create game
window = create_window()
clock = Clock()
# - Create small dot
small_color = 'red'
small_radius = 20
small_center = [200,100]
small_velocity = [1, 2]
# - Create big dot
big_color = 'blue'
big_radius = 40
big_center = [200,100]
big_velocity = [2, 1]
play_game(window, big_color, big_center, big_radius, big_velocity,
small_color, small_center, small_radius, small_velocity, clock)
window.close()
def update(self):
timer = Clock()
self.image.fill(COLOR)
self.anim.blit(self.image, (0, 0))
if self.up:
self.yvel = -JUMP
self.up = False
self.wasup = True
elif not self.wasup:
self.yvel += GRAVITY
else:
self.wasup = False
#pygame.time.delay(30)
self.rect.y += self.yvel
self.rect.x += SPEED
if (self.rect.y < 0):
self.rect.y = 0
if self.rect.y >= 400:
self.end = True
def __init__(self, row=4, col=19, port=33460):
factor_sim = 40
self.clock = Clock()
self.model = Model(row, col)
self.sim_width = self.model.width * factor_sim
self.sim_height = self.model.height * factor_sim
self.border_thickness = 1
self.cell_height = factor_sim
self.cell_width = factor_sim
self.connection = None
self.channel = None
self.display = None
self.running = False
# Create the Window, load its title, icon
environ['SDL_VIDEO_CENTERED'] = '1'
self.display = display.set_mode((self.sim_width, self.sim_height), 0,
32)
display.set_caption("Arbalet Frontage simulator", "Arbalet")
class Time:
__slots__ = ()
__clock = Clock()
__last_tick_time = 0
__delta_time = 0
time_scale = 1
@staticmethod
def tick() -> None:
cur_time = time()
Time.__delta_time = cur_time - Time.__last_tick_time
Time.__last_tick_time = cur_time
Time.__clock.tick(TARGET_FPS)
@staticmethod
def get_delta_time() -> float:
return Time.__delta_time * Time.time_scale
@staticmethod
def get_fps() -> float:
return 1 / Time.__delta_time if Time.__delta_time != 0 else 1 / TARGET_FPS
def setup(self):
PyGameInit()
set_caption("Pocong runner")
self.screen = set_mode(self.rect.size)
self.load_all_images()
self.base_position = [0, self.rect.height * 0.95]
self.base_diff = self.STONE_IMAGE.get_width(
) - self.BACKGROUND_IMAGE.get_width()
self.player = Player(self.PLAYER_IMAGE, [60, 450])
self.keris_diff = self.KERIS_IMAGE.get_width(
) - self.BACKGROUND_IMAGE.get_width()
self.kerisGroup = PyGameSpriteGroup()
for idx in range(random.randint(1, 2)):
keris_position = [
self.rect.width + random.randint(10, 200),
self.rect.height * 0.80
]
keris = Keris(self.KERIS_IMAGE, keris_position)
keris.rect.bottom += random.randint(100, self.rect.height - 120)
self.kerisGroup.add(keris)
self.bambu_diff = self.BAMBU_IMAGE.get_width(
) - self.BACKGROUND_IMAGE.get_width()
self.bambugroup = PyGameSpriteGroup()
for x in range(random.randint(1, 3)):
self.bambuPosition = [
random.randint(self.rect.width, 1000), self.rect.height * 0.80
]
bambuEnemy = Bambu(self.BAMBU_IMAGE, self.bambuPosition)
self.bambugroup.add(bambuEnemy)
self.health = Health(self.HEALTHBAR_IMAGE, self.HEALTH_IMAGE,
self.rect)
self.score = Score(SCORE_FONT)
self.clock = PyGameclock()
class GameServer(Server):
def __init__(self, host='0.0.0.0', port=9012, max_connection=4):
Server.__init__(self, host, port, max_connection)
self.players = {}
self.clock = Clock()
self.delta = 0
self.fps = 60
self.delay = 1000 / self.fps
def accepting(self, socket):
self.players[socket] = Player()
def recieving(self, socket, data):
if data.startwith(JUMP):
self.players[socket].do_jump()
elif data.startwith(MOVE_LEFT):
self.players[socket].move_left()
elif data.startwith(MOVE_RIGHT):
self.players[socket].move_right()
def disconnect(self, socket):
pass
def broadcasting(self, socket):
pass
def send(self, data):
for player in self.players:
player.send_data.put(data)
def server_loop(self):
for player in self.players:
player.update(self.delta, self.send)
self.delta = self.clock.tick(self.fps)
def start(self):
pygame.init()
screen = display.set_mode(self.size)
display.set_caption(self.title)
clock = Clock()
running = True
clock.tick(self.frame)
__import__('time').sleep(5)
while running:
clock.tick(self.frame)
for event in events.get():
if event.type == pygame.QUIT:
running = False
self.draw(screen)
display.flip()
pygame.quit()
def start_manip_update(self, manipulation):
util.post_piece_manip_ev(manipulation)
if manipulation == g_const.PIECE_MANIP_FALL_DOWN_ID:
self.start_world_update()
return # reset world_manip ticks, but don't change current_manip state
# if manipulation is rotation or strafing
elif manipulation >= g_const.PIECE_MANIP_LEFT_ID and manipulation <= g_const.PIECE_MANIP_CLOCKWISE_ID:
if manipulation <= g_const.PIECE_MANIP_RIGHT_ID: # if manipulation is strafing
if g_const.continue_strafe_while_key_held:
self.is_strafe_rot = True
self.strafe_rot_manip_clock = Clock()
self.strafe_rot_secs = 0 # reset timer
else:
return # don't change current_manip state if action is not repeated
else: # if manipulation is rotating
if g_const.continue_rot_while_key_held:
self.is_strafe_rot = True
self.strafe_rot_manip_clock = Clock()
self.strafe_rot_secs = 0
else:
return
else: # down
if g_const.continue_down_while_key_held:
self.is_world_down = False # not falling to world ticks
self.move_down_manip_clock = Clock()
self.move_down_secs = 0
else:
return
self.current_manip = manipulation
class Game:
def __init__(self):
self._window = Window('Poke the Dots', 500, 400)
self._adjust_window()
self._frame_rate = 90 # larger is faster game
self._close_selected = False
self._clock = Clock()
self._small_dot = Dot('red', [50, 75], 30, [1, 2], self._window)
self._big_dot = Dot('blue', [200, 100], 40, [2, 1], self._window)
self._small_dot.randomize()
self._big_dot.randomize()
self._score = 0
self._continue_game = True
def _adjust_window(self):
self._window.set_font_name('ariel')
self._window.set_font_size(64)
self._window.set_font_color('white')
self._window.set_bg_color('black')
def play(self):
while not self._close_selected:
# play frame
self.handle_events()
self.draw()
self.update()
self._window.close()
def handle_events(self):
event_list = get_events()
for event in event_list:
self.handle_one_event(event)
def handle_one_event(self, event):
if event.type == QUIT:
self._close_selected = True
elif self._continue_game and event.type == MOUSEBUTTONUP:
self.handle_mouse_up(event)
def handle_mouse_up(self, event):
self._small_dot.randomize()
self._big_dot.randomize()
def draw(self):
self._window.clear()
self.draw_score()
self._small_dot.draw()
self._big_dot.draw()
if not self._continue_game: # perform game over actions
self.draw_game_over()
self._window.update()
def update(self):
if self._continue_game:
# update during game
self._small_dot.move()
self._big_dot.move()
self._score = get_ticks() // 1000
self._clock.tick(self._frame_rate)
# decide continue
if self._small_dot.intersects(self._big_dot):
self._continue_game = False
def draw_game_over(self):
string = 'GAME OVER'
font_color = self._small_dot.get_color()
bg_color = self._big_dot.get_color()
original_font_color = self._window.get_font_color()
original_bg_color = self._window.get_bg_color()
self._window.set_font_color(font_color)
self._window.set_bg_color(bg_color)
height = self._window.get_height() - self._window.get_font_height()
self._window.draw_string(string, 0, height)
self._window.set_font_color(original_font_color)
self._window.set_bg_color(original_bg_color)
def draw_score(self):
string = 'Score: ' + str(self._score)
self._window.draw_string(string, 0, 0)
def serve(self):
clock = Clock()
while True:
clock.tick(60)
# check network
events = self.get_events()
if events:
try:
for event in events:
# Update the teams on JOIN and EXIT
if event.type == 'JOIN':
if event.group == 'ctf:dropflag':
for team, flag in self.flags.items():
if flag['owner'] == '':
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x': flag['x'],
'y': flag['y'],
'team': team
}))
elif event.group == 'ctf:gotflag':
for team, flag in self.flags.items():
if flag['owner'] != '':
self.node.shout(
'ctf:gotflag',
bson.dumps({
'uuid': flag['owner'],
'team': team
}))
elif event.group == 'ctf:teams':
self.players.set(self.node.peers())
self.set_teams()
place = self.get_team_from_uuid(
event.peer_uuid)
pos = self.level.get_place(place)
self.node.whisper(
event.peer_uuid,
bson.dumps({
'type': 'teleport',
'x': pos[0],
'y': pos[1]
}))
elif event.type == 'EXIT':
for team, flag in self.flags.items():
if flag['owner'] == str(event.peer_uuid):
# flag owner is leaving, drop
player = self.players.get(event.peer_uuid)
flag['x'] = player.x
flag['y'] = player.y
flag['owner'] = ''
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x': flag['x'],
'y': flag['y'],
'team': team
}))
self.players.set(self.node.peers())
self.set_teams()
elif event.type == 'SHOUT':
if event.group == "world:position":
new_position = bson.loads(event.msg[0])
network_player = self.players.get(
event.peer_uuid)
network_player.set_position(new_position)
# check if flag has been captured
for team, flag in self.flags.items():
if flag['owner'] != str(event.peer_uuid):
continue
tile = self.level.get_tile(
new_position['x'], new_position['y'])
if tile == TileType.RED_BLOCK and team == 'blue':
# TODO: blue's flag has been captured
spawn = Place.BLUE_SPAWN
elif tile == TileType.BLUE_BLOCK and team == 'red':
# TODO: red's flag has been captured
spawn = Place.RED_SPAWN
else:
continue
position = self.level.get_place(spawn)
flag['x'] = position[0]
flag['y'] = position[1]
flag['owner'] = ''
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x': flag['x'],
'y': flag['y'],
'team': team
}))
if event.group == 'ctf:gotflags':
flag_info = bson.loads(event.msg[0])
self.set_flags(flag_info)
elif event.type == 'WHISPER':
msg = bson.loads(event.msg[0])
network_player = self.players.get(event.peer_uuid)
if msg['type'] == 'death_report':
player = self.players.get(event.peer_uuid)
previously_owned_flag = None
if self.flags['blue']['owner'] == str(
event.peer_uuid):
previously_owned_flag = 'blue'
elif self.flags['red']['owner'] == str(
event.peer_uuid):
previously_owned_flag = 'red'
if previously_owned_flag:
flag = self.flags[previously_owned_flag]
flag['owner'] = ''
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x':
player.x,
'y':
player.y,
'team':
previously_owned_flag
}))
place = self.get_team_from_uuid(
event.peer_uuid)
pos = self.level.get_place(place)
self.node.whisper(
event.peer_uuid,
bson.dumps({
'type': 'teleport',
'x': pos[0],
'y': pos[1]
}))
player.x = pos[0]
player.y = pos[1]
except Exception as e:
print(e)
import traceback
print(traceback.format_exc())
pass
for team, flag in self.flags.items():
if flag["owner"] != '': continue
for uuid, player in self.players.players.items():
if flag['x'] == player.x and flag['y'] == player.y:
team_place = self.get_team_from_uuid(uuid)
pos = self.level.get_place(team_place)
if team == 'red' and team_place == Place.RED_SPAWN or team == 'blue' and team_place == Place.BLUE_SPAWN:
if player.x == pos[0] and player.y == pos[1]:
continue
self.node.shout(
'ctf:dropflag',
bson.dumps({
'x': pos[0],
'y': pos[1],
'team': team
}))
else:
flag["owner"] = uuid
self.node.shout(
'ctf:gotflag',
bson.dumps({
'uuid': uuid,
'team': team
}))
break
class Visualization:
def __init__(self, engine):
self.running = True
self.display_surf = None
self.size = self.width, self.height = 800, 600
self.center = self.width / 2, self.height / 2
self.clock = Clock()
self.font = None
self.engine = engine
self.engine.on_simulation_step = self.build_scene
self.scene = []
self.target_fps = 60.0
self.focused_car = 0
self.metadata = []
def on_init(self):
pygame.init()
pygame.font.init()
self.display_surf = pygame.display.set_mode(
self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
self.running = True
self.font = pygame.font.Font(pygame.font.get_default_font(), 12)
self.sprites = [
Sprite("images/blue-small.png"),
Sprite("images/orange-small.png"),
]
self.engine.restart()
def build_scene(self, engine):
self.scene = []
self.metadata = []
# if there are no cars break
if not self.engine.cars or len(self.engine.cars) == 0:
self.scene.append((self.center, 0, self.sprites[0]))
return
if self.focused_car >= len(self.engine.cars):
self.focused_car = 0
center = self.engine.cars[self.focused_car].position
for idx, car in enumerate(self.engine.cars):
car_pos = self.center - (center - car.position) * meter2pixel
self.scene.append(
(car_pos, car._angle, self.sprites[idx % len(self.sprites)]))
self.metadata.append(((int(car_pos.x), int(car_pos.y)), 0))
# for v in car.vertices():
# relpos = self.center - (center-v) * meter2pixel
# self.metadata.append((relpos.astype(np.int), 1))
if car == self.engine.cars[self.focused_car]:
for s in car._sensors:
if isinstance(s, LidarSensor):
for v in s._intersections:
if v is not None:
relpos = self.center - (center -
v) * meter2pixel
self.metadata.append(
(relpos.astype(np.int), 1))
def on_event(self, event):
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYDOWN:
pressed = pygame.key.get_pressed()
if pressed[pygame.K_ESCAPE]:
self.running = False
if pressed[pygame.K_SPACE]:
if self.engine.is_running:
self.engine.interrupt()
else:
self.engine.run()
if pressed[pygame.K_x]:
self.engine.restart()
if pressed[pygame.K_TAB]:
self.move_focus()
def move_focus(self):
self.focused_car += 1
self.build_scene(self.engine)
def on_loop(self):
pass
def on_render(self):
self.display_surf.fill(pygame.Color(0, 0, 0))
for pos, angle, sprite in self.scene:
rotated = pygame.transform.rotate(sprite.image, angle)
rect = rotated.get_rect()
relpos = pos - (rect.width / 2, rect.height / 2)
self.display_surf.blit(rotated, relpos)
for pos, typ in self.metadata:
if typ == 0:
pygame.draw.circle(self.display_surf, (255, 0, 0), pos, 3)
if typ == 1:
pygame.draw.circle(self.display_surf, (0, 255, 0), pos, 3)
# FPS writing
fps_surface = self.font.render(
"{:.0f} FPS".format(self.clock.get_fps()), True, (255, 255, 255))
self.display_surf.blit(
fps_surface,
(self.display_surf.get_width() - fps_surface.get_width(), 0))
# Simulation steps writing
step_surface = self.font.render(
"{} steps".format(self.engine.step_count), True, (255, 255, 255))
self.display_surf.blit(
step_surface,
(self.display_surf.get_width() - step_surface.get_width(),
fps_surface.get_height() + 5))
# Simulation control keys
lines = '''SPACE - start/stop simulation
X - restart simulation
TAB - move focus
ESC - quit'''
y = 5
for line in lines.split('\n'):
text = self.font.render(line.strip(), True, (255, 255, 255))
self.display_surf.blit(text, (5, y))
y += 5 + text.get_height()
pygame.display.flip()
self.clock.tick(self.target_fps)
def on_cleanup(self):
pygame.quit()
def on_execute(self):
if self.on_init() == False:
self.running = False
while (self.running):
for event in pygame.event.get():
self.on_event(event)
self.on_loop()
self.on_render()
self.on_cleanup()
class stateMachine(object):
def __init__(self, *args):
self.states = {}
self.states['null'] = self.nullState = simpleStateObject()
self.activeName = 'null'
self.running = False
self.globals = {}
self.previous = None
self.lastTickState = None
self.next = 'init'
self.flags = set() # tmp
self.autoSwitch = {'null': 'init', 'quit': 'null'}
self.clock = Clock()
def quit(self):
self.running = False
if 'quit' in self.states:
self._next('quit')
def state(self, stateName, stateType='simple'):
def registerState(f):
if stateType == 'simple':
self.states[stateName] = simpleStateObject(f)
try:
thisState = self.states[stateName]
if stateType == 'enter':
thisState.enter = f
self.states[stateName]._strSet.add('enter')
elif stateType == 'tick':
thisState.tick = f
self.states[stateName]._strSet.add('tick')
elif stateType == 'exit':
thisState.exit = f
self.states[stateName]._strSet.add('exit')
except KeyError:
if stateType == 'enter':
self.states[stateName] = stateObject(f)
elif stateType == 'tick':
self.states[stateName] = stateObject(None, f, None)
elif stateType == 'exit':
self.states[stateName] = stateObject(None, None, f)
return f
return registerState
def addState(self, name, enter=None, tick=None, exit=None):
self.states[name] = stateObject(enter, tick, exit)
def removeState(self, name):
del self.states[name]
def switch(self, newState):
self.next = newState
def _next(self, newState):
active = self.states[self.activeName]
if not isinstance(active, simpleStateObject):
active.exit()
print self.activeName,
else:
print '...',
self.previous = self.activeName
if isinstance(active, stateObject):
self.lastTickState = self.activeName
self.activeName = newState
active = self.states[self.activeName]
if not isinstance(active, simpleStateObject):
print '-->', self.activeName, active
active.enter()
try:
self.next = self.autoSwitch[self.activeName]
except KeyError:
self.next = self.activeName
else:
print '-->', self.activeName, active, '...'
active.method()
if self.next is None or self.next == self.activeName:
try:
self.next = self.autoSwitch[self.activeName]
except KeyError:
print ' Error: no switch parameter for simple state:', self.activeName
raise
self._next(self.next)
def run(self):
import game
self.running = True
game.msg.handler('state')(self.switch)
if self.next is not None and self.next != self.activeName:
self._next(self.next)
while self.running and not peek(QUIT):
self.states[self.activeName].tick()
if self.next is not None and self.next != self.activeName:
self._next(self.next)
game.msg('display::update')
game.msg.process()
self.clock.tick(game.fps)
self.quit()
def blit(self, surface):
self.update()
draw.circle(surface, self.color, (int(self.x), int(self.y)), int(self.radius+2), 1)
font.init()
ff = font.Font(None, int(W/100*12.5))
lable_x_positions = (('PRESS', int(W / 100 * 34.6875)),
('ESC', int(W / 100 * 40.625)),
('FOR', int(W / 100 * 40.625)),
('EXIT', int(W / 100 * 38.75)))
lable_start_y = int(W / 100 * 9.375)
mouse.set_visible(False)
square_list = []
timer = Clock()
done = True
while done:
for e in event.get():
if e.type == KEYDOWN:
if e.key == K_ESCAPE:
done = False
screen.fill((30, 30, 70))
# draw lables
for lable in lable_x_positions:
screen.blit(ff.render(lable[0], 1, (50, 50, 70)), (lable[1], lable_start_y * (lable_x_positions.index(lable) + 1)))
if len(square_list) < 500:
for i in range(randint(1, 5)):
class App:
'''
Base application
'''
def __init__(self):
self.surface: Surface = set_mode((settings.width, settings.height))
self.clock = Clock()
self.running = True
self.buttons = []
self.sliders = []
self.components = []
def __call__(self):
while self.running:
for e in get_events():
event: EventType = e
if event.type == QUIT_EVENT:
self.running = False
else:
self.dispatch(event.type, event.dict)
self.surface.fill(settings.colour_scheme.background)
[c.render() for c in self.components]
[b.render() for b in self.buttons]
[s.render() for s in self.sliders]
update_display()
self.clock.tick(60)
pg_quit()
def __iadd__(self, other):
print(f'Attempting to mount component: {other}')
if issubclass(type(other), ComponentBase):
other.mount(self.surface)
if issubclass(type(other), ButtonBase):
self.buttons.append(other)
elif isinstance(other, Slider):
self.sliders.append(other)
else:
self.components.append(other)
else:
raise NotImplementedError(f'Cannot add object of type {type(other)} to an app')
return self
def __isub__(self, other):
if issubclass(type(other), ComponentBase):
if issubclass(type(other), ButtonBase):
self.buttons.remove(other)
elif isinstance(other, Slider):
self.sliders.remove(other)
else:
self.components.remove(other)
return self
def dispatch(self, event_type: Event, event_data: Dict):
if event_type in (MOUSEBUTTONDOWN_EVENT, MOUSEBUTTONUP_EVENT,):
direction = 0 if event_type == MOUSEBUTTONUP_EVENT else 1
x, y = event_data['pos']
button = event_data['button']
if button == 1:
[b(x, y, direction) for b in self.buttons]
[s(x, y, direction) for s in self.sliders]
elif event_type == MOUSEMOTION_EVENT:
button_pressed = event_data['buttons'][0] == 1
x, y = event_data['pos']
if button_pressed:
[s(x, y, 2) for s in self.sliders]
def run(self):
self.prepare_borders()
player_one_side = 'left'
player_two_side = 'right'
player_one_speed = self.window.game.human_speed
player_two_speed = self.window.game.human_speed
player_one_engine = self.player_engine(left_keys)
player_two_engine = self.player_engine(right_keys)
if self.window.game.game_mode == 1:
player_one_side = self.window.game_side()
if player_one_side == 'left':
player_two_side = 'right'
else:
player_two_side = 'left'
player_one_speed = self.window.game.human_speed
player_two_speed = self.window.game.computer_speed
player_two_engine = self.player_engine(())
elif self.window.game.game_mode == 0:
player_one_speed = self.window.game.computer_speed
player_two_speed = self.window.game.computer_speed
player_one_engine = self.player_engine(())
player_two_engine = self.player_engine(())
player_one = Player('human', player_one_side, player_one_engine, player_one_speed)
player_two = Player('computer', player_two_side, player_two_engine, player_two_speed)
self.window.score_manager = ScoreManager(
match=(3, POINTS_TO_WIN),
player_one=player_one,
player_two=player_two
)
self.window.score_board = ScoreBoard(self.window.score_manager)
player_one.pad.borders = self.borders
player_two.pad.borders = self.borders
self.all_sprites.add(player_one.goal)
self.all_sprites.add(player_two.goal)
self.goals.add(player_one.goal)
self.goals.add(player_two.goal)
self.all_sprites.add(player_one.pad)
self.all_sprites.add(player_two.pad)
self.pads.add(player_one.pad)
self.pads.add(player_two.pad)
self.ball.pads = self.pads
self.ball.borders = self.borders
self.ball.goals = self.goals
# Game loop
clock = Clock()
pygame.time.set_timer(COMPUTER_MOVES_EVENT, COMPUTER_MOVES_TIMER_MS)
end_of_match = False
while not end_of_match:
end_of_set = False
while not end_of_set:
for event in pygame.event.get():
if event.type == pygame.QUIT:
end_of_match = True
break
player_one.handle(event)
player_two.handle(event)
pygame.event.pump()
self.all_sprites.update()
# Manage goals
self.ball.manage_goals()
# Game draw
self.window.screen.fill(green)
self.window.score_board.draw(self)
self.all_sprites.draw(self.window.screen)
# Screen update
pygame.display.flip()
if self.window.score_manager.end_of_set():
end_of_set = True
self.window.score_manager.end_set()
self.window.score_manager.new_set()
if self.window.score_manager.end_of_game():
end_of_match = True
clock.tick(FPS)
return 0
from background import Background
from placar import Placar
from som import Som
from player import Player
from enemy import Wooden, Steam
from controle import Controle
from grupos import (
grupo_player,
grupo_enemy,
grupo_objets_player,
grupo_objets_enemy,
All_sprites,
)
tick_enemies = 0
clock = Clock()
background = Background()
som = Som()
placar = Placar()
controle = Controle()
enemylist = [Wooden, Steam]
paralaxe = 0
running = True
stopgame = True
# som.play()
while running:
clock.tick(25)
screen.fill((255, 255, 255))
x = 0
grid_ptr += 15
sq_x += 1
refresh_grid()
else:
win()
elif not FIELD[grid_ptr + x + 1] & 1 << y:
show_col(x, FIELD[grid_ptr + x])
x += 1
abs_x += 1
else:
changed = False
reset()
clock = Clock()
#---------------------------------- MAINLOOP -------------------------------
while True:
changed = False
for event in pygame.event.get():
if event.type == QUIT:
quit_()
elif event.type == KEYDOWN:
if event.key == K_q:
quit_()
if won:
reset()
elif event.key == K_w:
class Loop:
def __init__(self, util: Util, cfg: Config, sfx: SfxHolder, txt: Text,
drawer: Drawer):
self.util = util
self.cfg = cfg
self.sfx = sfx
self.txt = txt
self.drawer = drawer
self.clock = Clock()
def main(self, screen, game: Game) -> bool:
# Dump first tick to ignore past
self.clock.tick(self.cfg.frames_per_second)
while True:
# Get change in time
dt = self.clock.tick(self.cfg.frames_per_second)
# Loop over events (quit, key down, key up)
for event in pg.event.get():
if user_quit(event):
return False
elif event.type == pg.KEYDOWN:
if event.key in self.cfg.all_keys:
game.press_key(event.key)
elif event.type == pg.KEYUP:
if event.key in self.cfg.all_keys:
game.release_key(event.key)
# Move and draw game (with possible paused screen and fps)
if not game.paused:
game.move(dt)
if not game.game_over:
self.drawer.draw_game(screen, game, dt)
if game.paused:
self.drawer.draw_paused_overlay(screen)
if self.cfg.draw_fps:
self.drawer.draw_fps(screen, self.clock.get_fps())
# Update display
pg.display.update()
# Break if game no longer running
if game.game_over:
return True
def game_over(self, screen, game: Game, scores: ScoresList) -> bool:
score_saved = False # not saved yet
self.sfx.game_over.play() # play audio
i = 0
while True:
# Fade-in game over screen
if i < 256:
pg.event.get() # dummy get
self.drawer.draw_game(screen, game, 0) # draw game
self.drawer.draw_game_over_overlay(
screen, i, score_saved) # fade-in game over screen
self.clock.tick(60) # slow-down the fade-in
# Refresh screen
pg.display.flip()
i += 1
# Check for quit or restart events
for event in pg.event.get():
if user_quit(event):
return False
elif event.type == pg.MOUSEBUTTONDOWN:
if self.txt.restart_rect.collidepoint(*event.pos):
return True
elif not score_saved and \
self.txt.save_score_rect.collidepoint(*event.pos):
for score in game.get_scores():
scores.add_score(score)
scores.write()
score_saved = True
def fast_loop(print_lock, state_vector_lock, imu, enc, iss, oss, rss, path,
ctrl):
clock = Clock()
imu_a_x = 0
imu_a_y = 0
p = path.pop(0)
with print_lock:
print(p)
start = time.time()
global x
global P
while True:
period = time.time() - start
actual_freq = 1 / period
# with print_lock:
# print("{}Hz".format(actual_freq))
start = time.time()
dist_to_point = sqrt((x[0][0] - p[0])**2 + (x[2][0] - p[1])**2)
if dist_to_point < dist_thresh:
if path:
p = path.pop(0) # get the next point on the path
with print_lock:
print(p)
else:
with print_lock:
print("Reached Goal")
ctrl.move('stop')
break
phi = ctrl.get_phi(x, p)
# with print_lock:
# print(np.degrees(phi))
a, b = ctrl.p_control(phi)
# with print_lock:
# print("A: {}, B: {}".format(a, b))
# State Estimation Code
# imu_theta = imu.euler[0]
# z_i = iss.measure_state(x, imu_a_x, imu_a_y, imu_theta)
# imu_a_x = imu.linear_acceleration[2]
# imu_a_y = imu.linear_acceleration[1]
l_ticks, r_ticks = enc.get_ticks() # ticks = encoder counts
l_ticks, r_ticks = oss.clean_input(l_ticks,
r_ticks) # removes noise if present
z_o = oss.measure_state(x, l_ticks, r_ticks)
#Kalman Filter
# State Propagation
with state_vector_lock:
x, P = kalman.predict(x, P, rss.A,
rss.Q) # can pass B, u as if you want...
# IMU Update
# with state_vector_lock:
# x, P = kalman.update(x, P, z_i, iss.H, iss.R)
# Odometry Update
with state_vector_lock:
x, P = kalman.update(x, P, z_o, oss.H, oss.R)
# with print_lock:
# print(x)
xx = x[0][0]
xy = x[2][0]
xt = x[4][0]
log_data(write_file, [xx, xy, xt])
# Path correction control code
#with path_planning_lock:
# run control code based on position estimate and current planned path
# does this need to run every loop?
# Actuate motors
#rc_robot.actuate(args)
clock.tick(
freq
) # limits the loop to "freq" fps - stops unnecessary processing power being used
class Game:
"""Object handling main loop and IO."""
def __init__(self, config):
pygame.mixer.pre_init(frequency=44100)
pygame.init()
self.headless = config.headless and config.server
if config.muted or self.headless:
pygame.mixer.quit()
else:
pygame.mixer.music.load(NOISE if config.space else MUSIC)
pygame.mixer.music.set_volume(config.musicvol)
pygame.mixer.music.play(-1)
pygame.display.set_icon(ICON)
if config.server:
self.server = socket()
self.server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.server.bind((config.host, config.port))
self.server.listen(1)
print('Socket server is listening on {}:{}'.format(config.host,
config.port))
self.timeout = config.timeout
self.sockinp = 0, 0, -pi * 3 / 4, 0, 0 # freeze and point to NW
else:
self.server = self.sockinp = None
# self.fps is a float to make sure floordiv won't be used in Python 2
self.max_fps, self.fps = config.max_fps, float(config.max_fps)
self.musicvol = config.musicvol
self.key, self.mouse = config.key, config.mouse
self.maze = Maze(config.max_fps, config.size, config.headless,
config.export_dir, 1000.0 / config.export_rate)
self.hero = self.maze.hero
self.clock, self.paused = Clock(), False
def __enter__(self): return self
def export_txt(self):
"""Export maze data to string."""
export = self.maze.update_export(forced=True)
return '{} {} {} {}\n{}{}{}{}'.format(
len(export['m']), len(export['e']), len(export['b']), export['s'],
''.join(row + '\n' for row in export['m']), join(export['h']),
''.join(map(join, export['e'])), ''.join(map(join, export['b'])))
def update(self):
"""Draw and handle meta events on Pygame window.
Return False if QUIT event is captured, True otherwise.
"""
events = pygame.event.get()
for event in events:
if event.type == QUIT:
return False
elif event.type == VIDEORESIZE:
self.maze.resize((event.w, event.h))
elif event.type == KEYDOWN:
if event.key == self.key['mute']:
if pygame.mixer.get_init() is None:
pygame.mixer.init(frequency=44100)
pygame.mixer.music.load(MUSIC)
pygame.mixer.music.set_volume(self.musicvol)
pygame.mixer.music.play(-1)
else:
pygame.mixer.quit()
elif not self.server:
if event.key == self.key['new']:
self.maze.reinit()
elif event.key == self.key['pause'] and not self.hero.dead:
self.paused ^= True
# Compare current FPS with the average of the last 10 frames
new_fps = self.clock.get_fps()
if new_fps < self.fps:
self.fps -= 1
elif self.fps < self.max_fps and not self.paused:
self.fps += 5
if not self.paused: self.maze.update(self.fps)
if not self.headless: self.maze.draw()
self.clock.tick(self.fps)
return True
def move(self, x, y):
"""Command the hero to move faster in the given direction."""
maze = self.maze
velocity = maze.distance * HERO_SPEED / self.fps
accel = velocity * HERO_SPEED / self.fps
if x == y == 0:
maze.set_step()
x, y = maze.stepx, maze.stepy
else:
x, y = -x, -y # or move the maze in the reverse direction
if maze.next_move > 0 or not x:
maze.vx -= sign(maze.vx) * accel
if abs(maze.vx) < accel * 2: maze.vx = 0.0
elif x * maze.vx < 0:
maze.vx += x * 2 * accel
else:
maze.vx += x * accel
if abs(maze.vx) > velocity: maze.vx = x * velocity
if maze.next_move > 0 or not y:
maze.vy -= sign(maze.vy) * accel
if abs(maze.vy) < accel * 2: maze.vy = 0.0
elif y * maze.vy < 0:
maze.vy += y * 2 * accel
else:
maze.vy += y * accel
if abs(maze.vy) > velocity: maze.vy = y * velocity
def control(self, x, y, angle, firing, slashing):
"""Control how the hero move and attack."""
self.move(x, y)
self.hero.update_angle(angle)
self.hero.firing = firing
self.hero.slashing = slashing
def remote_control(self):
"""Handle remote control though socket server.
This function is supposed to be run in a Thread.
"""
clock = Clock()
while True:
connection, address = self.server.accept()
connection.settimeout(self.timeout)
time = get_ticks()
print('[{}] Connected to {}:{}'.format(time, *address))
self.maze.reinit()
while True:
if self.hero.dead:
connection.send('0000000'.encode())
break
data = self.export_txt().encode()
alpha = deg(self.hero.angle)
connection.send('{:07}'.format(len(data)).encode())
connection.send(data)
try:
buf = connection.recv(7)
except: # client is closed or timed out
break
if not buf: break
try:
move, angle, attack = map(int, buf.decode().split())
except ValueError: # invalid input
break
y, x = (i - 1 for i in divmod(move, 3))
# Time is the essence.
angle = self.hero.angle if angle == alpha else radians(angle)
self.sockinp = x, y, angle, attack & 1, attack >> 1
clock.tick(self.fps)
self.sockinp = 0, 0, -pi * 3 / 4, 0, 0
new_time = get_ticks()
print('[{0}] {3}:{4} scored {1} points in {2}ms'.format(
new_time, self.maze.get_score(), new_time - time, *address))
connection.close()
if not self.hero.dead: self.maze.lose()
def user_control(self):
"""Handle direct control from user's mouse and keyboard."""
if not self.hero.dead:
keys = pygame.key.get_pressed()
right = keys[self.key['right']] - keys[self.key['left']]
down = keys[self.key['down']] - keys[self.key['up']]
buttons = pygame.mouse.get_pressed()
try:
autove = keys[self.key['autove']]
except KeyError:
autove = buttons[self.mouse['autove']]
try:
firing = keys[self.key['shot']]
except KeyError:
firing = buttons[self.mouse['shot']]
try:
slashing = keys[self.key['slash']]
except KeyError:
slashing = buttons[self.mouse['slash']]
# Follow the mouse cursor
x, y = pygame.mouse.get_pos()
maze = self.maze
if right or down:
maze.destx = maze.desty = MIDDLE
maze.stepx = maze.stepy = 0
elif autove:
maze.destx, maze.desty = maze.get_grid(x, y)
maze.set_step(maze.is_displayed)
if maze.stepx == maze.stepy == 0:
maze.destx = maze.desty = MIDDLE
angle = atan2(y - self.hero.y, x - self.hero.x)
self.control(right, down, angle, firing, slashing)
def __exit__(self, exc_type, exc_value, traceback):
if self.server is not None: self.server.close()
if not self.hero.dead: self.maze.dump_records()
pygame.quit()
def play(self):
set_repeat(1, 1)
timer = Clock()
while not self.end:
for event in get():
if event.type == QUIT:
exit()
if event.type == KEYDOWN:
k = event.key
if k == K_ESCAPE:
self.game_pause()
if k == K_DOWN:
self.hero.rotate(0)
self.hero.ismoved = True
if k == K_UP:
self.hero.rotate(1)
self.hero.ismoved = True
if k == K_RIGHT:
self.hero.rotate(2)
self.hero.ismoved = True
if k == K_LEFT:
self.hero.rotate(3)
self.hero.ismoved = True
if k == K_SPACE:
self.hero.place_bomb(self.sprites_and_bombs)
elif event.type == KEYUP and event.key != 32:
self.hero.ismoved = False
for m in self.mobs:
m.strategy()
self.screen.fill(self.color)
self.grass.update(self.screen)
self.bonuses.update(self.screen)
self.sprites.update(self.screen)
self.hero.update(self.screen, self.sprites)
self.mobs.update(self.screen, self.sprites_and_bombs)
self.show_info()
update()
killed = False
clock = get_ticks()
for ex in self.hero.explosions:
if clock + 780 < ex.clear_time:
for m in self.mobs:
if collide_rect(m, ex):
self.scores += 15
m.kill()
if collide_rect(self.hero, ex):
killed = True
if killed or self.hero.collide(self.mobs):
self.death()
if self.end:
break
else:
for bon in self.bonuses:
if bon.visible() and collide_rect(self.hero, bon):
if bon.type == 4:
self.lives += 1
elif bon.type == 5:
self.max_bombs += 1
self.hero.max_bombs += 1
elif bon.type == 6:
self.strength += 1
self.hero.strength += 1
bon.remove(self.bonuses)
self.scores += 10
if len(self.mobs) == 0:
self.lvl += 1
self.scores += 20
self.load_level()
timer.tick(self.fps)
def __init__(self):
"""Initialization of GameState."""
# Level1State()
game = Game()
folder = os.path.dirname(os.path.realpath(__file__))
(width, height) = (ScreenSize.WIDTH.value, ScreenSize.HEIGHT.value)
screen = pygame.display.set_mode((width, height))
background_colour = (0, 0, 0)
screen.fill(background_colour)
font = pygame.font.SysFont("monospace", 40, True)
level_label = font.render("Level: " + str(game.level), 1,
(255, 255, 255))
points_label = font.render(
"Points: " + str(game.board.number_of_touched_tiles), 1,
(255, 255, 255))
hp_label = font.render("Hp: " + str(game.player.hp), 1,
(255, 255, 255))
screen.blit(level_label, (0, 0))
screen.blit(points_label, (0, 50))
screen.blit(hp_label, (0, 100))
board_dis = BoardDisplay(game.board)
board_dis.display_board(screen)
chicken_image = pygame.image.load(
os.path.join(folder, "chickenFront.png"))
ball_image = pygame.image.load(os.path.join(folder, "ball.png"))
snake_image = SnakeImage()
screen.blit(chicken_image, game.chicken.position)
pygame.display.flip()
FALL_DOWN_BALL = USEREVENT + 1
MOVE_SNAKE = USEREVENT + 2
pygame.time.set_timer(FALL_DOWN_BALL, 1500)
pygame.time.set_timer(MOVE_SNAKE, 1500)
clock = Clock()
running = True
not_frozen = True
while running:
for e in pygame.event.get():
if e.type == QUIT:
sys.exit(0)
elif e.type == KEYDOWN and not_frozen:
controler = ChickenControl()
possible_move = controler.move_chicken(
game.chicken, e.key, game.board)
if possible_move is None:
continue
tile = game.handle_level(possible_move)
if_collision = False
if tile == "NO_MORE_HP":
self.handle_lose(font, game, screen)
not_frozen = False
continue
if tile == "ONE_HP_LOST":
game.move_chicken_to_start_position()
else:
if_collision = game.check_collision_with_villains()
if not if_collision:
game.handle_touch_tile(tile)
tileControl = TileControl()
tileControl.change_color(tile, board_dis)
self.display_screen(font, background_colour, ball_image,
board_dis, chicken_image, game,
level_label, snake_image, screen)
if_lose = False
if if_collision:
if_lose = game.handle_collision_with_villain()
pygame.time.wait(500)
if if_lose:
self.handle_lose(font, game, screen)
not_frozen = False
continue
self.display_screen(font, background_colour, ball_image,
board_dis, chicken_image, game,
level_label, snake_image, screen)
if game.if_win():
if game.level == 3:
lose_label = font.render(
"Congratulations. You win! :) ", 1,
(255, 255, 255))
final_points = font.render(
"You score: " +
str(game.board.number_of_touched_tiles), 1,
(255, 255, 255))
screen.blit(lose_label, (350.5, 0))
screen.blit(final_points, (400.5, 50))
pygame.display.flip()
sys.exit(0)
else:
pygame.time.set_timer(FALL_DOWN_BALL, 0)
pygame.time.set_timer(MOVE_SNAKE, 0)
game.next_level()
game.board_for_next_level()
board_dis = BoardDisplay(game.board)
pygame.time.set_timer(FALL_DOWN_BALL, 1500)
pygame.time.set_timer(MOVE_SNAKE, 1500)
continue
elif e.type == FALL_DOWN_BALL and not_frozen:
if len(game.list_of_villains) != 0:
for villain in game.list_of_villains:
if_ball_need_to_fall_down = villain.move_down(
game.board)
if if_ball_need_to_fall_down:
game.list_of_villains.remove(villain)
self.display_screen(font, background_colour,
ball_image, board_dis,
chicken_image, game, level_label,
snake_image, screen)
if_collision = game.check_collision_with_villains()
if if_collision:
if_lose = game.handle_collision_with_villain()
if if_lose:
self.handle_lose(font, game, screen)
if len(game.list_of_villains
) < game.max_number_of_villains:
if_create_new_villain = random.randint(0, 10) % 2
if if_create_new_villain == 1:
game.add_villain()
self.display_screen(font, background_colour,
ball_image, board_dis,
chicken_image, game, level_label,
snake_image, screen)
continue
elif e.type == MOVE_SNAKE and not_frozen:
if game.snake is None:
if_create_new_villain = random.randint(0, 100) % 3
if if_create_new_villain == 1:
game.add_snake()
snake_image = SnakeImage()
else:
continue
else:
game.move_snake()
if not game.snake.if_ball:
snake_image.change_ball_into_snake()
self.display_screen(font, background_colour,
ball_image, board_dis,
chicken_image, game, level_label,
snake_image, screen)
if_collision = game.check_collision_with_villains()
if if_collision:
if_lose = game.handle_collision_with_villain()
if if_lose:
self.handle_lose(font, game, screen)
not_frozen = False
class SimEngine:
auto_setup = None
event = None
fps = 60
values = None
simple_gui = None
world = None
def __init__(self,
gui_left_upper,
caption="Basic Model",
gui_right_upper=None,
patch_size=11,
board_rows_cols=(51, 51),
clear=None,
bounce=None,
fps=None):
# Constants for the main loop in start() below.
self.CTRL_D = 'D:68'
self.CTRL_d = 'd:68'
self.ESCAPE = 'Escape:27'
self.NORMAL = 'normal'
self.Q = 'Q'
self.q = 'q'
self.clock = Clock()
SimEngine.fps = fps if fps else 60
self.idle_fps = 10
SimEngine.simple_gui = SimpleGUI(gui_left_upper,
caption=caption,
gui_right_upper=gui_right_upper,
patch_size=patch_size,
board_rows_cols=board_rows_cols,
clear=clear,
bounce=bounce,
fps=fps)
self.graph_point = None
@staticmethod
def draw_world():
""" Fill the screen with the background color, draw the world, and update the display. """
SimEngine.simple_gui.fill_screen()
SimEngine.world.draw()
pg.display.update()
@staticmethod
def gui_get(key):
"""
Widgets typically have a 'disabled' property. The following makes
it possible to use 'enabled' as the negation of 'disabled'.
"""
if not SimEngine.values:
(SimEngine.event, SimEngine.values) = gui.WINDOW.read(timeout=10)
value = SimEngine.values.get(
key, None) if key != 'enabled' else not SimEngine.values.get(
'disabled', None)
return int(value) if value != float('inf') and isinstance(
value, float) and value == int(value) else value
@staticmethod
def gui_set(key, **kwargs):
"""
Widgets typically have a 'disabled' property. The following makes
it possible to use 'enabled' as the negation of 'disabled'.
"""
if 'enabled' in kwargs:
value = kwargs.get('enabled')
kwargs['disabled'] = not bool(value)
kwargs.pop('enabled')
widget = gui.WINDOW[key]
widget.update(**kwargs)
def model_loop(self):
# Run this loop until the model signals it is finished or until the user stops it by pressing the Stop button.
while True:
(SimEngine.event, SimEngine.values) = gui.WINDOW.read(timeout=10)
if SimEngine.event in (None, SimEngine.simple_gui.EXIT):
return SimEngine.simple_gui.EXIT
self.set_grab_anywhere(self.gui_get('Grab'))
if SimEngine.event == FPS:
SimEngine.fps = SimEngine.gui_get(FPS)
if SimEngine.event.startswith(SimEngine.simple_gui.GRAPH):
SimEngine.world.mouse_click(SimEngine.values['-GRAPH-'])
if SimEngine.event == GOSTOP:
SimEngine.gui_set(GO_ONCE, enabled=True)
break
elif SimEngine.world.done:
SimEngine.gui_set(GOSTOP, enabled=True)
SimEngine.gui_set(GO_ONCE, enabled=True)
break
elif SimEngine.event == '__TIMEOUT__':
# This increments the World's tick counter for the number of times we have gone around this loop.
# Examples.starburst uses it to decide when to "explode." Look at its step method.
SimEngine.world.increment_ticks()
# Take a step in the simulation.
SimEngine.world.step()
# This line limits how fast the simulation runs. It is not a counter.
self.clock.tick(SimEngine.fps)
else:
SimEngine.world.handle_event(SimEngine.event)
SimEngine.draw_world()
return self.NORMAL
@staticmethod
def set_grab_anywhere(allow_grab_anywhere):
if allow_grab_anywhere:
gui.WINDOW.grab_any_where_on()
else:
gui.WINDOW.grab_any_where_off()
def top_loop(self, the_world, auto_setup=False):
SimEngine.world = the_world
SimEngine.draw_world()
SimEngine.auto_setup = auto_setup
# Let events come through pygame to this level.
pg.event.set_grab(False)
while SimEngine.event not in [
self.ESCAPE, self.q, self.Q, self.CTRL_D, self.CTRL_d
]:
(SimEngine.event, SimEngine.values) = gui.WINDOW.read(timeout=10)
if SimEngine.event in (None, SimEngine.simple_gui.EXIT):
gui.WINDOW.close()
break
self.set_grab_anywhere(self.gui_get('Grab'))
if SimEngine.event == FPS:
SimEngine.fps = SimEngine.gui_get(FPS)
if not SimEngine.auto_setup and SimEngine.event == '__TIMEOUT__':
continue
if SimEngine.event.startswith(SimEngine.simple_gui.GRAPH):
SimEngine.world.mouse_click(SimEngine.values['-GRAPH-'])
elif SimEngine.auto_setup or SimEngine.event == SimEngine.simple_gui.SETUP:
gui_set(SimEngine.simple_gui.SETUP, enabled=False)
gui_set(GO_ONCE, enabled=False)
SimEngine.world.reset_all()
returned_value = SimEngine.world.setup()
gui_set(SimEngine.simple_gui.SETUP, enabled=True)
gui_set(GOSTOP,
text='go',
button_color=('white', 'green'),
enabled=True)
gui_set(GO_ONCE, enabled=True)
SimEngine.auto_setup = False
if returned_value == SimEngine.simple_gui.EXIT:
gui.WINDOW.close()
break
elif SimEngine.event == GO_ONCE:
SimEngine.gui_set(GOSTOP,
text='stop',
button_color=('white', 'red'),
enabled=False)
SimEngine.gui_set(GO_ONCE, enabled=False)
SimEngine.gui_set(SimEngine.simple_gui.SETUP, enabled=False)
SimEngine.world.increment_ticks()
SimEngine.world.step()
SimEngine.gui_set(SimEngine.simple_gui.SETUP, enabled=True)
SimEngine.gui_set(GOSTOP,
text='go',
button_color=('white', 'green'),
enabled=True)
SimEngine.gui_set(GO_ONCE, enabled=True)
elif SimEngine.event == GOSTOP:
SimEngine.gui_set(GOSTOP,
text='stop',
button_color=('white', 'red'))
SimEngine.gui_set(GO_ONCE, enabled=False)
SimEngine.gui_set(SimEngine.simple_gui.SETUP, enabled=False)
returned_value = self.model_loop()
SimEngine.gui_set(GOSTOP,
text='go',
button_color=('white', 'green'),
enabled=True)
SimEngine.gui_set(GO_ONCE, enabled=True)
SimEngine.gui_set(SimEngine.simple_gui.SETUP, enabled=True)
SimEngine.world.final_thoughts()
if returned_value == SimEngine.simple_gui.EXIT:
gui.WINDOW.close()
break
else:
# For anything else, e.g., a button the user defined.
SimEngine.world.handle_event(SimEngine.event)
SimEngine.draw_world()
self.clock.tick(self.idle_fps)
def __init__(self, player: Player, speed):
threading.Thread.__init__(self)
self.player = player
self.speed = speed
self.clock = Clock()
