Jump to content
  • Advertisement
Sign in to follow this  
CJWR

question on what this error message means

This topic is 4810 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Compiler Error C2102 '&' requires l-value The address-of operator (&) must be applied to an l-value expression. so what is an l-value expression? i'm trying to figure out way my game won't compile. and this is the error i keep getting.

Share this post


Link to post
Share on other sites
Advertisement
CJWR,

I believe the error message you're getting is suggesting that the '&' operator, also known as the bit-wise AND operator, can only be used in an expression which has an l-value.

An l-value is an operand to the LEFT of an equal sign. For example:

a = b & c;

Here you can see that B is being AND'd with c, and the result is being stored in the l-value of 'a'.

If this does not provide enough information to be of help to you, post the line of code that's giving the error and I can post back the correct syntax.

Cheers and good luck!

Share this post


Link to post
Share on other sites

//main.cpp

// INCLUDES ///////////////////////////////////////////////
#define WIN32_LEAN_AND_MEAN // just say no to MFC
#define INITGUID
#include <windows.h> // include important windows stuff
#include <windowsx.h>
#include <mmsystem.h>
#include <iostream.h> // include important C/C++ stuff
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include <io.h>
#include <fcntl.h>
#include <ddraw.h> // include directdraw

#include "screen.h"

// DEFINES ////////////////////////////////////////////////
// defines for windows
#define WINDOW_CLASS_NAME "WINCLASS1"

// default screen size
#define SCREEN_WIDTH 800 // size of screen
#define SCREEN_HEIGHT 600
#define SCREEN_BPP 8 // bits per pixel

#define BITMAP_ID 0x4D42 // universal id for a bitmap
#define MAX_COLORS_PALETTE 256

//ship defines
#define SHIP_SIZE_X 77 //size of ship
#define SHIP_SIZE_Y 62 //size of ship
#define SHIP_SPEED 10 //speed of ship
#define MAX_HEALTH 3 //max health of your ship
#define ENGINE_SIZE_X 9 //size of engine
#define ENGINE_SIZE_Y 6 //size of engine
#define THRUSTER_SIZE_X 5 //size of thruster
#define THRUSTER_SIZE_Y 4 //size of thruster

//star defines
#define NUMBER_OF_STARS 100 //number of stars

//missle defines///////////////////////////////
#define MAX_MISSLES 10 //max number at one time
#define MISSILE_SPEED 10 //speed

//PHOTON defines
#define PHOTON_SIZE_X 10 //size x
#define PHOTON_SIZE_Y 10 //size y

//QUANTUM defines
#define QUANTUM_SIZE_X 10
#define QUANTUM_SIZE_Y 10

//ALIEN defines
#define MAX_ALIEN 2 // max at a time
#define ALIEN_SPEED 5 //speed
#define ALIEN_SIZE_X 63 //size x
#define ALIEN_SIZE_Y 65 // size y

//BEAM defines
#define MAX_BEAM 6
#define BEAM_SPEED 10
#define BEAM_SIZE_X 10
#define BEAM_SIZE_Y 10

//powerup defines//////////////////////////////
#define POWERUP_SPEED 5

//SHIELD defines
#define SHIELD_SIZE_X 24
#define SHIELD_SIZE_Y 24

//TORP defines
#define TORP_SIZE_X 36
#define TORP_SIZE_Y 18

#define EX_SIZE_X 84
#define EX_SIZE_Y 72

// TYPES //////////////////////////////////////////////////////
// basic unsigned types
typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char UCHAR;
typedef unsigned char BYTE;

// container structure for bitmaps .BMP file
typedef struct BITMAP_FILE_TAG
{
BITMAPFILEHEADER bitmapfileheader; // this contains the bitmapfile header
BITMAPINFOHEADER bitmapinfoheader; // this is all the info including the palette
PALETTEENTRY palette[256]; // we will store the palette here
UCHAR *buffer; // this is a pointer to the data

} BITMAP_FILE, *BITMAP_FILE_PTR;

// PROTOTYPES //////////////////////////////////////////////
int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height);

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename);

int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap);

int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE4 lpdds,int color);

int Scan_Image_Bitmap(BITMAP_FILE_PTR bitmap, LPDIRECTDRAWSURFACE4 lpdds, int cx,int cy);

LPDIRECTDRAWSURFACE4 DDraw_Create_Surface(int width, int height, int mem_flags, int color_key);

int DDraw_Draw_Surface(LPDIRECTDRAWSURFACE4 source, int x, int y,
int width, int height, LPDIRECTDRAWSURFACE4 dest,
int transparent);

LPDIRECTDRAWCLIPPER DDraw_Attach_Clipper(LPDIRECTDRAWSURFACE4 lpdds,
int num_rects,
LPRECT clip_list);

int Draw_Text_GDI(char *text, int x,int y,COLORREF color, LPDIRECTDRAWSURFACE4 lpdds);

//display functions
int Draw_Background();
int Draw_Aliens();
int Draw_Missles();
int Draw_PowerUps();
int Draw_BEAM();

void update_frames();

// MACROS /////////////////////////////////////////////////
// tests if a key is up or down
#define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEYUP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// initializes a direct draw struct
#define DDRAW_INIT_STRUCT(ddstruct) { memset(&ddstruct,0,sizeof(ddstruct)); ddstruct.dwSize=sizeof(ddstruct); }

// GLOBALS ////////////////////////////////////////////////

HWND main_window_handle = NULL; // globally track main window
int window_closed = 0; // tracks if window is closed
HINSTANCE hinstance_app = NULL; // globally track hinstance

SCREEN screen(); //the screen object

// directdraw stuff
/*
LPDIRECTDRAW4 lpdd = NULL; // dd4 object
LPDIRECTDRAWSURFACE4 lpddsprimary = NULL; // dd primary surface
LPDIRECTDRAWSURFACE4 lpddsback = NULL; // dd back surface
LPDIRECTDRAWPALETTE lpddpal = NULL; // a pointer to the created dd palette
LPDIRECTDRAWCLIPPER lpddclipper = NULL; // dd clipper
PALETTEENTRY palette[256]; // color palette
PALETTEENTRY save_palette[256]; // used to save palettes
DDSURFACEDESC2 ddsd; // a direct draw surface description struct
DDBLTFX ddbltfx; // used to fill
DDSCAPS2 ddscaps; // a direct draw surface capabilities struct
HRESULT ddrval; // result back from dd calls
DWORD start_clock_count = 0; // used for timing
*/

BITMAP_FILE bitmap; // holds the bitmap

LPDIRECTDRAWSURFACE4 lpddsbackground = NULL; //this will hold the background image
LPDIRECTDRAWSURFACE4 ship[2]; //bitmap images of ship
LPDIRECTDRAWSURFACE4 engines[3]; //bitmap images of ship engines
LPDIRECTDRAWSURFACE4 thrusters[2]; //bitmap images of ship thrusters
LPDIRECTDRAWSURFACE4 shield[4]; //bitmap images of shield
LPDIRECTDRAWSURFACE4 torp[3]; //bitmap images of torp
LPDIRECTDRAWSURFACE4 alien[3]; //bitmap images of alien
LPDIRECTDRAWSURFACE4 photon[3]; //bitmap images of photon
LPDIRECTDRAWSURFACE4 quantum[3]; //bitmap images of quantum
LPDIRECTDRAWSURFACE4 beam[3]; //bitmap image of beam
LPDIRECTDRAWSURFACE4 explode[7]; //bitmap images of explode

int GAME_STATE = 0; //holds the game state 0 = intro, 1 = play, 2 = pause, 3 = done

char buffer[80]; // general printing buffer

int gwidth = -1;
int gheight = -1;

