Sign in to follow this  
gamesneverdie

Tilesheets and SDL

Recommended Posts

I'm having some problems with lazyfoo's tutorial again :/
Right now I'm at the Tiling tutorial and again the sample code from there works fine ([url="http://lazyfoo.net/SDL_tutorials/lesson29/index.php"]tutorial 29[/url]).
But my code is not in just one, but more source files (as shown [url="http://lazyfoo.net/articles/article07/index.php"]here[/url]).
These are the errors I get:
[img]http://www.imgnow.net/uploads/711053169errors.png[/img]
I guess, I forgot to include something, but I have no clue what it could be.

Thanks in advance for any answers :)

Share this post


Link to post
Share on other sites
In future, please post errors as text. This makes it easier to copy the errors or quote them.

This isn't an "Alternative Games Libraries" issue, its a basic C++ language problem.

The problem is that on classes.h on line 20 the compiler cannot see a declaration of "Tile". This isn't necessarily caused by not including something, it can be caused by the order of includes. Read [url="http://www.gamedev.net/page/resources/_/reference/programming/languages/c-and-c/organizing-code-files-in-c-and-c-r1798"]this[/url], it contains all the information you need to fix this problem.

Share this post


Link to post
Share on other sites
Looking at the error messages you are using Tile in your code in classes.h without declaring it before. The other error is that you send arguments of the wrong type to Man::move.

Share this post


Link to post
Share on other sites
Hidden
[quote name='PoriKori' timestamp='1306933911' post='4818256']
I'm having some problems with lazyfoo's tutorial again :/
Right now I'm at the Tiling tutorial and again the sample code from there works fine ([url="http://lazyfoo.net/SDL_tutorials/lesson29/index.php"]tutorial 29[/url]).
But my code is not in just one, but more source files (as shown [url="http://lazyfoo.net/articles/article07/index.php"]here[/url]).
These are the errors I get:
[img]http://www.imgnow.net/uploads/711053169errors.png[/img]
I guess, I forgot to include something, but I have no clue what it could be.

Thanks in advance for any answers :)
[/quote]

Since you've modified the code you could you post your code either enclosed source tags or attached as a zip. Otherwise we can only guess what the problem might be.

Share this post


Link to post
The second error is likely caused by the first, the compiler is using the "default int" fallback while compiling the Man class declaration. Later on the Tile class is declared and then the compiler is confused when a Tile is being passed to what it decided was an int.

Share this post


Link to post
Share on other sites
The only place I defined "Tile" was in main, but lazyfoo's tutorial does the same.
So far I have "Tile *tiles[TOTAL_TILES];" in main, but I dont know what to do. I've read the article you linked, rip-off, but I still don't know what to do.

If I change the including orders (functions.h before classes.h) I get these errors:
[quote]Compiling: game1.cpp
In file included from C:\game1\game1.cpp:9:
C:\game1\functions.h:33: error: 'Tile' was not declared in this scope
C:\game1\functions.h:33: error: 'tiles' was not declared in this scope
C:\game1\functions.h:33: error: expected primary-expression before ']' token
C:\game1\functions.h:35: error: 'Tile' has not been declared
In file included from C:\game1\game1.cpp:11:
C:\game1\classes.h:20: error: 'Tile' has not been declared
C:\game1\game1.cpp: In function 'int SDL_main(int, char**)':
C:\game1\game1.cpp:60: error: 'set_tiles' cannot be used as a function
C:\game1\game1.cpp:86: error: no matching function for call to 'Man::move(int, Tile* [192])'
C:\\game1\classes.h:20: note: candidates are: void Man::move(Uint32, int**)
Process terminated with status 1 (0 minutes, 8 seconds)
7 errors, 0 warnings[/quote]
If I include classes.h before functions.h I get the same errors as above.

Share this post


Link to post
Share on other sites
Consider splitting your program into more files. Instead of monolithic "classes.h" and "functions.h", separate into additional files such as "tile.h" and "man.h", with the associated source files.

Share this post


Link to post
Share on other sites
That would still not fix this error.
What I have now is this:
function prototype in class Man: void move(Uint32 deltaTicks, Tile *tiles[]);
To my understanding a function expects input of some sort like int etc. In this case one "Uint32" and one "Tile". My guess would be that "Tile" is defined in one of the SDL libraries, because when everything is in one file it works.
The only other declaration of "Tile" is in my main function, where I use the class to create every Tile-object with "Tile *tiles[TOTAL_TILES];"

