• Announcements

    • khawk

      Download the Game Design and Indie Game Marketing Freebook   07/19/17

      GameDev.net and CRC Press have teamed up to bring a free ebook of content curated from top titles published by CRC Press. The freebook, Practices of Game Design & Indie Game Marketing, includes chapters from The Art of Game Design: A Book of Lenses, A Practical Guide to Indie Game Marketing, and An Architectural Approach to Level Design. The GameDev.net FreeBook is relevant to game designers, developers, and those interested in learning more about the challenges in game development. We know game development can be a tough discipline and business, so we picked several chapters from CRC Press titles that we thought would be of interest to you, the GameDev.net audience, in your journey to design, develop, and market your next game. The free ebook is available through CRC Press by clicking here. The Curated Books The Art of Game Design: A Book of Lenses, Second Edition, by Jesse Schell Presents 100+ sets of questions, or different lenses, for viewing a game’s design, encompassing diverse fields such as psychology, architecture, music, film, software engineering, theme park design, mathematics, anthropology, and more. Written by one of the world's top game designers, this book describes the deepest and most fundamental principles of game design, demonstrating how tactics used in board, card, and athletic games also work in video games. It provides practical instruction on creating world-class games that will be played again and again. View it here. A Practical Guide to Indie Game Marketing, by Joel Dreskin Marketing is an essential but too frequently overlooked or minimized component of the release plan for indie games. A Practical Guide to Indie Game Marketing provides you with the tools needed to build visibility and sell your indie games. With special focus on those developers with small budgets and limited staff and resources, this book is packed with tangible recommendations and techniques that you can put to use immediately. As a seasoned professional of the indie game arena, author Joel Dreskin gives you insight into practical, real-world experiences of marketing numerous successful games and also provides stories of the failures. View it here. An Architectural Approach to Level Design This is one of the first books to integrate architectural and spatial design theory with the field of level design. The book presents architectural techniques and theories for level designers to use in their own work. It connects architecture and level design in different ways that address the practical elements of how designers construct space and the experiential elements of how and why humans interact with this space. Throughout the text, readers learn skills for spatial layout, evoking emotion through gamespaces, and creating better levels through architectural theory. View it here. Learn more and download the ebook by clicking here. Did you know? GameDev.net and CRC Press also recently teamed up to bring GDNet+ Members up to a 20% discount on all CRC Press books. Learn more about this and other benefits here.
Sign in to follow this  
Followers 0
ISDCaptain01

How do I get enemies to shoot at me? (C++)

1 post in this topic

Im making a vertical shooter. I can get the enemies to move around and come and ram their ship at me, but I wrote some code for them to shoot bullets at me but nothing happens here is my code, I will highlight the bullet code in bold

 

header file

#pragma once
#include <allegro.h>
#include "mappyal.h"
#include <iostream>
using namespace std;

//Must run at 640 x 480
#define WIDTH 640
#define HEIGHT 480

//Color macros
#define WHITE makecol(255, 255, 255)
#define GRAY makecol(60, 60, 60)
#define RED makecol(200, 0, 0)
#define BLACK makecol(0, 0, 0)
#define BLUE makecol(0, 0, 255)

//Game macros
#define MAX_ENEMIES 20
#define MAX_BULLETS 20
#define MAX_EXPLOSIONS 10
#define BOTTOM 48000 - HEIGHT
#define MAX_ENEMY_BULLETS 20


//Sprite class
class SPRITE
{
public:
	int dir, alive;
	int x, y;
	int width, height;
	int xspeed, yspeed;
	int xdelay, ydelay;
	int xcount, ycount;
	int curframe, maxframe, animdir;
	int framecount, framedelay;
};

//y offset in pixel
extern int yoffset;

//Player variables
extern int firecount;
extern int firedelay;
extern int health;
extern int score;

//Sound effects
extern SAMPLE *sounds[10];
extern int volume;
extern int pitch;
extern int pan;