int score = 0; // the score for player 1
int GPT = 0; //used in pausing the game
int Missle_TIME = 0; //used for missle firing
int Starsx[NUMBER_OF_STARS];
int Starsy[NUMBER_OF_STARS];
int Starss[NUMBER_OF_STARS];
int ALIENx[MAX_ALIEN];
int ALIENy[MAX_ALIEN];
int ALIEN[MAX_ALIEN];
int ALIEN_Total = 0;
int BEAMx[MAX_BEAM]; //x
int BEAMy[MAX_BEAM]; //y
int BEAM_Total; //total
int BEAM[MAX_BEAM]; //tracks if a beam slot is in use
int Shipx = 0;
int Shipy = 0;
int Ship_Health = 0;
int Misslesx[MAX_MISSLES];
int Misslesy[MAX_MISSLES];
int Missle_Total = 0;
int Missles[MAX_MISSLES];
int Missle_Type[MAX_MISSLES]; // 1 = photon, 2 = quantum
int Fire_Type;
int Missle_Size_X; //missle size
int Missle_Size_Y; //missle size
int PowerUpx;
int PowerUpy;
int PowerUp;
int PowerUpType;
int PowerUp_Size_X;
int PowerUp_Size_Y;
int frame_ship = 0; //holds which frame of the ship to display
int ship_till_next=0; //holds how many flips to wait before drawing the next frame of the ship
int frame_engine = 0; //holds which frame of the ship engines to display
int engine_till_next=0; //holds how many flips to wait before drawing the next frame of the engines
int frame_alien = 0;
int alien_till_next=0; //holds how many flips to wait before drawing the next frame of the aliens
int frame_torp = 0;
int torp_till_next=0;
int frame_shield = 0;
int shield_till_next=0;
int frame_torpup = 0;
int torpup_till_next=0;
int frame_beam = 0;
int beam_till_next=0;

int alien1_timer; //holds how many more frames to draw with alien1 exploding
int alien2_timer;

//prototypes2
int Draw_Rectangle(int x1, int y1, int x2, int y2, int color,LPDIRECTDRAWSURFACE4 lpdds=screen().lpddsback);

// FUNCTIONS ////////////////////////////////////////////////
void update_frames(){
ship_till_next--;
engine_till_next--;
torp_till_next--;
alien_till_next--;
shield_till_next--;
torpup_till_next--;
beam_till_next--;

//check if ship needs to be updated, if so, update
if(ship_till_next <= 0){
if(frame_ship == 0){
frame_ship = 1;
}
else if(frame_ship == 1){
frame_ship = 0;
}
else frame_ship = 0;
ship_till_next = 10;
}

//check if engines needs to be updated, if so, update
if(engine_till_next <=0){
if(frame_engine == 0){
frame_engine = 1;
}
else if(frame_engine == 1){
frame_engine = 2;
}
else if(frame_engine == 2){
frame_engine = 0;
}
else frame_engine = 0;
engine_till_next = 10;
}

//check if torp needs to be updated, if so, update
if(torp_till_next <= 0){
if(frame_torp == 0){
frame_torp = 1;
}
else if(frame_torp == 1){
frame_torp = 2;
}
else if(frame_torp == 2){
frame_torp = 0;
}
else frame_torp = 0;
torp_till_next = 5;
}

//check if aliens needs to be updated, if so, update
if(alien_till_next <=0){
if(frame_alien == 0){
frame_alien = 1;
}
else if(frame_alien == 1){
frame_alien = 2;
}
else if(frame_alien == 2){
frame_alien = 0;
}
else frame_alien = 0;
alien_till_next = 10;
}

//check if shield needs to be updated, if so, update
if(shield_till_next <=0){
if(frame_shield == 0){
frame_shield = 1;
}
else if(frame_shield == 1){
frame_shield = 2;
}
else if(frame_shield == 2){
frame_shield = 3;
}
else if(frame_shield == 3){
frame_shield = 0;
}
else frame_shield = 0;
shield_till_next = 8;
}

//check if torp_up needs to be updated, if so, update
if(torpup_till_next <= 0){
if(frame_torpup == 0){
frame_torpup = 1;
}
else if(frame_torpup == 1){
frame_torpup = 2;
}
else if(frame_torpup == 2){
frame_torpup = 0;
}
else frame_torpup = 0;
torpup_till_next = 10;
}

//check if beam needs to be updated, if so, update
if(beam_till_next <= 0){
if(frame_beam == 0){
frame_beam = 1;
}
else if(frame_beam == 1){
frame_beam = 2;
}
else if(frame_beam == 2){
frame_beam = 0;
}
else frame_beam = 0;
beam_till_next = 10;
}

}

int Draw_Rectangle(int x1, int y1, int x2, int y2, int color,
LPDIRECTDRAWSURFACE4 lpdds)
{
// this function uses directdraw to draw a filled rectangle

DDBLTFX ddbltfx; // this contains the DDBLTFX structure
RECT fill_area; // this contains the destination rectangle

// clear out the structure and set the size field
DDRAW_INIT_STRUCT(ddbltfx);

// set the dwfillcolor field to the desired color
ddbltfx.dwFillColor = color;

// fill in the destination rectangle data (your data)
fill_area.top = y1;
fill_area.left = x1;
fill_area.bottom = y2+1;
fill_area.right = x2+1;

// ready to blt to surface, in this case blt to primary
lpdds->Blt(&fill_area, // ptr to dest rectangle
NULL, // ptr to source surface, NA
NULL, // ptr to source rectangle, NA
DDBLT_COLORFILL | DDBLT_WAIT | DDBLT_ASYNC, // fill and wait
&ddbltfx); // ptr to DDBLTFX structure

// return success
return(1);
} // end Draw_Rectangle

int Draw_Background(){
//draws the background
Draw_Rectangle(0,0,SCREEN_WIDTH-1, SCREEN_HEIGHT-1,0); //background
//draws the stars
for(int i = 0; i < NUMBER_OF_STARS; i++){
Starsy = Starsy + Starss;
Draw_Rectangle(Starsx,Starsy,Starsx+1,Starsy+1,255); //background
if(Starsy > SCREEN_HEIGHT){
Starsy = 0;
Starsx = rand()%SCREEN_WIDTH;
Starss = rand()%3 + 2;
}
}
return 0;
}