Share this post


Link to post
Share on other sites
Uint32 is defined in SDL.h too ([url="http://www.gamedev.net/topic/602707-errors-in-stdioh/"]had similar problem before[/url]) and no, Tile was not introduced before this tutorial. There is no other definition or declaration in the sample source on lazyfoo either and that works for me.

Share this post


Link to post
Share on other sites
My apologies, I wasn't thinking of the sized integer types. Most SDL types are prefixed with SDL_ though (e.g. SDL_Surface).

I see a class declaration for Tile on [url="http://lazyfoo.net/SDL_tutorials/lesson29/index.php"]this Lazy Foo tutorial[/url]. I found it with [url="https://encrypted.google.com/search?q=Tile+site%3Alazyfoo.net"]this Google search[/url].

Share this post


Link to post
Share on other sites
I fail to see the problem. Copy the Tile class declaration into a suitable header file. The Tile class is not part of SDL, it is something Lazy Foo provided for the tutorial.

Share this post


Link to post
Share on other sites
Here you go:

game1.cpp
[code]//Headers
#include <string>
#include <sstream>

#include "constants.h"
#include "globals.h"
#include "functions.h"
#include "classes.h"

using namespace std;

int main(int argc, char* args[]) {

//Quit Flag
bool quit = false;

//Initialize
if(init() == false) {
return 1;
}

//Load the files
if(load_files() == false) {
return 1;
}

Tile *tiles[TOTAL_TILES];

//Frame Number Tracker
int frame = 0;

//The FPS Regulator
Timer fps;

//The Frame timer
Timer fps1;

//Timer used to update the caption
Timer update;

//Keeps track of time since last rendering
Timer delta;
delta.start();

//Start the update and frame timer
update.start();
fps1.start();

Man man1;

//Cap FPS : YES / NO
bool cap = true;

clip_tiles();

//Set the tiles
if(set_tiles(tiles) == false) {
return 1;
}

//While the user has not quit
while(quit == false) {
//Start the frame timer
fps.start();

//While there is an event to handle
while(SDL_PollEvent(&event)) {
man1.handle_input();
//If the User Xed the window
if(event.type == SDL_KEYDOWN) {
//Set the proper message surface
switch(event.key.keysym.sym) {
case SDLK_RETURN: cap = (!cap); break;
default: ;
}
} else if(event.type == SDL_QUIT) {
//Quit the program
quit = true;
}
}

//Move the man
man1.move(delta.get_ticks(), tiles);
//Set camera
man1.set_camera();

//Show the tiles
for(int t = 0; t < TOTAL_TILES; t++) {
tiles[t]->show();
}

delta.start();

//fill the screen white
//SDL_FillRect(screen, &screen->clip_rect,SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF));

//Show the wall
//SDL_FillRect(screen, &wall, SDL_MapRGB(screen->format, 0x77, 0x77, 0x77));

//Show the man
man1.show();
//Increment the frame counter
frame++;

//If a second has passed since the caption updated
if(update.get_ticks() > 1000) {
//The framerate as a string
stringstream framerate;

//Calculate the fps and create a string
framerate << "FPS: " << frame / (fps1.get_ticks() / 1000.f);

//Create the surface
fpstext = TTF_RenderText_Solid(font, framerate.str().c_str(), textColor);

update.start();
}

//Show fps
apply_surface(530, 5, fpstext, screen, NULL);

//Update the screen
if(SDL_Flip(screen) == -1) {
return 1;
}
//Cap FPS YES/NO?
if((cap == true) && (fps.get_ticks() < 1000 / FRAMES_PER_SECOND)) {
//Sleep remaining frame time
SDL_Delay((1000 / FRAMES_PER_SECOND) - fps.get_ticks());
}
}

//Free the surfaces and quit SDL
clean_up();
return 0;
}
[/code]

functions.cpp
[code]#include "SDL/SDL.h"
#include "SDL/SDL_image.h"
#include "SDL/SDL_ttf.h"
#include <string>
#include "constants.h"
#include "functions.h"
#include "globals.h"

