148 lines
6.8 KiB
GDScript
148 lines
6.8 KiB
GDScript
@tool
|
|
extends Node2D
|
|
const Maze = preload("res://games/pacman/pacman_maze.gd")
|
|
const Rules = preload("res://games/pacman/pacman_rules.gd")
|
|
const SHEET = preload("res://games/pacman/art/sprites.png")
|
|
const MAZE_RECT := Rect2(0, 24, 224, 248)
|
|
const GAME_RECT := Rect2(0, 0, 224, 288)
|
|
const FONT = preload("res://games/pacman/art/text.png")
|
|
const DEATH_ANIMATION_SECONDS := 1.55
|
|
const DEATH_POP_SECONDS := 0.24
|
|
var model
|
|
var debug_grid := false
|
|
|
|
func _ready() -> void:
|
|
texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
|
|
|
|
func _process(_dt: float) -> void:
|
|
if Engine.is_editor_hint(): return
|
|
var available := get_viewport_rect().size
|
|
var factor := minf(available.x / 224.0, available.y / 288.0)
|
|
if factor >= 1.0: factor = floorf(factor)
|
|
scale = Vector2.ONE * factor
|
|
position = ((available - Vector2(224, 288) * factor) * 0.5).floor()
|
|
queue_redraw()
|
|
|
|
func _draw() -> void:
|
|
draw_rect(_viewport_bounds(), Color.BLACK)
|
|
if model == null: return
|
|
if model.state == "intermission":
|
|
_intermission()
|
|
_draw_edge_mask(GAME_RECT)
|
|
return
|
|
var flash: bool = model.state == "clear" and int(model.phase_time * 5) % 2 == 0
|
|
draw_texture_rect_region(SHEET, MAZE_RECT, Rect2(228, 0, 224, 248), Color(0.7, 0.7, 1.0) if flash else Color.WHITE)
|
|
for tile in model.dots:
|
|
var center := _pixel(Vector2(tile))
|
|
if model.dots[tile]:
|
|
if int(model.clock * 4) % 2 == 0: draw_circle(center, 3.5, Color("ffb8ae"))
|
|
else: draw_rect(Rect2(center - Vector2.ONE, Vector2(2, 2)), Color("ffb8ae"))
|
|
if model.fruit_time > 0:
|
|
_sprite(Rect2(504 + Rules.fruit_index(model.level) * 16, 48, 16, 16), _actor_pixel(Vector2(13.5, 17)))
|
|
if model.state not in ["ready", "dying", "death_pop", "lost", "won", "clear"]:
|
|
for i in range(4): _ghost(i)
|
|
if model.state not in ["ready", "death_pop", "lost", "won", "clear"]: _player()
|
|
if model.state == "death_pop":
|
|
_sprite(Rect2(664, 0, 16, 16), _actor_pixel(Maze.position(model.player)))
|
|
if model.popup_time > 0: _text(model.popup_text, _pixel(model.popup_position) - Vector2(12, 4), Color.CYAN)
|
|
_draw_edge_mask(MAZE_RECT)
|
|
_text("1UP", Vector2(24, 0))
|
|
_text("HIGH SCORE", Vector2(80, 0))
|
|
_text(str(model.score).pad_zeros(2), Vector2(8, 8))
|
|
_text(str(model.high_score).pad_zeros(2), Vector2(88, 8))
|
|
for i in range(mini(model.lives - 1, 5)):
|
|
_sprite(Rect2(600, 16, 16, 16), Vector2(16 + i * 16, 280))
|
|
_text("L%d" % model.level, Vector2(192, 276), Color("ffb852"))
|
|
match model.state:
|
|
"idle":
|
|
_banner("PRESS START", Color.YELLOW)
|
|
_text("ARROWS TO MOVE", Vector2(56, 256))
|
|
"ready":
|
|
_banner("READY!", Color.YELLOW)
|
|
_text("PLAYER ONE", Vector2(72, 112), Color("33aaff"))
|
|
"won": _banner("YOU WIN!", Color.CYAN)
|
|
"lost": _banner("GAME OVER", Color.RED)
|
|
if debug_grid:
|
|
for y in range(31):
|
|
for x in range(28):
|
|
if Maze.walkable(Vector2i(x,y)):
|
|
draw_rect(Rect2(x * 8, y * 8 + 24, 8, 8), Color(0, 1, 0, 0.25), false)
|
|
|
|
func _viewport_bounds() -> Rect2:
|
|
if Engine.is_editor_hint(): return GAME_RECT
|
|
return get_global_transform_with_canvas().affine_inverse() * get_viewport_rect()
|
|
|
|
func _draw_edge_mask(visible_area: Rect2) -> void:
|
|
var outer := _viewport_bounds().merge(visible_area)
|
|
draw_rect(Rect2(outer.position, Vector2(visible_area.position.x - outer.position.x, outer.size.y)), Color.BLACK)
|
|
draw_rect(Rect2(Vector2(visible_area.end.x, outer.position.y), Vector2(outer.end.x - visible_area.end.x, outer.size.y)), Color.BLACK)
|
|
draw_rect(Rect2(Vector2(visible_area.position.x, outer.position.y), Vector2(visible_area.size.x, visible_area.position.y - outer.position.y)), Color.BLACK)
|
|
draw_rect(Rect2(Vector2(visible_area.position.x, visible_area.end.y), Vector2(visible_area.size.x, outer.end.y - visible_area.end.y)), Color.BLACK)
|
|
|
|
func _pixel(tile: Vector2) -> Vector2:
|
|
return Vector2(4, 28) + tile * 8.0
|
|
|
|
func _actor_pixel(tile: Vector2) -> Vector2:
|
|
return _pixel(tile)
|
|
|
|
func _intermission() -> void:
|
|
var elapsed: float = 5.28 - model.phase_time
|
|
var frame := int(model.clock * 12) % 2
|
|
if elapsed < 2.64:
|
|
var x := 240.0 - elapsed * 105.0
|
|
_sprite(Rect2(456 + frame * 16, 16, 16, 16), Vector2(x, 144))
|
|
_sprite(Rect2(488 + frame * 16, 64, 16, 16), Vector2(x + 40, 144))
|
|
else:
|
|
var x := -40.0 + (elapsed - 2.64) * 110.0
|
|
_sprite(Rect2(584 + frame * 16, 64, 16, 16), Vector2(x + 55, 144))
|
|
draw_texture_rect_region(SHEET, Rect2(x - 16, 128, 32, 32), Rect2(504 + frame * 32, 16, 32, 32))
|
|
_text("LEVEL %d CLEAR" % model.level, Vector2(56, 200), Color.YELLOW)
|
|
|
|
func _sprite(region: Rect2, center: Vector2) -> void:
|
|
draw_texture_rect_region(SHEET, Rect2(center.round() - Vector2(8, 8), Vector2(16, 16)), region)
|
|
if center.x < 8: draw_texture_rect_region(SHEET, Rect2(center.round() + Vector2(216, -8), Vector2(16, 16)), region)
|
|
elif center.x > 216: draw_texture_rect_region(SHEET, Rect2(center.round() - Vector2(232, 8), Vector2(16, 16)), region)
|
|
|
|
func _player() -> void:
|
|
var p: Dictionary = model.player
|
|
var region := Rect2(456, 0, 16, 16)
|
|
if model.state == "dying":
|
|
var elapsed: float = DEATH_ANIMATION_SECONDS - model.phase_time
|
|
var frame := clampi(int(elapsed / DEATH_ANIMATION_SECONDS * 11.0), 0, 10)
|
|
region = Rect2(488 + frame * 16, 0, 16, 16)
|
|
else:
|
|
var row: int = {Vector2i.RIGHT: 0, Vector2i.LEFT: 1, Vector2i.UP: 2, Vector2i.DOWN: 3}.get(p.dir, 0)
|
|
var frame: int = [0, 1, 2, 1][int(model.player_anim_time * 12.0) % 4] if p.tile != p.next else 1
|
|
region = Rect2(456 + frame * 16, row * 16, 16, 16)
|
|
_sprite(region, _actor_pixel(Maze.position(p)))
|
|
|
|
func _ghost(index: int) -> void:
|
|
var g: Dictionary = model.ghosts[index]
|
|
var direction: int = {Vector2i.RIGHT: 0, Vector2i.LEFT: 1, Vector2i.UP: 2, Vector2i.DOWN: 3}.get(g.dir, 0)
|
|
var frame := int(model.clock * 8) % 2
|
|
var region := Rect2(456 + direction * 32 + frame * 16, 64 + index * 16, 16, 16)
|
|
if g.status in ["eyes", "entering"]: region = Rect2(584 + direction * 16, 80, 16, 16)
|
|
elif g.frightened:
|
|
var white: bool = model.fright_time < 2.0 and int(model.fright_time * 6) % 2 == 0
|
|
region = Rect2(584 + frame * 16 + (32 if white else 0), 64, 16, 16)
|
|
var center := _actor_pixel(Maze.position(g))
|
|
if g.status == "house": center.y += sin(model.clock * 6 + index) * 2
|
|
_sprite(region, center)
|
|
|
|
func _banner(message: String, color: Color) -> void:
|
|
var width := message.length() * 8
|
|
draw_rect(Rect2(112 - width / 2 - 4, 160, width + 8, 12), Color.BLACK)
|
|
_text(message, Vector2(112 - width / 2, 162), color)
|
|
|
|
func _text(message: String, at: Vector2, color := Color.WHITE) -> void:
|
|
for i in range(message.length()):
|
|
var c := message[i]
|
|
var region := Rect2()
|
|
var code := c.unicode_at(0)
|
|
if code >= 65 and code <= 79: region = Rect2((code - 65) * 8, 0, 8, 8)
|
|
elif code >= 80 and code <= 90: region = Rect2((code - 80) * 8, 8, 8, 8)
|
|
elif code >= 48 and code <= 57: region = Rect2((code - 48) * 8, 16, 8, 8)
|
|
elif c == "!": region = Rect2(88, 8, 8, 8)
|
|
else: continue
|
|
draw_texture_rect_region(FONT, Rect2(at + Vector2(i * 8, 0), Vector2(8, 8)), region, color)
|