int Draw_Aliens(){
if(ALIEN[0] == 0){
//create alien 1
ALIENx[0] = rand()%600;
if(ALIENx[0] > SCREEN_WIDTH-80||ALIENx[0] < 40){
ALIENx[0] = 200;
}
ALIENy[0] = 0;
ALIEN[0] = 1;
ALIEN_Total = ALIEN_Total + 1;
}
if(ALIEN[1] == 0){
//create alien 2
ALIENx[1] = rand()%600;
if(ALIENx[1] > SCREEN_WIDTH-80||ALIENx[1] < 40){
ALIENx[1] = 400;
}
ALIENy[1] = 0;
ALIEN[1] = 1;
ALIEN_Total = ALIEN_Total + 1;
}
if(ALIEN[0] == 1){
//draw alien 1
ALIENy[0] = ALIENy[0] + ALIEN_SPEED;
DDraw_Draw_Surface(alien[frame_alien],ALIENx[0],ALIENy[0],ALIEN_SIZE_X,ALIEN_SIZE_Y,screen().lpddsback,1);
if(ALIENy[0] > SCREEN_HEIGHT){
ALIEN_Total = ALIEN_Total - 1;
ALIEN[0] = 0;
ALIENx[0] = 0;
ALIENy[0] = 0;
}
}
if(ALIEN[1] == 1){
//draw alien 2
ALIENy[1] = ALIENy[1] + ALIEN_SPEED;
DDraw_Draw_Surface(alien[frame_alien],ALIENx[1],ALIENy[1],ALIEN_SIZE_X,ALIEN_SIZE_Y,screen().lpddsback,1);
if(ALIENy[1] > SCREEN_HEIGHT){
ALIEN_Total = ALIEN_Total - 1;
ALIEN[1] = 0;
ALIENx[1] = 0;
ALIENy[1] = 0;
}
}
//check to see if a missle hit an alien
int center;
for(int i = 0; i < MAX_ALIEN; i++){ //alien counter
if(ALIEN == 1){ //make sure the alien exists
for(int j = 0; j < MAX_MISSLES; j++){ //missle counter
if(Missles[j] == 1){ //make sure missle exists
center = Misslesx[j]+(PHOTON_SIZE_X/2);
if(center>=ALIENx&&center<=ALIENx+ALIEN_SIZE_X){
if(Misslesy[j]>=ALIENy&&Misslesy[j]<=ALIENy+ALIEN_SIZE_Y){
ALIEN = 2;
ALIEN_Total = ALIEN_Total - 1;
score = score + 1;
Missles[j] = 0;
Missle_Total = Missle_Total - 1;
}
}
}
}
}
}
//check to see if a ALIEN hit the SHIP
for(int k = 0; k < MAX_ALIEN; k++){
if(ALIEN[k] == 1){ //make sure alien exists
center = ALIENx[k]+(ALIEN_SIZE_X/2);
if(center>=Shipx&&center<=Shipx+(SHIP_SIZE_X)){
if(ALIENy[k]>=Shipy&&ALIENy[k]<=Shipy+SHIP_SIZE_Y){
if(Fire_Type == 2){
Missle_Total = 0;
for(int i = 0; i<MAX_MISSLES; i++){
Missles = 0;
}
}
ALIEN[k] = 2;
ALIEN_Total = ALIEN_Total - 1;
Ship_Health = Ship_Health - 1;
Fire_Type = 1;
Missle_Size_X = PHOTON_SIZE_X;
Missle_Size_Y = PHOTON_SIZE_Y;
}
}
}
}
//check to see if a ALIEN hit the lower side of the screen
for(int l = 0; l < MAX_ALIEN; l++){
if(ALIEN[l] == 1){ //make sure noob exists
if(ALIENy[l]>=SCREEN_HEIGHT){
ALIEN[l] = 0;
ALIEN_Total = ALIEN_Total - 1;
score = score - 2;
}
}
}
//check if any aliens should be exploding, and draw if they should be
if(ALIEN[0] == 2){
ALIENy[0] = ALIENy[0] + alien1_timer/6; //slow the alien down
if(alien1_timer/4 < 6){
DDraw_Draw_Surface(alien[frame_alien],ALIENx[0],ALIENy[0],ALIEN_SIZE_X,ALIEN_SIZE_Y,screen().lpddsback,1);
}
else;
DDraw_Draw_Surface(explode[alien1_timer/4],ALIENx[0]-10,ALIENy[0]-6,EX_SIZE_X,EX_SIZE_Y,screen().lpddsback,1);
alien1_timer++;
if(alien1_timer >= 28){
alien1_timer = 0;
ALIEN[0] = 0;
}
else;
}
else;
if(ALIEN[1] == 2){
ALIENy[1] = ALIENy[1] + alien2_timer/6; //slow the alien down
if(alien2_timer/4 < 6){
DDraw_Draw_Surface(alien[frame_alien],ALIENx[1],ALIENy[1],ALIEN_SIZE_X,ALIEN_SIZE_Y,screen().lpddsback,1);
}
else;
DDraw_Draw_Surface(explode[alien2_timer/4],ALIENx[1]-10,ALIENy[1]-6,EX_SIZE_X,EX_SIZE_Y,screen().lpddsback,1);
alien2_timer++;
if(alien2_timer >= 28){
alien2_timer = 0;
ALIEN[1] = 0;
}
else;
}
else;

return 0;
}

int Draw_BEAM(){
int rn;
// srand(Start_Clock());
for(int i = 0; i < MAX_BEAM; i++){
rn = rand()%50;
if(BEAM == 0 && rn == 1){
//create a beam for alien rn
rn = rand()%MAX_ALIEN;
BEAM = 1;
BEAMx = ALIENx[rn]+(ALIEN_SIZE_X-BEAM_SIZE_X)/2;
BEAMy = ALIENy[rn]+ALIEN_SIZE_Y-1;
BEAM_Total = BEAM_Total + 1;
}
}
for(i = 0; i < MAX_BEAM; i++){
if(BEAM == 1){
//draw beam
BEAMy = BEAMy + BEAM_SPEED;
DDraw_Draw_Surface(beam[frame_beam],BEAMx,BEAMy,BEAM_SIZE_X,BEAM_SIZE_Y,screen().lpddsback,1);
if(BEAMy > SCREEN_HEIGHT){
BEAM_Total = BEAM_Total - 1;
BEAM = 0;
}
}
}
int center;
for(i = 0; i < MAX_BEAM; i++){
if(BEAM == 1){
center = BEAMx+(BEAM_SIZE_X/2);
if(center>=Shipx&&center<=Shipx+(SHIP_SIZE_X)){
if(BEAMy>=Shipy&&BEAMy<=Shipy+SHIP_SIZE_Y){
if(Fire_Type == 2){
Missle_Total = 0;
for(int i = 0; i<MAX_MISSLES; i++){
Missles = 0;
}
}
BEAM = 0;
BEAM_Total = BEAM_Total - 1;
Ship_Health = Ship_Health - 1;
Fire_Type = 1;
Missle_Size_X = PHOTON_SIZE_X;
Missle_Size_Y = PHOTON_SIZE_Y;
}
}

}
}
for(i = 0; i < MAX_BEAM; i++){
if(BEAM == 1){ //make sure the beam exists
for(int j = 0; j < MAX_MISSLES; j++){ //missle counter
if(Missles[j] == 1){ //make sure missle exists
center = Misslesx[j]+(PHOTON_SIZE_X/2);
if(center>=BEAMx&&center<=BEAMx+BEAM_SIZE_X){
if(Misslesy[j]>=BEAMy&&Misslesy[j]<=BEAMy+BEAM_SIZE_Y){
BEAM = 0;
BEAM_Total = BEAM_Total - 1;
Missles[j] = 0;
Missle_Total = Missle_Total - 1;
}
}
}
}
}
}
return 0;
}

int Draw_PowerUps(){
char buffer[80]; // used to print text
// srand(Start_Clock());
int sdp;
sdp = rand()%100;
if(sdp == 0&&PowerUp == 0){ //create powerup
sdp = rand()%2;
if(sdp == 0){
PowerUp = 1;
PowerUpx = 0;
PowerUpy = rand()%80;
PowerUpType = 1; //P13
PowerUp_Size_X = SHIELD_SIZE_X;
PowerUp_Size_Y = SHIELD_SIZE_Y;
}
else
if(sdp == 1){
PowerUp = 1;
PowerUpx = 0;
PowerUpy = rand()%80;
PowerUpType = 2; //C0ff33
PowerUp_Size_X = TORP_SIZE_X;
PowerUp_Size_Y = TORP_SIZE_Y;
}
}
if(PowerUp == 1){ //move and display powerup
PowerUpx = PowerUpx + POWERUP_SPEED;
PowerUpy = PowerUpy + POWERUP_SPEED;
if(PowerUpType == 1){
DDraw_Draw_Surface(shield[frame_shield],PowerUpx,PowerUpy,PowerUp_Size_X,PowerUp_Size_Y,screen().lpddsback,1);
}
if(PowerUpType == 2){
DDraw_Draw_Surface(torp[frame_torp],PowerUpx,PowerUpy,PowerUp_Size_X,PowerUp_Size_Y,screen().lpddsback,1);
}
}
//check to see if it went off screen and destroy the powerup if it did
if(PowerUpx>SCREEN_WIDTH||PowerUpy>SCREEN_HEIGHT){
PowerUp = 0;
}
//check to see if the GAT hit the powerup
int center = 0;
if(PowerUp == 1){ //make sure powerup exists
center = PowerUpx+(PowerUp_Size_X/2);
if(center>=Shipx&&center<=Shipx+SHIP_SIZE_X){
if(PowerUpy>=Shipy&&PowerUpy<=Shipy+SHIP_SIZE_Y){
PowerUp = 0;
if(PowerUpType == 1){
if(Ship_Health < 3){
Ship_Health = Ship_Health + 1;
}
}
if(PowerUpType == 2){
Fire_Type = 2;
Missle_Size_X = QUANTUM_SIZE_X;
Missle_Size_Y = QUANTUM_SIZE_Y;
Missle_Total = 0;
if(Fire_Type == 1){
for(int i = 0; i<MAX_MISSLES; i++){
Missles = 0;
}
}
}
}
}
}
return 0;
}