SDL_Surface *load_image(string filename) {
//Temporary storage for the image that's used
SDL_Surface* loadedImage = NULL;
//The optimized image that will be used
SDL_Surface* optimizedImage = NULL;

//Load the image
loadedImage = IMG_Load(filename.c_str());

//If nothing went wrong in loading the image
if(loadedImage != NULL) {
//Create an optimized image
optimizedImage = SDL_DisplayFormat(loadedImage);
//Free the old image
SDL_FreeSurface(loadedImage);
//If the image was optimized fine
if(optimizedImage != NULL) {
//Map the color key
Uint32 colorkey = SDL_MapRGB(optimizedImage->format, 0xFF, 0, 0xFF);
//Set all pink pixels to transparent
SDL_SetColorKey(optimizedImage, SDL_SRCCOLORKEY, colorkey);
}
}
//Return the optimized image
return optimizedImage;
}

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;
}

//Initialize SDL ttf
if(TTF_Init() == -1) {
return false;
}

//Set the window caption
SDL_WM_SetCaption("GAME 1", NULL);

//If everthing runs fine
return true;
}


bool load_files() {

//Load the images
man = load_image("man.png");

//Open the font
font = TTF_OpenFont("Dina.fon", 10);

//If there was an error loading the man
if(man == NULL) {
return false;
}

//If there was an error loading the font
if(font == NULL) {
return false;
}

//If everything's fine
return true;
}

void apply_surface(int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip) {
//Make a temporary rectangle to hold the offsets
SDL_Rect offset;

//Give the offsets to the rectangle
offset.x = x;
offset.y = y;

//Blit the surface
SDL_BlitSurface(source, clip, destination, &offset);
}

void clean_up() {
//Free the surfaces
SDL_FreeSurface(fpstext);
SDL_FreeSurface(man);
SDL_FreeSurface(background);
SDL_FreeSurface(screen);
SDL_FreeSurface(tileSheet);

//Free the tiles
for(int t = 0; t < TOTAL_TILES; t++) {
delete tiles[t];
}

//Close the font
TTF_CloseFont(font);

//Quit SDL_ttf
TTF_Quit();

//Quit SDL
SDL_Quit();
}

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 sides from A are outside of B > !collision
if(bottomA <= topB) {
return false;
}
if(topA >= bottomB) {
return false;
}
if(rightA <= leftB) {
return false;
}
if(leftA >= rightB) {
return false;
}
//If any of the sides of A are inside of B > collision
return true;
}

bool set_tiles(Tile *tiles[]) {
//The tile offsets
int x = 0, y = 0;
//Open the map
ifstream map("lazy.map");
//If loading error
if(map == NULL) {
return false;
}

//Initialize the tiles
for(int t = 0; t < TOTAL_TILES; t++) {
//Determines that kind of tile will be made
int tileType = -1;
//Read tile from map file
map >> tileType;
//If error reading 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(x, y, tileType);
}
//if we dont recognize the tile type
else {
//Stop loading map
map.close();
return false;
}
//Move to next tile spot
x += TILE_WIDTH;
//If we have gone too far
if(x >= LEVEL_WIDTH) {
//Move back
x = 0;
//Move to the next row
y += TILE_HEIGHT;
}
}
//close the file
map.close();
//If the map was loaded fine
return true;
}

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;
}

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;
}
[/code]

man.cpp
[code]//The headers
#include "SDL/SDL.h"
#include "SDL/SDL_image.h"
#include <string>
#include "constants.h"
#include "classes.h"
#include "functions.h"
#include "globals.h"

Man::Man() {
//Initialize the offsets
box.x = 0;
box.y = 0;

//Man's dimensions
box.w = MAN_WIDTH;
box.h = MAN_HEIGHT;

//Initialize velocity
xVel = 0;
yVel = 0;
}

void Man::handle_input() {
//if a key was pressed
if(event.type == SDL_KEYDOWN) {
//Adjust velocity
switch(event.key.keysym.sym) {
case SDLK_UP: yVel -= MAN_VEL; break;
case SDLK_DOWN: yVel += MAN_VEL; break;
case SDLK_LEFT: xVel -= MAN_VEL; break;
case SDLK_RIGHT: xVel += MAN_VEL; break;
default: ;
}
}
//If a key was pressed
if(event.type == SDL_KEYUP) {
//Adjust velocity
switch(event.key.keysym.sym) {
case SDLK_UP: yVel += MAN_VEL; break;
case SDLK_DOWN: yVel -= MAN_VEL; break;
case SDLK_LEFT: xVel += MAN_VEL; break;
case SDLK_RIGHT: xVel -= MAN_VEL; break;
default: ;
}
}
}

