tanksprite.c

Go to the documentation of this file.

#include "tanksprite.h"
#include "color.h"
#include <memory.h>

#define FHoriz  1

#define FVert   2

#define Trans   4

static const Uint8 spriteProtos[3][8] = {
    {   // up
        0x10, //{ 0, 0, 0, 0, 1, 0, 0, 0 },
        0x10, //{ 0, 0, 0, 0, 1, 0, 0, 0 },
        0xD6, //{ 0, 1, 1, 0, 1, 0, 1, 1 },
        0xFE, //{ 0, 1, 1, 1, 1, 1, 1, 1 },
        0xFE, //{ 0, 1, 1, 1, 1, 1, 1, 1 },
        0xFE, //{ 0, 1, 1, 1, 1, 1, 1, 1 },
        0xC6, //{ 0, 1, 1, 0, 0, 0, 1, 1 },
        0xC6  //{ 0, 1, 1, 0, 0, 0, 1, 1 }
    },
    {   // 22.5 to the right
        0x24, //{ 0, 0, 1, 0, 0, 1, 0, 0 },
        0x26, //{ 0, 1, 1, 0, 0, 1, 0, 0 },
        0x9E, //{ 0, 1, 1, 1, 1, 0, 0, 1 },
        0xFF, //{ 1, 1, 1, 1, 1, 1, 1, 1 },
        0xFF, //{ 1, 1, 1, 1, 1, 1, 1, 1 },
        0x72, //{ 0, 1, 0, 0, 1, 1, 1, 0 },
        0x70, //{ 0, 0, 0, 0, 1, 1, 1, 0 },
        0x20  //{ 0, 0, 0, 0, 0, 1, 0, 0 }
    },
    {   // 45 up right
        0x98, //{ 0, 0, 0, 1, 1, 0, 0, 1 },
        0x5C, //{ 0, 0, 1, 1, 1, 0, 1, 0 },
        0x3E, //{ 0, 1, 1, 1, 1, 1, 0, 0 },
        0xFF, //{ 1, 1, 1, 1, 1, 1, 1, 1 },
        0xFB, //{ 1, 1, 0, 1, 1, 1, 1, 1 },
        0x70, //{ 0, 0, 0, 0, 1, 1, 1, 0 },
        0x38, //{ 0, 0, 0, 1, 1, 1, 0, 0 },
        0x18  //{ 0, 0, 0, 1, 1, 0, 0, 0 }
    }
};

const static Uint8 imgFlags[16] = {
    0,
    0,
    0,
    FHoriz | FVert | Trans,
    FHoriz | Trans,
    FHoriz | Trans,
    FVert,
    FVert,
    FVert,
    FHoriz | FVert,
    FHoriz | FVert,
    Trans,
    Trans,
    FVert | Trans,
    FHoriz,
    FHoriz
};

Uint8 sprites[16][8];

const Uint8 shellInitLoc[16][2] = {
    { 4, 0 }, // up
    { 5, 0 },
    { 7, 0 }, // up right
    { 7, 2 },
    { 7, 4 }, // right
    { 7, 5 },
    { 7, 7 }, // down right
    { 5, 7 },
    { 4, 7 }, // down
    { 2, 7 },
    { 0, 7 }, // down left
    { 0, 5 },
    { 0, 4 }, // left
    { 0, 2 },
    { 0, 0 }, // up left
    { 2, 0 }
};

void GenTankSprites() {
    int h, v, th, tv, t, img, rot;
    Uint8 flags;
    memset(sprites, 0, sizeof(sprites));
    for (rot = 0; rot < 16; rot++) {
        // get the flags to use
        flags = imgFlags[rot];
        // figure out which proto sprite to use
        if ((img = rot & 3) > 2) img = 1;
        // loop through each pixel of the sprite
        for (v = 0; v < 8; v++) {
            for (h = 0; h < 8; h++) {
                // modify the coordinates to use base on the flags
                if (flags & FHoriz) {
                    th = 7 - h;
                }
                else {
                    th = h;
                }
                if (flags & FVert) {
                    tv = 7 - v;
                }
                else {
                    tv = v;
                }
                if (flags & Trans) {
                    t = th;
                    th = tv;
                    tv = t;
                }
                if (spriteProtos[img][tv] & (1 << th)) {
                    sprites[rot][v] |= 1 << h;
                }
            }
        }
    }
}

