Une fonction de définition n'est pas autorisé ici before '{'

j'en suis VRAIMENT ennuyeux d'erreur. j'ai cherché partout pour elle! je suis même allé en arrière et a changé le cours de ma

if (case)
    //to-do

à

if (case)
{
    //to-do
}

je n'ai pas de poser beaucoup de questions de ce genre, mais je suis vraiment frustré, et je suis presque certain c'est quelque chose de simple que je ne suis pas le voir.

voici l'erreur:

entity.cpp: In member function ‘virtual void Entity::clean()’:
entity.cpp:148: error: a function-definition is not allowed here before ‘{’ token
entity.cpp:394: error: expected ‘}’ at end of input

voici mon code de classe:

#include "./entity.hpp"
std::vector<Entity *> Entity::entity_list_;
std::vector<EntityCollision> EntityCollision::collision_list_;
EntityCollision::EntityCollision()
{
a_ = NULL;
b_ = NULL;
}
Entity::Entity()
{
image_buffer_ = NULL;
x_ = y_ = 0.0f;
width_ = height_ = 0;
animation_state_ = 0;
move_left_ = false;
move_right_ = false;
type_ = ENTITY_TYPE_GENERIC;
flags_ = ENTITY_FLAG_GRAVITY;
dead_ = false;
speed_x_ = 0;
speed_y_ = 0;
max_speed_x_ = 0;
max_speed_y_ = 0;
column_x_ = 0;
column_y_ = 0;
column_width_ = 0;
column_height_ = 0;
}
Entity::~Entity()
{
}
bool Entity::init(const std::string &image_file, int width, int height, int max_frames)
{
if ((image_buffer_ = Surface::mount_image(image_file)) == NULL)
{
return false;
}
animation_helper_.max_frames_ = max_frames;
width_ = width;
height_ = height;
return Surface::set_color_key(255, 0, 255, image_buffer_);
}
void Entity::render(SDL_Surface *dest)
{
if (image_buffer_ == NULL || dest == NULL)
{
return;
}
Surface::draw(x_ - CameraManager::camera_controller_.x(),
y_ - CameraManager::camera_controller_.y(),
current_frame_column_ * width_,
(current_frame_row_ + animation_helper_.current_frame()) * height_,
width_, height_,
image_buffer_,
dest);
}
void Entity::animate()
{
if (move_left_)
{
current_frame_column_ = 0;
}
else if (move_right_)
{
current_frame_column_ = 1;
}
animation_helper_.animate();
}
void Entity::collision(Entity *entity)
{
}
void Entity::update()
{
/* if the entity isn't moving left or right */
if (move_left_ == false && move_right_ == false)
{
stop(); //stop movement
}
if (move_left_) //if it wants to move left
{
accel_x_ = -0.5; //move negatively down x axis
}
else if (move_right_)
{
accel_x_ = 0.5; //move positively up the x axis
}
/* if gravity is applied to the entity */
if (flags_ & ENTITY_FLAG_GRAVITY)
{
accel_y_ = 0.75f; //it will fall
}
/* set the entity's speed */
speed_x_ += accel_x_ * FPSManager::fps_controller_.speed_factor();
speed_y_ += accel_y_ * FPSManager::fps_controller_.speed_factor();
/* make sure the entity won't move too fast */
if (speed_x_ > max_speed_x_)
{
speed_x_ = max_speed_x_;
}
if (speed_x_ < -max_speed_x_)
{
speed_x_ = -max_speed_x_;
}
if (speed_y_ > max_speed_y_)
{
speed_y_ = max_speed_y_;
}
if (speed_y_ < -max_speed_y_)
{
speed_y_ = -max_speed_y_;
}
animate(); //animate the entity
move(speed_x_, speed_y_); //now move it
}
void Entity::clean()
{
if (image_buffer_) //if the image buffer has an image on it
{
SDL_FreeSurface(image_buffer_); //get rid of it!
}
image_buffer_ = NULL; //just set it to null if it doesn't :\
}
void Entity::move(float x, float y)
{
/* if thee entity  doesn't want to move, why try? */
if (x == 0 && y == 0)
{
return;
}
double new_x = 0; //the x position increment
double new_y = 0; //the y position increment
/* give us the correct movement per second */
x *= FPSManager::fps_controller_.speed_factor();
y *= FPSManager::fps_controller_.speed_factor();
if (y != 0) //if we should move up or down
{
if (y >= 0) //down in this case
{
new_y = FPSManager::fps_controller_.speed_factor();
}
else //up in this case
{
new_y = -FPSManager::fps_controller_.speed_factor();
}
}
while (true)
{
if (flags_ & ENTITY_FLAG_GHOST) //is the entity a ghost?
{
/* notify the entity of other collisions */
valid_pos((int) (x_ + new_x), (int) (y_ + new_y));
/* move regardless of the results */
x_ += new_x_;
y_ += new_y_;
}
else
{
/* if the new y position is valid (empty) */
if (valid_pos((int) (x_ + new_x), (int) y_))
{
x_ += new_x; //move the entity
}
else
{
speed_x_ = 0;
}
/* if the new y position is valid (empty) */
if (valid_pos((int) x_, (int) (y_ + new_y)))
{
y_ += new_y; //move the entity
}
else
{
speed_y_ = 0;
}
}
/* decrease x by new_x until it reaches 0 */
x += -new_x;
/* decrease y by new_y until it reaches 0 */
y += -new_y;
if (new_x > 0 && x <= 0)
{
new_x = 0;
}
if (new_x < 0 && x >= 0)
{
new_x = 0;
}
if (new_y > 0 && y <= 0)
{
new_y = 0;
}
if (new_y < 0 && y >= 0)
{
new_y = 0;
}
/* if the entity reached it's new position on the x axis */
if (x == 0)
{
new_x = 0; //don't move left || right anymore
}
/* if the entity reached it's new position on the y axis */
if (y == 0)
{
new_y = 0; //don't move up || down anymore
}
/* when we finally come to a stop */
if (x == 0 && y == 0)
{
break; //break out of the loop
}
if (new_x == 0 && new_y == 0)
{
break;
}
}
}
void Entity::stop()
{
if (speed_x_ > 0)
{
accel_x_ = -1;
}
if (speed_x_ < 0)
{
accel_x_ = 1;
}
if (speed_x_ < 2.0f && speed_x_ > -2.0f)
{
accel_x_ = 0;
speed_x_ = 0;
}
}
bool Entity::collides(int o_x, int o_y, int o_w, int o_h)
{
int left1, left2;
int right1, right2;
int top1, int top2;
int bottom1, int bottom2;
int t_x = (int) x_ + column_x_;
int t_y = (int) y_ + column_y_;
left1 = t_x;
left2 = o_x;
right1 = left1 + width_ - 1 - column_width_;
right2 = o_x + o_w - 1;
top1 = t_y;
top2 = o_y;
bottom1 = top1 + height_ - 1 - column_height_;
bottom2 = o_y + o_h - 1;
if (bottom1 < top2)
{
return false;
}
if (top1 > bottom2)
{
return false;
}
if (right1 < left2)
{
return false;
}
if (left1 > right2)
{
return false;
}
return true;
}
bool valid_pos(int x, int y)
{
bool _return = true;
int start_x = (x + column_x_) / TILE_SIZE;
int start_y = (y + column_y_) / TILE_SIZE;
int end_x = ((x + column_x_) + width_ - column_width_ - 1) / TILE_SIZE;
int end_y = ((x + column_y_) + height_ - column_height_ - 1) / TILE_SIZE;
for (int i_y = start_y; i_y < end_y; i_y++)
{
for (int i_x = start_x; i_x < end_x; i_x++)
{
Tile *tile = MapManager::map_control_.get_tile(i_x * TILE_SIZE,
i_y * TILE_SIZE);
if (valid_pos_tile(tile) == false)
{
_return = false;
}
}
}
if (flags_ & ENTITY_FLAG_MAPONLY)
{
}
else
{
for (int i = 0; i < entity_list_.size(); i++)
{
if (!valid_pos_entity(entity_list_[i], x, y))
{
_return = false;
}
}
}
return _return;
}
bool valid_pos(Tile *t)
{
if (t == NULL)
{
return true;
}
if (tile->type_id_ == TILE_TYPE_BLOCK)
{
return false;
}
return true;
}
bool valid_pos(Entity *e, int x, int y)
{
if ((this != e) && (e != NULL) && (e->dead_ == false) &&
(e->flags_ ^ ENTITY_FLAG_MAPONLY) &&
(e->collides(x + column_x, y + column_y,
width_ - column_width_ - 1,
height_ - column_height_ - 1) == true))
{
EntityCollision ec;
ec.a_ = this;
ec.b_ = e;
EntityCollision::collision_list_.push_back(ec);
return false;
}
return true;
}

grâce

edit: je ne sais pas pourquoi certains de l'indentation cassé. la fixation de maintenant.