void Man::move(Uint32 deltaTicks, Tile *tiles[]) {
//Move the dot horizontally
box.x += xVel * (deltaTicks / 1000.f);
//If the dot went too far > move back
if(box.x < 0) {
box.x = 0;
} else if(box.x + MAN_WIDTH > LEVEL_WIDTH) {
box.x = LEVEL_WIDTH - MAN_WIDTH;
}

//Horizontal Collision detection
if(touches_wall(box, tiles)) {
//Man coming from left
if(((box.x + MAN_WIDTH) >= tiles.x) && (box.x <= tiles.x) && ((box.y >= tiles.y) || (box.y + MAN_HEIGHT) <= (tiles.y + tiles.h))) {
box.x = tiles.x - MAN_WIDTH;
}
//Man coming from right
if((box.x <= (tiles.x + tiles.w)) && (box.x >= tiles.x) && ((box.y >= tiles.y) || (box.y + MAN_HEIGHT) <= (tiles.y + tiles.h))) {
box.x = tiles.x + tiles.w;
}
}

//Move the dot vertically
box.y += yVel * (deltaTicks / 1000.f);
//If the dot went too far > move back
if(box.y < 0) {
box.y = 0;
} else if(box.y + MAN_HEIGHT > LEVEL_HEIGHT) {
box.y = LEVEL_HEIGHT - MAN_HEIGHT;
}

//Vertical collision
if(touches_wall(box, tiles)) {
//Man coming from the top
if((box.y + MAN_HEIGHT >= tiles.y) && (box.y <= tiles.y) && ((box.x >= tiles.x) || (box.x + MAN_WIDTH) <= (tiles.x + tiles.w))) {
box.y = tiles.y - MAN_HEIGHT;
}
//Man coming from the bottom
if((box.y <= (tiles.y + tiles.h)) && (box.y >= tiles.y) && ((box.x >= tiles.x) || (box.x + MAN_WIDTH) <= (tiles.x + tiles.w))) {
box.y = tiles.y + tiles.h;
}
}
}

void Man::set_camera() {
//Center the camera over the man
camera.x = (box.x + MAN_WIDTH / 2) - SCREEN_WIDTH / 2;
camera.y = (box.y + MAN_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;
}
}

void Man::show() {
apply_surface((int)box.x - camera.x, (int)box.y - camera.y, man, screen, NULL);
}
[/code]

tiles.cpp
[code]

Tile::Tile(int x, int y, int tileType) {
//Get the offsets
box.x = x;
box.y = y;
//Set the collision box
box.w = TILE_WIDTH;
box.h = TILE_HEIGHT;
//Get the tile type
type = tileType;
}

void Tile::show() {
//If the tile is on screen
if(check_collision(camera, box) == true) {
//Show the tile
apply_surface(box.x - camera.x, box.y - camera.y, tileSheet, screen, &clips[type]);
}
}

int Tile::get_type() {
return type;
}

SDL_Rect Tile::get_box() {
return box;
}
[/code]

global.cpp
[code]//Headers
#include "SDL/SDL.h"
#include "globals.h"
#include "SDL/SDL_ttf.h"
#include "constants.h"

//The surfaces
SDL_Surface *fpstext = NULL;
SDL_Surface *man = NULL;
SDL_Surface *background = NULL;
SDL_Surface *screen = NULL;

//Event structures
SDL_Event event;

//The font that's going to be used
TTF_Font *font = NULL;

//The Color of the text
SDL_Color textColor = {128, 128, 128};

//The wall
SDL_Rect wall;

SDL_Rect camera = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};

[/code]

timer.cpp
[code]#include "SDL/SDL.h"
#include "classes.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;
}

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 is not running
return 0;
}

void Timer::pause() {
//If the timer is running and is not 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;
}
}

bool Timer::is_started() {
return started;
}

bool Timer::is_paused() {
return paused;
}
[/code]

classes.h
[code]#ifndef CLASSES_H
#define CLASSES_H

#include "SDL/SDL.h"

//The man that will move around on the screen
class Man {
private:
//The collision box
SDL_Rect box;
//The velocity
float xVel, yVel;

public:
//Initialize all variables
Man();
//Takes key presses and adjusts the man's velocity
void handle_input();
//Move the man
void move(Uint32 deltaTicks, Tile *tiles[]);
//Show on screen
void show();
//Sets the camera over the man
void set_camera();
};

