613 lines
16 KiB
Zig
613 lines
16 KiB
Zig
const std = @import("std");
|
|
const Allocator = std.mem.Allocator;
|
|
const assert = std.debug.assert;
|
|
|
|
const Engine = @import("./engine/root.zig");
|
|
const imgui = Engine.imgui;
|
|
const Gfx = Engine.Graphics;
|
|
const Vec2 = Engine.Math.Vec2;
|
|
const Vec4 = Engine.Math.Vec4;
|
|
const Rect = Engine.Math.Rect;
|
|
const rgb = Engine.Math.rgb;
|
|
const rgb_hex = Engine.Math.rgb_hex;
|
|
|
|
const Timer = @import("./timer.zig");
|
|
const Entity = @import("./entity.zig");
|
|
const Assets = @import("./assets.zig");
|
|
|
|
const tiled = @import("tiled");
|
|
|
|
const Game = @This();
|
|
|
|
const KeyState = Engine.Input.KeyState;
|
|
|
|
pub const Input = struct {
|
|
dt: f64,
|
|
move_up: KeyState,
|
|
move_down: KeyState,
|
|
move_left: KeyState,
|
|
move_right: KeyState,
|
|
restart: bool
|
|
};
|
|
|
|
pub const Level = struct {
|
|
entities: Entity.List,
|
|
timers: Timer.List,
|
|
|
|
pub const empty = Level{
|
|
.entities = .empty,
|
|
.timers = .empty
|
|
};
|
|
|
|
pub fn clone(self: *Level, gpa: Allocator) !Level {
|
|
var entities = try self.entities.clone(gpa);
|
|
errdefer entities.deinit(gpa);
|
|
|
|
var timers = try self.timers.clone(gpa);
|
|
errdefer timers.deinit(gpa);
|
|
|
|
return Level{
|
|
.entities = entities,
|
|
.timers = timers
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *Level, gpa: Allocator) void {
|
|
self.entities.deinit(gpa);
|
|
self.timers.deinit(gpa);
|
|
}
|
|
};
|
|
|
|
const key = "XXXXX-XXXXX-XXXXX";
|
|
|
|
gpa: Allocator,
|
|
|
|
canvas_size: Vec2,
|
|
level: Level,
|
|
assets: *Assets,
|
|
|
|
current_level: u32,
|
|
levels: std.ArrayList(Level),
|
|
|
|
last_up_repeat_at: ?f64 = null,
|
|
last_down_repeat_at: ?f64 = null,
|
|
last_left_repeat_at: ?f64 = null,
|
|
last_right_repeat_at: ?f64 = null,
|
|
|
|
show_grid: bool = false,
|
|
|
|
timers: Timer.List = .empty,
|
|
level_exit_transition: ?Timer.Id = null,
|
|
level_enter_transition: ?Timer.Id = null,
|
|
|
|
finale: bool = false,
|
|
finale_timer: ?Timer.Id = null,
|
|
finale_counter: u32 = 0,
|
|
|
|
pub fn init(gpa: Allocator, assets: *Assets) !Game {
|
|
var self = Game{
|
|
.gpa = gpa,
|
|
.canvas_size = (Vec2.init(20, 15)),
|
|
.level = .empty,
|
|
.levels = .empty,
|
|
.current_level = 0,
|
|
.assets = assets
|
|
};
|
|
errdefer self.deinit();
|
|
|
|
var scratch = std.heap.ArenaAllocator.init(gpa);
|
|
defer scratch.deinit();
|
|
|
|
var xml_buffers = tiled.xml.Lexer.Buffers.init(gpa);
|
|
defer xml_buffers.deinit();
|
|
|
|
var tilesets: tiled.Tileset.List = .empty;
|
|
defer tilesets.deinit(gpa);
|
|
|
|
try tilesets.add(
|
|
gpa,
|
|
"tileset.tsx",
|
|
try tiled.Tileset.initFromBuffer(
|
|
gpa,
|
|
&scratch,
|
|
&xml_buffers,
|
|
@embedFile("assets/tiled/tileset.tsx")
|
|
)
|
|
);
|
|
|
|
try self.levels.append(gpa, try loadLevelFromEmbedTiled(gpa, tilesets, "assets/tiled/first.tmx"));
|
|
try self.levels.append(gpa, try loadLevelFromEmbedTiled(gpa, tilesets, "assets/tiled/second.tmx"));
|
|
try self.levels.append(gpa, try loadLevelFromEmbedTiled(gpa, tilesets, "assets/tiled/third.tmx"));
|
|
try self.levels.append(gpa, try loadLevelFromEmbedTiled(gpa, tilesets, "assets/tiled/fourth.tmx"));
|
|
|
|
try self.restartLevel();
|
|
|
|
return self;
|
|
}
|
|
|
|
fn restartLevel(self: *Game) !void {
|
|
const level_copy = try self.levels.items[self.current_level].clone(self.gpa);
|
|
errdefer level_copy.deinit(self.gpa);
|
|
|
|
self.level.deinit(self.gpa);
|
|
self.level = level_copy;
|
|
}
|
|
|
|
fn nextLevel(self: *Game) !void {
|
|
if (self.level_exit_transition != null) {
|
|
return;
|
|
}
|
|
|
|
if (self.current_level < self.levels.items.len) {
|
|
self.level_exit_transition = try self.timers.start(self.gpa, .{
|
|
.duration = 1
|
|
});
|
|
}
|
|
}
|
|
|
|
fn loadLevelFromEmbedTiled(gpa: Allocator, tilesets: tiled.Tileset.List, comptime path: []const u8) !Level {
|
|
var scratch = std.heap.ArenaAllocator.init(gpa);
|
|
defer scratch.deinit();
|
|
|
|
var xml_buffers = tiled.xml.Lexer.Buffers.init(gpa);
|
|
defer xml_buffers.deinit();
|
|
|
|
const map = try tiled.Tilemap.initFromBuffer(
|
|
gpa,
|
|
&scratch,
|
|
&xml_buffers,
|
|
@embedFile(path)
|
|
);
|
|
defer map.deinit();
|
|
|
|
var level: Level = .empty;
|
|
errdefer level.deinit(gpa);
|
|
|
|
for (map.layers) |*layer| {
|
|
if (!layer.visible) {
|
|
continue;
|
|
}
|
|
if (layer.variant != .tile) {
|
|
continue;
|
|
}
|
|
|
|
for (0..map.height) |y| {
|
|
for (0..map.width) |x| {
|
|
const tile = map.getTile(layer, tilesets, x, y) orelse continue;
|
|
const tile_props = tile.getProperties();
|
|
const tile_type = tile_props.getString("type") orelse "";
|
|
|
|
const tile_width: f32 = @floatFromInt(tile.tileset.tile_width);
|
|
const tile_height: f32 = @floatFromInt(tile.tileset.tile_height);
|
|
const tile_position_in_image = tile.tileset.getTilePositionInImage(tile.id).?;
|
|
var entity: Entity = .{
|
|
.type = .nil,
|
|
.position = Vec2.init(@floatFromInt(x), @floatFromInt(y)),
|
|
.render_tile = .{
|
|
.position = .{
|
|
.x = tile_position_in_image.x / tile_width,
|
|
.y = tile_position_in_image.y / tile_height,
|
|
}
|
|
},
|
|
};
|
|
if (std.mem.eql(u8, tile_type, "player")) {
|
|
entity.type = .player;
|
|
} else if (std.mem.eql(u8, tile_type, "key")) {
|
|
entity.type = .key;
|
|
} else if (std.mem.eql(u8, tile_type, "locked_door")) {
|
|
entity.type = .door;
|
|
entity.locked = true;
|
|
} else if (std.mem.eql(u8, tile_type, "pot")) {
|
|
entity.type = .pot;
|
|
} else if (std.mem.eql(u8, tile_type, "staircase")) {
|
|
entity.type = .staircase;
|
|
} else if (std.mem.eql(u8, tile_type, "solid")) {
|
|
entity.type = .solid;
|
|
}
|
|
|
|
_ = try level.entities.insert(gpa, entity);
|
|
}
|
|
}
|
|
}
|
|
|
|
return level;
|
|
}
|
|
|
|
pub fn deinit(self: *Game) void {
|
|
self.timers.deinit(self.gpa);
|
|
self.level.deinit(self.gpa);
|
|
for (self.levels.items) |*level| {
|
|
level.deinit(self.gpa);
|
|
}
|
|
self.levels.deinit(self.gpa);
|
|
}
|
|
|
|
fn drawGrid(self: *Game, size: Vec2, color: Vec4, line_width: f32) void {
|
|
var x: f32 = 0;
|
|
while (x < self.canvas_size.x) {
|
|
x += size.x;
|
|
Gfx.drawLine(
|
|
.init(x, 0),
|
|
.init(x, self.canvas_size.y),
|
|
color,
|
|
line_width
|
|
);
|
|
}
|
|
|
|
var y: f32 = 0;
|
|
while (y < self.canvas_size.y) {
|
|
y += size.y;
|
|
Gfx.drawLine(
|
|
.init(0, y),
|
|
.init(self.canvas_size.x, y),
|
|
color,
|
|
line_width
|
|
);
|
|
}
|
|
}
|
|
|
|
fn getEntityAt(self: *Game, pos: Vec2) ?Entity.Id {
|
|
var iter = self.level.entities.iterator();
|
|
while (iter.next()) |tuple| {
|
|
const entity = tuple.item;
|
|
if (entity.type == .nil) {
|
|
continue;
|
|
}
|
|
|
|
if (entity.position.eql(pos)) {
|
|
return tuple.id;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
fn isSolidAt(self: *Game, pos: Vec2) bool {
|
|
if (self.getEntityAt(pos)) |entity_id| {
|
|
const entity = self.level.entities.getAssumeExists(entity_id);
|
|
return entity.type == .solid;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
fn canMove(self: *Game, entity: *Entity, dir: Vec2) bool {
|
|
const next_pos = entity.position.add(dir);
|
|
if (self.isSolidAt(next_pos)) {
|
|
return false;
|
|
}
|
|
if (next_pos.x < 0 or next_pos.x >= self.canvas_size.x) {
|
|
return false;
|
|
}
|
|
if (next_pos.y < 0 or next_pos.y >= self.canvas_size.y) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
fn moveEntity(self: *Game, entity_id: Entity.Id, dir: Vec2) bool {
|
|
const entity = self.level.entities.get(entity_id) orelse return true;
|
|
|
|
if (entity.type == .solid) {
|
|
return false;
|
|
}
|
|
|
|
if (entity.type == .nil) {
|
|
return true;
|
|
}
|
|
|
|
if (dir.x == 0 and dir.y == 0) {
|
|
return true;
|
|
}
|
|
|
|
const next_pos = entity.position.add(dir);
|
|
if (self.getEntityAt(next_pos)) |next_entity_id| {
|
|
const next_entity = self.level.entities.getAssumeExists(next_entity_id);
|
|
if (next_entity.type == .door and next_entity.locked and entity.type == .key) {
|
|
_ = self.level.entities.removeAssumeExists(entity_id);
|
|
next_entity.locked = false;
|
|
return true;
|
|
}
|
|
|
|
if (next_entity.type == .pot or next_entity.type == .key) {
|
|
if (!self.moveEntity(next_entity_id, dir)) {
|
|
return false;
|
|
}
|
|
} else if (next_entity.type == .door) {
|
|
if (next_entity.locked) {
|
|
return false;
|
|
}
|
|
} else if (next_entity.type == .solid) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
entity.position = next_pos;
|
|
|
|
return true;
|
|
}
|
|
|
|
pub fn getInput(self: *Game, frame: Engine.Frame) Input {
|
|
_ = self; // autofix
|
|
const input = frame.input;
|
|
return Input{
|
|
.dt = frame.dt,
|
|
.move_up = input.getKeyState(frame, .W),
|
|
.move_down = input.getKeyState(frame, .S),
|
|
.move_left = input.getKeyState(frame, .A),
|
|
.move_right = input.getKeyState(frame, .D),
|
|
.restart = input.isKeyPressed(.R)
|
|
};
|
|
}
|
|
|
|
fn drawEntity(self: *Game, entity: *Entity) void {
|
|
if (entity.render_tile) |render_tile| {
|
|
var tile_coord = switch (render_tile) {
|
|
.id => |tile_id| self.assets.tile_coords.get(tile_id),
|
|
.position => |position| position
|
|
};
|
|
|
|
if (entity.type == .door) {
|
|
if (entity.locked) {
|
|
tile_coord = self.assets.tile_coords.get(.locked_door);
|
|
} else {
|
|
tile_coord = self.assets.tile_coords.get(.open_door);
|
|
}
|
|
}
|
|
|
|
self.drawTile(tile_coord, entity.position);
|
|
}
|
|
}
|
|
|
|
fn hasStaricaseAt(self: *Game, position: Vec2) bool {
|
|
var iter = self.level.entities.iterator();
|
|
while (iter.nextItem()) |entity| {
|
|
if (entity.type == .staircase and entity.position.eql(position)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
pub fn tickLevel(self: *Game, input: Input) !void {
|
|
const bg_color = rgb_hex("#222323").?;
|
|
|
|
if (input.restart) {
|
|
try self.restartLevel();
|
|
}
|
|
|
|
self.level.timers.now += input.dt;
|
|
|
|
var cover_opacity: f32 = 0;
|
|
var can_move = true;
|
|
|
|
if (self.level_exit_transition) |timer| {
|
|
can_move = false;
|
|
|
|
cover_opacity = self.timers.percent_passed(timer);
|
|
|
|
if (self.timers.finished(timer)) {
|
|
self.current_level += 1;
|
|
if (self.current_level == self.levels.items.len) {
|
|
self.finale = true;
|
|
return;
|
|
} else {
|
|
try self.restartLevel();
|
|
self.level_exit_transition = null;
|
|
|
|
self.level_enter_transition = try self.timers.start(self.gpa, .{
|
|
.duration = 1
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (self.level_enter_transition) |timer| {
|
|
cover_opacity = 1 - self.timers.percent_passed(timer);
|
|
if (self.timers.finished(timer)) {
|
|
self.level_enter_transition = null;
|
|
}
|
|
}
|
|
|
|
var move: Vec2 = .init(0, 0);
|
|
if (can_move) {
|
|
const repeat_options = KeyState.RepeatOptions{
|
|
.first_at = 0.3,
|
|
.period = 0.1
|
|
};
|
|
|
|
if (input.move_up.pressed or input.move_up.repeat(&self.last_up_repeat_at, repeat_options)) {
|
|
move.y -= 1;
|
|
}
|
|
if (input.move_down.pressed or input.move_down.repeat(&self.last_down_repeat_at, repeat_options)) {
|
|
move.y += 1;
|
|
}
|
|
if (input.move_left.pressed or input.move_left.repeat(&self.last_left_repeat_at, repeat_options)) {
|
|
move.x -= 1;
|
|
}
|
|
if (input.move_right.pressed or input.move_right.repeat(&self.last_right_repeat_at, repeat_options)) {
|
|
move.x += 1;
|
|
}
|
|
}
|
|
|
|
var iter = self.level.entities.iterator();
|
|
while (iter.next()) |tuple| {
|
|
const entity = tuple.item;
|
|
const entity_id = tuple.id;
|
|
if (entity.type == .player) {
|
|
_ = self.moveEntity(entity_id, move);
|
|
if (self.hasStaricaseAt(entity.position)) {
|
|
try self.nextLevel();
|
|
}
|
|
}
|
|
}
|
|
|
|
var top_layer: std.ArrayList(Entity.Id) = .empty;
|
|
defer top_layer.deinit(self.gpa);
|
|
|
|
var bottom_layer: std.ArrayList(Entity.Id) = .empty;
|
|
defer bottom_layer.deinit(self.gpa);
|
|
|
|
iter = self.level.entities.iterator();
|
|
while (iter.next()) |tuple| {
|
|
const entity = tuple.item;
|
|
const entity_id = tuple.id;
|
|
if (entity.type == .player or entity.type == .key or entity.type == .pot) {
|
|
try top_layer.append(self.gpa, entity_id);
|
|
} else {
|
|
try bottom_layer.append(self.gpa, entity_id);
|
|
}
|
|
}
|
|
|
|
for (bottom_layer.items) |entity_id| {
|
|
const entity = self.level.entities.getAssumeExists(entity_id);
|
|
self.drawEntity(entity);
|
|
}
|
|
|
|
for (top_layer.items) |entity_id| {
|
|
const entity = self.level.entities.getAssumeExists(entity_id);
|
|
self.drawEntity(entity);
|
|
}
|
|
|
|
if (cover_opacity != 0) {
|
|
Gfx.drawRectangle(.init(0, 0), .init(self.canvas_size.x, self.canvas_size.y), bg_color.multiply(Vec4.init(1, 1, 1, cover_opacity)));
|
|
}
|
|
}
|
|
|
|
pub fn tickFinale(self: *Game) !void {
|
|
const color = rgb(200, 200, 200);
|
|
|
|
const Line = struct {
|
|
pos: Vec2,
|
|
font: Gfx.Font,
|
|
text: []const u8,
|
|
};
|
|
|
|
const regular_font = Gfx.Font{
|
|
.id = self.assets.font_map.get(.regular),
|
|
.size = 64
|
|
};
|
|
|
|
const bold_font = Gfx.Font{
|
|
.id = self.assets.font_map.get(.bold),
|
|
.size = 64
|
|
};
|
|
|
|
const lines = [5]Line{
|
|
.{
|
|
.pos = Vec2.init(1, 1),
|
|
.font = regular_font,
|
|
.text = "Congratulations scientist"
|
|
},
|
|
.{
|
|
.pos = Vec2.init(1, 2),
|
|
.font = regular_font,
|
|
.text = "You have passed the entrance exam"
|
|
},
|
|
.{
|
|
.pos = Vec2.init(1, 3),
|
|
.font = regular_font,
|
|
.text = "Here is your entry code"
|
|
},
|
|
.{
|
|
.pos = Vec2.init(1, 5),
|
|
.font = bold_font,
|
|
.text = key
|
|
},
|
|
.{
|
|
.pos = Vec2.init(1, 7),
|
|
.font = regular_font,
|
|
.text = "I'll meet you at the lab"
|
|
}
|
|
};
|
|
|
|
if (self.finale_timer == null) {
|
|
if (self.finale_counter < lines.len) {
|
|
self.finale_timer = try self.timers.start(self.gpa, .{
|
|
.duration = 2,
|
|
});
|
|
}
|
|
}
|
|
|
|
if (self.finale_timer) |timer| {
|
|
if (self.timers.finished(timer)) {
|
|
self.finale_timer = null;
|
|
self.finale_counter += 1;
|
|
}
|
|
}
|
|
|
|
for (0..self.finale_counter) |i| {
|
|
const line = lines[i];
|
|
try Gfx.drawText(self.gpa, line.pos, line.font, color, line.text);
|
|
}
|
|
|
|
if (self.finale_counter < lines.len) {
|
|
var opacity: f32 = 0;
|
|
if (self.finale_timer) |timer| {
|
|
opacity = self.timers.percent_passed(timer);
|
|
}
|
|
|
|
const line = lines[self.finale_counter];
|
|
try Gfx.drawText(self.gpa, line.pos, line.font, color.multiply(Vec4.init(1, 1, 1, opacity)), line.text);
|
|
}
|
|
}
|
|
|
|
pub fn tick(self: *Game, frame: Engine.Frame) !void {
|
|
const input = self.getInput(frame);
|
|
|
|
const bg_color = rgb_hex("#222323").?;
|
|
|
|
Gfx.drawRectangle(.init(0, 0), .init(self.canvas_size.x, self.canvas_size.y), bg_color);
|
|
if (self.show_grid) {
|
|
self.drawGrid(.init(1, 1), rgb(20, 20, 20), 0.1);
|
|
}
|
|
|
|
self.timers.now += input.dt;
|
|
|
|
if (self.finale) {
|
|
try self.tickFinale();
|
|
} else {
|
|
try self.tickLevel(input);
|
|
}
|
|
}
|
|
|
|
fn drawTile(self: *Game, tile_coord: Vec2, pos: Vec2) void {
|
|
Gfx.drawTexturedRectangle(
|
|
pos,
|
|
.init(1, 1),
|
|
Gfx.white,
|
|
self.assets.tilemap_view,
|
|
Rect.init(
|
|
tile_coord.x,
|
|
tile_coord.y,
|
|
1,
|
|
1
|
|
).multiply(self.assets.tile_size).divide(self.assets.tilemap_size)
|
|
);
|
|
}
|
|
|
|
pub fn debug(self: *Game) !void {
|
|
if (!imgui.beginWindow(.{
|
|
.name = "Debug",
|
|
.pos = Vec2.init(20, 20),
|
|
.size = Vec2.init(400, 200),
|
|
})) {
|
|
return;
|
|
}
|
|
defer imgui.endWindow();
|
|
|
|
imgui.textFmt("Entities: {}", .{self.level.entities.len});
|
|
imgui.textFmt("Timers: {}", .{self.level.timers.array_list.len});
|
|
_ = imgui.checkbox("Show grid", &self.show_grid);
|
|
|
|
if (imgui.button("Skip level")) {
|
|
try self.nextLevel();
|
|
}
|
|
|
|
if (imgui.button("Finale")) {
|
|
self.finale = true;
|
|
}
|
|
}
|