def update(self):
v = self.velocity
mass = self.mass
F = mass * 200
self.force += Vec2d(0, -mass * 200)
# Resetar o jogador
if pyxel.btnp(pyxel.KEY_R):
self.body.position = (WIDTH / 2, HEIGHT / 2)
v = Vec2d(0, 0)
# Controles
if pyxel.btn(pyxel.KEY_LEFT):
if self.can_jump and self.remaining_jumps > 0:
v = Vec2d(-self.SPEED, v.y)
elif v.x <= 0:
v = Vec2d(-self.SPEED / 2, v.y)
elif pyxel.btn(pyxel.KEY_RIGHT):
if self.can_jump and self.remaining_jumps > 0:
v = Vec2d(+self.SPEED, v.y)
elif v.x <= 0:
v = Vec2d(+self.SPEED / 2, v.y)
else:
r = 0.5 if self.can_jump else 1.0
v = Vec2d(v.x * r, v.y)
if (pyxel.btnp(pyxel.KEY_UP) and self.can_jump
and self.remaining_jumps > 0):
v = Vec2d(v.x, self.JUMP_SPEED)
self.remaining_jumps -= 1
elif (pyxel.btnp(pyxel.KEY_DOWN)
and self.remaining_jumps < self.NUMBER_JUMPS):
v = Vec2d(v.x, -self.JUMP_SPEED)
self.velocity = v
def update (self):
v = self.velocity
mass = self.mass
F = mass * 200
self.force += Vec2d(0, -mass * 200)
if pyxel.btnp(pyxel.KEY_R):
self.particles.emmit(self.position, self.velocity)
self.position = (self.INIT_X, self.INIT_Y)
v = Vec2d(0,0)
self.velocity = v
def __init__(self, scenario=utils.SCENARIO):
self.camera = phys.Camera(flip_y=True)
self.space = phys.space(
gravity=(0, -25),
wireframe=True,
camera=self.camera,
elasticity=1.0,
)
# Inicializa o jogo
self.state = utils.GameState.RUNNING
pyxel.load("assets.pyxres")
# Cria jogador
self.my_player = player.Player(50, 50)
self.my_player.register(self.space, self.message)
# Cria chão
f = phys.rect(0, 0, 1000, 48, body_type="static")
# Cria cenário
for line in march_string(scenario,
"=",
scale=8.0,
translate=Vec2d(0.0, 48),
flip_y=True):
line = [Vec2d(2 * x, y) for (x, y) in line]
phys.poly(line, body_type="static", color=pyxel.COLOR_PEACH)
# Cria sensor para condição de vitória
phys.rect(
1000 - 16,
48,
16,
16,
collision_type=utils.ColType.TARGET,
sensor=True,
body_type="static",
)
# Cria margens
phys.margin(0, 0, 1000, utils.HEIGHT)
# Cria inimigos
for _ in range(self.N_ENEMIES):
my_enemy = enemy.Enemy.random(0, 1000, utils.HEIGHT / 2,
utils.HEIGHT)
my_enemy.register(self.space, self.message)
def make_floor(self, x, y, step, dy):
body = self.space.static_body
a = Vec2d(x, y)
for _ in range(self.FLOOR_N):
b = a + (step, random.uniform(-dy, dy))
body.create_segment(a, b, 1, collision_type=self.FLOOR_COL_TYPE)
a = b
def update(self):
v = self.velocity
mass = self.mass
F = mass * 200
self.force += Vec2d(0, -mass * 200)
# Resetar o jogador
if pyxel.btnp(pyxel.KEY_R):
self.body.position = (WIDTH / 2, HEIGHT / 2)
v = Vec2d(0, 0)
# Controles
#ESQUERDA E DIREITA
if pyxel.btn(self.CONTROLS[0]):
if self.can_jump and self.remaining_jumps > 0:
v = Vec2d(-self.SPEED, v.y)
elif v.x <= 0:
v = Vec2d(-self.SPEED / 2, v.y)
sfx_player_walk()
elif pyxel.btn(self.CONTROLS[1]):
if self.can_jump and self.remaining_jumps > 0:
v = Vec2d(+self.SPEED, v.y)
elif v.x <= 0:
v = Vec2d(+self.SPEED / 2, v.y)
sfx_player_walk()
else:
r = 0.5 if self.can_jump else 1.0
v = Vec2d(v.x * r, v.y)
#PULO E DESCER RÁPIDO
if (pyxel.btnp(self.CONTROLS[2]) and self.can_jump
and self.remaining_jumps > 0):
v = Vec2d(v.x, self.JUMP_SPEED)
self.remaining_jumps -= 1
sfx_sound_player_jump()
elif (pyxel.btnp(self.CONTROLS[3])
and self.remaining_jumps < self.NUMBER_JUMPS):
v = Vec2d(v.x, -self.JUMP_SPEED)
self.velocity = v
def update(self):
v = self.velocity
mass = self.mass
F = mass * 200
self.force += Vec2d(0, -mass * 200)
if pyxel.btn(pyxel.KEY_LEFT):
if self.can_jump:
v = Vec2d(-self.SPEED, v.y)
elif v.x <= 0:
v = Vec2d(-self.SPEED / 2 / 2, v.y)
elif pyxel.btn(pyxel.KEY_RIGHT):
if self.can_jump:
v = Vec2d(+self.SPEED, v.y)
elif v.x <= 0:
v = Vec2d(+self.SPEED / 2, v.y)
else:
r = 0.5 if self.can_jump else 1.0
v = Vec2d(v.x * r, v.y)
if self.can_jump and pyxel.btnp(pyxel.KEY_UP):
v = Vec2d(v.x, self.JUMP_SPEED)
self.velocity = v
class Game:
PLAYER_SHAPE = [(0, 6), (-3, -3), (+3, -3)]
METEOR_SHAPE = [(-2, 0), (0, -7), (2, 0)]
BASE_SHAPE = (25, 5)
PLAYER_SPEED = 90
PLAYER_COLOR = pyxel.COLOR_PINK
BASE_COLOR = pyxel.COLOR_ORANGE
GRAVITY = Vec2d(0, -25)
THRUST = -3 * GRAVITY
ANGULAR_VELOCITY = 180
FLOOR_STEP = 30
FLOOR_DY = 15
FLOOR_N = 42
PLAYER_COL_TYPE = 1
BASE_COL_TYPE = 2
FLOOR_COL_TYPE = 3
METEOR_COL_TYPE = 4
MAX_IMPULSE = 30
def __init__(self):
self.space = space = phys.space(
gravity=self.GRAVITY,
camera=phys.Camera(flip_y=True),
friction=1,
)
self.landed = False
self.victory = False
self.explosion = False
# Cria jogador
self.player = space.create_poly(
self.PLAYER_SHAPE,
mass=1,
moment=2,
position=SCREEN / 2,
friction=1.0,
collision_type=self.PLAYER_COL_TYPE,
filter=ShapeFilter(group=1),
)
self.particles = Particles(space)
self.explosion_particles = ExplosionParticles(space)
# Cria base
dx = random.uniform(-WIDTH, WIDTH)
self.base = space.create_box(
self.BASE_SHAPE,
position=self.player.position + (dx, -0.45 * HEIGHT),
friction=1.0,
collision_type=self.BASE_COL_TYPE,
body_type=Body.STATIC,
)
self.meteor = []
for _ in range(1000):
# Cria meteoros
meteor_x = random.randint(-1500, 1500)
meteor_y = random.randint(100, 3000)
self.meteor.append(
self.space.create_poly(
self.METEOR_SHAPE,
mass=1,
moment=2,
position=self.player.position + (meteor_x, meteor_y),
friction=1.0,
collision_type=self.METEOR_COL_TYPE,
))
# Cria chão
shape = list(self.base.shapes)[0]
bb = shape.cache_bb()
self.make_floor(bb.right, bb.bottom, self.FLOOR_STEP, self.FLOOR_DY)
self.make_floor(bb.left, bb.bottom, -self.FLOOR_STEP, self.FLOOR_DY)
# Escuta colisões entre base/chão e jogador
space.collision_handler(self.PLAYER_COL_TYPE,
self.BASE_COL_TYPE,
post_solve=self.on_land)
self.space.collision_handler(self.PLAYER_COL_TYPE,
self.FLOOR_COL_TYPE,
begin=self.on_collision)
self.space.collision_handler(self.PLAYER_COL_TYPE,
self.METEOR_COL_TYPE,
begin=self.on_collision)
def on_collision(self, arb: Arbiter):
if not self.landed:
self.explosion = True
self.landed = True
self.victory = False
return True
def on_land(self, arb: Arbiter):
if not self.landed:
self.victory = arb.total_impulse.length < self.MAX_IMPULSE
self.landed = True
def make_floor(self, x, y, step, dy):
body = self.space.static_body
a = Vec2d(x, y)
for _ in range(self.FLOOR_N):
b = a + (step, random.uniform(-dy, dy))
body.create_segment(a, b, 1, collision_type=self.FLOOR_COL_TYPE)
a = b
def update(self):
if not self.landed:
if pyxel.btn(pyxel.KEY_LEFT):
self.player.angular_velocity = +self.ANGULAR_VELOCITY
elif pyxel.btn(pyxel.KEY_RIGHT):
self.player.angular_velocity = -self.ANGULAR_VELOCITY
else:
self.player.angular_velocity = 0.0
if pyxel.btn(pyxel.KEY_UP):
self.player.apply_force_at_local_point(4 * self.THRUST)
for _ in range(2):
self.particles.emmit(
position=self.player.local_to_world(
(random.uniform(-2, 2), -3)),
velocity=-random.uniform(50, 90) *
self.player.rotation_vector.perpendicular(),
)
elif self.landed and self.explosion:
for x in range(-10, 10):
self.explosion_particles.emmit(
position=self.player.local_to_world((x, x)),
velocity=1 * self.player.rotation_vector.perpendicular(),
)
self.explosion_particles.emmit(
position=self.player.local_to_world((-x, -x)),
velocity=1 * self.player.rotation_vector.perpendicular(),
)
self.explosion_particles.emmit(
position=self.player.local_to_world((x, -x)),
velocity=1 * self.player.rotation_vector.perpendicular(),
)
self.explosion_particles.emmit(
position=self.player.local_to_world((-x, x)),
velocity=1 * self.player.rotation_vector.perpendicular(),
)
self.explosion = False
dt = 1 / FPS
self.particles.update()
self.explosion_particles.update()
self.space.step(dt, sub_steps=4)
self.space.camera.follow(self.player.position)
def draw(self):
pyxel.cls(0)
camera = self.space.camera
camera.draw(self.space.static_body)
camera.draw(self.base)
self.particles.draw(camera)
self.explosion_particles.draw(camera)
camera.draw(self.player)
for meteor in self.meteor:
camera.draw(meteor)
if self.landed:
msg = "PARABENS!" if self.victory else "PERDEU :("
x = WIDTH / 2 - len(msg) * pyxel.FONT_WIDTH / 2
pyxel.text(x, HEIGHT // 2 - 20, msg, pyxel.COLOR_RED)
from easymunk import Vec2d, Arbiter, Body, Vec2d, ShapeFilter, pyxel as phys
import pyxel
import random
FPS = 30
WIDTH, HEIGHT = 256, 196
SCREEN = Vec2d(WIDTH, HEIGHT)
class Particles:
def __init__(self, space):
self.particles = []
self.space = space
def draw(self, camera=pyxel):
for p in self.particles:
x, y = p.position
if random.random() < 0.15:
camera.rect(x, y, 2, 2, self.get_color(p.duration))
else:
camera.pset(x, y, self.get_color(p.duration))
def update(self):
for p in self.particles.copy():
p.velocity = p.velocity.rotated(random.uniform(-5, 5))
p.duration -= 1
if p.duration <= 0:
self.particles.remove(p)
def emmit(self, position, velocity):
p = self.space.create_circle(
class Game:
# Cores
# Outras propriedades
CAMERA_TOL = Vec2d(WIDTH / 2 - 64, HEIGHT / 2 - 48)
N_ENEMIES = 20
def __init__(self, scenario=SCENARIO):
self.paused = False
self.camera = phys.Camera(flip_y=True)
self.space = phys.space(
gravity=(0, -25),
wireframe=True,
camera=self.camera,
elasticity=1.0,
)
# Inicializa o jogo
self.state = GameState.GAMEPLAY
pyxel.load("resources/assets.pyxres")
pyxel.cls(pyxel.COLOR_LIGHTBLUE)
# Cria jogador
self.player = Player(50, 50)
self.player.register(self.space, self.message)
# Cria chão
f = phys.rect(0, 0, 1000, 48, body_type="static")
# Cria margens
phys.margin(0, 0, 1000, HEIGHT)
def message(self, msg, sender):
fn = getattr(self, f'handle_{msg}', None)
if fn is None:
print(f'Mensagem desconhecida: "{msg} ({sender})')
else:
fn(sender)
def draw(self):
pyxel.cls(pyxel.COLOR_LIGHTBLUE)
for body in self.space.bodies:
if isinstance(body, (Player)):
body.draw(self.camera)
else:
self.camera.draw(body)
# Desenha texto informativo
pyxel.text(
5, 5,
"Setas para controlar o personagem (ele tem 3 pulos)\nR para resetar",
pyxel.COLOR_BLACK)
info_text = "Posicao: (" + str(round(
self.player.position[0], 3)) + ", " + str(
round(self.player.position[1],
3)) + ")\n" + "Velocidade: (" + str(
round(self.player.velocity.x, 3)) + ", " + str(
round(self.player.velocity.y,
3)) + ")\n" + "Pulos Restantes: " + str(
self.player.remaining_jumps)
pyxel.text(5, 30, info_text, pyxel.COLOR_BLACK)
msg = ""
if self.paused:
msg = 'PAUSED'
if msg:
x = (WIDTH - len(msg) * pyxel.FONT_WIDTH) / 2
pyxel.text(round(x), HEIGHT // 2, msg, pyxel.COLOR_RED)
def handle_hit_player(self, sender):
self.state = GameState.GAMEPLAY
def handle_hit_target(self, sender):
self.state = GameState.GAMEPLAY
def update(self):
if (pyxel.btnp(pyxel.KEY_P)):
self.paused = False if self.paused else True
if not self.paused:
self.space.step(1 / 30, 2)
self.player.update()
self.camera.follow(self.player.position, tol=self.CAMERA_TOL)
class Game:
# Outras propriedades
CAMERA_TOL = Vec2d(WIDTH / 2 - 64, HEIGHT / 2 - 48)
N_ENEMIES = 20
def __init__(self, scenario=SCENARIO):
self.paused = False
self.camera = phys.Camera(flip_y=True)
self.space = phys.space(
gravity=(0, -25),
wireframe=True,
camera=self.camera,
elasticity=1.0,
)
# Inicializa o jogo
self.state = GameState.GAMEPLAY
pyxel.load("pr_resources/assets1.pyxres")
pyxel.cls(BACKGROUND_COLOR)
# Cria jogadores
self.player1 = Player(50, 50, 'dog', 'ArrowKeys', self.space)
self.player1.register(self.space, self.message)
#self.player2 = Player(80, 50, 'rabbit', 'WASD')
#self.player2.register(self.space, self.message)
self.ball = Ball(50, 150, self.space)
self.ball.register(self.space, self.message)
# Cria chão
f = Ground()
# Cria margens
phys.margin(0, 0, WIDTH - 30, HEIGHT, elasticity=1, friction=1)
# Toca música
music_bgm()
def message(self, msg, sender):
fn = getattr(self, f'handle_{msg}', None)
if fn is None:
print(f'Mensagem desconhecida: "{msg} ({sender})')
else:
fn(sender)
def draw(self):
pyxel.cls(BACKGROUND_COLOR)
for body in self.space.bodies:
if isinstance(body, (Player)):
body.draw(self.camera)
else:
self.camera.draw(body)
# Desenha texto informativo
pyxel.text(
10, 5,
"Setas para controlar o personagem (ele tem 3 pulos)\nR para resetar",
pyxel.COLOR_YELLOW)
info_text = "Posicao: (" + str(round(
self.player1.position[0], 3)) + ", " + str(
round(self.player1.position[1],
3)) + ")\n" + "Velocidade: (" + str(
round(self.player1.velocity.x, 3)) + ", " + str(
round(self.player1.velocity.y,
3)) + ")\n" + "Pulos Restantes: " + str(
self.player1.remaining_jumps
) + "\nScore: " + str(self.ball.SCORE)
pyxel.text(10, 30, info_text, pyxel.COLOR_YELLOW)
msg = ""
if self.paused:
msg = 'PAUSED'
if msg:
x = (WIDTH - len(msg) * pyxel.FONT_WIDTH) / 2
pyxel.text(round(x), HEIGHT // 2, msg, pyxel.COLOR_RED)
def handle_hit_player(self, sender):
self.state = GameState.GAMEPLAY
def handle_hit_target(self, sender):
self.state = GameState.GAMEPLAY
def update(self):
if (pyxel.btnp(pyxel.KEY_P)):
self.paused = False if self.paused else True
if not self.paused:
self.space.step(1 / FPS, 2)
self.player1.update()
#self.player2.update()
self.ball.update()
self.camera.follow(self.player1.position, tol=self.CAMERA_TOL)
class Game:
# Cores
# Outras propriedades
CAMERA_TOL = Vec2d(utils.WIDTH / 2 - 64, utils.HEIGHT / 2 - 48)
N_ENEMIES = 20
def __init__(self, scenario=utils.SCENARIO):
self.camera = phys.Camera(flip_y=True)
self.space = phys.space(
gravity=(0, -25),
wireframe=True,
camera=self.camera,
elasticity=1.0,
)
# Inicializa o jogo
self.state = utils.GameState.RUNNING
pyxel.load("assets.pyxres")
# Cria jogador
self.my_player = player.Player(50, 50)
self.my_player.register(self.space, self.message)
# Cria chão
f = phys.rect(0, 0, 1000, 48, body_type="static")
# Cria cenário
for line in march_string(scenario,
"=",
scale=8.0,
translate=Vec2d(0.0, 48),
flip_y=True):
line = [Vec2d(2 * x, y) for (x, y) in line]
phys.poly(line, body_type="static", color=pyxel.COLOR_PEACH)
# Cria sensor para condição de vitória
phys.rect(
1000 - 16,
48,
16,
16,
collision_type=utils.ColType.TARGET,
sensor=True,
body_type="static",
)
# Cria margens
phys.margin(0, 0, 1000, utils.HEIGHT)
# Cria inimigos
for _ in range(self.N_ENEMIES):
my_enemy = enemy.Enemy.random(0, 1000, utils.HEIGHT / 2,
utils.HEIGHT)
my_enemy.register(self.space, self.message)
def message(self, msg, sender):
fn = getattr(self, f'handle_{msg}', None)
if fn is None:
print(f'Mensagem desconhecida: "{msg} ({sender})')
else:
fn(sender)
def handle_hit_player(self, sender):
self.state = utils.GameState.GAME_OVER
def handle_hit_target(self, sender):
self.state = utils.GameState.HAS_WON
def draw(self):
pyxel.cls(0)
for body in self.space.bodies:
if isinstance(body, (player.Player, enemy.Enemy)):
body.draw(self.camera)
else:
self.camera.draw(body)
msg = ""
if self.state is utils.GameState.GAME_OVER:
msg = "GAME OVER"
elif self.state is utils.GameState.HAS_WON:
msg = "PARABENS!"
if msg:
x = (utils.WIDTH - len(msg) * pyxel.FONT_WIDTH) / 2
pyxel.text(round(x), utils.HEIGHT // 2, msg, pyxel.COLOR_YELLOW)
def update(self):
self.space.step(1 / 30, 2)
if self.state is not utils.GameState.GAME_OVER:
self.my_player.update()
self.camera.follow(self.my_player.position, tol=self.CAMERA_TOL)