obstacle.c

Go to the documentation of this file.

#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include "obstacle.h"
#include "game.h"
#include "gameconfig.h"
#include "color.h"
#include "tanksprite.h"

Obstacle *obstacles = NULL;

void ObstacleInit() {
    int loop;
    Obstacle *obst;
    // the obstacle array should already be initialized
    assert(obstacles != NULL);
    // loop through the obstacles
    for (obst = obstacles, loop = gameOpts.obstacles; loop > 0;
    loop--, obst++) {
        // compute screen coordinates
        obst->ri.loc.h = obst->loc.h * dInfo.luw;
        obst->ri.loc.w = obst->loc.w * dInfo.luh;
        obst->ri.loc.x = obst->loc.x * dInfo.luw;
        obst->ri.loc.y = obst->loc.y * dInfo.luh;
        // draw the obstacles as solid rectangles
        obst->ri.renderer = SolidFillRenderer;
        // clear out a few values
        obst->ri.parent = NULL;
        obst->ri.next = obst->ri.prev = NULL;
        // use the already set obstacle color
        obst->ri.data = &(colorVals[COLOR_OBSTACLE]);
        // add the item to the render system
        AddRenderItem(&(obst->ri), LAYER_OBSTACLES);
        // make it visible in the next frame
        PlaceRenderItem(&(obst->ri));
    }
}

void ObstacleUninit() {
    int loop;
    Obstacle *obst;
    // if there are no obstacles . . .
    if ((loop = gameOpts.obstacles) == 0) {
        // . . . there is nothing to do
        return;
    }
    // loop through the obstacles
    for (obst = obstacles; loop > 0; loop--, obst++) {
        // remove the obstacle's render item
        RemoveRenderItem(&(obst->ri));
    }
    // deallocate the obstacles
    free(obstacles);
    // clear the count
    gameOpts.obstacles = 0;
}

Bool IsCollidingObstacle(Player *p, Obstacle *o) {
    SDL_Rect rect;
    int delta;
    Uint8 *pSprite;
    
    // Compute overlap region.
    if ((delta = o->loc.y - (p->y >> 8)) > 0) {
        // check for no vertical overlap
        if (delta >= 8)
            return FALSE;
        // set y starting position
        rect.y = delta;
        // set the height of the overlap
        rect.h = 8 - delta;
    }
    else {
        // check for no vertical overlap
        if (-delta >= o->loc.h)
            return FALSE;
        // set the overlap height
        if ((Sint16)(rect.h = o->loc.h + delta) > 8)
            rect.h = 8;
        // set y starting position
        rect.y = 0;
    }
    // see which is further left
    if ((delta = o->loc.x - (p->x >> 8)) > 0) {
        // check for no horizontal overlap
        if (delta >= 8)
            return FALSE;
        // set x starting position
        rect.x = delta;
        // set the width shift
        rect.w = delta;
    }
    else {
        // check for no horizontal overlap
        if (-delta >= o->loc.w)
            return FALSE;
        // set the overlap width shift
        if ((Sint16)(rect.w = 8 - (o->loc.w + delta)) < 0)
            rect.w = 0;
        // set x starting position
        rect.x = 0;
    }
    
    // compute the location of each player's sprite
    pSprite = &(sprites[(p->rot >> 8) & 0xF][rect.y]);
    
    // loop through the overlapping height
    for (; rect.h > 0; rect.h--, pSprite++) {
        // check for a collision
        if (((*pSprite) >> rect.x) & (0xFF >> rect.w)) return TRUE;
    }
    // no collision
    return FALSE;
}

---