int Draw_Missles(){
char buffer[80]; // used to print text
for(int i = 0; i < MAX_MISSLES; i++){
if(Missles == 1){
Misslesy=Misslesy-MISSILE_SPEED;
if(Fire_Type == 1){
DDraw_Draw_Surface(photon[frame_torp],Misslesx,Misslesy,Missle_Size_X,Missle_Size_Y,screen().lpddsback,1);
}
if(Fire_Type == 2){
DDraw_Draw_Surface(quantum[frame_torp],Misslesx,Misslesy,Missle_Size_X,Missle_Size_Y,screen().lpddsback,1);
}
if(Misslesy<-48){
Missles = 0;
Missle_Total = Missle_Total - 1;
}
}
}
return 0;
}

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename)
{
// this function opens a bitmap file and loads the data into bitmap

int file_handle, // the file handle
index; // looping index

UCHAR *temp_buffer = NULL; // used to convert 24 bit images to 16 bit
OFSTRUCT file_data; // the file data information

// open the file if it exists
if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
return(0);

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

// test if this is a bitmap file
if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
{
// close the file
_lclose(file_handle);

// return error
return(0);
} // end if

// now we know this is a bitmap, so read in all the sections

// first the bitmap infoheader

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

// now load the color palette if there is one
if (bitmap->bitmapinfoheader.biBitCount == 8)
{
_lread(file_handle, &bitmap->palette,MAX_COLORS_PALETTE*sizeof(PALETTEENTRY));

// now set all the flags in the palette correctly and fix the reversed
// BGR RGBQUAD data format
for (index=0; index < MAX_COLORS_PALETTE; index++)
{
// reverse the red and green fields
int temp_color = bitmap->palette[index].peRed;
bitmap->palette[index].peRed = bitmap->palette[index].peBlue;
bitmap->palette[index].peBlue = temp_color;

// always set the flags word to this
bitmap->palette[index].peFlags = PC_NOCOLLAPSE;
} // end for index

} // end if

// finally the image data itself
_lseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);

// now read in the image, if the image is 8 or 16 bit then simply read it
// but if its 24 bit then read it into a temporary area and then convert
// it to a 16 bit image

if (bitmap->bitmapinfoheader.biBitCount==8 || bitmap->bitmapinfoheader.biBitCount==16 ||
bitmap->bitmapinfoheader.biBitCount==24)
{
// delete the last image if there was one
if (bitmap->buffer)
free(bitmap->buffer);

// allocate the memory for the image
if (!(bitmap->buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
{
// close the file
_lclose(file_handle);

// return error
return(0);
} // end if

// now read it in
_lread(file_handle,bitmap->buffer,bitmap->bitmapinfoheader.biSizeImage);

} // end if
else
{
// serious problem
return(0);

} // end else

#if 0
// write the file info out
printf("\nfilename:%s \nsize=%d \nwidth=%d \nheight=%d \nbitsperpixel=%d \ncolors=%d \nimpcolors=%d",
filename,
bitmap->bitmapinfoheader.biSizeImage,
bitmap->bitmapinfoheader.biWidth,
bitmap->bitmapinfoheader.biHeight,
bitmap->bitmapinfoheader.biBitCount,
bitmap->bitmapinfoheader.biClrUsed,
bitmap->bitmapinfoheader.biClrImportant);
#endif

// close the file
_lclose(file_handle);

// flip the bitmap
Flip_Bitmap(bitmap->buffer,
bitmap->bitmapinfoheader.biWidth*(bitmap->bitmapinfoheader.biBitCount/8),
bitmap->bitmapinfoheader.biHeight);

// return success
return(1);

} // end Load_Bitmap_File

///////////////////////////////////////////////////////////

int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap)
{
// this function releases all memory associated with "bitmap"
if (bitmap->buffer)
{
// release memory
free(bitmap->buffer);

// reset pointer
bitmap->buffer = NULL;

} // end if

// return success
return(1);

} // end Unload_Bitmap_File

///////////////////////////////////////////////////////////

int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height)
{
// this function is used to flip bottom-up .BMP images

UCHAR *buffer; // used to perform the image processing
int index; // looping index

// allocate the temporary buffer
if (!(buffer = (UCHAR *)malloc(bytes_per_line*height)))
return(0);

// copy image to work area
memcpy(buffer,image,bytes_per_line*height);

// flip vertically
for (index=0; index < height; index++)
memcpy(&image[((height-1) - index)*bytes_per_line],
&buffer[index*bytes_per_line], bytes_per_line);

// release the memory
free(buffer);

// return success
return(1);

} // end Flip_Bitmap

///////////////////////////////////////////////////////////////

LPDIRECTDRAWCLIPPER DDraw_Attach_Clipper(LPDIRECTDRAWSURFACE4 lpdds,
int num_rects,
LPRECT clip_list)

{
// this function creates a clipper from the sent clip list and attaches
// it to the sent surface

int index; // looping var
LPDIRECTDRAWCLIPPER lpddclipper; // pointer to the newly created dd clipper
LPRGNDATA region_data; // pointer to the region data that contains
// the header and clip list

// first create the direct draw clipper
if (FAILED(screen().lpdd->CreateClipper(0,&lpddclipper,NULL)))
return(NULL);

// now create the clip list from the sent data

// first allocate memory for region data
region_data = (LPRGNDATA)malloc(sizeof(RGNDATAHEADER)+num_rects*sizeof(RECT));

// now copy the rects into region data
memcpy(region_data->Buffer, clip_list, sizeof(RECT)*num_rects);

// set up fields of header
region_data->rdh.dwSize = sizeof(RGNDATAHEADER);
region_data->rdh.iType = RDH_RECTANGLES;
region_data->rdh.nCount = num_rects;
region_data->rdh.nRgnSize = num_rects*sizeof(RECT);

region_data->rdh.rcBound.left = 64000;
region_data->rdh.rcBound.top = 64000;
region_data->rdh.rcBound.right = -64000;
region_data->rdh.rcBound.bottom = -64000;

// find bounds of all clipping regions
for (index=0; index<num_rects; index++)
{
// test if the next rectangle unioned with the current bound is larger
if (clip_list[index].left < region_data->rdh.rcBound.left)
region_data->rdh.rcBound.left = clip_list[index].left;

if (clip_list[index].right > region_data->rdh.rcBound.right)
region_data->rdh.rcBound.right = clip_list[index].right;

if (clip_list[index].top < region_data->rdh.rcBound.top)
region_data->rdh.rcBound.top = clip_list[index].top;

if (clip_list[index].bottom > region_data->rdh.rcBound.bottom)
region_data->rdh.rcBound.bottom = clip_list[index].bottom;

} // end for index

// now we have computed the bounding rectangle region and set up the data
// now let's set the clipping list

if (FAILED(lpddclipper->SetClipList(region_data, 0)))
{
// release memory and return error
free(region_data);
return(NULL);
} // end if

// now attach the clipper to the surface
if (FAILED(lpdds->SetClipper(lpddclipper)))
{
// release memory and return error
free(region_data);
return(NULL);
} // end if

// all is well, so release memory and send back the pointer to the new clipper
free(region_data);
return(lpddclipper);

} // end DDraw_Attach_Clipper

///////////////////////////////////////////////////////////

int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE4 lpdds,int color)
{
DDBLTFX ddbltfx; // this contains the DDBLTFX structure

// clear out the structure and set the size field
DDRAW_INIT_STRUCT(ddbltfx);

// set the dwfillcolor field to the desired color
ddbltfx.dwFillColor = color;

// ready to blt to surface
lpdds->Blt(NULL, // ptr to dest rectangle
NULL, // ptr to source surface, NA
NULL, // ptr to source rectangle, NA
DDBLT_COLORFILL | DDBLT_WAIT, // fill and wait
&ddbltfx); // ptr to DDBLTFX structure

// return success
return(1);
} // end DDraw_Fill_Surface

///////////////////////////////////////////////////////////////