//Bitmaps and sprites
extern BITMAP *buffer;
extern BITMAP *temp;
extern BITMAP *explosion_images[6];
extern SPRITE *explosions[MAX_EXPLOSIONS];
extern BITMAP *bigexp_images[7];
extern SPRITE *bigexp;
extern BITMAP *player_images[3];
extern SPRITE *player;
extern BITMAP *bullet_images[2];
extern SPRITE *bullets[MAX_BULLETS];
extern BITMAP *enemy_plane_images[3];
extern SPRITE *enemy_planes[MAX_ENEMIES];
extern BITMAP *progress, *bar;
extern BITMAP *bonus_shot_image;
extern SPRITE *bonus_shot;
extern int gameover;
extern BITMAP *gameend;
extern BITMAP *enemy_bullet_image;
extern SPRITE *enemy_bullets[MAX_ENEMY_BULLETS];


//Function prototypes
BITMAP *grabframe(BITMAP *source, int width, int height, 
	            int startx, int starty, int columns, int frame);
void loadsprite();
int inside(int x, int y, int left, int top, int right, int bottom);
void updatesprite(SPRITE *spr);
void startexplosion(int x, int y);
void updateexplosions();
void updatebonuses();
void updatebullet(SPRITE *spr);
void updatebullets();
void fireatenemy();
void bouncex_warpy(SPRITE *spr);
void displayprogress(int life);
void updateenemyplanes();
void updatescroller();
void updateplayer();
void checkinput();
void initialize();
void endgame(int &health, int &score);
void loadsounds();
void updateenemybullet(SPRITE *spr);
void updateenemybullets();
void fireatplayer();

My bullet code is located in the implementation file. the functions are called updateenemybulle, updatenememybullets, and fireatplayer(I call this in updateenemyplanes()). Skip the loadsprites code. Im just loading them in

 

heres the implementation file


