Yatis-Lephe-Industries
/
BosonX
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
BosonX/src/main.cpp

390 lines
11 KiB
C++
Raw Permalink Blame History

#include "level.h"
#include "generator.h"
#include "render.h"
#include "game.h"
#include "util.h"
#include "log.h"
#include "menu.h"
#include <gint/display.h>
#include <gint/keyboard.h>
#include <gint/timer.h>
#include <gint/clock.h>
#include <gint/cpu.h>
#include <azur/gint/render.h>
#include <gint/drivers/r61524.h>
#include <gint/drivers/keydev.h>
#include <fxlibc/printf.h>
#include <gint/gint.h>
#ifdef LOG_USB_ENABLE
#include <gint/usb.h>
#include <gint/usb-ff-bulk.h>
/* Screenshot next frame */
bool volatile screenshot = false;
/* Send next frame as video to fxlink */
bool volatile videocapture = false;
GUNUSED static bool async_event_filter(key_event_t ev)
{
if(ev.key == KEY_7) {
if(ev.type == KEYEV_DOWN)
screenshot = true;
return false;
}
if(ev.key == KEY_8) {
if(ev.type == KEYEV_DOWN)
videocapture = !videocapture;
return false;
}
return true;
}
GUNUSED static void hook_prefrag(int id, void *fragment, int size)
{
if(!screenshot && !videocapture)
return;
/* Screenshot takes precedence */
char const *type = screenshot ? "image" : "video";
int pipe = usb_ff_bulk_output();
if(id == 0) {
usb_fxlink_header_t h;
usb_fxlink_image_t sh;
int size = azrp_width * azrp_height * 2;
usb_fxlink_fill_header(&h, "fxlink", type, size + sizeof sh);
sh.width = htole32(azrp_width);
sh.height = htole32(azrp_height);
sh.pixel_format = htole32(USB_FXLINK_IMAGE_RGB565);
usb_write_sync(pipe, &h, sizeof h, false);
usb_write_sync(pipe, &sh, sizeof sh, false);
}
usb_write_sync(pipe, fragment, size, false);
if(id == azrp_frag_count - 1) {
usb_commit_sync(pipe);
screenshot = false;
}
}
GUNUSED static void hook_dupdate(void)
{
if(screenshot) {
usb_fxlink_screenshot(true);
screenshot = false;
}
else if(videocapture) {
usb_fxlink_videocapture(false);
}
}
#endif /* LOG_USB_ENABLE */
int play_level(int level_id)
{
struct game game;
struct camera *camera = &game.camera;
struct player *player = &game.player;
game.level = level_create(level_id);
game.t = 0.0;
game.t_death = 0.0;
game.debug.footer = false;
game.debug.invincible = false;
camera->set_fov(120.0);
camera->screen_size = vec2(DWIDTH, DHEIGHT);
player->z = 0.0;
player->vz = 3.0;
player->platform = 0;
player->stance = player::Falling;
player->blueanim = 0.0;
player->jump_dir = 0;
player->jump_t = 0.0;
player->height = 1.0;
player->vheight = 0.0;
player->frame = 0.0;
player->energy_percent = 0.0;
/* Input buffering */
struct { int left, right, up, shift; } keybuffer = {};
/* FPS regulation setup */
int volatile need_frame = 1;
int last_frame_us = 0;
int timer = timer_configure(TIMER_ANY, 33000, GINT_CALL_SET(&need_frame));
timer_start(timer);
camera_track(camera, player);
log_printf("cylinder quasiradius: %s\n",str(space_cylinder_quasiradius()));
log_printf("player: at %s\n", str(player->pos()));
log_printf("camera: at %s, screen distance %s, platform %d, "
"angle vector %s\n",
str(camera->pos),
str(camera->screen_distance()),
camera->platform,
str(camera->angle_vector));
if(level_id == 4) {
player->energy_percent = 350.0;
player->height = num(-10.0);
game.t_death = num(10.0);
level_update(&game.level, num(350.0), 0);
}
bool game_run = true;
while(game_run) {
while(!need_frame) sleep();
need_frame = 0;
//======= Initial data updates =======//
num dt = 1.0 / 30;
game.t += dt;
prof_t perf_frame = prof_make();
prof_enter_norec(perf_frame);
level_update(&game.level, player->z, player->platform);
camera_track(camera, player);
struct platform *standing_on =
game_platform_under_player(&game, &game.player);
struct platform *hitting =
game_block_hitting_player(&game, &game.player);
//======= Rendering =======//
prof_t perf_comp = prof_make();
render_game(game, &perf_comp);
num floor = 0;
if(game.debug.footer) {
drect(0, DHEIGHT-20, DWIDTH-1, DHEIGHT-1, C_WHITE);
dprint(4, 209, C_BLACK, "render:%4d+%4dus comp:%4dus FPS:%02d",
prof_time(azrp_perf_render) - prof_time(azrp_perf_r61524),
prof_time(azrp_perf_r61524),
prof_time(perf_comp),
last_frame_us ? 1000000 / last_frame_us : 0);
r61524_display(gint_vram, DHEIGHT-20, 20, R61524_DMA_WAIT);
}
//======= Input =======//
key_event_t ev;
while((ev = pollevent()).type != KEYEV_NONE) {
if(ev.type == KEYEV_UP || ev.type == KEYEV_HOLD)
continue;
int key = ev.key;
if(key == KEY_EXIT || key == KEY_MENU)
game_run = false;
if(key == KEY_OPTN)
game.debug.footer = !game.debug.footer;
#if 0
if(key == KEY_VARS)
game.debug.invincible = !game.debug.invincible;
#endif
if(key == KEY_LEFT)
keybuffer.left = 8;
if(key == KEY_RIGHT)
keybuffer.right = 8;
if(key == KEY_UP)
keybuffer.up = 8;
if(key == KEY_SHIFT)
keybuffer.shift = 8;
}
if(!game_run) break;
int key = keybuffer.left ? KEY_LEFT :
keybuffer.right ? KEY_RIGHT :
keybuffer.up ? KEY_UP :
keybuffer.shift ? KEY_SHIFT : 0;
if(key && !player->airborne()) {
player->stance = player::Jumping;
player->jump_dir = (key == KEY_RIGHT) - (key == KEY_LEFT);
player->jump_t = 0.0;
player->jump_key = key;
player->vheight = JUMP_THRUST;
player->frame = 0.0;
keybuffer.left = 0;
keybuffer.right = 0;
keybuffer.up = 0;
keybuffer.shift = 0;
}
if(keybuffer.left > 0)
keybuffer.left--;
if(keybuffer.right > 0)
keybuffer.right--;
if(keybuffer.up > 0)
keybuffer.up--;
if(keybuffer.shift > 0)
keybuffer.shift--;
//======= Simulation =======//
num vz = player->vz * (num(1) + player->energy_percent / 200);
if(player->stance == player::Collided) {
game.t_death += dt;
}
else {
player->z += vz * dt;
player->height += player->vheight * dt;
}
/* Apply gravity */
num gravity = 0.0;
if(player->stance == player::Jumping) {
gravity = HOVERING_GRAVITY;
}
else if(player->stance == player::Falling) {
gravity = FALLING_GRAVITY;
}
player->vheight += gravity * dt;
floor = game_height_at(&game, player->z, player->platform);
if(player->airborne()) {
player->jump_t += dt;
/* Update the current platform number after rotation */
if(player->jump_t > TIME_ROTATION && player->jump_dir) {
int p = player->platform + player->jump_dir;
p = (p + PLATFORM_COUNT) % PLATFORM_COUNT;
player->platform = p;
player->jump_dir = 0;
}
/* Switch to falling if the jump key is released */
if(player->stance == player::Jumping
&& player->jump_t > TIME_JUMP_THRUST_MIN
&& !keydown(player->jump_key)) {
player->stance = player::Falling;
player->vheight = -1;
}
if((player->height >= floor - STEP_HEIGHT
&& player->height <= floor)
|| (game.debug.invincible && player->height < 0)) {
player->stance = player::Running;
player->jump_dir = 0;
player->jump_t = 0.0;
player->height = floor;
player->vheight = 0;
player->jump_key = 0;
player->frame = 0.0;
if(game.debug.invincible && player->height < 0)
player->height = 0;
}
}
else if(floor < player->height && player->stance != player::Collided) {
player->stance = player::Falling;
player->vheight = 0.0;
}
/* Death condition #1/2: inside a platform (hit it in front) */
bool death_1 = (player->height >= floor - PLAYER_HEIGHT &&
player->height < floor - STEP_HEIGHT)
|| (hitting != NULL);
/* Death condition #2/2: below the kill plane */
bool death_2 = (player->height < LEVEL_RADIUS - KILL_PLANE_RADIUS);
if(!game.debug.invincible && (death_1 || death_2)) {
if(player->stance != player::Collided)
shader_ptrace_reset();
player->stance = player::Collided;
}
else if(standing_on && standing_on->type == PLATFORM_BLUE) {
player->energy_percent += dt * vz * 5.5;
}
else if(standing_on && standing_on->type == PLATFORM_RED) {
standing_on->falling = true;
}
/* Blue platform animation progress */
if(standing_on && standing_on->type == PLATFORM_BLUE) {
player->blueanim += dt;
if(player->blueanim >= num(2.0))
player->blueanim -= num(2.0);
}
else if(player->blueanim > 0) {
if(player->blueanim < num(2.0))
player->blueanim = num(2.0);
player->blueanim += dt;
if(player->blueanim >= num(2.5))
player->blueanim = 0;
}
for(auto &p: game.level.platform_buffer) {
if(p.type == PLATFORM_RED && p.falling) {
p.height -= PLATFORM_FALL_SPEED * dt;
if(standing_on == &p)
player->height = p.height;
}
}
if(game.t_death >= TIME_DEATH_ANIMATION && keybuffer.shift)
break;
game_advance(&game);
prof_leave_norec(perf_frame);
last_frame_us = prof_time(perf_frame);
}
timer_stop(timer);
return 0;
}
int main(void)
{
int level;
__printf_enable_fp();
prof_init();
render_init();
space_init();
extern font_t font_boson;
dfont(&font_boson);
azrp_config_scale(1);
#if LOG_USB_ENABLE
dclear(C_WHITE);
dtext_opt(DWIDTH/2, DHEIGHT/2, C_BLACK, C_NONE, DTEXT_CENTER, DTEXT_MIDDLE,
"Waiting for USB log...", -1);
dupdate();
log_init(true);
azrp_hook_set_prefrag(hook_prefrag);
dupdate_set_hook(GINT_CALL(hook_dupdate));
keydev_set_async_filter(keydev_std(), async_event_filter);
#endif
while (1) {
if (menu_title() != 0) {
gint_osmenu();
continue;
}
while (menu_select_level(&level) >= 0) {
play_level(level + 1);
}
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink