walkero
/
starfighter
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
starfighter/code/classes.h

753 lines
16 KiB
C++
Raw Blame History

/*
Copyright (C) 2003 Parallel Realities
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
extern void showErrorAndExit(int errorId, const char *name);
class Collision {
private:
Collision(){}
public:
static signed char collision(float x0, float y0, int w0, int h0, float x2, float y2, int w1, int h1)
{
float x1 = x0 + w0;
float y1 = y0 + h0;
float x3 = x2 + w1;
float y3 = y2 + h1;
return !(x1<x2 || x3<x0 || y1<y2 || y3<y0);
}
static signed char collision(object *object1, object *object2)
{
float x0 = object1->x;
float y0 = object1->y;
float w0 = object1->image[0]->w;
float h0 = object1->image[0]->h;
float x2 = object2->x;
float y2 = object2->y;
float w1 = object2->image[0]->w;
float h1 = object2->image[0]->h;
float x1 = x0 + w0;
float y1 = y0 + h0;
float x3 = x2 + w1;
float y3 = y2 + h1;
return !(x1<x2 || x3<x0 || y1<y2 || y3<y0);
}
static signed char collision(collectables *object1, object *object2)
{
float x0 = object1->x;
float y0 = object1->y;
float w0 = object1->image->w;
float h0 = object1->image->h;
float x2 = object2->x;
float y2 = object2->y;
float w1 = object2->image[0]->w;
float h1 = object2->image[0]->h;
float x1 = x0 + w0;
float y1 = y0 + h0;
float x3 = x2 + w1;
float y3 = y2 + h1;
return !(x1<x2 || x3<x0 || y1<y2 || y3<y0);
}
};
class Math {
private:
Math(){}
public:
static void limitChar(signed char *in, int low, int high)
{
if (*in < low)
*in = low;
if (*in > high)
*in = high;
}
static void limitChar(unsigned char *in, int low, int high)
{
if (*in < low)
*in = low;
if (*in > high)
*in = high;
}
static void limitCharAdd(signed char *in, int add, int low, int high)
{
int tmp = (int)*in + add;
if (tmp < low)
tmp = low;
if (tmp > high)
tmp = high;
*in = tmp;
}
static void limitCharAdd(unsigned char *in, int add, int low, int high)
{
int tmp = (int)*in + add;
if (tmp < low)
tmp = low;
if (tmp > high)
tmp = high;
*in = tmp;
}
static void limitInt(int *in, int low, int high)
{
if (*in < low)
*in = low;
if (*in > high)
*in = high;
}
static void limitFloat(float *in, float low, float high)
{
if (*in < low)
*in = low;
if (*in > high)
*in = high;
}
static void wrapChar(signed char *in, signed char low, signed char high)
{
if (*in < low)
*in = high;
if (*in > high)
*in = low;
}
static void wrapInt(int *in, int low, int high)
{
if (*in < low)
*in = high;
if (*in > high)
*in = low;
}
static void wrapFloat(float *in, float low, float high)
{
if (*in < low)
*in = high;
if (*in > high)
*in = low;
}
static int rrand(int min, int max)
{
int r = min;
max++;
if ((max - min) == 0)
return min;
r += rand() % (max - min);
return r;
}
};
class Graphics {
unsigned long frameLimit;
int thirds;
public:
Uint32 red;
Uint32 darkRed;
Uint32 yellow;
Uint32 darkYellow;
Uint32 green;
Uint32 darkGreen;
Uint32 blue;
Uint32 darkBlue;
Uint32 darkerBlue;
Uint32 black;
Uint32 white;
Uint32 lightGrey;
Uint32 darkGrey;
SDL_Surface *screen, *background;
SDL_Surface *shape[MAX_SHAPES];
SDL_Surface *shipShape[MAX_SHIPSHAPES];
SDL_Surface *fontShape[MAX_FONTSHAPES];
SDL_Surface *shopSurface[MAX_SHOPSHAPES];
bRect *bufferHead;
bRect *bufferTail;
textObject textShape[MAX_TEXTSHAPES];
SDL_Rect blitRect;
SDL_Surface *messageBox;
Graphics()
{
bufferHead = new bRect;
bufferHead->next = NULL;
bufferTail = bufferHead;
for (int i = 0 ; i < MAX_SHAPES ; i++)
shape[i] = NULL;
for (int i = 0 ; i < MAX_SHIPSHAPES ; i++)
shipShape[i] = NULL;
for (int i = 0 ; i < MAX_TEXTSHAPES ; i++)
textShape[i].image = NULL;
for (int i = 0 ; i < MAX_SHOPSHAPES ; i++)
shopSurface[i] = NULL;
background = NULL;
messageBox = NULL;
}
SDL_Surface *setTransparent(SDL_Surface *sprite)
{
SDL_SetColorKey(sprite, (SDL_SRCCOLORKEY|SDL_RLEACCEL), SDL_MapRGB(sprite->format, 0, 0, 0));
return sprite;
}
void addBuffer(int x, int y, int w, int h)
{
bRect *rect = new bRect;
rect->next = NULL;
rect->x = x;
rect->y = y;
rect->w = w;
rect->h = h;
bufferTail->next = rect;
bufferTail = rect;
}
void blit(SDL_Surface *image, int x, int y, SDL_Surface *dest)
{
// Set up a rectangle to draw to
blitRect.x = x;
blitRect.y = y;
blitRect.w = image->w;
blitRect.h = image->h;
/* Blit onto the screen surface */
if(SDL_BlitSurface(image, NULL, dest, &blitRect) < 0)
{
printf("BlitSurface error: %s\n", SDL_GetError());
showErrorAndExit(2, "");
}
addBuffer(blitRect.x, blitRect.y, blitRect.w, blitRect.h);
}
void blit(SDL_Surface *image, int x, int y)
{
blit(image, x, y, screen);
}
void blitText(int i)
{
blit(textShape[i].image, (int)textShape[i].x, (int)textShape[i].y, screen);
}
void flushBuffer()
{
bRect *prevRect = bufferHead;
bRect *rect = bufferHead;
bufferTail = bufferHead;
while (rect->next != NULL)
{
rect = rect->next;
prevRect->next = rect->next;
delete rect;
rect = prevRect;
}
bufferHead->next = NULL;
}
void unBuffer()
{
bRect *prevRect = bufferHead;
bRect *rect = bufferHead;
bufferTail = bufferHead;
while (rect->next != NULL)
{
rect = rect->next;
blitRect.x = rect->x;
blitRect.y = rect->y;
blitRect.w = rect->w;
blitRect.h = rect->h;
if (SDL_BlitSurface(background, &blitRect, screen, &blitRect) < 0)
{
printf("BlitSurface error: %s\n", SDL_GetError());
showErrorAndExit(2, "");
}
prevRect->next = rect->next;
delete rect;
rect = prevRect;
}
bufferHead->next = NULL;
}
/*
In 16 bit mode this is slow. VERY slow. Don't write directly to a surface
that constantly needs updating (eg - the main game screen)
*/
int renderString(const char *in, int x, int y, int fontColor, signed char wrap, SDL_Surface *dest)
{
SDL_Rect area;
area.x = x;
area.y = y;
area.w = 8;
area.h = 14;
SDL_Rect letter;
letter.y = 0;
letter.w = 8;
letter.h = 14;
while (*in != '\0')
{
if (*in != 32)
{
letter.x = (*in - 33);
letter.x *= 8;
letter.x--; // Temp fix
/* Blit onto the screen surface */
if(SDL_BlitSurface(fontShape[fontColor], &letter, dest, &area) < 0)
{
printf("BlitSurface error: %s\n", SDL_GetError());
showErrorAndExit(2, "");
}
}
area.x += 9;
if (wrap)
{
if ((area.x > (dest->w - 70)) && (*in == 32))
{
area.y += 16;
area.x = x;
}
}
in++;
}
return area.y;
}
int drawString(const char *in, int x, int y, int fontColor, signed char wrap, SDL_Surface *dest)
{
renderString(in, x, y - 1, FONT_OUTLINE, wrap, dest);
renderString(in, x, y + 1, FONT_OUTLINE, wrap, dest);
renderString(in, x, y + 2, FONT_OUTLINE, wrap, dest);
renderString(in, x - 1, y, FONT_OUTLINE, wrap, dest);
renderString(in, x - 2, y, FONT_OUTLINE, wrap, dest);
renderString(in, x + 1, y, FONT_OUTLINE, wrap, dest);
return renderString(in, x, y, fontColor, wrap, dest);
}
int drawString(const char *in, int x, int y, int fontColor, SDL_Surface *dest)
{
if (x == -1)
x = (dest->w - (strlen(in) * 9)) / 2;
return drawString(in, x, y, fontColor, 0, dest);
}
int drawString(const char *in, int x, int y, int fontColor)
{
if (x == -1)
x = (800 - (strlen(in) * 9)) / 2;
return drawString(in, x, y, fontColor, 0, screen);
}
/*
Finds the location of the requested color within the palette and returns
it's number. This colors are used for drawing rectangles, circle, etc in
the correct colors.
*/
void setColorIndexes()
{
red = SDL_MapRGB(screen->format, 0xff, 0x00, 0x00);
darkRed = SDL_MapRGB(screen->format, 0x66, 0x00, 0x00);
yellow = SDL_MapRGB(screen->format, 0xff, 0xff, 0x00);
darkYellow = SDL_MapRGB(screen->format, 0x66, 0x66, 0x00);
green = SDL_MapRGB(screen->format, 0x00, 0xff, 0x00);
darkGreen = SDL_MapRGB(screen->format, 0x00, 0x66, 0x00);
blue = SDL_MapRGB(screen->format, 0x00, 0x00, 0xff);
darkBlue = SDL_MapRGB(screen->format, 0x00, 0x00, 0x99);
darkerBlue = SDL_MapRGB(screen->format, 0x00, 0x00, 0x44);
black = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
white = SDL_MapRGB(screen->format, 0xff, 0xff, 0xff);
lightGrey = SDL_MapRGB(screen->format, 0xcc, 0xcc, 0xcc);
darkGrey = SDL_MapRGB(screen->format, 0x99, 0x99, 0x99);
}
/*
Draws the background surface that has been loaded
*/
void drawBackGround()
{
blit(background, 0, 0, screen);
}
void clearScreen(Uint32 color)
{
SDL_FillRect(screen, NULL, color);
}
void updateScreen()
{
SDL_Flip(screen);
}
/*
* Delay until the next 60 Hz frame
*/
void delayFrame()
{
unsigned long now = SDL_GetTicks();
// Add 16 2/3 to frameLimit
frameLimit += 16;
if(thirds >= 2) {
thirds = 0;
} else {
thirds++;
frameLimit++;
}
if(now < frameLimit)
SDL_Delay(frameLimit - now);
else
frameLimit = now;
}
/*
* Set the pixel at (x, y) to the given value
* NOTE: The surface must be locked before calling this!
*/
void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
int bpp = surface->format->BytesPerPixel;
/* Here p is the address to the pixel we want to set */
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
switch(bpp) {
case 1:
*p = pixel;
break;
case 2:
*(Uint16 *)p = pixel;
break;
case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
p[0] = (pixel >> 16) & 0xff;
p[1] = (pixel >> 8) & 0xff;
p[2] = pixel & 0xff;
} else {
p[0] = pixel & 0xff;
p[1] = (pixel >> 8) & 0xff;
p[2] = (pixel >> 16) & 0xff;
}
break;
case 4:
*(Uint32 *)p = pixel;
break;
}
}
void drawLine(SDL_Surface *dest, int x1, int y1, int x2, int y2, int col)
{
int counter = 0;
if ( SDL_MUSTLOCK(dest) ) {
if ( SDL_LockSurface(dest) < 0 ) {
printf("Can't lock screen: %s\n", SDL_GetError());
showErrorAndExit(2, "");
}
}
while(1)
{
putpixel(dest, x1, y1, col);
if (x1 > x2) x1--;
if (x1 < x2) x1++;
if (y1 > y2) y1--;
if (y1 < y2) y1++;
if ((x1 == x2) && (y1 == y2))
{break;}
if (counter == 1000)
{printf("Loop Error!\n"); break;}
counter++;
}
if ( SDL_MUSTLOCK(dest) ) {
SDL_UnlockSurface(dest);
}
}
void drawLine(int x1, int y1, int x2, int y2, int col)
{
drawLine(screen, x1, y1, x2, y2, col);
}
/*
A quick(?) circle draw function. This code was posted to the SDL
mailing list... I didn't write it myself.
*/
void circle(int xc, int yc, int R, SDL_Surface *PIX, int col)
{
int x = 0, xx = 0;
int y = R, yy = R+R;
int p = 1-R;
putpixel(PIX, xc, yc - y, col);
putpixel(PIX, xc, yc + y, col);
putpixel(PIX, xc - y, yc, col);
putpixel(PIX, xc + y, yc, col);
while(x < y)
{
xx += 2;
++x;
if (p >= 0)
{
yy -= 2;
--y;
p -= yy;
}
p += xx + 1;
putpixel(PIX, xc - x, yc - y, col);
putpixel(PIX, xc + x, yc - y, col);
putpixel(PIX, xc - x, yc + y, col);
putpixel(PIX, xc + x, yc + y, col);
putpixel(PIX, xc - y, yc - x, col);
putpixel(PIX, xc + y, yc - x, col);
putpixel(PIX, xc - y, yc + x, col);
putpixel(PIX, xc + y, yc + x, col);
}
if ((x = y))
{
putpixel(PIX, xc - x, yc - y, col);
putpixel(PIX, xc + x, yc - y, col);
putpixel(PIX, xc - x, yc + y, col);
putpixel(PIX, xc + x, yc + y, col);
}
}
void blevelRect(SDL_Surface *dest, int x, int y, int w, int h, Uint8 red, Uint8 green, Uint8 blue)
{
SDL_Rect r = {x, y, w, h};
SDL_FillRect(dest, &r, SDL_MapRGB(screen->format, red, green, blue));
drawLine(dest, x, y, x + w, y, SDL_MapRGB(screen->format, 255, 255, 255));
drawLine(dest, x, y, x, y + h, SDL_MapRGB(screen->format, 255, 255, 255));
drawLine(dest, x, y + h, x + w, y + h, SDL_MapRGB(screen->format, 128, 128, 128));
drawLine(dest, x + w, y + 1, x + w, y + h, SDL_MapRGB(screen->format, 128, 128, 128));
}
void blevelRect(int x, int y, int w, int h, Uint8 red, Uint8 green, Uint8 blue)
{
blevelRect(screen, x, y, w, h, red, green, blue);
}
SDL_Surface *createSurface(int width, int height)
{
SDL_Surface *surface, *newImage;
Uint32 rmask, gmask, bmask, amask;
/* SDL interprets each pixel as a 32-bit number, so our masks must depend
on the endianness (byte order) of the machine */
#if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, rmask, gmask, bmask, amask);
if (surface == NULL) {
printf("CreateRGBSurface failed: %s\n", SDL_GetError());
showErrorAndExit(2, "");
}
newImage = SDL_DisplayFormat(surface);
SDL_FreeSurface(surface);
return newImage;
}
SDL_Surface *textSurface(const char *inString, int color)
{
SDL_Surface *surface = createSurface(strlen(inString) * 9, 16);
drawString(inString, 1, 1, color, surface);
return setTransparent(surface);
}
void textSurface(int index, const char *inString, int x, int y, int fontColor)
{
strcpy(textShape[index].text, inString);
textShape[index].x = x;
textShape[index].y = y;
textShape[index].fontColor = fontColor;
if (textShape[index].image != NULL)
{
SDL_FreeSurface(textShape[index].image);
}
textShape[index].image = textSurface(inString, fontColor);
if (x == -1)
textShape[index].x = (800 - textShape[index].image->w) / 2;
}
SDL_Surface *alphaRect(int width, int height, Uint8 red, Uint8 green, Uint8 blue)
{
SDL_Surface *surface = createSurface(width, height);
SDL_FillRect(surface, NULL, SDL_MapRGB(surface->format, red, green, blue));
SDL_SetAlpha(surface, SDL_SRCALPHA|SDL_RLEACCEL, 128);
return surface;
}
void createMessageBox(SDL_Surface *face, const char *message, signed char transparent)
{
if (messageBox != NULL)
{
SDL_FreeSurface(messageBox);
messageBox = NULL;
}
if (transparent)
messageBox = alphaRect(550, 60, 0x00, 0x00, 0x00);
else
messageBox = createSurface(550, 60);
signed char x = 60;
if (face != NULL)
{
blevelRect(messageBox, 0, 0, messageBox->w - 1, messageBox->h - 1, 0x00, 0x00, 0xaa);
blit(face, 5, 5, messageBox);
}
else
{
blevelRect(messageBox, 0, 0, messageBox->w - 1, messageBox->h - 1, 0x00, 0x00, 0x00);
x = 10;
}
drawString(message, x, 5, FONT_WHITE, 1, messageBox);
}
void freeGraphics()
{
for (int i = 0 ; i < MAX_SHAPES ; i++)
{
if (shape[i] != NULL)
{
SDL_FreeSurface(shape[i]);
shape[i] = NULL;
}
}
for (int i = 0 ; i < MAX_SHIPSHAPES ; i++)
{
if (shipShape[i] != NULL)
{
SDL_FreeSurface(shipShape[i]);
shipShape[i] = NULL;
}
}
for (int i = 0 ; i < MAX_TEXTSHAPES ; i++)
{
if (textShape[i].image != NULL)
{
SDL_FreeSurface(textShape[i].image);
textShape[i].image = NULL;
}
}
for (int i = 0 ; i < MAX_SHOPSHAPES ; i++)
{
if (shopSurface[i] != NULL)
{
SDL_FreeSurface(shopSurface[i]);
shopSurface[i] = NULL;
}
}
if (messageBox != NULL)
{
SDL_FreeSurface(messageBox);
messageBox = NULL;
}
}
};
Reference in New Issue View Git Blame Copy Permalink