//global variables BITMAP *buffer; BITMAP *temp; BITMAP *explosion_images[6]; SPRITE *explosions[MAX_EXPLOSIONS]; BITMAP *bigexp_images[7]; SPRITE *bigexp; BITMAP *player_images[3]; SPRITE *player; BITMAP *bullet_images[2]; SPRITE *bullets[MAX_BULLETS]; BITMAP *enemy_plane_images[3]; SPRITE *enemy_planes[MAX_ENEMIES]; BITMAP *progress, *bar; BITMAP *bonus_shot_image; SPRITE *bonus_shot; BITMAP *gameend; BITMAP *enemy_bullet_image; SPRITE *enemy_bullets[MAX_ENEMY_BULLETS]; //The sounds SAMPLE *sounds[10]; //sound variables int volume = 400; int pitch = 1000; int pan = 1000; //y offset in pixel int yoffset = BOTTOM; //Player variables int firecount = 0; int firedelay = 60; int health = 25; int score = 0; int gameover = 0; //Grabs the frame of a sprite sheet BITMAP *grabframe(BITMAP *source, int width, int height, int startx, int starty, int columns, int frame) { BITMAP *temp = create_bitmap(width, height); int x = startx + (frame % columns) * width; int y = starty + (frame / columns) * height; blit(source, temp, x, y, 0, 0, width, height); return temp; } //Load all the sprites into the game void loadsprite() { //counter variable int n; //load the progress bar temp = load_bitmap("progress.bmp", NULL); progress = grabframe(temp, 130, 14, 0, 0, 1, 0); bar = grabframe(temp, 6, 10, 130, 2, 1, 0); destroy_bitmap(temp); //load the bonus shot bonus_shot_image = load_bitmap("bonusshot.bmp", NULL); bonus_shot = new SPRITE; bonus_shot->alive = 0; bonus_shot->x = 0; bonus_shot->y = 0; bonus_shot->width = bonus_shot_image->w; bonus_shot->height = bonus_shot_image->h; bonus_shot->xdelay = 0; bonus_shot->ydelay = 2; bonus_shot->xcount = 0; bonus_shot->ycount = 0; bonus_shot->xspeed = 0; bonus_shot->yspeed = 1; //moving down the screen bonus_shot->curframe = 0; bonus_shot->maxframe = 0; bonus_shot->framecount = 0; bonus_shot->framedelay = 0; //Load the player temp = load_bitmap("p38.bmp", NULL); for(n = 0; n < 3; n++) { player_images[n] = grabframe(temp, 64, 64, 0, 0, 3, n); } destroy_bitmap(temp); player = new SPRITE; player->x = 320 - 32; //middle of screen player->y = 400; //nearly bottom of screen player->width = player_images[0]->w; player->height = player_images[0]->h; player->xdelay = 1; player->ydelay = 0; player->xcount = 0; player->ycount = 0; player->xspeed = 0; player->yspeed = 0; player->curframe = 0; player->maxframe = 2; player->framecount = 0; player->framedelay = 10; player->animdir = 1; //Load the bullets bullet_images[0] = load_bitmap("bullets.bmp", NULL); for(n = 0; n < MAX_BULLETS; n++) { bullets[n] = new SPRITE; bullets[n]->alive = 0; bullets[n]->x = 0; bullets[n]->y = 0; bullets[n]->width = bullet_images[0]->w; bullets[n]->height = bullet_images[0]->h; bullets[n]->xdelay = 0; bullets[n]->ydelay = 0; bullets[n]->xcount = 0; bullets[n]->ycount = 0; bullets[n]->xspeed = 0; bullets[n]->yspeed = -2; //moving up the screen bullets[n]->curframe = 0; bullets[n]->maxframe = 0; bullets[n]->framecount = 0; bullets[n]->framedelay = 0; bullets[n]->animdir = 0; } //Load the enemy bullets enemy_bullet_image = load_bitmap("enemy_bullet.bmp", NULL); for(n = 0; n < MAX_ENEMY_BULLETS; n++) { enemy_bullets[n] = new SPRITE; enemy_bullets[n]->alive = 0; enemy_bullets[n]->x = 0; enemy_bullets[n]->y = 0; enemy_bullets[n]->width = enemy_bullet_image->w; enemy_bullets[n]->height = enemy_bullet_image->h; enemy_bullets[n]->xcount = 0; enemy_bullets[n]->ycount = 0; enemy_bullets[n]->xdelay = 0; enemy_bullets[n]->ydelay = 0; enemy_bullets[n]->xspeed = 0; enemy_bullets[n]->yspeed = 2; enemy_bullets[n]->curframe = 0; enemy_bullets[n]->maxframe = 0; enemy_bullets[n]->framecount = 0; enemy_bullets[n]->framedelay = 0; enemy_bullets[n]->animdir = 0; } //load the enemy planes temp = load_bitmap("enemyplane1.bmp", NULL); for(n = 0; n < 3; n++) { enemy_plane_images[n] = grabframe(temp, 32, 32, 0, 0, 3, n); } destroy_bitmap(temp); for(n = 0; n < MAX_ENEMIES; n++) { enemy_planes[n] = new SPRITE; enemy_planes[n]->alive = 0; enemy_planes[n]->x = rand() % 100 + 50; enemy_planes[n]->y = 0; enemy_planes[n]->width = enemy_plane_images[0]->w; enemy_planes[n]->height = enemy_plane_images[0]->h; enemy_planes[n]->xdelay = 4; enemy_planes[n]->ydelay = 4; enemy_planes[n]->xcount = 0; enemy_planes[n]->ycount = 0; enemy_planes[n]->xspeed = (rand() % 2 - 3); enemy_planes[n]->yspeed = 1; //moving down the screen enemy_planes[n]->curframe = 0; enemy_planes[n]->maxframe = 2; enemy_planes[n]->framecount = 0; enemy_planes[n]->framedelay = 10; enemy_planes[n]->animdir = 1; } //Load the explosions temp = load_bitmap("explosion.bmp", NULL); for(n = 0; n < 6; n++) { explosion_images[n] = grabframe(temp, 32, 32, 0, 0, 6, n); } destroy_bitmap(temp); for(n = 0; n < MAX_EXPLOSIONS; n++) { explosions[n] = new SPRITE; explosions[n]->alive = 0; explosions[n]->x = 0; explosions[n]->y = 0; explosions[n]->width = explosion_images[0]->w; explosions[n]->height = explosion_images[0]->h; explosions[n]->xdelay = 0; explosions[n]->ydelay = 8; explosions[n]->xcount = 0; explosions[n]->ycount = 0; explosions[n]->yspeed = -1; //moving up the screen explosions[n]->xspeed = 0; explosions[n]->curframe = 0; explosions[n]->maxframe = 5; explosions[n]->framecount = 0; explosions[n]->framedelay = 15; explosions[n]->animdir = 1; } //load the big explosions temp = load_bitmap("bigexplosion.bmp", NULL); for(n = 0; n < 7; n++) { bigexp_images[n] = grabframe(temp, 64, 64, 0, 0, 7, n); } destroy_bitmap(temp); bigexp = new SPRITE; bigexp->alive = 0; bigexp->x = 0; bigexp->y = 0; bigexp->width = bigexp_images[0]->w; bigexp->height = bigexp_images[0]->h; bigexp->xdelay = 0; bigexp->ydelay = 8; bigexp->xcount = 0; bigexp->ycount = 0; bigexp->xspeed = 0; bigexp->yspeed = -1; //moves up the screen bigexp->curframe = 0; bigexp->maxframe = 6; bigexp->framecount = 0; bigexp->framedelay = 10; bigexp->animdir = 1; } //detects if a sprite is inside another one (collision detection) int inside(int x, int y, int left, int top, int right, int bottom) { if(x > left && x < right && y > top && y < bottom) return 1; else return 0; } //animates and moves the sprites void updatesprite(SPRITE *spr) { //update the x position if(++spr->xcount > spr->xdelay) { spr->xcount = 0; spr->x += spr->xspeed; } //update the y position if(++spr->ycount > spr->ydelay) { spr->ycount = 0; spr->y += spr->yspeed; } //update the frame based on animdir if(++spr->framecount > spr->framedelay) { spr->framecount = 0; if(spr->animdir == -1) { if(--spr->curframe < 0) spr->curframe = spr->maxframe; } if(spr->animdir == 1) { if(++spr->curframe > spr->maxframe) spr->curframe = 0; } } } void startexplosion(int x, int y) { int n; for(n = 0; n < MAX_EXPLOSIONS; n++) { //check to see if the explosions are inactive if(!explosions[n]->alive) { //make the explosions active explosions[n]->alive++; explosions[n]->x = x; explosions[n]->y = y; break; } } //launch bonus shot if ready if(!bonus_shot->alive) { bonus_shot->alive++; bonus_shot->x = x; bonus_shot->y = y; } } //responsible for drawing and moving the explosions void updateexplosions() { int n, c = 0; for(n = 0; n < MAX_EXPLOSIONS; n++) { if(explosions[n]->alive) { c++; updatesprite(explosions[n]); draw_sprite(buffer, explosion_images[explosions[n]->curframe], explosions[n]->x, explosions[n]->y); //once the explosion is complete, kill it if(explosions[n]->curframe >= explosions[n]->maxframe) { explosions[n]->curframe = 0; explosions[n]->alive = 0; } } } //textprintf_ex(buffer, font, 0, 430, WHITE, -1, "explosions %d", c); //update the big "player" explosion if needed if(bigexp->alive) { updatesprite(bigexp); draw_sprite(buffer, bigexp_images[bigexp->curframe], bigexp->x, bigexp->y); if(bigexp->curframe >= bigexp->maxframe) { bigexp->curframe = 0; bigexp->alive = 0; } } } //responsible for drawing and moving the bonuses void updatebonuses() { int x, y, x1, y1, x2, y2; //add more bonuses(yes , YOU!) //update bonus shot if alive if(bonus_shot->alive) { updatesprite(bonus_shot); draw_sprite(buffer, bonus_shot_image, bonus_shot->x, bonus_shot->y); if(bonus_shot->y > HEIGHT) bonus_shot->alive = 0; //see if player got bonus shot x = bonus_shot->x + bonus_shot->width/2; y = bonus_shot->y + bonus_shot->height/2; x1 = player->x; y1 = player->y; x2 = player->x + player->width; y2 = player->y + player->height; if(inside(x, y, x1, y1, x2, y2)) { //increase firing rate if(firedelay > 20) firedelay -= 2; bonus_shot->alive = 0; } } } void updatebullet(SPRITE *spr) { int n, x, y; int x1, y1, x2, y2; //move the bullets updatesprite(spr); //check bounds if(spr->y < 0) { spr->alive = 0; return; } for(n = 0; n < MAX_ENEMIES; n++) { if(enemy_planes[n]->alive) { //find the center of the bullets x = spr->x + spr->width/2; y = spr->y + spr->height/2; //get enemy bounding rectangle x1 = enemy_planes[n]->x; y1 = enemy_planes[n]->y - yoffset; x2 = x1 + enemy_planes[n]->width; y2 = y1 + enemy_planes[n]->height; //check for collisions if(inside(x, y, x1, y1, x2, y2)) { enemy_planes[n]->alive = 0; play_sample(sounds[1], volume, pan, pitch, FALSE); spr->alive = 0; startexplosion(spr->x+16, spr->y); score += 2; break; } } } } void updatebullets() { int n; //update/drawbullets for(n = 0; n < MAX_BULLETS; n++) { if(bullets[n]->alive) { updatebullet(bullets[n]); draw_sprite(buffer, bullet_images[0], bullets[n]->x, bullets[n]->y); } } } void updateenemybullet(SPRITE *spr) { int n, x, y; int x1, y1, x2, y2; //update the bullets updatesprite(spr); //check bounds if(spr->y > SCREEN_H) { spr->alive = 0; return; } //if the player is alive if(player->alive) { //find the center of the bullets x = spr->x + spr->width/2; y = spr->y + spr->height/2; //get the player bounding rectangle x1 = player->x; y1 = player->y + yoffset; x2 = x1 + player->width; y2 = y1 + player->height; //check for collisions if(inside(x, y, x1, y1, x2, y2)) { spr->alive = 0; play_sample(sounds[2], volume, pan, pitch, FALSE); if(health > 0) { health--; } bigexp->alive++; bigexp->x = player->x; bigexp->y = player->y; score--; } } } void updateenemybullets() { int n; //update draw bullets for(n = 0; n < MAX_ENEMY_BULLETS; n++) { if(enemy_bullets[n]->alive) { updateenemybullet(enemy_bullets[n]); draw_sprite(buffer, enemy_bullet_image, enemy_bullets[n]->x, enemy_bullets[n]->y); } } } //shoots bullets from the players plane void fireatenemy() { int n; for(n = 0; n < MAX_BULLETS; n++) { if(!bullets[n]->alive) { bullets[n]->alive++; bullets[n]->x = player->x; bullets[n]->y = player->y; return; } } } //make the enemies shoot at the player randomly void fireatplayer(SPRITE *enemy) { int n; for(n = 0; n < MAX_ENEMY_BULLETS; n++) { if(!enemy_bullets[n]->alive) { enemy_bullets[n]->alive++; enemy_bullets[n]->x = enemy->x; enemy_bullets[n]->y = enemy->y; return; } } } void bouncex_warpy(SPRITE *spr) { //if x position of sprite goes beyond left side of screen //bounce it back if(spr->x < 0 - spr->width) { spr->x = 0 - spr->width+1; //make sprite go in opposite direction spr->xspeed *= -1; } //if it goes beyond right side of screen else if(spr->x > SCREEN_W) { spr->x = SCREEN_W - spr->xspeed; //go the opposite direction spr->xspeed *= -1; } //warp y if plane has passed player if(spr->y > yoffset + 2000) { //respawn enemy plane spr->y = yoffset - 1000 - rand() % 1000; spr->alive++; spr->x = rand() % WIDTH; } //warps y from bottom to the top of the level if(spr->y < 0) { spr->y = 0; } else if( spr->y > 48000) { spr->y = 0; } } void displayprogress(int life) { int n; //draw the empty bar draw_sprite(buffer, progress, 490, 15); //fill up the bar with energy for(n = 0; n < life; n++) { draw_sprite(buffer, bar, 492+n*5, 17); } } void updateenemyplanes() { int n; int c = 0; //update/draw enemy planes for(n = 0; n < MAX_ENEMIES; n++) { if(enemy_planes[n]->alive) { c++; updatesprite(enemy_planes[n]); bouncex_warpy(enemy_planes[n]); fireatplayer(enemy_planes[n]); //is plane visible on screen if(enemy_planes[n]->y > yoffset-32 && enemy_planes[n]->y < yoffset + HEIGHT + 32) { //draw enemy planes on screen draw_sprite(buffer, enemy_plane_images[enemy_planes[n]->curframe], enemy_planes[n]->x, enemy_planes[n]->y - yoffset); } } //reset plane else { enemy_planes[n]->alive++; enemy_planes[n]->x = rand() % 100 + 50; enemy_planes[n]->y = yoffset - 2000 + rand() % 2000; } } //textprintf_ex(buffer, font, 0, 470, WHITE, -1, "Enemies %d", c); } void updatescroller() { //make sure it doesnt scroll beyond map edge if(yoffset < 5) { //level is over yoffset = 5; textout_centre_ex(buffer, font, "END OF LEVEL", SCREEN_W/2, SCREEN_H/2, WHITE, -1); } if(yoffset > BOTTOM) yoffset = BOTTOM; //scroll map up 1 pixel yoffset -= 1; //Draw the map with single layer MapDrawBG(buffer, 0, yoffset, 0, 0, SCREEN_W-1, SCREEN_H-1); } void updateplayer() { int n, x, y, x1, y1, x2, y2; //update/draw player sprite updatesprite(player); draw_sprite(buffer, player_images[player->curframe], player->x, player->y); //check for collision x = player->x + player->width/2; y = player->y + player->height/2; for(n = 0; n < MAX_ENEMIES; n++) { if(enemy_planes[n]->alive) { x1 = enemy_planes[n]->x; y1 = enemy_planes[n]->y - yoffset; x2 = x1 + enemy_planes[n]->width; y2 = y1 + enemy_planes[n]->height; if(inside(x, y, x1, y1, x2, y2)) { enemy_planes[n]->alive = 0; play_sample(sounds[2], volume, pan, pitch, FALSE); if(health > 0) { health--; } bigexp->alive++; bigexp->x = player->x; bigexp->y = player->y; score++; } } } } void checkinput() { //check for keyboard input if(key[KEY_UP]) { player->y -= 1; if(player->y < 100) player->y = 100; } if(key[KEY_DOWN]) { player->y += 1; if(player->y > HEIGHT - 65) player->y = HEIGHT - 65; } if(key[KEY_LEFT]) { player->x -= 1; if(player->x < 0) player->x = 0; } if(key[KEY_RIGHT]) { player->x += 1; if(player->x > WIDTH - 65) player->x = WIDTH-65; } if(key[KEY_SPACE]) { if(firecount > firedelay) { firecount = 0; fireatenemy(); play_sample(sounds[0], volume, pan, pitch, FALSE); } } } void initialize() { //initialize the program allegro_init(); install_timer(); install_keyboard(); set_color_depth(16); //set the screen int ret = set_gfx_mode(GFX_SAFE, 640, 480, 0, 0); if(ret != 0) { allegro_message("Error loading screen"); return; } srand(time(NULL)); //Install the sound system if((install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, "") != 0)) { allegro_message("Failed to load sound system"); } //Create the double buffer buffer = create_bitmap(SCREEN_W, SCREEN_H); clear_bitmap(buffer); //Load the mappy file int check = MapLoad("level1.fmp"); if(check != 0) { set_gfx_mode(GFX_TEXT, 0, 0, 0, 0); allegro_message("Could not load level1.fmp"); return; } //Set an 8 bit pallete MapSetPal8(); //create gameover screen gameend = create_bitmap(SCREEN_W, SCREEN_H); clear_to_color(gameend, BLUE); textout_ex(gameend, font, "Game Over", SCREEN_W/2 - 50, SCREEN_H/2 - 20, WHITE, -1); } void endgame(int &health, int &score) { if(health == 0) { play_sample(sounds[4], volume, pan, pitch, FALSE); textprintf_ex(gameend, font, SCREEN_W/2 - 50, SCREEN_H/2 - 5, WHITE, -1, "Score: %d", score); blit(gameend, buffer, 0, 0, 0, 0, SCREEN_W, SCREEN_H); } } void loadsounds() { sounds[0] = load_sample("Gun_Shot.wav"); sounds[1] = load_sample("enemyexplosion.wav"); sounds[2] = load_sample("playerdamaged.wav"); sounds[3] = load_sample("enemygun.wav"); sounds[4] = load_sample("playerdead.wav"); sounds[5] = load_sample("seashore2.wav"); }

 heres the mian.cpp