void DrawTank(SDL_Surface *dest, RenderItem *item) {
    SDL_Rect rect;
    int h, v, color = colorVals[((Player*)item)->team];
    Uint8 *sprite;
    Uint8 line;
    
    // get a pointer to the start of the sprite
    sprite = &(sprites[(((Player*)item)->rot >> 8) & 0xF][0]);
    // loop through each pixel of the sprite
    for (v = 0; v < 8; v++, sprite++) {
        // get the line data from the sprite
        line = *sprite;
        for (h = 0; h < 8; h++, line >>= 1) {
            // check pixels from left to right
            if (line & 1) {
                // calclate screen position of the pixel
                rect.x = item->physLocX + h * dInfo.luw;
                rect.w = dInfo.luw;
                rect.y = item->physLocY + v * dInfo.luh;
                rect.h = dInfo.luh;
                // draw it
                SDL_FillRect(dest, &rect, color);
            }
        }
    }
}

Bool IsCollidingTank(Player *p1, Player *p2) {
    SDL_Rect p1rect, p2rect;
    int p1pos, p2pos, delta;
    Uint8 *p1sprite, *p2sprite;
    
    // Compute overlap region.
    // first, find the pixel coordinates by getting rid of the sub-pixel part
    p1pos = p1->y >> 8;
    p2pos = p2->y >> 8;
    if ((delta = p2pos - p1pos) > 0) {
        // check for no vertical overlap
        if (delta >= 8)
            return FALSE;
        // set y starting positions
        p1rect.y = delta;
        p2rect.y = 0;
    }
    else {
        // check for no vertical overlap
        if ((delta = -delta) >= 8)
            return FALSE;
        // set y starting positions
        p2rect.y = delta;
        p1rect.y = 0;
    }
    // store the height (same for p1 & p2)
    p1rect.h = 8 - delta;
    // see which is further left
    p1pos = p1->x >> 8;
    p2pos = p2->x >> 8;
    if ((delta = p2pos - p1pos) > 0) {
        // check for no horizontal overlap
        if (delta >= 8)
            return FALSE;
        // set x starting positions
        p1rect.x = delta;
        p2rect.x = 0;
    }
    else {
        // check for no horizontal overlap
        if ((delta = -delta) >= 8)
            return FALSE;
        // set x starting positions
        p2rect.x = delta;
        p1rect.x = 0;
    }
    // store the width (same for p1 & p2)
    //p1rect.w = 8 - delta;
    
    // check for an overlap of the sprites; do not include a 1 pixel boundry
    if ((delta >= 8) || ((Sint16)(p1rect.h) <= 0)) return FALSE;
    
    // compute the location of each player's sprite
    p1sprite = &(sprites[(p1->rot >> 8) & 0xF][p1rect.y]);
    p2sprite = &(sprites[(p2->rot >> 8) & 0xF][p2rect.y]);
    
    // loop through the overlapping height
    for (; p1rect.h > 0; p1rect.h--, p1sprite++, p2sprite++) {
        // check for a collision
        if (((*p1sprite) >> p1rect.x) & ((*p2sprite) >> p2rect.x)) return TRUE;
    }
    // no collision
    return FALSE;
}

Bool IsCollidingShell(Player *tank, Player *shell) {
    int x, y;
    // Compute where the shell is on the sprite.
    // First, compute the x coord on the sprite and check for no overlap
    if (((x = (shell->shellX >> 8) - (tank->x >> 8)) < 0) || (x >= 8)) {
        // no overlap so no collision
        return FALSE;
    }
    // next compute the y coord on the sprite and check for no overlap
    if (((y = (shell->shellY >> 8) - (tank->y >> 8)) < 0) || (y >= 8)) {
        // no overlap so no collision
        return FALSE;
    }
    // pixel check for collision
    if ((sprites[(tank->rot >> 8) & 0xF][y] >> x) & 1)
        return TRUE;
    return FALSE;
}

---