int DDraw_Draw_Surface(LPDIRECTDRAWSURFACE4 source, // source surface to draw
int x, int y, // position to draw at
int width, int height, // size of source surface
LPDIRECTDRAWSURFACE4 dest, // surface to draw the surface on
int transparent = 1) // transparency flag
{
// draw a bob at the x,y defined in the BOB
// on the destination surface defined in dest

RECT dest_rect, // the destination rectangle
source_rect; // the source rectangle

// fill in the destination rect
dest_rect.left = x;
dest_rect.top = y;
dest_rect.right = x+width-1;
dest_rect.bottom = y+height-1;

// fill in the source rect
source_rect.left = 0;
source_rect.top = 0;
source_rect.right = width-1;
source_rect.bottom = height-1;

// test transparency flag

if (transparent)
{
// enable color key blit
// blt to destination surface
if (FAILED(dest->Blt(&dest_rect, source,
&source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
NULL)))
return(0);

} // end if
else
{
// perform blit without color key
// blt to destination surface
if (FAILED(dest->Blt(&dest_rect, source,
&source_rect,(DDBLT_WAIT),
NULL)))
return(0);

} // end if

// return success
return(1);

} // end DDraw_Draw_Surface

///////////////////////////////////////////////////////////////

int Scan_Image_Bitmap(BITMAP_FILE_PTR bitmap, // bitmap file to scan image data from
LPDIRECTDRAWSURFACE4 lpdds, // surface to hold data
int cx, int cy) // cell to scan image from
{
// this function extracts a bitmap out of a bitmap file

UCHAR *source_ptr, // working pointers
*dest_ptr;

DDSURFACEDESC2 ddsd; // direct draw surface description

// get the addr to destination surface memory

// set size of the structure
ddsd.dwSize = sizeof(ddsd);

// lock the display surface
lpdds->Lock(NULL,
&ddsd,
DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,
NULL);

// compute position to start scanning bits from
//cx = cx*(ddsd.dwWidth+1) + 1;
//cy = cy*(ddsd.dwHeight+1) + 1;

gwidth = ddsd.dwWidth;
gheight = ddsd.dwHeight;

int pitch = ((bitmap->bitmapinfoheader.biWidth + 3)&(~3))*(bitmap->bitmapinfoheader.biBitCount/8);

// extract bitmap data
source_ptr = bitmap->buffer + cy*pitch+cx;

// assign a pointer to the memory surface for manipulation
dest_ptr = (UCHAR *)ddsd.lpSurface;

// iterate thru each scanline and copy bitmap
for (int index_y=0; index_y < ddsd.dwHeight; index_y++)
{
// copy next line of data to destination
memcpy(dest_ptr, source_ptr, ddsd.dwWidth*(bitmap->bitmapinfoheader.biBitCount/8));

// advance pointers
dest_ptr += (ddsd.lPitch);
// source_ptr += bitmap->bitmapinfoheader.biWidth;
source_ptr += pitch;
} // end for index_y

// unlock the surface
lpdds->Unlock(NULL);

// return success
return(1);

} // end Scan_Image_Bitmap

///////////////////////////////////////////////////////////////

LPDIRECTDRAWSURFACE4 DDraw_Create_Surface(int width, int height, int mem_flags, int ck = 255)
{
// this function creates an offscreen plain surface

DDSURFACEDESC2 ddsd; // working description
LPDIRECTDRAWSURFACE4 lpdds; // temporary surface

// set to access caps, width, and height
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;

// set dimensions of the new bitmap surface
ddsd.dwWidth = width;
ddsd.dwHeight = height;

// set surface to offscreen plain
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | mem_flags;

// create the surface
if (FAILED(screen().lpdd->CreateSurface(&ddsd,&lpdds,NULL)))
return(NULL);

// test if user wants a color key
if (ck >= 0)
{
// set color key to color 0
DDCOLORKEY color_key; // used to set color key
color_key.dwColorSpaceLowValue = ck;
color_key.dwColorSpaceHighValue = ck;

// now set the color key for source blitting
lpdds->SetColorKey(DDCKEY_SRCBLT, &color_key);
} // end if

// return surface
return(lpdds);
} // end DDraw_Create_Surface


///////////////////////////////////////////////////////////////

LRESULT CALLBACK WindowProc(HWND hwnd,
UINT msg,
WPARAM wparam,
LPARAM lparam)
{
// this is the main message handler of the system
PAINTSTRUCT ps; // used in WM_PAINT
HDC hdc; // handle to a device context
char buffer[80]; // used to print strings

// what is the message
switch(msg)
{
case WM_CREATE:
{
// do initialization stuff here
// return success
return(0);
} break;

case WM_PAINT:
{
// simply validate the window
hdc = BeginPaint(hwnd,&ps);

// end painting
EndPaint(hwnd,&ps);

// return success
return(0);
} break;

case WM_DESTROY:
{

// kill the application, this sends a WM_QUIT message
PostQuitMessage(0);

// return success
return(0);
} break;

default:break;

} // end switch

// process any messages that we didn't take care of
return (DefWindowProc(hwnd, msg, wparam, lparam));

} // end WinProc

///////////////////////////////////////////////////////////

int Draw_Text_GDI(char *text, int x,int y,COLORREF color, LPDIRECTDRAWSURFACE4 lpdds)
{
// this function draws the sent text on the sent surface
// using color index as the color in the palette

HDC xdc; // the working dc

// get the dc from surface
if (FAILED(lpdds->GetDC(&xdc)))
return(0);

// set the colors for the text up
SetTextColor(xdc,color);

// set background mode to transparent so black isn't copied
SetBkMode(xdc, TRANSPARENT);

// draw the text a
TextOut(xdc,x,y,text,strlen(text));

// release the dc
lpdds->ReleaseDC(xdc);

// return success
return(1);
} // end Draw_Text_GDI

///////////////////////////////////////////////////////////////