//Variables that help us determine the frames per second
int fps = 0;
int frames_done = 0;
int old_time = 0;

//Timer variables
volatile long ticks = 0;
volatile int game_time = 0;

//Interrupt handler functions
void ticker()
{
	ticks++;
}
END_OF_FUNCTION(ticker)

void game_time_ticker()
{
	game_time++;
}
END_OF_FUNCTION(game_time_ticker)

//Amount of times a ticker is called per second
const int updates_per_second = 180;



//displays the stats
void displaystats()
{
	
	//display some status information
	textprintf_ex(buffer, font, 0, 410, WHITE, -1, "Life %d", health); 
	textprintf_ex(buffer, font, 0, 420, WHITE, -1, "Firing rate %d", firedelay);
	textprintf_ex(buffer, font, 0, 440, WHITE, -1, "Yoffset %d", yoffset);
	textprintf_ex(buffer, font, 0, 460, WHITE, -1, "Framerate %d", fps);

	//display score
	textprintf_ex(buffer, font, 22, 22, GRAY, -1, "SCORE: %d", score);
	textprintf_ex(buffer, font, 20, 20, RED, -1, "SCORE: %d", score);
}




int main()
{
	int n;

	//Intialize the game
	initialize();

	//indetify variables used by interupt funtions and lock them
	LOCK_VARIABLE(ticks);
	LOCK_VARIABLE(game_time);
	LOCK_FUNCTION(ticker);
	LOCK_FUNCTION(game_time_ticker);
	
	//create new interupt handler
    install_int_ex(ticker, BPS_TO_TIMER(updates_per_second));
	install_int_ex(game_time_ticker, BPS_TO_TIMER(10));


	//Load in all the sprites 
	loadsprite();

	//load in all the sounds
	loadsounds();
	play_sample(sounds[5], 200, pan, pitch, TRUE);

    //Start the main game loop
	while(!key[KEY_ESC])
	{
		
		while(ticks == 0)
		{
			rest(100 / updates_per_second);//rest until a full tick has passed
		}

		while(ticks > 0)
		{

		int old_ticks = ticks;
		
		//check if the player is interacting with the controls
		checkinput();

		//draw/update the map to the buffer
		updatescroller();

		//update and draw the enemy and player
		updateplayer();
		updateenemyplanes();

		//draw and update the bullets 
		updatebullets();
		updateenemybullets();
		
		//draw and update the explosions
		updateexplosions();

		//draw and update bonuses and
		//apply its effects on players if it collideds
		updatebonuses();

		//display health
		displayprogress(health);

		//display the stats
		displaystats();

		//check if the game needs to end
		endgame(health, score);

		ticks--;
		if(old_ticks <= ticks)//logic is taking too long: abort and draw a frame
	    break; 
		
		}

		//if a second has passed since we last measured the frame rate
        if(game_time - old_time >= 10)
		{
			fps = frames_done;

			//fps now holds the the number of frames done in the last second
			//you can now output it using textout_ex et al
			//textprintf_ex(buffer, font, 0, 460, WHITE, -1, "Framerate %d", fps);

			//reset for next second
			frames_done = 0;
			old_time = game_time;
		}


		//blit the double buffer
		acquire_screen();
		blit(buffer, screen, 0, 0, 0, 0, SCREEN_W-1, SCREEN_H-1);
		release_screen();

		frames_done++;// we drew a frame
		firecount++;
	}

	//delete mappy level
	MapFreeMem();

	//delete bitmaps
	destroy_bitmap(buffer);
	destroy_bitmap(progress);
	destroy_bitmap(bar);

	for(n = 0; n < 6; n++)
	{
		destroy_bitmap(explosion_images[n]);
	}
	for(n = 0; n < 3; n++)
	{
		destroy_bitmap(player_images[n]);
		//destroy_bitmap(bullet_images[n]);
		destroy_bitmap(enemy_plane_images[n]);
		//destroy_bitmap(enemy_bullet_image);
	}

	//delete the sprite pointers
	delete player;
	for(n = 0; n < MAX_EXPLOSIONS; n++)
	{
		delete explosions[n];
	}
	for(n = 0; n < MAX_BULLETS; n++)
	{
		delete bullets[n];
	}
	for(n = 0; n < MAX_ENEMIES; n++)
	{
		delete enemy_planes[n];
	}
	for(n = 0; n < MAX_ENEMY_BULLETS; n++)
	{
		delete enemy_bullets[n];
	}


	allegro_exit();
	return 0;

}
END_OF_MAIN()
0

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!


Register a new account

Sign in

Already have an account? Sign in here.


Sign In Now
Sign in to follow this  
Followers 0