• Create Account

Banner advertising on our site currently available from just \$5!

# Jac0blee

Member Since 12 Feb 2012
Offline Last Active Feb 16 2012 07:44 PM

### Help with tiled maps

14 February 2012 - 05:51 PM

Hi guys i was experementing with tiled maps and wondered how to make the user stop when they hit a wall. also how to make directional bullet firing controlled by mouse. im a new programmer and need a little bit of a kickstart thanks for the help!

### First Post

12 February 2012 - 05:52 PM

Hi this is my first forum post,

as of now i have developed one game that i will share with you all soon, im working on a second game that uses finite ai (the bad guys move towards you) and was wondering how to make walls and how to have a tiled background move correctly with the player and enemies heres the code for the game:
```#include <allegro5\allegro.h>
#include <allegro5\allegro_image.h>
#include <allegro5\allegro_primitives.h>
#include <allegro5\allegro_font.h>
#include <allegro5\allegro_ttf.h>
#include <iostream>
#include <math.h>
#include "classes.h"
using namespace std;
const int WIDTH = 800;
const int HEIGHT = 600;
const int NUM_BULLETS = 10;
int num;
bool movingMap = true;
const int cavex = WIDTH - 100;
const int cavey = HEIGHT / 2;
bool keys[] = {false, false, false, false, false};
enum KEYS{UP, DOWN, LEFT, RIGHT, SPACE};
enum STATE{IDLE, CHASING, RETREATING, ENTERING};
ALLEGRO_FONT *font18;
void ChangeState(int &state, int newState);
float CheckDistance(int x1, int y1, int x2, int y2);
float AngleToTarget(int x1, int y1, int x2, int y2);
void InitPlayer(Player &player);
void MovePlayerRight(Player &player);
void MovePlayerLeft(Player &player);
void MovePlayerUp(Player &player);
void MovePlayerDown(Player &player);
//void ResetPlayerDir(Player &player);
void InitBullet(Bullet bullets[], int size);
void FireBullet(Bullet bullets[], Player &player, int size);
void DrawBullet(Bullet bullets[], int size);
void UpdateBullet(Bullet bullets[], int size);
void CollideBullet(Bullet bullets[], int size, Enemy bad[]);
int main(int argc, char **argv)
{
//==============================================
//SHELL VARIABLES
//==============================================
bool done = false;
bool render = false;
float gameTime = 0;
int frames = 0;
int gameFPS = 0;

int xOff = 0;
int yOff = 0;
int mapColumns = 10;
int mapSize = 100;
int tileSize = 100;
int map[] = {0, 1, 1, 1, 0, 0, 1, 1, 0, 0,
0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
0, 1, 0, 0, 1, 1, 0, 0, 0, 1,
0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
1, 1, 0, 1, 1, 1, 0, 0, 0, 0,
0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
1, 1, 1, 0, 1, 1, 0, 0, 0, 1,
0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
0, 0, 1, 1, 1, 1, 1, 1, 0, 0};
//==============================================
//PROJECT VARIABLES
//==============================================
Player player;
Bullet bullets[NUM_BULLETS];
int state = -1;
int threshold = 200;
//==============================================
//ALLEGRO VARIABLES
//==============================================
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer;
ALLEGRO_BITMAP *bgSheet = NULL;

//==============================================
//ALLEGRO INIT FUNCTIONS
//==============================================
if(!al_init())		  //initialize Allegro
return -1;
display = al_create_display(WIDTH, HEIGHT);   //create our display object
if(!display)		  //test display object
return -1;
//==============================================
//==============================================
al_install_keyboard();

//==============================================
//PROJECT INIT
//==============================================
InitPlayer(player);
InitBullet(bullets, NUM_BULLETS);
al_install_mouse();
ChangeState(state, IDLE);
//==============================================
//TIMER INIT AND STARTUP
//==============================================
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / 60);
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_start_timer(timer);
gameTime = al_current_time();
while(!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
//==============================================
//INPUT
//==============================================
if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_LEFT:
player.dirX = -1;
player.dirY = 0;
keys[LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
player.dirX = 1;
player.dirY = 0;
keys[RIGHT] = true;
break;
case ALLEGRO_KEY_UP:
player.dirY = -1;
player.dirX = 0;
keys[UP] = true;
break;
case ALLEGRO_KEY_DOWN:
player.dirY = 1;
player.dirX = 0;
keys[DOWN] = true;
break;
case ALLEGRO_KEY_SPACE:
keys[SPACE] = true;
FireBullet(bullets, player, NUM_BULLETS);
break;
}
}
else if(ev.type == ALLEGRO_EVENT_KEY_UP)
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
done = true;
break;
case ALLEGRO_KEY_LEFT:
keys[LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
keys[RIGHT] = false;
break;
case ALLEGRO_KEY_UP:
keys[UP] = false;
break;
case ALLEGRO_KEY_DOWN:
keys[DOWN] = false;
break;
case ALLEGRO_KEY_SPACE:
keys[SPACE] = false;
break;
}
}
else if(ev.type == ALLEGRO_EVENT_MOUSE_AXES)
{
//playerx = ev.mouse.x;
//playery = ev.mouse.y;
}
//==============================================
//GAME UPDATE
//==============================================
else if(ev.type == ALLEGRO_EVENT_TIMER)
{

if(player.live == true)
{
if(xOff + (tileSize * mapColumns) > WIDTH)
xOff -= keys[RIGHT] * player.speed;
if(xOff < 0)
xOff += keys[LEFT] * player.speed;
if(yOff + (tileSize * mapColumns) > HEIGHT)
yOff -= keys[DOWN] * player.speed;
if(yOff < 0)
yOff += keys[UP] * player.speed;

}
// moving the player

if(keys[UP] == true)
MovePlayerUp(player);
else if(keys[DOWN] == true)
MovePlayerDown(player);
if(keys[LEFT] == true)
MovePlayerLeft(player);
else if(keys[RIGHT] == true)
MovePlayerRight(player);
UpdateBullet(bullets, NUM_BULLETS);
if(!player.live)
{
al_draw_textf(font18, al_map_rgb(255,255,0), WIDTH - 600, 10, 0, "You are Dead!");
}
render = true;
//UPDATE FPS===========
frames++;
if(al_current_time() - gameTime >= 1)
{
gameTime = al_current_time();
gameFPS = frames;
frames = 0;
}
//=====================
for(int i = 0; i < NUM_BADDIES; i++)
{
{
// if(state == IDLE)
// {
//   ChangeState(state, CHASING);
// }
/*else*/ //if(state == CHASING)
// {

//  {
//    ChangeState(state, RETREATING);
//   }
//else
//{
//  ChangeState(state, RETREATING);
//}
// }
/*else if(state == RETREATING)
{
{
ChangeState(state, IDLE);
}
else
{
ChangeState(state, CHASING);
}
}*/
}
{
}
}
}
//==============================================
//RENDER
//==============================================
if(render && al_is_event_queue_empty(event_queue))
{
for(int i = 0; i < mapSize; i++)
{
al_draw_bitmap_region(bgSheet, tileSize * map[i], 0, tileSize, tileSize, xOff + tileSize * (i %  mapColumns), yOff + tileSize * (i /  mapColumns), 0);
}
render = false;
al_draw_textf(font18, al_map_rgb(255 ,0 ,255), 5, 5, 0, "FPS: %i", gameFPS); //display FPS on screen
al_draw_textf(font18, al_map_rgb(255 ,0 ,255), 100, 5, 0, "Lives: %i", player.lives / 10);
al_draw_textf(font18, al_map_rgb(255 ,0 ,255), 100, 20, 0, "SPAWN: %i", num);
//BEGIN PROJECT RENDER================
if(player.live)
{
al_draw_filled_rectangle(player.x - 10, player.y - 10, player.x + 10, player.y + 10, al_map_rgba_f(.3,0,.2,.5));
}
DrawBullet(bullets, NUM_BULLETS);
al_draw_textf(font18, al_map_rgb(255,0,255), 5, 50, 0, "Player dirX: %i PlayerdirY: %i", player.dirX, player.dirY);
for(int i = 0; i < NUM_BADDIES; i++)
{
{
al_draw_rectangle(player.x - player.boundx, player.y - player.boundy, player.x + player.boundx, player.y + player.boundy, al_map_rgb(0,0,255), 1);
}
}
//FLIP BUFFERS========================

//ResetPlayerDir(player);
al_flip_display();
al_clear_to_color(al_map_rgb(0,0,0));
}
}
//==============================================
//DESTROY PROJECT OBJECTS
//==============================================
//SHELL OBJECTS=================================
al_destroy_font(font18);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
al_destroy_display(display);
return 0;
}
void ChangeState(int &state, int newState)
{
if(state == IDLE)
{
cout << "leaving IDLE state" << endl;
}
else if(state == CHASING)
{
cout << "leaving CHASING state" << endl;
}
else if(state == RETREATING)
{
cout << "leaving RETREATING state" << endl;
}
state = newState;
if(state == IDLE)
{
cout << "now IDLING" << endl;
}
else if(state == CHASING)
{
cout << "now CHASING" << endl;
}
else if(state == RETREATING)
{
cout << "now RETREATING" << endl;
}
}
float CheckDistance(int x1, int y1, int x2, int y2)
{
return sqrt(pow((float)x1 - x2, 2) + pow((float)y1 - y2, 2));
}
float AngleToTarget(int x1, int y1, int x2, int y2)
{
float deltaX = (x2 - x1);
float deltaY = (y2 - y1);
return atan2(deltaY, deltaX);
}
void InitPlayer(Player &player)
{
player.x = 10;
player.y = WIDTH / 2;
player.dirX = 0;
player.dirY = 0;
player.boundx = 10;
player.boundy = 10;
player.speed = 5;
player.live = true;
player.lives = 200;
}
void MovePlayerUp(Player &player)
{
//player.animationRow = 0;
if(player.live)
{
player.y -= player.speed;
if(player.y < 0)
player.y = 0;
}
player.dirY = 1;
}
void MovePlayerDown(Player &player)
{
if(player.live)
{
//player.animationRow = 2;
player.y += player.speed;
if(player.y > HEIGHT)
player.y = HEIGHT;
}
player.dirY = -1;
}
void MovePlayerLeft(Player &player)
{
if(player.live)
{
//player.curFrame = 2;
player.x -= player.speed;
if(player.x < 0)
player.x = 0;
}
player.dirX = -1;
}
void MovePlayerRight(Player &player)
{
if(player.live)
{
//player.curFrame = 1;
player.x += player.speed;
if(player.x > WIDTH)
player.x = WIDTH;
}
player.dirX = 1;
}
/*void ResetPlayerDir(Player &player)
{
player.dirX = 0;
player.dirY = 0;
}*/
{
for(int i = 0; i < NUM_BADDIES; i++)
{
{
if(player.live)
{
al_draw_textf(font18, al_map_rgb(255,0,0), (WIDTH / 2) - 200, 10, 0, "BITTEN");
//player.lives--;
}
if(player.lives <= 0)
player.live = false;
}
}
}
{
for(int i = 0; i < NUM_BADDIES; i++)
{
}
}
{
for(int i = 0; i < NUM_BADDIES; i++)
{
{
if(rand() % 10 == 0)
{
if(rand() % 200 == 0)
{
bad[i].x = 30 + rand() % WIDTH;
bad[i].speed = rand() % 3 + 2;
num = 0;
}

if(rand() % 4 == 1)
{
bad[i].y = 30 + rand() % HEIGHT;
bad[i].speed = rand() % 3 + 2;
num = 1;
}

if(rand() % 4 == 2)
{
bad[i].y = 30 + rand() % HEIGHT;
bad[i].speed = rand() % 3 + 2;
num = 2;
}

if(rand() % 4 == 3)
{
num = 3;
bad[i].x = 30 + rand() % WIDTH;
bad[i].speed = rand() % 3 + 2;
}
}
}
}
}
void InitBullet(Bullet bullets[], int size)
{
for(int i = 0; i < size; i++)
{
bullets[i].speed = 10;
bullets[i].dirX = 0;
bullets[i].dirY = 0;
bullets[i].live = false;
}
}
void FireBullet(Bullet bullets[], Player &player, int size)
{

for(int i = 0; i < size; i++)
{
if(!bullets[i].live)
{
cout << "firing Bullet!" << endl;
if(player.dirX == 1)
{
bullets[i].live = true;
bullets[i].dirX = 1;
bullets[i].x = player.x + 2;
bullets[i].y = player.y;
break;
}
else if(player.dirX == -1)
{
bullets[i].dirX = -1;
bullets[i].x = player.x - 2;
bullets[i].y = player.y;
bullets[i].live = true;
break;
}
else if(player.dirY == 1)
{
bullets[i].dirY = 1;
bullets[i].y = player.y - 2;
bullets[i].x = player.x;
bullets[i].live = true;
break;
}
else if(player.dirY == -1)
{
bullets[i].live = true;
bullets[i].dirY = -1;
bullets[i].y = player.y + 2;
bullets[i].x = player.x;
break;
}
}
}
}
void DrawBullet(Bullet bullets[], int size)
{
for(int i = 0; i < size; i++)
{
if(bullets[i].live)
al_draw_filled_rectangle(bullets[i].x, bullets[i].y + 3, bullets[i].x - 4, (bullets[i].y - 4) + 3, al_map_rgb(255,0,255));
}
}
void UpdateBullet(Bullet bullets[], int size)
{
for(int i = 0; i < size; i++)
{
if(bullets[i].live == true)
{
if(bullets[i].dirX == 1)
{
bullets[i].x += bullets[i].speed;
if(bullets[i].x > WIDTH)
{
bullets[i].live = false;
cout << "bullet went out of bounds!" << endl;
bullets[i].dirX = 0;
bullets[i].dirY = 0;
}
}
else if(bullets[i].dirX == -1)
{
bullets[i].x -= bullets[i].speed;
if(bullets[i].x < 0)
{
bullets[i].live = false;
cout << "bullet went out of bounds!" << endl;
bullets[i].dirX = 0;
bullets[i].dirY = 0;
}
}
else if(bullets[i].dirY == -1)
{
bullets[i].y += bullets[i].speed;
if(bullets[i].y > HEIGHT)
{
bullets[i].live = false;
cout << "bullet went out of bounds!" << endl;
bullets[i].dirX = 0;
bullets[i].dirY = 0;
}
}
else if(bullets[i].dirY == 1)
{
bullets[i].y -= bullets[i].speed;
if(bullets[i].y < 0)
{
bullets[i].live = false;
bullets[i].dirX = 0;
bullets[i].dirY = 0;
cout << "bullet went out of bounds!" << endl;
}
}
/*
if(bullets[i].dirX == -1 && bullets[i].dirY == -1)
{
bullets[i].y -= (bullets[i].speed / 2);
bullets[i].x -= (bullets[i].speed / 2);
if(bullets[i].y < 0)
{
bullets[i].live = false;
bullets[i].dirX = 0;
bullets[i].dirY = 0;
cout << "bullet went out of bounds!" << endl;
}
if(bullets[i].x < 0)
{
bullets[i].live = false;
bullets[i].dirX = 0;
bullets[i].dirY = 0;
cout << "bullet went out of bounds!" << endl;
}
}*/
}
}
}
void CollideBullet(Bullet bullets[], int size, Enemy bad[])
{
for(int i = 0; i < size; i++)
{
if(bullets[i].live)
{
for(int j = 0; j < NUM_BADDIES; j++)
{
{
{
bullets[i].live = false;
cout <<"you got him!" << endl;
break;
}
}
}
}
}
}
struct Player
{
int x;
int y;
int dirX;
int dirY;
int boundx;
int boundy;
int speed;
int lives;
bool live;
};
struct Enemy
{
int x;
int y;
int speed;
int boundx;
int boundy;
bool live;
};
struct Bullet
{
int x;
int y;
int dirX;
int dirY;
int speed;
bool live;
};
```
thank you.

PARTNERS