int Game_Main(void *parms = NULL, int num_parms = 0)
{
int index; // general looping variable


// make sure this isn't executed again
if(window_closed)
return(0);

//test if user is hitting ESC and send WM_CLOSE
if(KEYDOWN(VK_ESCAPE)){
PostMessage(main_window_handle,WM_CLOSE,0,0);
window_closed = 1;
} // end if

GPT = GPT - 1;
Missle_TIME = Missle_TIME - 1;


//draw background
Draw_Background();

//pause game
if (KEYDOWN(VK_TAB)){
if(GPT < 0){
GAME_STATE = 2;
GPT = 33;
}
}
//move ship left
if (KEYDOWN(VK_LEFT)){
Shipx = Shipx - SHIP_SPEED;
if(Shipx <= 0){
Shipx = 0;
}
DDraw_Draw_Surface(thrusters[1],Shipx+SHIP_SIZE_X-2,Shipy+28,THRUSTER_SIZE_X,THRUSTER_SIZE_Y,screen().lpddsback);
}
//move ship right
if (KEYDOWN(VK_RIGHT)){
Shipx = Shipx + SHIP_SPEED;
if(Shipx >= SCREEN_WIDTH-(SHIP_SIZE_X)){
Shipx = SCREEN_WIDTH-(SHIP_SIZE_X);
}
DDraw_Draw_Surface(thrusters[0],Shipx-THRUSTER_SIZE_X+2,Shipy+28,THRUSTER_SIZE_X,THRUSTER_SIZE_Y,screen().lpddsback);
}
//fire a weapon
if (KEYDOWN(VK_SPACE)){
if(Missle_Total < MAX_MISSLES && Missle_TIME < 0){
Missle_Total = Missle_Total + 1;
Missle_TIME = 7;
int done = 0;
if(Fire_Type == 1){
for(int i = 0; i<MAX_MISSLES; i++){
if(Missles == 0){
Misslesx = Shipx+(SHIP_SIZE_X/2)-PHOTON_SIZE_X/2;
Misslesy = Shipy-5;
Missles = 1;
i = MAX_MISSLES;
}
}
}
if(Fire_Type == 2){
for(int j = 0; j<MAX_MISSLES; j++){
if(Missles[j] == 0){
Misslesx[j] = Shipx+19;
Misslesy[j] = Shipy+8;
Missles[j] = 1;
Misslesx[j+1] = Shipx+51;
Misslesy[j+1] = Shipy+8;
Missles[j+1] = 1;
j = MAX_MISSLES;
}
j = j + 1;
}
}
}
}

// d3dDevice->Clear (0, NULL, lpddsback, 0, 0, 0);

/*
//clear back buffer
UCHAR *back_buffer = (UCHAR *)ddsd.lpSurface;
if(ddsd.lPitch == SCREEN_WIDTH){
memset(back_buffer,0,SCREEN_WIDTH*SCREEN_HEIGHT);
}
else{
UCHAR *dest_ptr = back_buffer;
for(int y=0; y<SCREEN_HEIGHT; y++){
memset(dest_ptr,0,SCREEN_WIDTH);
dest_ptr+=ddsd.lPitch;
}
}
*/

// clear the drawing surface
// DDraw_Fill_Surface(lpddsback, 0);

//draw ship and engines
DDraw_Draw_Surface(ship[frame_ship],Shipx,Shipy,SHIP_SIZE_X,SHIP_SIZE_Y,screen().lpddsback);
DDraw_Draw_Surface(engines[frame_engine],Shipx+2,Shipy+59,ENGINE_SIZE_X,ENGINE_SIZE_Y,screen().lpddsback);
DDraw_Draw_Surface(engines[frame_engine],Shipx+66,Shipy+59,ENGINE_SIZE_X,ENGINE_SIZE_Y,screen().lpddsback);

Draw_Missles();
Draw_Aliens();
Draw_PowerUps();
Draw_BEAM();

// draw the info
sprintf(buffer,"Space Version 2.1"); //title
Draw_Text_GDI(buffer, 1,566, 255, screen().lpddsback);
sprintf(buffer,"Copyright 2005 Charles Reed"); //title
Draw_Text_GDI(buffer, 1,582, 255, screen().lpddsback);
sprintf(buffer,"SCORE: %d", score); //score
Draw_Text_GDI(buffer, 1,0, 255, screen().lpddsback);
if(Ship_Health == 3){
sprintf(buffer,"SHIELD: ***");
}
if(Ship_Health == 2){
sprintf(buffer,"SHIELD: **");
}
if(Ship_Health == 1){
sprintf(buffer,"SHIELD: *");
}
if(Ship_Health <= 0){
sprintf(buffer," ");
GAME_STATE = 3;
}
Draw_Text_GDI(buffer, 0,16, 255, screen().lpddsback);

update_frames();

// flip pages
while (FAILED(screen().lpddsprimary->Flip(NULL, DDFLIP_WAIT)));

// wait a sec
Sleep(30);

// return success or failure or your own return code here
return(1);
} // end Game_Main

int Game_Intro(){
if(window_closed)
return(0);
Draw_Rectangle(0,0,SCREEN_WIDTH-1, SCREEN_HEIGHT-1,0); //clear screen
sprintf(buffer,"SPACE Version 2.1");
Draw_Text_GDI(buffer, 290,271, 255, screen().lpddsback);
sprintf(buffer,"by Charles Reed");
Draw_Text_GDI(buffer, 290,287, 255, screen().lpddsback);
sprintf(buffer,"Press <SPACE> to begin");
Draw_Text_GDI(buffer, 290,303, 255, screen().lpddsback);

// flip the surfaces
while (FAILED(screen().lpddsprimary->Flip(NULL, DDFLIP_WAIT)));

// sync to 33ish fps
Sleep(30);
if(KEYDOWN(VK_ESCAPE)){
PostMessage(main_window_handle,WM_CLOSE,0,0);
window_closed = 1;
} // end if
if(KEYDOWN(VK_SPACE)){
for(int i = 0; i < 3; i++){
ALIEN = 0;
}
GPT = 33; //for pausing game
ALIEN_Total = 0;
Ship_Health = MAX_HEALTH;
score = 0;
PowerUp = 0;
PowerUpType = 0;
Missle_Size_X = PHOTON_SIZE_X;
Missle_Size_Y = PHOTON_SIZE_Y;
Fire_Type = 1;
//reset all missles
for(i = 0; i < MAX_MISSLES; i++){
Missles = 0;
}
//setup stars
for(i = 0; i < NUMBER_OF_STARS; i++){
Starsx = rand()%SCREEN_WIDTH;
Starsy = rand()%SCREEN_HEIGHT;
Starss = rand()%3 + 2;
}
//setup ship
Shipx = SCREEN_WIDTH/2-30;
Shipy = SCREEN_HEIGHT-101;
alien1_timer = 0;
alien2_timer = 0;
GAME_STATE = 1;
} // end if

return 0;
}

int Game_Paused(){
// make sure this isn't executed again
if(window_closed)
return(0);
char buffer[80]; // used to print text
Draw_Rectangle(0,0,SCREEN_WIDTH-1, SCREEN_HEIGHT-1,0); //clear screen
sprintf(buffer,"GAME PAUSED: TAB TO UNPAUSE"); //pause
Draw_Text_GDI(buffer, 200,231, 255, screen().lpddsback);
sprintf(buffer,"--Controls--"); //pause
Draw_Text_GDI(buffer, 200,247, 255, screen().lpddsback);
sprintf(buffer,"Left Arrow: Move Left"); //pause
Draw_Text_GDI(buffer, 200,263, 255, screen().lpddsback);
sprintf(buffer,"Right Arrow: Move Right"); //pause
Draw_Text_GDI(buffer, 200,279, 255, screen().lpddsback);
sprintf(buffer,"Escape Key: Quit Game"); //pause
Draw_Text_GDI(buffer, 200,295, 255, screen().lpddsback);
sprintf(buffer,"Tab Key: Pause or Unpause Game"); //pause
Draw_Text_GDI(buffer, 200,311, 255, screen().lpddsback);
GPT = GPT - 1;
if(KEYDOWN(VK_TAB)){
if(GPT < 0){
GPT = 33;
GAME_STATE = 1;
}
}
// flip the surfaces
while (FAILED(screen().lpddsprimary->Flip(NULL, DDFLIP_WAIT)));

// sync to 33ish fps
Sleep(30);
if(KEYDOWN(VK_ESCAPE)){
PostMessage(main_window_handle,WM_CLOSE,0,0);
window_closed = 1;
} // end if
return 0;
}

int Game_Done(){
// make sure this isn't executed again
if(window_closed)
return(0);
Draw_Rectangle(0,0,SCREEN_WIDTH-1, SCREEN_HEIGHT-1,0);
sprintf(buffer,"GAME OVER"); //pause
Draw_Text_GDI(buffer, 200,231, 255, screen().lpddsback);
sprintf(buffer,"TRY AGAIN: TAB");
Draw_Text_GDI(buffer, 200,247, 255, screen().lpddsback);
sprintf(buffer,"QUIT: ESCAPE"); //pause
Draw_Text_GDI(buffer, 200,263, 255, screen().lpddsback);
sprintf(buffer,"SCORE: %d", score); //pause
Draw_Text_GDI(buffer, 200,279, 255, screen().lpddsback);
// flip the surfaces
while (FAILED(screen().lpddsprimary->Flip(NULL, DDFLIP_WAIT)));
// sync to 33ish fps
Sleep(30);
if(KEYDOWN(VK_TAB)){
GAME_STATE = 0;
}
if(KEYDOWN(VK_ESCAPE)){
PostMessage(main_window_handle,WM_CLOSE,0,0);
window_closed = 1;
} // end if
return 0;
}

////////////////////////////////////////////////////////////