class Tile {
private:
//The attributes of the tile
SDL_Rect box;
//The tile type
int type;

public:
//Initializes the variables
Tile(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();
};

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();
};

#endif
[/code]

constants.h
[code]#ifndef CONSTANTS_H
#define CONSTANTS_H

//Screen constants
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int SCREEN_BPP = 32;

//FPS
const int FRAMES_PER_SECOND = 30;

//Dimensions of the level
const int LEVEL_WIDTH = 1280;
const int LEVEL_HEIGHT = 960;

//Dimensions of the man
const int MAN_WIDTH = 16;
const int MAN_HEIGHT = 16;
const int MAN_VEL = 200;

//Tile constants
const int TILE_WIDTH = 80;
const int TILE_HEIGHT = 80;
const int TOTAL_TILES = 192;
const int TILE_SPRITES = 12;

//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;

#endif
[/code]

functions.h
[code]#ifndef FUNCTIONS_H
#define FUNCTIONS_H

//Headers
#include "SDL/SDL.h"
#include "SDL/SDL_image.h"
#include <string>

using namespace std;

//File Loader
SDL_Surface *load_image(string filename);

//Surface Blitter
void apply_surface(int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip);

//Initialization
bool init();

//File loading
bool load_files();

//Clean up
void clean_up();

//Check collision
bool check_collision(SDL_Rect A, SDL_Rect B);

//Clip the tilesheet
void clip_tiles();

//Set the tiles
bool set_tiles(Tile *tiles[]);

bool touches_wall(SDL_Rect box, Tile *tiles[]);


#endif
[/code]

globals.h
[code]#ifndef GLOBALS_H
#define GLOBALS_H

//Headers
#include "SDL/SDL.h"
#include "SDL/SDL_ttf.h"
#include "SDL/SDL_image.h"

//The surfaces
extern SDL_Surface *fpstext;
extern SDL_Surface *man;
extern SDL_Surface *background;
extern SDL_Surface *screen;
extern SDL_Surface *tileSheet;

//Event structures
extern SDL_Event event;

//The font that's going to be used
extern TTF_Font *font;

//The Color of the text
extern SDL_Color textColor;

//The wall
extern SDL_Rect wall;

//The camera
extern SDL_Rect camera;

#endif
[/code]

Share this post


Link to post
Share on other sites
In classes.h move the "class Tile {}" above "class Man {}"

You are using the Tile class in the Man class, but Man doesn't know it exists yet because it doesn't get defined until afterward.


[EDIT]
Like this:

[code]
#ifndef CLASSES_H
#define CLASSES_H

#include "SDL/SDL.h"


class Tile {
private:
//The attributes of the tile
SDL_Rect box;
//The tile type
int type;

public:
//Initializes the variables
Tile(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 man that will move around on the screen
class Man {
private:
//The collision box
SDL_Rect box;
//The velocity
float xVel, yVel;

public:
//Initialize all variables
Man();
//Takes key presses and adjusts the man's velocity
void handle_input();
//Move the man
void move(Uint32 deltaTicks, Tile *tiles[]);
//Show on screen
void show();
//Sets the camera over the man
void set_camera();
};


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();
};

#endif
[/code]

Share this post


Link to post
Share on other sites
Thanks! That helped, and I saw that I forgot the headers in tiles.cpp.
I have to redo the collision checking, as this code was from an earlier tutorial, that I came up with in that special case.
Anyways, I got another error, which I couldnt fix now:

C:\game1\tiles.cpp: In member function 'void Tile::show()':
C:\game1\tiles.cpp:25: error: 'clips' was not declared in this scope

clips as it is, are a bunch of declarations inside void clip_tiles() in function.cpp

How would I do this?

Share this post


Link to post
Share on other sites
I don't even see where clips is actually defined anywhere?

Try this:
Define clips in functions.h (SDL_Rect clips[12] or whatever)
Include functions.h (and Tiles.h :)) in Tiles.cpp

That will define your clips and give your tiles class access to it.

Share this post


Link to post
Share on other sites
If you read and understood the article I linked in my first reply, the solution should have been apparent. Also my suggestion [url="http://www.gamedev.net/topic/603306-tilesheets-and-sdl/page__view__findpost__p__4819009"]in this reply[/url] could have solved your problem. Later you said the class was in a separate header file, it wasn't: it was in the same one has class Man.

All these things were obstacles to finding your solution. In future, please be clearer and more upfront about what you did and whether you understand the responses your getting.

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