rocks.c

   1 #include <SDL_image.h>
   2 #include <math.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "common.h"
   7 #include "config.h"
   8 #include "file.h"
   9 #include "globals.h"
  10 #include "mt.h"
  11 #include "rocks.h"
  12
  13 SDL_Surface *load_image(char *filename);
  14
  15 struct rock rocks[MAXROCKS], *free_rocks;
  16
  17 struct rock **rock_buckets[2];
  18 int n_buckets;
  19 // we have two sets of buckets -- this variable tells which we are using.
  20 int p;
  21 int bw, bh;
  22 int grid_size;
  23
  24 SDL_Surface *surf_rock[NROCKS];
  25 struct shape rock_shapes[NROCKS];
  26
  27 // timers for rock generation.
  28 float rtimers[4];
  29
  30 uint32_t nrocks;
  31 float nrocks_timer;
  32 float nrocks_inc_ticks = 2*60*20/(F_ROCKS-I_ROCKS);
  33
  34 // constants for rock generation.
  35 #define KH (32*20)  // 32 s for a speed=1 rock to cross the screen horizontally.
  36 #define KV (24*20)  // 24 s for a speed=1 rock to cross the screen vertically.
  37 #define RDX 2.5  // range for rock dx values (+/-)
  38 #define RDY 2.5  // range for rock dy values (+/-)
  39
  40 static inline struct rock **
  41 bucket(int x, int y, int p)
  42 {
  43         int b = (x+grid_size)/grid_size + bw*((y+grid_size)/grid_size);
  44         return &rock_buckets[p][b];
  45 }
  46
  47 void
  48 init_buckets(void)
  49 {
  50         int scr_grid_w = (XSIZE+2*grid_size-1) / grid_size;
  51         int scr_grid_h = (YSIZE+2*grid_size-1) / grid_size;
  52         bw = 1 + scr_grid_w + 1;
  53         bh = 1 + scr_grid_h + 1;
  54         n_buckets = bw * bh;
  55
  56         rock_buckets[0] = malloc(n_buckets * sizeof(struct rock *));
  57         rock_buckets[1] = malloc(n_buckets * sizeof(struct rock *));
  58         if(!rock_buckets[0] || !rock_buckets[1]) {
  59                 fprintf(stderr, "Can't allocate rock buckets.\n");
  60                 exit(1);
  61         }
  62         p = 0;
  63 }
  64
  65 void
  66 transfer_rock(struct rock *r, struct rock **from, struct rock **to)
  67 {
  68         *from = &r->next->rock;
  69         r->next = SPRITE(*to);
  70         *to = r;
  71 }
  72
  73 void
  74 reset_rocks(void)
  75 {
  76         int i;
  77
  78         for(i=0; i<MAXROCKS; i++) rocks[i].image = NULL;
  79         rocks[0].next = NULL; free_rocks = &rocks[MAXROCKS-1];
  80         for(i = 1; i<MAXROCKS; i++) rocks[i].next = SPRITE(&rocks[i-1]);
  81         for(i = 0; i<n_buckets; i++) {
  82                 rock_buckets[0][i] = NULL;
  83                 rock_buckets[1][i] = NULL;
  84         }
  85
  86         nrocks = I_ROCKS;
  87         nrocks_timer = 0;
  88 }
  89
  90 #define ROCK_LEN sizeof("sprites/rockXX.png")
  91
  92 int
  93 init_rocks(void)
  94 {
  95         int i;
  96         char a[ROCK_LEN];
  97         int maxw=0, maxh=0;
  98
  99         for(i = 0; i<NROCKS; i++) {
 100                 snprintf(a, ROCK_LEN, "sprites/rock%02d.png", i);
 101                 NULLERROR(surf_rock[i] = load_image(a));
 102                 get_shape(surf_rock[i], &rock_shapes[i]);
 103                 maxw = max(maxw, rock_shapes[i].w);
 104                 maxh = max(maxh, rock_shapes[i].h);
 105         }
 106         grid_size = max(maxw, maxh) * 3 / 2;
 107         init_buckets();
 108         reset_rocks();
 109         return 0;
 110 }
 111
 112 enum { LEFT, RIGHT, TOP, BOTTOM };
 113
 114
 115 // compute the number of rocks/tick that should be coming from each side,
 116 // and the speed ranges of rocks coming from each side
 117 void
 118 rock_sides(float *ti, float *speed_min, float *speed_max)
 119 {
 120         float dx0,dx1, dy0,dy1;
 121         float hfactor, vfactor;
 122         int i;
 123
 124         for(i=0; i<4; i++) ti[i] = 0;
 125         for(i=0; i<4; i++) speed_min[i] = 0;
 126         for(i=0; i<4; i++) speed_max[i] = 0;
 127         hfactor = (float)nrocks/KH; vfactor = (float)nrocks/KV;
 128
 129         dx0 = -RDX - screendx; dx1 = RDX - screendx;
 130         dy0 = -RDY - screendy; dy1 = RDY - screendy;
 131
 132         if(dx0 < 0) {
 133                 speed_max[RIGHT] = -dx0;
 134                 if(dx1 < 0) {
 135                         // Rocks moving left only. So the RIGHT side of the screen
 136                         speed_min[RIGHT] = -dx1;
 137                         ti[RIGHT] = -(dx0+dx1)/2;
 138                 } else {
 139                         // Rocks moving left and right
 140                         speed_max[LEFT] = dx1;
 141                         ti[RIGHT] = -dx0/2;
 142                         ti[LEFT] = dx1/2;
 143                 }
 144         } else {
 145                 // Rocks moving right only. So the LEFT side of the screen
 146                 speed_min[LEFT] = dx0;
 147                 speed_max[LEFT] = dx1;
 148                 ti[LEFT] = (dx0+dx1)/2;
 149         }
 150         ti[LEFT] *= hfactor;
 151         ti[RIGHT] *= hfactor;
 152
 153         if(dy0 < 0) {
 154                 speed_max[BOTTOM] = -dy0;
 155                 if(dy1 < 0) {
 156                         // Rocks moving up only. So the BOTTOM of the screen
 157                         speed_min[BOTTOM] = -dy1;
 158                         ti[BOTTOM] = -(dy0+dy1)/2;
 159                 } else {
 160                         // Rocks moving up and down
 161                         speed_max[TOP] = dy1;
 162                         ti[BOTTOM] = -dy0/2;
 163                         ti[TOP] = dy1/2;
 164                 }
 165         } else {
 166                 // Rocks moving down only. so the TOP of the screen
 167                 speed_min[TOP] = dy0;
 168                 speed_max[TOP] = dy1;
 169                 ti[TOP] = (dy0+dy1)/2;
 170         }
 171         ti[TOP] *= vfactor;
 172         ti[BOTTOM] *= vfactor;
 173 }
 174
 175 float
 176 weighted_rnd_range(float min, float max) {
 177         return sqrt(min * min + frnd() * (max * max - min * min));
 178 }
 179
 180 void
 181 new_rocks(void)
 182 {
 183         int i;
 184         struct rock *r;
 185         float ti[4];
 186         float rmin[4];
 187         float rmax[4];
 188
 189         if(nrocks < F_ROCKS) {
 190                 nrocks_timer += t_frame;
 191                 if(nrocks_timer >= nrocks_inc_ticks) {
 192                         nrocks_timer -= nrocks_inc_ticks;
 193                         nrocks++;
 194                 }
 195         }
 196
 197         rock_sides(ti, rmin, rmax);
 198
 199         // increment timers
 200         for(i=0; i<4; i++) rtimers[i] += ti[i]*t_frame;
 201
 202         // generate rocks
 203         for(i=0; i<4; i++) {
 204                 while(rtimers[i] >= 1) {
 205                         rtimers[i] -= 1;
 206                         if(!free_rocks) return;  // sorry, we ran out of rocks!
 207                         r = free_rocks;
 208                         r->type = urnd() % NROCKS;
 209                         r->image = surf_rock[r->type];
 210                         r->shape = &rock_shapes[r->type];
 211                         switch(i) {
 212                                 case RIGHT:
 213                                         r->x = XSIZE;
 214                                         r->y = frnd()*(YSIZE + r->image->h);
 215
 216                                         r->dx = -weighted_rnd_range(rmin[i], rmax[i]) + screendx;
 217                                         r->dy = RDY*crnd();
 218                                         break;
 219                                 case LEFT:
 220                                         r->x = -r->image->w;
 221                                         r->y = frnd()*(YSIZE + r->image->h);
 222
 223                                         r->dx = weighted_rnd_range(rmin[i], rmax[i]) + screendx;
 224                                         r->dy = RDY*crnd();
 225                                         break;
 226                                 case BOTTOM:
 227                                         r->x = frnd()*(XSIZE + r->image->w);
 228                                         r->y = YSIZE;
 229
 230                                         r->dx = RDX*crnd();
 231                                         r->dy = -weighted_rnd_range(rmin[i], rmax[i]) + screendy;
 232                                         break;
 233                                 case TOP:
 234                                         r->x = frnd()*(XSIZE + r->image->w);
 235                                         r->y = -r->image->h;
 236
 237                                         r->dx = RDX*crnd();
 238                                         r->dy = weighted_rnd_range(rmin[i], rmax[i]) + screendy;
 239                                         break;
 240                         }
 241                         transfer_rock(r, &free_rocks, bucket(r->x, r->y, p));
 242                 }
 243         }
 244 }
 245
 246 void
 247 move_rocks(void)
 248 {
 249         int b;
 250         struct rock **head;
 251         struct rock *r;
 252
 253         // Move all the rocks
 254         for(b=0; b<n_buckets; b++) {
 255                 head=&rock_buckets[p][b]; r=*head;
 256                 while(*head) {
 257                         r=*head;
 258
 259                         // move
 260                         r->x += (r->dx - screendx)*t_frame;
 261                         r->y += (r->dy - screendy)*t_frame;
 262
 263                         // clip it, or sort it into the other bucket set
 264                         // (either way we move it out of this list).
 265                         if(r->x + r->image->w < 0 || r->x >= XSIZE
 266                                         || r->y + r->image->h < 0 || r->y >= YSIZE) {
 267                                 transfer_rock(r, head, &free_rocks);
 268                                 r->image = NULL;
 269                         } else transfer_rock(r, head, bucket(r->x, r->y, 1-p));
 270                 }
 271         }
 272         p = 1-p;  // switch current set of buckets.
 273 }
 274
 275 void
 276 draw_rocks(void)
 277 {
 278         int i;
 279         SDL_Rect dest;
 280
 281         for(i=0; i<MAXROCKS; i++) {
 282                 if(!rocks[i].image) continue;
 283                 dest.x = rocks[i].x; dest.y = rocks[i].y;
 284                 SDL_BlitSurface(rocks[i].image,NULL,surf_screen,&dest);
 285         }
 286 }
 287
 288 int
 289 hit_in_bucket(struct rock *r, float x, float y, struct shape *shape)
 290 {
 291         for(; r; r=&r->next->rock) {
 292                 if(collide(x - r->x, y - r->y, r->shape, shape)) return 1;
 293         }
 294         return 0;
 295 }
 296
 297 int
 298 hit_rocks(float x, float y, struct shape *shape)
 299 {
 300         int ix, iy;
 301         int l, r, t, b;
 302         struct rock **bucket;
 303
 304         ix = x + grid_size; iy = y + grid_size;
 305         l = ix / grid_size; r = (ix+shape->w)/grid_size;
 306         t = iy / grid_size; b = (iy+shape->h)/grid_size;
 307         bucket = &rock_buckets[p][l + t*bw];
 308
 309         if(hit_in_bucket(*bucket, x, y, shape)) return true;
 310         if(l > 0 && hit_in_bucket(*(bucket-1), x, y, shape)) return true;
 311         if(t > 0 && hit_in_bucket(*(bucket-bw), x, y, shape)) return true;
 312         if(l > 0 && t > 0 && hit_in_bucket(*(bucket-1-bw), x, y, shape)) return true;
 313
 314         if(r > l) {
 315                 if(hit_in_bucket(*(bucket+1), x, y, shape)) return true;
 316                 if(t > 0 && hit_in_bucket(*(bucket+1-bw), x, y, shape)) return true;
 317         }
 318         if(b > t) {
 319                 if(hit_in_bucket(*(bucket+bw), x, y, shape)) return true;
 320                 if(l > 0 && hit_in_bucket(*(bucket-1+bw), x, y, shape)) return true;
 321         }
 322         if(r > l && b > t && hit_in_bucket(*(bucket+1+bw), x, y, shape)) return true;
 323         return false;
 324 }
 325
 326 int
 327 pixel_hit_in_bucket(struct rock *r, float x, float y)
 328 {
 329         for(; r; r=&r->next->rock) {
 330                 if(x < r->x || y < r->y) continue;
 331                 if(pixel_collide(x - r->x, y - r->y, r->shape)) return 1;
 332         }
 333         return 0;
 334 }
 335
 336 int
 337 pixel_hit_rocks(float x, float y)
 338 {
 339         int ix, iy;
 340         int l, t;
 341         struct rock **bucket;
 342
 343         ix = x + grid_size; iy = y + grid_size;
 344         l = ix / grid_size; t = iy / grid_size;
 345         bucket = &rock_buckets[p][l + t*bw];
 346         if(pixel_hit_in_bucket(*bucket, x, y)) return true;
 347         if(l > 0 && pixel_hit_in_bucket(*(bucket-1), x, y)) return true;
 348         if(t > 0 && pixel_hit_in_bucket(*(bucket-bw), x, y)) return true;
 349         if(l > 0 && t > 0 && pixel_hit_in_bucket(*(bucket-1-bw), x, y)) return true;
 350         return false;
 351 }
 352
 353 void
 354 blast_rocks(float x, float y, float radius, int onlyslow)
 355 {
 356         int b;
 357         struct rock *r;
 358         float dx, dy, n;
 359
 360         if(onlyslow) return;
 361
 362         for(b=0; b<n_buckets; b++) {
 363                 for(r=rock_buckets[p][b]; r; r=&r->next->rock) {
 364                         if(r->x <= 0) continue;
 365
 366                         // This makes it so your explosion from dying magically doesn't leave
 367                         // any rocks that aren't moving much on the x axis. If onlyslow is set,
 368                         // only rocks that are barely moving will be pushed.
 369                         if(onlyslow && (r->dx - screendx < -4 || r->dx - screendx > 3)) continue;
 370
 371                         dx = r->x - x;
 372                         dy = r->y - y;
 373
 374                         n = sqrt(dx*dx + dy*dy);
 375                         if(n < radius) {
 376                                 n *= 15;
 377                                 r->dx += 54.0*dx/n;
 378                                 r->dy += 54.0*dy/n;
 379                         }
 380                 }
 381         }
 382 }