int Game_Init(void *parms = NULL, int num_parms = 0){
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here

LPDIRECTDRAW lpdd_temp;

// first create base IDirectDraw interface
if (FAILED(DirectDrawCreate(NULL, &lpdd_temp, NULL)))
return(0);

// now query for IDirectDraw4
if (FAILED(lpdd_temp->QueryInterface(IID_IDirectDraw4,
(LPVOID *)&screen().lpdd)))
return(0);

// set cooperation to full screen
if (FAILED(screen().lpdd->SetCooperativeLevel(main_window_handle,
DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))
return(0);

// set display mode to 800x600x8
if (FAILED(screen().lpdd->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,0,0)))
return(0);

// we need a complex surface system with a primary and backbuffer

// clear ddsd and set size
DDRAW_INIT_STRUCT(screen().ddsd);

// enable valid fields
screen().ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;

// set the backbuffer count field to 1, use 2 for triple buffering
screen().ddsd.dwBackBufferCount = 1;

// request a complex, flippable
screen().ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;

// create the primary surface
if (FAILED(lpdd->CreateSurface(&ddsd, &lpddsprimary, NULL)))
return(0);

// now query for attached surface from the primary surface

// this line is needed by the call
ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;

// get the attached back buffer surface
if (FAILED(lpddsprimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsback)))
return(0);

// build up the palette data array
for (int color=1; color < 255; color++)
{
// fill with random RGB values
palette[color].peRed = rand()%256;
palette[color].peGreen = rand()%256;
palette[color].peBlue = rand()%256;

// set flags field to PC_NOCOLLAPSE
palette[color].peFlags = PC_NOCOLLAPSE;
} // end for color

// now fill in entry 0 and 255 with black and white
palette[0].peRed = 0;
palette[0].peGreen = 0;
palette[0].peBlue = 0;
palette[0].peFlags = PC_NOCOLLAPSE;

palette[255].peRed = 255;
palette[255].peGreen = 255;
palette[255].peBlue = 255;
palette[255].peFlags = PC_NOCOLLAPSE;

// create the palette object
if (FAILED(lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_ALLOW256 |
DDPCAPS_INITIALIZE,
palette,&lpddpal, NULL)))
return(0);

// finally attach the palette to the primary surface
if (FAILED(lpddsprimary->SetPalette(lpddpal)))
return(0);

// set clipper up on back buffer since that's where well clip
RECT screen_rect= {0,0,SCREEN_WIDTH,SCREEN_HEIGHT};
lpddclipper = DDraw_Attach_Clipper(lpddsback,1,&screen_rect);

// load the 8-bit image
if (!Load_Bitmap_File(&bitmap,"gra.bmp"))
return(0);

// load it's palette into directdraw
if (FAILED(lpddpal->SetEntries(0,0,MAX_COLORS_PALETTE,bitmap.palette)))
return(0);

// clean the surfaces
DDraw_Fill_Surface(lpddsprimary,0);
DDraw_Fill_Surface(lpddsback,0);

// create the buffer to hold the background
lpddsbackground = DDraw_Create_Surface(800,600,0,-1);

// copy the background bitmap image to the background surface

// lock the surface
lpddsbackground->Lock(NULL,&ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);

// get video pointer to primary surfce
UCHAR *image_buffer = (UCHAR *)ddsd.lpSurface;

// test if memory is linear
if (ddsd.lPitch == SCREEN_WIDTH){
// copy memory from double buffer to primary buffer
memcpy((void *)image_buffer, (void *)bitmap.buffer, SCREEN_WIDTH*SCREEN_HEIGHT);
} // end if
else{ // non-linear

// make copy of source and destination addresses
UCHAR *dest_ptr = image_buffer;
UCHAR *src_ptr = bitmap.buffer;

// memory is non-linear, copy line by line
for (int y=0; y < SCREEN_HEIGHT; y++){
// copy line
memcpy((void *)dest_ptr, (void *)src_ptr, SCREEN_WIDTH);

// advance pointers to next line
dest_ptr+=ddsd.lPitch;
src_ptr +=SCREEN_WIDTH;
} // end for

} // end else

// now unlock the primary surface
if (FAILED(lpddsbackground->Unlock(NULL)))
return(0);

// seed random number generator
srand(GetTickCount());

//load the ship images
ship[0] = DDraw_Create_Surface(SHIP_SIZE_X,SHIP_SIZE_Y,0,255);
ship[1] = DDraw_Create_Surface(SHIP_SIZE_X,SHIP_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,ship[0],1,1);
Scan_Image_Bitmap(&bitmap,ship[1],78,1);

//load the engine images
engines[0] = DDraw_Create_Surface(ENGINE_SIZE_X,ENGINE_SIZE_Y,0,255);
engines[1] = DDraw_Create_Surface(ENGINE_SIZE_X,ENGINE_SIZE_Y,0,255);
engines[2] = DDraw_Create_Surface(ENGINE_SIZE_X,ENGINE_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,engines[0],1,88);
Scan_Image_Bitmap(&bitmap,engines[1],10,88);
Scan_Image_Bitmap(&bitmap,engines[2],19,88);

//load the thruster images
thrusters[0] = DDraw_Create_Surface(THRUSTER_SIZE_X,THRUSTER_SIZE_Y,0,255);
thrusters[1] = DDraw_Create_Surface(THRUSTER_SIZE_X,THRUSTER_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,thrusters[0],28,88);
Scan_Image_Bitmap(&bitmap,thrusters[1],33,88);

//load the photon images
photon[0] = DDraw_Create_Surface(PHOTON_SIZE_X,PHOTON_SIZE_Y,0,255);
photon[1] = DDraw_Create_Surface(PHOTON_SIZE_X,PHOTON_SIZE_Y,0,255);
photon[2] = DDraw_Create_Surface(PHOTON_SIZE_X,PHOTON_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,photon[0],1,94);
Scan_Image_Bitmap(&bitmap,photon[1],12,94);
Scan_Image_Bitmap(&bitmap,photon[2],23,94);

//load the quantum images
quantum[0] = DDraw_Create_Surface(QUANTUM_SIZE_X,QUANTUM_SIZE_Y,0,255);
quantum[1] = DDraw_Create_Surface(QUANTUM_SIZE_X,QUANTUM_SIZE_Y,0,255);
quantum[2] = DDraw_Create_Surface(QUANTUM_SIZE_X,QUANTUM_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,quantum[0],1,105);
Scan_Image_Bitmap(&bitmap,quantum[1],12,105);
Scan_Image_Bitmap(&bitmap,quantum[2],23,105);

//load the explode images
explode[0] = DDraw_Create_Surface(EX_SIZE_X,EX_SIZE_Y,0,255);
explode[1] = DDraw_Create_Surface(EX_SIZE_X,EX_SIZE_Y,0,255);
explode[2] = DDraw_Create_Surface(EX_SIZE_X,EX_SIZE_Y,0,255);
explode[3] = DDraw_Create_Surface(EX_SIZE_X,EX_SIZE_Y,0,255);
explode[4] = DDraw_Create_Surface(EX_SIZE_X,EX_SIZE_Y,0,255);
explode[5] = DDraw_Create_Surface(EX_SIZE_X,EX_SIZE_Y,0,255);
explode[6] = DDraw_Create_Surface(EX_SIZE_X,EX_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,explode[0],101,66);
Scan_Image_Bitmap(&bitmap,explode[1],186,66);
Scan_Image_Bitmap(&bitmap,explode[2],271,66);
Scan_Image_Bitmap(&bitmap,explode[3],356,66);
Scan_Image_Bitmap(&bitmap,explode[4],441,66);
Scan_Image_Bitmap(&bitmap,explode[5],526,66);
Scan_Image_Bitmap(&bitmap,explode[6],611,66);

//load the alien image
alien[0] = DDraw_Create_Surface(ALIEN_SIZE_X,ALIEN_SIZE_Y,0,255);
alien[1] = DDraw_Create_Surface(ALIEN_SIZE_X,ALIEN_SIZE_Y,0,255);
alien[2] = DDraw_Create_Surface(ALIEN_SIZE_X,ALIEN_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,alien[0],155,1);
Scan_Image_Bitmap(&bitmap,alien[1],218,1);
Scan_Image_Bitmap(&bitmap,alien[2],281,1);

//load the shield image
shield[0] = DDraw_Create_Surface(SHIELD_SIZE_X,SHIELD_SIZE_Y,0,255);
shield[1] = DDraw_Create_Surface(SHIELD_SIZE_X,SHIELD_SIZE_Y,0,255);
shield[2] = DDraw_Create_Surface(SHIELD_SIZE_X,SHIELD_SIZE_Y,0,255);
shield[3] = DDraw_Create_Surface(SHIELD_SIZE_X,SHIELD_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,shield[0],1,63);
Scan_Image_Bitmap(&bitmap,shield[1],26,63);
Scan_Image_Bitmap(&bitmap,shield[2],51,63);
Scan_Image_Bitmap(&bitmap,shield[3],76,63);

