Modifying code from the SDL legacy tutorial I have tried to render tiles are new way. This is a link to the tutorial. http://lazyfoo.net/SDL_tutorials/lesson29/index.php
No matter what I’ve tried and how logical it seems I cannot control where I render my tile to. In order to render I must change the value of my variables. I got the idea to read from a map file and check for conditions to render my level. At the bottom of my post you can view all of my code but I suspect my problem remains exclusively with the [color=red:6285b8fdf0]set tiles fucntion[/color:6285b8fdf0]
[size=18:6285b8fdf0]My problem in my code[/size:6285b8fdf0]
bool set_tiles( Tile *tiles[], Tile *walls[] )
{
//The tile offsets
int x = 0, y = 0;
int a = 0, b = 0;
int p = 0, q = 0;
//Open the map
std::ifstream map( "lazy.map" );
std::ifstream map2( "Zrender.map" );
std::ifstream coords ("Coords.map");
//If the map couldn't be loaded
if( map == NULL )
{
return false;
}
if( map2 == NULL )
{
return false;
}
//Initialize the tiles
for( int t = 0; t < TOTAL_TILES; t++ )
{
//Determines what kind of tile will be made
int tileType = -1;
//Read tile from map file
map >> tileType;
//If the was a problem in reading the map
if( map.fail() == true )
{
//Stop loading map
map.close();
return false;
}
//If the number is a valid tile number
if( ( tileType >= 0 ) && ( tileType < TILE_SPRITES ) )
{
tiles[ t ] = new Tile(NULL, NULL, NULL , NULL, x, y, tileType );
//Move to next tile spot
x += TILE_WIDTH;
}
//If we don't recognize the tile type
else
{
//Stop loading map
map.close();
return false;
}
//If we've gone too far
if( x >= LEVEL_WIDTH )
{
//Move back
x = 0;
//Move to the next row
y += TILE_HEIGHT;
}
}
//Ending of for loop.
for( int tz = 0; tz < TOTAL_TILES_WALL; tz++ )
{
//Determines what kind of tile will be made
int tileTypeWall = -1;
int Position = -1;
//Read tile from map file
map2 >> tileTypeWall;
coords >> Position;
//If the was a problem in reading the map
if( map2.fail() == true )
{
//Stop loading map
map2.close();
return false;
}
if (Position == 0)
{
p += TILE_WIDTH;
}
//If the number is a valid tile number
if ( tileTypeWall == TILE_RED_WALLf )
{
walls[ tz ] = new Tile( NULL, NULL, p , q, NULL, NULL, tileTypeWall );
}
}
//Close the file
map.close();
//If the map was loaded fine
return true;
}
[size=18:6285b8fdf0]ALL OF MY CODE[/size:6285b8fdf0]> //The headers
#include “SDL.h”
#include “SDL_image.h”
#include
#include//The gravity of the game
const float ACCELARATION = 300;
const int YS_VEL_WALK = 100;//Screen attributes
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int SCREEN_BPP = 32;/*Frames rate
This concept was removed due to needs of performance, and independed movement.
Investigate uses in prototype before deleteion of concept.
*/
//const int FRAMES_PER_SECOND = 20;//The Ys dimensions
const int YS_WIDTH = 25;
const int YS_HEIGHT = 19;
const int LANDPAD_WIDTH = 19;
const int LANDPAD_HEIGHT = 7;//The dimensions of the level
const int LEVEL_WIDTH = 1280;
const int LEVEL_HEIGHT = 960;//Tile constants
const int TILE_WIDTH = 80;
const int TILE_HEIGHT = 80;
const int TILE_WALLf_HEIGHT = 20;
const int TILE_WALLf_WIDTH = 20;
const int TILE_WALLs_HEIGHT = 20;
const int TILE_WALLs_WIDTH = 3;
const int TOTAL_TILES = 192;
const int TOTAL_TILES_WALL = 1;
const int TILE_SPRITESWALL = 11;
const int TILE_SPRITES = 23;//The different tile sprites
const int TILE_RED = 0;
const int TILE_GREEN = 1;
const int TILE_BLUE = 2;
const int TILE_CENTER = 3;
const int TILE_TOP = 4;
const int TILE_TOPRIGHT = 5;
const int TILE_RIGHT = 6;
const int TILE_BOTTOMRIGHT = 7;
const int TILE_BOTTOM = 8;
const int TILE_BOTTOMLEFT = 9;
const int TILE_LEFT = 10;
const int TILE_TOPLEFT = 11;
const int TILE_RED_WALLf = 12;
const int TILE_GREEN_WALLf= 13;
const int TILE_BLUE_WALLf= 14;
const int TILE_RED_WALLs= 15;
const int TILE_GREEN_WALLs= 16;
const int TILE_BLUE_WALLs= 17;
const int Move_Over_Right = 18;
const int TilePlacement2 = 19;
const int TilePlacement3 = 20;
const int TilePlacement4 = 21;
const int TilePlacement5 = 22;//The surfaces
SDL_Surface *dot = NULL;
SDL_Surface *screen = NULL;
SDL_Surface *tileSheet = NULL;
SDL_Surface *walltilesheet = NULL;
SDL_Surface *LandPad = NULL;
SDL_Surface *Ysguy1 = NULL;
//Sprite from the tile sheet
SDL_Rect clips[ TILE_SPRITES ];//The event structure
SDL_Event event;//The camera
SDL_Rect camera = { 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT };
//////
//The tile
class Tile
{
private:
//The attributes of the tile
SDL_Rect floorpad;
SDL_Rect wallside;
SDL_Rect wallfront;//The tile type int type; public: //Initializes the variables Tile(int a, int b, int p, int q, int x, int y, int tileType ); //Shows the tile void show(); //Get the tile type int get_type(); //Get the collision box SDL_Rect get_box();
};
//The dot
class Dot
{
private:
//Land pad’s collision box
SDL_Rect box;//The velocity of the dot float xVel, yVel, zVel;
float x, y, z;
bool grounded;
public:
//Initializes the variables
Dot();//Takes key presses and adjusts the dot's velocity void handle_input(); //Moves the dot void move( Tile *tiles[], Uint32 deltaTicks); //Shows on the screen void show(); //Sets the camera over the dot void set_camera();
};
//The timer
class Timer
{
private:
//The clock time when the timer started
int startTicks;//The ticks stored when the timer was paused int pausedTicks; //The timer status bool paused; bool started; public: //Initializes variables Timer(); //The various clock actions void start(); void stop(); void pause(); void unpause(); //Gets the timer's time int get_ticks(); //Checks the status of the timer bool is_started(); bool is_paused();
};
SDL_Surface load_image( std::string filename )
{
//The image that’s loaded
SDL_Surface loadedImage = NULL;//The optimized surface that will be used SDL_Surface* optimizedImage = NULL; //Load the image loadedImage = IMG_Load( filename.c_str() ); //If the image loaded if( loadedImage != NULL ) { //Create an optimized surface optimizedImage = SDL_DisplayFormat( loadedImage ); //Free the old surface SDL_FreeSurface( loadedImage ); //If the surface was optimized if( optimizedImage != NULL ) { //Color key surface SDL_SetColorKey( optimizedImage, SDL_SRCCOLORKEY, SDL_MapRGB( optimizedImage->format, 0, 0xFF, 0xFF ) ); } } //Return the optimized surface return optimizedImage;
}
void apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip = NULL )
{
//Holds offsets
SDL_Rect offset;//Get offsets offset.x = x; offset.y = y; //Blit SDL_BlitSurface( source, clip, destination, &offset );
}
void showCharacterMovement(int x, int z, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip = NULL)
{
//Holds offsets
SDL_Rect offset;//Get offsets offset.x = x; offset.y = z; //Blit SDL_BlitSurface( source, clip, screen, &offset);
}
bool check_collision( SDL_Rect A, SDL_Rect B )
{
//The sides of the rectangles
int leftA, leftB;
int rightA, rightB;
int topA, topB;
int bottomA, bottomB;//Calculate the sides of rect A leftA = A.x; rightA = A.x + A.w; topA = A.y; bottomA = A.y + A.h; //Calculate the sides of rect B leftB = B.x; rightB = B.x + B.w; topB = B.y; bottomB = B.y + B.h; //If any of the sides from A are outside of B if( bottomA <= topB ) { return false; } if( topA >= bottomB ) { return false; } if( rightA <= leftB ) { return false; } if( leftA >= rightB ) { return false; } //If none of the sides from A are outside B return true;
}
bool init()
{
//Initialize all SDL subsystems
if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
{
return false;
}//Set up the screen screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE ); //If there was an error in setting up the screen if( screen == NULL ) { return false; } //Set the window caption SDL_WM_SetCaption( "Sega forum testing shit and ect", NULL ); //If everything initialized fine return true;
}
bool load_files()
{
//Load the dot image
dot = load_image( “dot.png” );//If there was a problem in loading the dot if( dot == NULL ) { return false; } //Load the tile sheet tileSheet = load_image( "tiles.png" ); //If there was a problem in loading the tiles if( tileSheet == NULL ) { return false; }
//Load the tile sheet
LandPad = load_image( “LandPad.png” );//If there was a problem in loading the tiles if( LandPad == NULL ) { return false; }
//Load the tile sheet
Ysguy1 = load_image( “Ysguy1.png” );//If there was a problem in loading the tiles if( Ysguy1 == NULL ) { return false; } //If everything loaded fine return true;
}
void clean_up( Tile *tiles[], Tile *walls[] )
{
//Free the surfaces
SDL_FreeSurface( dot );
SDL_FreeSurface( tileSheet );
SDL_FreeSurface( LandPad );
SDL_FreeSurface( Ysguy1 );
//Free the tiles
for( int t = 0; t < TOTAL_TILES; t++ )
{
delete tiles[ t ];
}
for( int tz = 0; tz < TOTAL_TILES_WALL; tz++ )
{
delete walls[ tz ];
}
//Quit SDL
SDL_Quit();
}void clip_tiles()
{
//Clip the sprite sheet
clips[ TILE_RED ].x = 0;
clips[ TILE_RED ].y = 0;
clips[ TILE_RED ].w = TILE_WIDTH;
clips[ TILE_RED ].h = TILE_HEIGHT;clips[ TILE_GREEN ].x = 0; clips[ TILE_GREEN ].y = 80; clips[ TILE_GREEN ].w = TILE_WIDTH; clips[ TILE_GREEN ].h = TILE_HEIGHT; clips[ TILE_BLUE ].x = 0; clips[ TILE_BLUE ].y = 160; clips[ TILE_BLUE ].w = TILE_WIDTH; clips[ TILE_BLUE ].h = TILE_HEIGHT; clips[ TILE_TOPLEFT ].x = 80; clips[ TILE_TOPLEFT ].y = 0; clips[ TILE_TOPLEFT ].w = TILE_WIDTH; clips[ TILE_TOPLEFT ].h = TILE_HEIGHT; clips[ TILE_LEFT ].x = 80; clips[ TILE_LEFT ].y = 80; clips[ TILE_LEFT ].w = TILE_WIDTH; clips[ TILE_LEFT ].h = TILE_HEIGHT; clips[ TILE_BOTTOMLEFT ].x = 80; clips[ TILE_BOTTOMLEFT ].y = 160; clips[ TILE_BOTTOMLEFT ].w = TILE_WIDTH; clips[ TILE_BOTTOMLEFT ].h = TILE_HEIGHT; clips[ TILE_TOP ].x = 160; clips[ TILE_TOP ].y = 0; clips[ TILE_TOP ].w = TILE_WIDTH; clips[ TILE_TOP ].h = TILE_HEIGHT; clips[ TILE_CENTER ].x = 160; clips[ TILE_CENTER ].y = 80; clips[ TILE_CENTER ].w = TILE_WIDTH; clips[ TILE_CENTER ].h = TILE_HEIGHT; clips[ TILE_BOTTOM ].x = 160; clips[ TILE_BOTTOM ].y = 160; clips[ TILE_BOTTOM ].w = TILE_WIDTH; clips[ TILE_BOTTOM ].h = TILE_HEIGHT; clips[ TILE_TOPRIGHT ].x = 240; clips[ TILE_TOPRIGHT ].y = 0; clips[ TILE_TOPRIGHT ].w = TILE_WIDTH; clips[ TILE_TOPRIGHT ].h = TILE_HEIGHT; clips[ TILE_RIGHT ].x = 240; clips[ TILE_RIGHT ].y = 80; clips[ TILE_RIGHT ].w = TILE_WIDTH; clips[ TILE_RIGHT ].h = TILE_HEIGHT; clips[ TILE_BOTTOMRIGHT ].x = 240; clips[ TILE_BOTTOMRIGHT ].y = 160; clips[ TILE_BOTTOMRIGHT ].w = TILE_WIDTH; clips[ TILE_BOTTOMRIGHT ].h = TILE_HEIGHT;
clips[ TILE_RED_WALLf ].x = 0;
clips[ TILE_RED_WALLf ].y = 240;
clips[ TILE_RED_WALLf ].w = TILE_WALLf_WIDTH;
clips[ TILE_RED_WALLf ].h = TILE_WALLf_HEIGHT;clips[ TILE_GREEN_WALLf ].x = 21;
clips[ TILE_GREEN_WALLf ].y = 240;
clips[ TILE_GREEN_WALLf ].w = TILE_WALLf_WIDTH;
clips[ TILE_GREEN_WALLf ].h = TILE_WALLf_HEIGHT;clips[ TILE_BLUE_WALLf ].x = 41;
clips[ TILE_BLUE_WALLf ].y = 240;
clips[ TILE_BLUE_WALLf ].w = TILE_WALLf_WIDTH;
clips[ TILE_BLUE_WALLf ].h = TILE_WALLf_HEIGHT;
//
clips[ TILE_RED_WALLs ].x = 61;
clips[ TILE_RED_WALLs ].y = 240;
clips[ TILE_RED_WALLs ].w = TILE_WALLs_WIDTH;
clips[ TILE_RED_WALLs ].h = TILE_WALLs_HEIGHT;clips[ TILE_BLUE_WALLs ].x = 64;
clips[ TILE_BLUE_WALLs ].y = 240;
clips[ TILE_BLUE_WALLs ].w = TILE_WALLs_WIDTH;
clips[ TILE_BLUE_WALLs ].h = TILE_WALLs_HEIGHT;clips[ TILE_GREEN_WALLs ].x = 67;
clips[ TILE_GREEN_WALLs ].y = 240;
clips[ TILE_GREEN_WALLs ].w = TILE_WALLs_WIDTH;
clips[ TILE_GREEN_WALLs ].h = TILE_WALLs_HEIGHT;
}bool set_tiles( Tile *tiles[], Tile *walls[] )
{
//The tile offsets
int x = 0, y = 0;
int a = 0, b = 0;
int p = 0, q = 0;//Open the map std::ifstream map( "lazy.map" );
std::ifstream map2( “Zrender.map” );
std::ifstream coords (“Coords.map”);
//If the map couldn’t be loaded
if( map == NULL )
{
return false;
}
if( map2 == NULL )
{
return false;
}
//Initialize the tiles
for( int t = 0; t < TOTAL_TILES; t++ )
{
//Determines what kind of tile will be made
int tileType = -1;//Read tile from map file map >> tileType; //If the was a problem in reading the map if( map.fail() == true ) { //Stop loading map map.close(); return false; } //If the number is a valid tile number if( ( tileType >= 0 ) && ( tileType < TILE_SPRITES ) ) { tiles[ t ] = new Tile(NULL, NULL, NULL , NULL, x, y, tileType ); //Move to next tile spot x += TILE_WIDTH; } //If we don't recognize the tile type else { //Stop loading map map.close(); return false; } //If we've gone too far if( x >= LEVEL_WIDTH ) { //Move back x = 0; //Move to the next row y += TILE_HEIGHT; } }
//Ending of for loop.
for( int tz = 0; tz < TOTAL_TILES_WALL; tz++ )
{//Determines what kind of tile will be made int tileTypeWall = -1; int Position = -1; //Read tile from map file map2 >> tileTypeWall; coords >> Position; //If the was a problem in reading the map if( map2.fail() == true ) { //Stop loading map map2.close(); return false; } if (Position == 0) { p += TILE_WIDTH; } //If the number is a valid tile number if ( tileTypeWall == TILE_RED_WALLf ) { walls[ tz ] = new Tile( NULL, NULL, p , q, NULL, NULL, tileTypeWall ); } } //Close the file map.close(); //If the map was loaded fine return true;
}
bool touches_wall( SDL_Rect box, Tile *tiles[] )
{
//Go through the tiles
for( int t = 0; t < TOTAL_TILES; t++ )
{
//If the tile is a wall type tile
if( ( tiles[ t ]->get_type() >= TILE_CENTER ) && ( tiles[ t ]->get_type() <= TILE_TOPLEFT ) )
{
//If the collision box touches the wall tile
if( check_collision( box, tiles[ t ]->get_box() ) == true )
{
return true;
}
}
}//If no wall tiles were touched return false;
}
Tile::Tile( int a, int b, int p, int q, int x, int y, int tileType )
{
//Get the offsets
floorpad.x = x;
floorpad.y = y;//Set the collision box floorpad.w = TILE_WIDTH; floorpad.h = TILE_HEIGHT;
wallside.x = a;
wallside.y = b;
wallside.w = TILE_WALLs_WIDTH;
wallside.h = TILE_WALLs_HEIGHT;wallfront.x = p;
wallfront.y = q;
wallfront.w = TILE_WALLf_WIDTH;
wallfront.h = TILE_WALLf_HEIGHT;//Get the tile type type = tileType;
}
void Tile::show()
{
//If the tile is on screen
if( check_collision( camera, floorpad ) == true )
{
//Show the tile
apply_surface( floorpad.x - camera.x, floorpad.y - camera.y, tileSheet, screen, &clips[ type ] );
}if( check_collision( camera, wallfront ) == true )
{
apply_surface( wallfront.x - camera.x, wallfront.y - camera.y, walltilesheet, screen, &clips[ type ] );
}
}int Tile::get_type()
{
return type;
}SDL_Rect Tile::get_box()
{
return floorpad;
}Dot::Dot()
{
//Initialize the offsets
box.x = 0;
box.y = 0;
box.w = LANDPAD_WIDTH;
box.h = LANDPAD_HEIGHT;x = 0;
y = 0;
z = y + YS_HEIGHT;
//Initialize the velocity
xVel = 0;
yVel = 0;
zVel = 0;
}void Dot::handle_input()
{
//If a key was pressed
if( event.type == SDL_KEYDOWN )
{
//Adjust the velocity
switch( event.key.keysym.sym )
{
case SDLK_UP: yVel -= YS_VEL_WALK; zVel -= YS_VEL_WALK; break;
case SDLK_DOWN: yVel += YS_VEL_WALK; zVel += YS_VEL_WALK; break;
case SDLK_LEFT: xVel -= YS_VEL_WALK; break;
case SDLK_RIGHT: xVel += YS_VEL_WALK; break;
case SDLK_SPACE: if(grounded == true){z -= 4; zVel -= YS_VEL_WALK + 20;} break;
}
}
//If a key was released
else if( event.type == SDL_KEYUP )
{
//Adjust the velocity
switch( event.key.keysym.sym )
{
case SDLK_UP: yVel += YS_VEL_WALK; zVel += YS_VEL_WALK; break;
case SDLK_DOWN: yVel -= YS_VEL_WALK; zVel -= YS_VEL_WALK; break;
case SDLK_LEFT: xVel += YS_VEL_WALK; break;
case SDLK_RIGHT: xVel -= YS_VEL_WALK; break;
}
}
}void Dot::move( Tile *tiles[], Uint32 deltaTicks )
{//Move the dot left or right
x += xVel * ( deltaTicks / 1000.f );
box.x = x;
//If the dot went too far to the left or right or touched a wall
if( ( x < 0 ) || ( x + YS_WIDTH > LEVEL_WIDTH )|| touches_wall( box, tiles ) )
{
//move back
x -= xVel* ( deltaTicks / 1000.f );
}//Move the dot up or down y += yVel * ( deltaTicks / 1000.f );
box.y = y;
//If the dot went too far up or down or touched a wall
if( ( y < 0 ) || ( y + YS_HEIGHT > LEVEL_HEIGHT ) || touches_wall( box, tiles ) )
{
//move back
y -= yVel* ( deltaTicks / 1000.f );
}if (z + YS_HEIGHT > y)
{
grounded = true;
}
else if (z + YS_HEIGHT < y)
{
grounded = false;
}if (grounded == true)
{
zVel = yVel;
z = y - YS_HEIGHT + 2;
}
else if (grounded == false)
{
zVel += ACCELARATION * ( deltaTicks / 1000.f );
z += zVel * ( deltaTicks / 1000.f );
}
}void Dot::show()
{
//Show the dot
apply_surface( (int)x - camera.x, (int)y - camera.y, LandPad, screen );
showCharacterMovement( (int)x - camera.x,(int)z - camera.y, Ysguy1, screen );}
void Dot::set_camera()
{
//Center the camera over the dot
camera.x = ( box.x + YS_WIDTH / 2 ) - SCREEN_WIDTH / 2;
camera.y = ( box.y + YS_HEIGHT / 2 ) - SCREEN_HEIGHT / 2;//Keep the camera in bounds. if( camera.x < 0 ) { camera.x = 0; } if( camera.y < 0 ) { camera.y = 0; } if( camera.x > LEVEL_WIDTH - camera.w ) { camera.x = LEVEL_WIDTH - camera.w; } if( camera.y > LEVEL_HEIGHT - camera.h ) { camera.y = LEVEL_HEIGHT - camera.h; }
}
Timer::Timer()
{
//Initialize the variables
startTicks = 0;
pausedTicks = 0;
paused = false;
started = false;
}void Timer::start()
{
//Start the timer
started = true;//Unpause the timer paused = false; //Get the current clock time startTicks = SDL_GetTicks();
}
void Timer::stop()
{
//Stop the timer
started = false;//Unpause the timer paused = false;
}
void Timer::pause()
{
//If the timer is running and isn’t already paused
if( ( started == true ) && ( paused == false ) )
{
//Pause the timer
paused = true;//Calculate the paused ticks pausedTicks = SDL_GetTicks() - startTicks; }
}
void Timer::unpause()
{
//If the timer is paused
if( paused == true )
{
//Unpause the timer
paused = false;//Reset the starting ticks startTicks = SDL_GetTicks() - pausedTicks; //Reset the paused ticks pausedTicks = 0; }
}
int Timer::get_ticks()
{
//If the timer is running
if( started == true )
{
//If the timer is paused
if( paused == true )
{
//Return the number of ticks when the timer was paused
return pausedTicks;
}
else
{
//Return the current time minus the start time
return SDL_GetTicks() - startTicks;
}
}//If the timer isn't running return 0;
}
bool Timer::is_started()
{
return started;
}bool Timer::is_paused()
{
return paused;
}int main( int argc, char* args[] )
{
//Quit flag
bool quit = false;//The dot Dot myDot; //The tiles that will be used Tile *tiles[ TOTAL_TILES ];
Tile *walls[ TOTAL_TILES_WALL ];
//The frame rate regulator
Timer delta;//Initialize if( init() == false ) { return 1; } //Load the files if( load_files() == false ) { return 1; } //Clip the tile sheet clip_tiles(); //Set the tiles if( set_tiles( tiles, walls) == false ) { return 1; }
//While the user hasn’t quit
while( quit == false )
{
//While there’s events to handle
while( SDL_PollEvent( &event ) )
{
//Handle events for the dot
myDot.handle_input();//If the user has Xed out the window if( event.type == SDL_QUIT ) { //Quit the program quit = true; } } //Move the dot myDot.move( tiles, delta.get_ticks() ); //Restart delta timer delta.start(); //Set the camera myDot.set_camera(); //Show the tiles for( int t = 0; t < TOTAL_TILES; t++ ) { tiles[ t ]->show(); } for( int tz = 0; tz < TOTAL_TILES_WALL; tz++ ) { walls[ tz ]->show(); } //Show the dot on the screen myDot.show(); //Update the screen if( SDL_Flip( screen ) == -1 ) { return 1; } } //Clean up clean_up( tiles, walls ); return 0;
}