badge/jumpnrun/jumpnrun.c

   1 #include "game_state.h"
   2 #include "jumpnrun.h"
   3 #include "collision.h"
   4 #include "levels.h"
   5 #include "player.h"
   6 #include "render.h"
   7 #include "stats.h"
   8
   9 #include "../ui/display.h"
  10 #include "../ui/event.h"
  11 #include "../ui/sprite.h"
  12 #include "../util/util.h"
  13
  14 #include <assert.h>
  15 #include <math.h>
  16 #include <stddef.h>
  17 #include <stdio.h>
  18
  19 static vec2d       gravity     () { return (vec2d) { FIXED_POINT(0,   0), FIXED_POINT(0,  56) }; }
  20 static vec2d       move_max    () { return (vec2d) { FIXED_POINT(0, 600), FIXED_POINT(1, 300) }; }
  21 static fixed_point accel_horiz () { return           FIXED_POINT(0,  50); }
  22 static fixed_point accel_vert  () { return           FIXED_POINT(0, 167); }
  23 static fixed_point drag_factor () { return           FIXED_POINT(0, 854); }
  24
  25 static inline int imax(int x, int y) {
  26   return x < y ? y : x;
  27 }
  28
  29 static inline fixed_point hacker_left  (vec2d const *pos, jumpnrun_game_state const *state) { (void) state; return pos->x; }
  30 static inline fixed_point hacker_top   (vec2d const *pos, jumpnrun_game_state const *state) { (void) state; return pos->y; }
  31 static inline fixed_point hacker_right (vec2d const *pos, jumpnrun_game_state const *state) { return fixed_point_add(hacker_left(pos, state), jumpnrun_player_extents().x); }
  32 static inline fixed_point hacker_bottom(vec2d const *pos, jumpnrun_game_state const *state) { return fixed_point_add(hacker_top (pos, state), jumpnrun_player_extents().y); }
  33
  34 int jumpnrun_level_assert_left_side(jumpnrun_game_state const *state) {
  35   static int const lmargin = 20;
  36   static int const rmargin = 50;
  37
  38   int pos_cur = fixed_point_cast_int(state->player.base.hitbox.pos.x);
  39   int pos_rel = pos_cur - state->screen_left;
  40
  41   if(pos_rel < lmargin) {
  42     return imax(0, pos_cur - lmargin);
  43   } else if(pos_rel > BADGE_DISPLAY_WIDTH - rmargin) {
  44     return pos_cur - (BADGE_DISPLAY_WIDTH - rmargin);
  45   }
  46
  47   return state->screen_left;
  48 }
  49
  50 static int jumpnrun_bsearch_tile(jumpnrun_level const *lv, jumpnrun_game_state const *state) {
  51   int front = 0;
  52   int len   = lv->header.tile_count;
  53
  54   while(len > 0) {
  55     int mid = front + len / 2;
  56
  57     if(fixed_point_lt(tile_right(&lv->tiles[mid]), FIXED_INT(state->screen_left - JUMPNRUN_MAX_SPAWN_MARGIN))) {
  58       front = mid + 1;
  59       len -= len / 2 + 1;
  60     } else {
  61       len /= 2;
  62     }
  63   }
  64
  65   return front;
  66 }
  67
  68 jumpnrun_tile_range jumpnrun_visible_tiles(jumpnrun_level const *lv,
  69                                            jumpnrun_game_state const *state) {
  70   jumpnrun_tile_range r;
  71
  72   r.first = jumpnrun_bsearch_tile(lv, state);
  73
  74   for(r.last = r.first;
  75       r.last < lv->header.tile_count && lv->tiles[r.last].pos.x * JUMPNRUN_TILE_PIXEL_WIDTH < state->screen_left + BADGE_DISPLAY_WIDTH + JUMPNRUN_MAX_SPAWN_MARGIN;
  76       ++r.last)
  77     ;
  78
  79   return r;
  80 }
  81
  82 void jumpnrun_apply_gravity(vec2d *inertia) {
  83   *inertia = vec2d_add(*inertia, gravity());
  84 }
  85
  86 void jumpnrun_passive_movement(vec2d *inertia)
  87 {
  88   jumpnrun_apply_gravity(inertia);
  89
  90   inertia->x = fixed_point_min(fixed_point_max(fixed_point_neg(move_max().x), inertia->x), move_max().x);
  91   inertia->y = fixed_point_min(fixed_point_max(fixed_point_neg(move_max().y), inertia->y), move_max().y);
  92 }
  93
  94 static void jumpnrun_apply_movement(jumpnrun_level      const *lv,
  95                                     jumpnrun_tile_range const *tilerange,
  96                                     jumpnrun_game_state       *state,
  97                                     vec2d                     *inertia_mod) {
  98   switch(badge_event_current_input_state() &
  99          (BADGE_EVENT_KEY_LEFT |
 100           BADGE_EVENT_KEY_RIGHT)) {
 101   case BADGE_EVENT_KEY_LEFT:
 102     //    state->player.base.inertia.x = state->player.touching_ground ? fixed_point_sub(state->player.base.inertia.x, accel_horiz()) : fixed_point_neg(speed_jump_x());
 103     state->player.base.inertia.x = fixed_point_sub(state->player.base.inertia.x, accel_horiz());
 104     state->player.base.flags |= JUMPNRUN_MOVEABLE_MIRRORED;
 105     break;
 106   case BADGE_EVENT_KEY_RIGHT:
 107     //    state->player.base.inertia.x = state->player.touching_ground ? fixed_point_add(state->player.base.inertia.x, accel_horiz()) : speed_jump_x();
 108     state->player.base.inertia.x = fixed_point_add(state->player.base.inertia.x, accel_horiz());
 109     state->player.base.flags &= ~JUMPNRUN_MOVEABLE_MIRRORED;
 110     break;
 111   default:
 112     if(jumpnrun_moveable_touching_ground(&state->player.base)) {
 113       state->player.base.inertia.x = fixed_point_mul(state->player.base.inertia.x, drag_factor());
 114     } //else {
 115       //state->player.base.inertia.x = FIXED_INT(0);
 116     //}
 117
 118     break;
 119   }
 120
 121   if(state->player.base.jumpable_frames == 0) {
 122     // intentionally left blank.
 123   } else if(badge_event_current_input_state() & BADGE_EVENT_KEY_BTN_A) {
 124     state->player.base.inertia.y = fixed_point_sub(state->player.base.inertia.y, accel_vert());
 125     --state->player.base.jumpable_frames;
 126   } else {
 127     state->player.base.jumpable_frames = 0;
 128   }
 129
 130   jumpnrun_passive_movement(&state->player.base.inertia);
 131
 132   vec2d new_pos = vec2d_add(state->player.base.hitbox.pos, state->player.base.inertia);
 133
 134   if(fixed_point_lt(new_pos.x, FIXED_INT(state->screen_left))) {
 135     new_pos.x = FIXED_INT(state->screen_left);
 136     state->player.base.inertia.x = FIXED_INT(0);
 137   }
 138
 139   *inertia_mod = state->player.base.inertia;
 140   bool killed = collisions_tiles_displace(&new_pos, &state->player.base, lv, tilerange, inertia_mod);
 141   state->player.base.inertia = *inertia_mod;
 142
 143   if(fixed_point_gt(rectangle_top(&state->player.base.hitbox), FIXED_INT(BADGE_DISPLAY_HEIGHT))) {
 144     jumpnrun_player_despawn(&state->player);
 145   } else if(killed) {
 146     jumpnrun_player_kill   (&state->player);
 147   }
 148 }
 149
 150 void jumpnrun_level_tick(jumpnrun_level      *lv,
 151                          jumpnrun_game_state *state)
 152 {
 153   jumpnrun_tile_range tilerange = jumpnrun_visible_tiles(lv, state);
 154   vec2d inertia_mod = state->player.base.inertia;
 155
 156   if(jumpnrun_player_alive(&state->player)) {
 157     jumpnrun_apply_movement(lv, &tilerange, state, &inertia_mod);
 158   }
 159
 160   state->screen_left = jumpnrun_level_assert_left_side(state);
 161
 162   if(state->tick == 0) {
 163     badge_framebuffer fb = { { { 0 } } };
 164
 165     for(uint16_t tile = tilerange.first; tile < tilerange.last; ++tile) {
 166       jumpnrun_render_tile(&fb, state, &lv->tiles[tile]);
 167     }
 168
 169     for(uint16_t item = 0; item < lv->header.item_count; ++item) {
 170       jumpnrun_item *item_obj = &lv->items[item];
 171
 172       if(item_obj->flags & JUMPNRUN_ITEM_COLLECTED) {
 173         continue;
 174       }
 175
 176       int screenpos = fixed_point_cast_int(item_obj->pos.x) - state->screen_left;
 177       if(screenpos > -item_obj->type->sprite.width &&
 178          screenpos < BADGE_DISPLAY_WIDTH) {
 179         rectangle item_rect = rect_from_item(item_obj);
 180
 181         if(rectangle_intersect(&state->player.base.hitbox, &item_rect)) {
 182           item_obj->type->on_collect(item_obj, state, lv);
 183         }
 184
 185         jumpnrun_render_item(&fb, state, item_obj);
 186       }
 187     }
 188
 189     for(uint16_t shot_ix = 0; shot_ix < JUMPNRUN_MAX_SHOTS; ++shot_ix) {
 190       jumpnrun_shot *shot = &state->shots[shot_ix];
 191       jumpnrun_shot_process(shot);
 192       if(jumpnrun_shot_spawned(shot)) {
 193         jumpnrun_render_shot(&fb, state, shot);
 194       }
 195     }
 196
 197     for(uint16_t enemy_ix = 0; enemy_ix < lv->header.enemy_count; ++enemy_ix) {
 198       jumpnrun_enemy *enemy = &lv->enemies[enemy_ix];
 199       jumpnrun_process_enemy(enemy, &fb, state, lv, &tilerange, &inertia_mod);
 200     }
 201
 202     if(jumpnrun_player_alive(&state->player)) {
 203       jumpnrun_render_player(&fb, state);
 204       jumpnrun_player_advance_animation(&state->player);
 205     } else if(jumpnrun_moveable_finished_dying(&state->player.base)) {
 206       jumpnrun_player_despawn(&state->player);
 207     } else if(jumpnrun_moveable_dying(&state->player.base)) {
 208       jumpnrun_render_splosion(&fb, state, &state->player.base);
 209       state->player.base.tick_minor += JUMPNRUN_STATE_TICKS_PER_FRAME;
 210     }
 211
 212     badge_framebuffer_flush(&fb);
 213
 214     if(!jumpnrun_moveable_touching_ground(&state->player.base)) {
 215       state->player.base.anim_frame = 2;
 216     } else if(fixed_point_gt(fixed_point_abs(state->player.base.inertia.x), FIXED_POINT(0, 200))) {
 217       state->player.base.anim_frame = (state->player.base.anim_frame + 1) % JUMPNRUN_PLAYER_FRAMES;
 218     } else {
 219       state->player.base.anim_frame = 0;
 220     }
 221   } else {
 222     for(uint16_t shot_ix = 0; shot_ix < JUMPNRUN_MAX_SHOTS; ++shot_ix) {
 223       jumpnrun_shot_process(&state->shots[shot_ix]);
 224     }
 225
 226     for(uint16_t enemy_ix = 0; enemy_ix < lv->header.enemy_count; ++enemy_ix) {
 227       jumpnrun_enemy *enemy = &lv->enemies[enemy_ix];
 228       jumpnrun_process_enemy(enemy, NULL, state, lv, &tilerange, &inertia_mod);
 229     }
 230   }
 231
 232   state->player.base.inertia = inertia_mod;
 233   ++state->tick;
 234   if(state->tick == JUMPNRUN_STATE_TICKS_PER_FRAME) {
 235     state->tick = 0;
 236   }
 237 }
 238
 239 uint8_t jumpnrun_play_level(char const *lvname) {
 240   jumpnrun_level lv;
 241
 242   JUMPNRUN_LEVEL_LOAD(lv, lvname);
 243
 244   jumpnrun_game_state gs;
 245
 246   jumpnrun_game_state_init(&gs, &lv);
 247
 248   do {
 249     jumpnrun_show_lives_screen(&gs);
 250     jumpnrun_game_state_respawn(&gs, &lv);
 251
 252     while((gs.player.base.flags & JUMPNRUN_PLAYER_DEAD) == 0 &&
 253           (gs.            flags & JUMPNRUN_STATE_WON  ) == 0) {
 254       badge_event_t ev = badge_event_wait();
 255
 256       switch(badge_event_type(ev)) {
 257       case BADGE_EVENT_USER_INPUT:
 258       {
 259         uint8_t old_state = badge_event_old_input_state(ev);
 260         uint8_t new_state = badge_event_new_input_state(ev);
 261         uint8_t new_buttons = new_state & (old_state ^ new_state);
 262
 263         if((new_buttons & BADGE_EVENT_KEY_BTN_A) && jumpnrun_moveable_touching_ground(&gs.player.base)) {
 264           gs.player.base.jumpable_frames = 12;
 265         }
 266
 267         if((new_buttons & BADGE_EVENT_KEY_BTN_B)) {
 268           uint8_t i;
 269           for(i = 0; i < JUMPNRUN_MAX_SHOTS && jumpnrun_shot_spawned(&gs.shots[i]); ++i)
 270             ;
 271
 272           if(i < JUMPNRUN_MAX_SHOTS && jumpnrun_player_alive(&gs.player)) {
 273             jumpnrun_shot_spawn(gs.shots + i, &gs);
 274           }
 275         }
 276
 277         break;
 278       }
 279       case BADGE_EVENT_GAME_TICK:
 280       {
 281         jumpnrun_level_tick(&lv, &gs);
 282         break;
 283       }
 284       }
 285     }
 286   } while((gs.flags & JUMPNRUN_STATE_WON) == 0 && gs.player.lives-- != 0);
 287
 288   if(gs.flags & JUMPNRUN_STATE_WON) {
 289     jumpnrun_show_you_rock();
 290     return JUMPNRUN_WON;
 291   }
 292
 293   if(++gs.player.lives == 0) {
 294     jumpnrun_show_game_over();
 295     return JUMPNRUN_LOST;
 296   }
 297
 298   return JUMPNRUN_ERROR;
 299 }