//load the torp image
torp[0] = DDraw_Create_Surface(TORP_SIZE_X,TORP_SIZE_Y,0,255);
torp[1] = DDraw_Create_Surface(TORP_SIZE_X,TORP_SIZE_Y,0,255);
torp[2] = DDraw_Create_Surface(TORP_SIZE_X,TORP_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,torp[0],101,139);
Scan_Image_Bitmap(&bitmap,torp[1],138,139);
Scan_Image_Bitmap(&bitmap,torp[2],175,139);

//load the beam image
beam[0] = DDraw_Create_Surface(BEAM_SIZE_X,BEAM_SIZE_Y,0,255);
beam[1] = DDraw_Create_Surface(BEAM_SIZE_X,BEAM_SIZE_Y,0,255);
beam[2] = DDraw_Create_Surface(BEAM_SIZE_X,BEAM_SIZE_Y,0,255);
Scan_Image_Bitmap(&bitmap,beam[0],0,116);
Scan_Image_Bitmap(&bitmap,beam[1],12,116);
Scan_Image_Bitmap(&bitmap,beam[2],23,116);

Unload_Bitmap_File(&bitmap);

//return success or failure or your own return code here
return(1);

} //end Game_Init

/////////////////////////////////////////////////////////////

int Game_Shutdown(void *parms = NULL, int num_parms = 0)
{
// this is called after the game is exited and the main event
// loop while is exited, do all you cleanup and shutdown here

// kill all the surfaces


// first the palette
if (lpddpal)
{
lpddpal->Release();
lpddpal = NULL;
} // end if

// now the primary surface
if (lpddsprimary)
{
lpddsprimary->Release();
lpddsprimary = NULL;
} // end if

// now blow away the IDirectDraw4 interface
if (lpdd)
{
lpdd->Release();
lpdd = NULL;
} // end if

// return success or failure or your own return code here
return(1);

} // end Game_Shutdown

// WINMAIN ////////////////////////////////////////////////

int WINAPI WinMain( HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{

WNDCLASSEX winclass; // this will hold the class we create
HWND hwnd; // generic window handle
MSG msg; // generic message
HDC hdc; // graphics device context

// first fill in the window class stucture
winclass.cbSize = sizeof(WNDCLASSEX);
winclass.style = CS_DBLCLKS | CS_OWNDC |
CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc = WindowProc;
winclass.cbClsExtra = 0;
winclass.cbWndExtra = 0;
winclass.hInstance = hinstance;
winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName = NULL;
winclass.lpszClassName = WINDOW_CLASS_NAME;
winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

// save hinstance in global
hinstance_app = hinstance;

// register the window class
if (!RegisterClassEx(&winclass))
return(0);

// create the window
if (!(hwnd = CreateWindowEx(NULL, // extended style
WINDOW_CLASS_NAME, // class
"GATGame Version 2.0", // title
WS_POPUP | WS_VISIBLE,
0,0, // initial x,y
SCREEN_WIDTH,SCREEN_HEIGHT, // initial width, height
NULL, // handle to parent
NULL, // handle to menu
hinstance,// instance of this application
NULL))) // extra creation parms
return(0);

// hide mouse
ShowCursor(FALSE);

// save main window handle
main_window_handle = hwnd;

// initialize game here
Game_Init();

// enter main event loop
while(TRUE)
{
// test if there is a message in queue, if so get it
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)){
// test if this is a quit
if (msg.message == WM_QUIT)
break;

// translate any accelerator keys
TranslateMessage(&msg);

// send the message to the window proc
DispatchMessage(&msg);
} // end if

// main game processing goes here
if(GAME_STATE == 0){
Game_Intro();
}
else if(GAME_STATE == 1){
Game_Main();
}
else if(GAME_STATE == 2){
Game_Paused();
}
else if(GAME_STATE == 3){
Game_Done();
}
else;

} // end while

// closedown game here
Game_Shutdown();

// return to Windows like this
return(msg.wParam);

} // end WinMain



//screen.cpp - source file for the screen class

#include "screen.h"

SCREEN::SCREEN(){
lpdd = NULL; // dd4 object
lpddsprimary = NULL; // dd primary surface
lpddsback = NULL; // dd back surface
lpddpal = NULL; // a pointer to the created dd palette
lpddclipper = NULL; // dd clipper
start_clock_count = 0;
}

SCREEN::SCREEN(const SCREEN& other){
lpdd = other.lpdd;
lpddsprimary = other.lpddsprimary;
lpddsback = other.lpddsback;
lpddpal = other .lpddpal;
lpddclipper = other.lpddclipper;
//copy the palette
for(int i = 0; i < 256; i++){
palette = other.palette;
}
//copy the save_palette
for(int j = 0; j < 256; j++){
save_palette[j] = other.save_palette[j];
}
ddsd = other.ddsd;
ddbltfx = other.ddbltfx;
ddscaps = other.ddscaps;
ddrval = other.ddrval;
start_clock_count = other.start_clock_count;
}



//screen.h - header file for the screen class

/* Screen class infomation
the screen class is designed to hold all the data members used to output graphics onto the screen.
as well as any and all functions needed to setup the directX control of the screen. A game engine
should only have one screen object. any other class that needs to output to the screen should then
pass the screen object into it. this will allow for the class to output graphics or text onto the
screen.
*/


#include <ddraw.h> //for direct draw

#ifndef __SCREEN__
#define __SCREEN__

class SCREEN{
public:
//constructors
SCREEN(); //default
SCREEN(const SCREEN& other); //copy

LPDIRECTDRAW4 lpdd; // dd4 object
LPDIRECTDRAWSURFACE4 lpddsprimary; // dd primary surface
LPDIRECTDRAWSURFACE4 lpddsback; // dd back surface
LPDIRECTDRAWPALETTE lpddpal; // a pointer to the created dd palette
LPDIRECTDRAWCLIPPER lpddclipper; // dd clipper
PALETTEENTRY palette[256]; // color palette
PALETTEENTRY save_palette[256]; // used to save palettes
DDSURFACEDESC2 ddsd; // a direct draw surface description struct
DDBLTFX ddbltfx; // used to fill
DDSCAPS2 ddscaps; // a direct draw surface capabilities struct
HRESULT ddrval; // result back from dd calls
DWORD start_clock_count; // used for timing
private:
bool is_vaild; //holds if this is a vaild screen.
};

#endif
[\source]

thank you for any help you can give me, i'm rather confused.

Share this post


Link to post
Share on other sites
jwalsh thank you for explaining about the & operator. i thought it was talking about & used for derefuncing rather than joining to things together.

this is the line of code giving me this error:
if(FAILED(lpdd_temp->QueryInterface(IID_IDirectDraw4,(LPVOID *)&screen().lpdd)))

it is line number 1468 in main.cpp

Share this post


Link to post
Share on other sites
Quote:
Original post by CodeMunkie
I think he meant post the line of code that is causing the error.


you might be right, but this way, at least we'll hopefully figure out the problem.

Share this post


Link to post
Share on other sites
Get rid of the & symbol in that statement, and it may work. You are already typecasting it to be a pointer, so you don't need to say that it's a pointer as well with the & symbol.

Share this post


Link to post
Share on other sites
You might try wrapping some parenthesis in that line. I may be wrong, but I think it is evaluating &screen() and then .lpdd which is not what you intended. Try this instead:

if(FAILED(lpdd_temp->QueryInterface(IID_IDirectDraw4,(LPVOID *)&(screen().lpdd))))


Quote:
Get rid of the & symbol in that statement, and it may work. You are already typecasting it to be a pointer, so you don't need to say that it's a pointer as well with the & symbol.

No it is correct syntax. lpdd is a pointer, and he is casting to LPVOID* (pointer to pointer), so the & is necessary.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!