entity.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3
   4 #include <util.h>
   5 #include <video.h>
   6 #include <stage.h>
   7 #include <input.h>
   8 #include <entity.h>
   9
  10
  11 extern Y* mk_ent0(void);
  12
  13 #define MAX_PLAYERS 4
  14 #define MAX_ENTS 128
  15
  16 static Y* entities[MAX_ENTS];
  17 static struct {int x, y;} ent_v[MAX_ENTS];
  18 static int next_ent = MAX_PLAYERS;
  19
  20
  21
  22 int inside_rect(int x, int y, int x0, int y0, int x1, int y1){
  23         return !(x < x0 || x > x1 || y < y0 || y > y1);
  24 }
  25
  26 int rects_overlap(rect r1, rect r2){
  27         return !(
  28                 r1.x > r2.x + r2.w ||
  29                 r2.x > r1.x + r1.w ||
  30                 r1.y > r2.y + r2.h ||
  31                 r2.y > r1.y + r1.h
  32         );
  33 }
  34
  35
  36
  37 int update_noop(Y* e){
  38         return 0;
  39 }
  40
  41 int stage_noop(Y* e, struct stghit hit){
  42         return 0;
  43 }
  44
  45 int overlap_noop(Y* e, Y* f){
  46         return 0;
  47 }
  48
  49 int diverge_noop(Y* e, Y* f){
  50         return 0;
  51 }
  52 static void find_visible_ents(int ents[], int* count){
  53
  54 }
  55
  56 void entity_master_simulate(){
  57         int visible_ents[MAX_ENTS];
  58         int visible_count = 0;
  59
  60         find_visible_ents(visible_ents, &visible_count);
  61
  62         {
  63                 Y* e = entities[0];
  64                 int x0 = e->x;
  65                 int y0 = e->y;
  66                 int vx;
  67                 int vy;
  68                 int w = e->box.w;
  69                 int h = e->box.h;
  70                 struct stghit hit;
  71
  72                 e->update(e);
  73
  74                 vx = e->x - x0;
  75                 vy = e->y - y0;
  76
  77                 hit = stage_collide_rect(
  78                         e->x, e->y,
  79                         w, h,
  80                         vx, vy
  81                 );
  82
  83                 if(hit.yes){
  84                         e->stage(e, hit);
  85                 }
  86         }
  87
  88         /* for all pairs, if overlapping do events */
  89         /* for all overlaps, if not overlapping do events */
  90         /* for all in screen, move and record v */
  91         /* for all in screen, stage collision */
  92 }
  93
  94 void draw_entities(){
  95         int i;
  96         Y* e;
  97         for(i=0; i<MAX_ENTS; i++){
  98                 if(entities[i] != NULL){
  99                         e = entities[i];
 100                         draw_gfx(0, e->x/1024, e->y/1024, 16, 0, 8, 8);
 101                 }
 102         }
 103 }
 104
 105 void setup_test_entities(){
 106         int i;
 107         for(i=0; i<MAX_ENTS; i++){
 108                 entities[i] = NULL;
 109         }
 110
 111         entities[0] = mk_ent0();
 112 }
 113
 114 void player_press(int player, enum input_button button){
 115         Y* e = entities[0];
 116         switch(button){
 117                 case LEFT_BUTTON: e->r.a = -1000; break;
 118                 case RIGHT_BUTTON: e->r.a = 1000; break;
 119                 case UP_BUTTON: e->r.b = -1000; break;
 120                 case DOWN_BUTTON: e->r.b = 1000; break;
 121                 case FIRE_BUTTON: stage_debug(); break;
 122                 default: break;
 123         }
 124 }
 125
 126 void player_release(int player, enum input_button button){
 127         Y* e = entities[0];
 128         switch(button){
 129                 case LEFT_BUTTON: e->r.a = 0; break;
 130                 case RIGHT_BUTTON: e->r.a = 0; break;
 131 //              case UP_BUTTON: e->r.b = 0; break;
 132 //              case DOWN_BUTTON: e->r.b = 0; break;
 133                 default: break;
 134         }
 135 }
 136
 137 /*
 138 struct entity {
 139         int x; int y;  spatial
 140         int z;  z order
 141         unsigned flbits;  common class
 142         int gfx;  image
 143         struct {int a,b,c,d,e,f;} r;
 144         struct {int x, y, w, h;} box; used to detect collision
 145         int (*update)(Y*);
 146         int (*stage)(Y*,int,int);
 147         int (*overlap)(Y*,Y*);
 148         int (*diverge)(Y*,Y*);
 149 };
 150 */
 151
 152 Y* mk_dummy_ent(int x, int y){
 153         memory clear_r = {0,0,0,0,0,0};
 154         rect standard = {0,0,16,16};
 155         Y* ent = malloc(sizeof(Y));
 156         ent->x = x;
 157         ent->y = y;
 158         ent->z = 0;
 159         ent->flbits = 0;
 160         ent->gfx = 0;
 161         ent->r = clear_r;
 162         ent->box = standard;
 163         ent->update = update_noop;
 164         ent->stage = stage_noop;
 165         ent->overlap = overlap_noop;
 166         ent->diverge = diverge_noop;
 167         return ent;
 168 }
 169
 170
 171
 172
 173 int mini_rand(int g){
 174         return (g*9 + 171) % 256;
 175 }
 176
 177
 178
 179
 180