Air Labyrinth v0.1
This commit is contained in:
Derek Jamison
371
vgm/apps/air_labyrinth/game.c
Normal file
371
vgm/apps/air_labyrinth/game.c
Normal file
@@ -0,0 +1,371 @@
|
||||
// Air Labyrinth -- by @CodeAllNight (https://youtube.com/@MrDerekJamison/about)
|
||||
//
|
||||
// v0.1 - Initial release (d-pad and tilt controls for player movement)
|
||||
//
|
||||
/*
|
||||
This game was made based on the [air_arkanoid]
|
||||
(https://github.com/flipperdevices/flipperzero-good-faps/tree/dev/air_arkanoid) and
|
||||
[flipperzero-game-engine-example](https://github.com/flipperdevices/flipperzero-game-engine-example)
|
||||
projects. Thanks to the authors of these projects for the inspiration and the code.
|
||||
*/
|
||||
|
||||
#include "game.h"
|
||||
#include "walls.h"
|
||||
|
||||
#define MOTION_X 1
|
||||
#define MOTION_Y 1
|
||||
|
||||
/****** Entities: Player ******/
|
||||
|
||||
typedef struct {
|
||||
Vector trajectory; // Direction player would like to move.
|
||||
float radius; // collision radius
|
||||
int8_t dx; // x direction
|
||||
int8_t dy; // y direction
|
||||
Sprite* sprite; // player sprite
|
||||
} PlayerContext;
|
||||
|
||||
// Forward declaration of player_desc, because it's used in player_spawn function.
|
||||
static const EntityDescription player_desc;
|
||||
|
||||
static void player_spawn(Level* level, GameManager* manager) {
|
||||
Entity* player = level_add_entity(level, &player_desc);
|
||||
|
||||
// Set player position.
|
||||
// Depends on your game logic, it can be done in start entity function, but also can be done here.
|
||||
entity_pos_set(player, (Vector){64, 28});
|
||||
|
||||
entity_collider_add_rect(player, 3, 2);
|
||||
|
||||
// Get player context
|
||||
PlayerContext* player_context = entity_context_get(player);
|
||||
|
||||
// Load player sprite
|
||||
player_context->sprite = game_manager_sprite_load(manager, "player.fxbm");
|
||||
player_context->dx = 0;
|
||||
player_context->dy = 0;
|
||||
player_context->radius = 5;
|
||||
player_context->trajectory = (Vector){0, 0};
|
||||
}
|
||||
|
||||
static float player_x_from_pitch(float pitch) {
|
||||
if(pitch > 9.0) {
|
||||
return 1.0f;
|
||||
} else if(pitch < -9.0) {
|
||||
return -1.0f;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static float player_y_from_roll(float roll) {
|
||||
if(roll > 5.0) {
|
||||
return 0.7f;
|
||||
} else if(roll < -20.0) {
|
||||
return -0.7f;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void player_update(Entity* self, GameManager* manager, void* context) {
|
||||
// Get player context
|
||||
PlayerContext* player = context;
|
||||
player->dx = 0;
|
||||
player->dy = 0;
|
||||
|
||||
GameContext* game_context = game_manager_game_context_get(manager);
|
||||
if(game_context->imu_present) {
|
||||
FURI_LOG_D(
|
||||
"Player",
|
||||
"pitch:%f roll:%f yaw:%f",
|
||||
(double)imu_pitch_get(game_context->imu),
|
||||
(double)imu_roll_get(game_context->imu),
|
||||
(double)imu_yaw_get(game_context->imu));
|
||||
|
||||
player->trajectory = vector_add(
|
||||
player->trajectory,
|
||||
(Vector){
|
||||
player_x_from_pitch(-imu_pitch_get(game_context->imu)),
|
||||
player_y_from_roll(-imu_roll_get(game_context->imu))});
|
||||
}
|
||||
|
||||
// Get game input
|
||||
InputState input = game_manager_input_get(manager);
|
||||
|
||||
// Control player movement
|
||||
if(input.held & GameKeyUp) {
|
||||
player->trajectory = vector_add(player->trajectory, (Vector){0, -0.8});
|
||||
}
|
||||
|
||||
if(input.held & GameKeyDown) {
|
||||
player->trajectory = vector_add(player->trajectory, (Vector){0, +0.8});
|
||||
}
|
||||
|
||||
if(input.held & GameKeyLeft) {
|
||||
player->trajectory = vector_add(player->trajectory, (Vector){-0.8, 0});
|
||||
}
|
||||
|
||||
if(input.held & GameKeyRight) {
|
||||
player->trajectory = vector_add(player->trajectory, (Vector){0.8, 0});
|
||||
}
|
||||
|
||||
// Get player position
|
||||
Vector pos = entity_pos_get(self);
|
||||
|
||||
if(player->trajectory.x >= 1.0) {
|
||||
player->dx = MOTION_X;
|
||||
player->trajectory.x = 0;
|
||||
pos.x += player->dx;
|
||||
} else if(player->trajectory.x <= -1.0) {
|
||||
player->dx = -MOTION_X;
|
||||
player->trajectory.x = 0;
|
||||
pos.x += player->dx;
|
||||
}
|
||||
|
||||
if(player->trajectory.y >= 1.0) {
|
||||
player->dy = MOTION_Y;
|
||||
player->trajectory.y = 0;
|
||||
pos.y += player->dy;
|
||||
} else if(player->trajectory.y <= -1.0) {
|
||||
player->dy = -MOTION_Y;
|
||||
player->trajectory.y = 0;
|
||||
pos.y += player->dy;
|
||||
}
|
||||
|
||||
// Clamp player position to screen bounds, considering player sprite size (10x10)
|
||||
pos.x = CLAMP(pos.x, 126, 3);
|
||||
pos.y = CLAMP(pos.y, 62, 2);
|
||||
|
||||
// Set new player position
|
||||
entity_pos_set(self, pos);
|
||||
|
||||
// Control game exit
|
||||
if(input.pressed & GameKeyBack) {
|
||||
game_manager_game_stop(manager);
|
||||
}
|
||||
}
|
||||
|
||||
static void player_render(Entity* self, GameManager* manager, Canvas* canvas, void* context) {
|
||||
// Get player context
|
||||
PlayerContext* player = context;
|
||||
|
||||
// Get player position
|
||||
Vector pos = entity_pos_get(self);
|
||||
|
||||
// Draw player sprite
|
||||
// We subtract 5 from x and y, because collision box is 10x10, and we want to center sprite in it.
|
||||
//canvas_draw_sprite(canvas, player->sprite, pos.x - 5, pos.y - 5);
|
||||
|
||||
// Collision box is 2x2 but image is 10x10.
|
||||
canvas_draw_sprite(canvas, player->sprite, pos.x - 5, pos.y - 5);
|
||||
|
||||
// Get game context
|
||||
GameContext* game_context = game_manager_game_context_get(manager);
|
||||
|
||||
// Draw score
|
||||
// canvas_printf(canvas, 80, 57, "Score: %lu", game_context->score);
|
||||
UNUSED(game_context);
|
||||
|
||||
canvas_draw_str(canvas, 20, 6, "@codeallnight - ver 0.1");
|
||||
canvas_draw_str(canvas, 10, 61, "video game module demo");
|
||||
}
|
||||
|
||||
static const EntityDescription player_desc = {
|
||||
.start = NULL, // called when entity is added to the level
|
||||
.stop = NULL, // called when entity is removed from the level
|
||||
.update = player_update, // called every frame
|
||||
.render = player_render, // called every frame, after update
|
||||
.collision = NULL, // called when entity collides with another entity
|
||||
.event = NULL, // called when entity receives an event
|
||||
.context_size =
|
||||
sizeof(PlayerContext), // size of entity context, will be automatically allocated and freed
|
||||
};
|
||||
|
||||
/****** Entities: Wall ******/
|
||||
|
||||
static void wall_start(Entity* self, GameManager* manager, void* context);
|
||||
|
||||
typedef struct {
|
||||
float width;
|
||||
float height;
|
||||
} WallContext;
|
||||
|
||||
static void wall_render(Entity* self, GameManager* manager, Canvas* canvas, void* context) {
|
||||
UNUSED(manager);
|
||||
|
||||
WallContext* wall = context;
|
||||
|
||||
Vector pos = entity_pos_get(self);
|
||||
|
||||
canvas_draw_box(
|
||||
canvas, pos.x - wall->width / 2, pos.y - wall->height / 2, wall->width, wall->height);
|
||||
}
|
||||
|
||||
static void wall_collision(Entity* self, Entity* other, GameManager* manager, void* context) {
|
||||
WallContext* wall = context;
|
||||
|
||||
// Check if wall collided with player
|
||||
if(entity_description_get(other) == &player_desc) {
|
||||
// Increase score
|
||||
GameContext* game_context = game_manager_game_context_get(manager);
|
||||
game_context->score++;
|
||||
|
||||
PlayerContext* player = (PlayerContext*)entity_context_get(other);
|
||||
if(player) {
|
||||
if(player->dx || player->dy) {
|
||||
Vector pos = entity_pos_get(other);
|
||||
|
||||
// TODO: Based on where we collided, we should still slide across/down the wall.
|
||||
UNUSED(wall);
|
||||
|
||||
if(player->dx) {
|
||||
FURI_LOG_D(
|
||||
"Player",
|
||||
"Player collided with wall, dx: %d. center:%f,%f",
|
||||
player->dx,
|
||||
(double)pos.x,
|
||||
(double)pos.y);
|
||||
pos.x -= player->dx;
|
||||
player->dx = 0;
|
||||
}
|
||||
if(player->dy) {
|
||||
FURI_LOG_D(
|
||||
"Player",
|
||||
"Player collided with wall, dy: %d. center:%f,%f",
|
||||
player->dy,
|
||||
(double)pos.x,
|
||||
(double)pos.y);
|
||||
pos.y -= player->dy;
|
||||
player->dy = 0;
|
||||
}
|
||||
entity_pos_set(other, pos);
|
||||
FURI_LOG_D("Player", "Set to center:%f,%f", (double)pos.x, (double)pos.y);
|
||||
}
|
||||
} else {
|
||||
FURI_LOG_D("Player", "Player collided with wall, but context null.");
|
||||
}
|
||||
} else {
|
||||
// HACK: Wall touching other items destroys each other (to help find collider issues)
|
||||
Level* level = game_manager_current_level_get(manager);
|
||||
level_remove_entity(level, self);
|
||||
level_remove_entity(level, other);
|
||||
}
|
||||
}
|
||||
|
||||
static const EntityDescription wall_desc = {
|
||||
.start = wall_start, // called when entity is added to the level
|
||||
.stop = NULL, // called when entity is removed from the level
|
||||
.update = NULL, // called every frame
|
||||
.render = wall_render, // called every frame, after update
|
||||
.collision = wall_collision, // called when entity collides with another entity
|
||||
.event = NULL, // called when entity receives an event
|
||||
.context_size =
|
||||
sizeof(WallContext), // size of entity context, will be automatically allocated and freed
|
||||
};
|
||||
|
||||
static uint8_t wall_index;
|
||||
|
||||
static void wall_start(Entity* self, GameManager* manager, void* context) {
|
||||
UNUSED(manager);
|
||||
|
||||
WallContext* wall = context;
|
||||
|
||||
// TODO: We can get the current number of items from the level (instead of wall_index).
|
||||
|
||||
if(wall_index < COUNT_OF(walls)) {
|
||||
if(walls[wall_index].horizontal) {
|
||||
wall->width = walls[wall_index].length * 2;
|
||||
wall->height = 1 * 2;
|
||||
} else {
|
||||
wall->width = 1 * 2;
|
||||
wall->height = walls[wall_index].length * 2;
|
||||
}
|
||||
|
||||
entity_pos_set(
|
||||
self,
|
||||
(Vector){
|
||||
walls[wall_index].x + wall->width / 2, walls[wall_index].y + wall->height / 2});
|
||||
|
||||
entity_collider_add_rect(self, wall->width, wall->height);
|
||||
|
||||
wall_index++;
|
||||
}
|
||||
}
|
||||
|
||||
/****** Level ******/
|
||||
|
||||
static void level_alloc(Level* level, GameManager* manager, void* context) {
|
||||
UNUSED(manager);
|
||||
UNUSED(context);
|
||||
|
||||
// Add player entity to the level
|
||||
player_spawn(level, manager);
|
||||
|
||||
// Add wall entities to the level
|
||||
wall_index = 0;
|
||||
for(size_t i = 0; i < COUNT_OF(walls); i++) {
|
||||
level_add_entity(level, &wall_desc);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Alloc/free is called once, when level is added/removed from the game.
|
||||
It useful if you have small amount of levels and entities, that can be allocated at once.
|
||||
|
||||
Start/stop is called when level is changed to/from this level.
|
||||
It will save memory, because you can allocate entities only for current level.
|
||||
*/
|
||||
static const LevelBehaviour level = {
|
||||
.alloc = level_alloc, // called once, when level allocated
|
||||
.free = NULL, // called once, when level freed
|
||||
.start = NULL, // called when level is changed to this level
|
||||
.stop = NULL, // called when level is changed from this level
|
||||
.context_size = 0, // size of level context, will be automatically allocated and freed
|
||||
};
|
||||
|
||||
/****** Game ******/
|
||||
|
||||
/*
|
||||
Write here the start code for your game, for example: creating a level and so on.
|
||||
Game context is allocated (game.context_size) and passed to this function, you can use it to store your game data.
|
||||
*/
|
||||
static void game_start(GameManager* game_manager, void* ctx) {
|
||||
UNUSED(game_manager);
|
||||
|
||||
// Do some initialization here, for example you can load score from storage.
|
||||
// For simplicity, we will just set it to 0.
|
||||
GameContext* game_context = ctx;
|
||||
game_context->score = 0;
|
||||
|
||||
game_context->imu = imu_alloc();
|
||||
game_context->imu_present = imu_present(game_context->imu);
|
||||
|
||||
// Add level to the game
|
||||
game_manager_add_level(game_manager, &level);
|
||||
}
|
||||
|
||||
/*
|
||||
Write here the stop code for your game, for example: freeing memory, if it was allocated.
|
||||
You don't need to free level, sprites or entities, it will be done automatically.
|
||||
Also, you don't need to free game_context, it will be done automatically, after this function.
|
||||
*/
|
||||
static void game_stop(void* ctx) {
|
||||
GameContext* game_context = ctx;
|
||||
imu_free(game_context->imu);
|
||||
game_context->imu = NULL;
|
||||
|
||||
// Do some deinitialization here, for example you can save score to storage.
|
||||
// For simplicity, we will just print it.
|
||||
FURI_LOG_I("Game", "Your score: %lu", game_context->score);
|
||||
}
|
||||
|
||||
/*
|
||||
Yor game configuration, do not rename this variable, but you can change it's content here.
|
||||
*/
|
||||
const Game game = {
|
||||
.target_fps = 30, // target fps, game will try to keep this value
|
||||
.show_fps = false, // show fps counter on the screen
|
||||
.always_backlight = true, // keep display backlight always on
|
||||
.start = game_start, // will be called once, when game starts
|
||||
.stop = game_stop, // will be called once, when game stops
|
||||
.context_size = sizeof(GameContext), // size of game context
|
||||
};
|
||||
Reference in New Issue
Block a user