title: A function-definition is not allowed here before '{'
body: <p>i am getting a REALLY annoying error.  i literally looked everywhere for it!  i even went back and changed all of my </p>
  
  <pre><code>if (case)
      // to-do
  </code></pre>
  
  <p>to</p>
  
  <pre><code>if (case)
  {
      // to-do
  }
  </code></pre>
  
  <p>i don't ask a lot of questions like this, but i am really getting frustrated, and i am almost positive it is something simple that i am not seeing.</p>
  
  <p>here is the error:</p>
  
  <pre><code>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
  </code></pre>
  
  <p>here is my class code:</p>
  
  <pre><code>#include "./entity.hpp"
  
  std::vector&lt;Entity *&gt; Entity::entity_list_;
  std::vector&lt;EntityCollision&gt; 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 &amp;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 &amp;&amp; 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_ &amp; 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_ &gt; max_speed_x_)
      {
        speed_x_ = max_speed_x_;
      }
  
    if (speed_x_ &lt; -max_speed_x_)
      {
        speed_x_ = -max_speed_x_;
      }
  
    if (speed_y_ &gt; max_speed_y_)
      {
        speed_y_ = max_speed_y_;
      }
  
    if (speed_y_ &lt; -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 &amp;&amp; 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 &gt;= 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_ &amp; 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 &gt; 0 &amp;&amp; x &lt;= 0)
        {
          new_x = 0;
        }
  
        if (new_x &lt; 0 &amp;&amp; x &gt;= 0)
        {
          new_x = 0;
        }
  
        if (new_y &gt; 0 &amp;&amp; y &lt;= 0)
        {
          new_y = 0;
        }
  
        if (new_y &lt; 0 &amp;&amp; y &gt;= 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 &amp;&amp; y == 0)
        {
          break; // break out of the loop
        }
  
        if (new_x == 0 &amp;&amp; new_y == 0)
        {
          break;
        }
      }
  }
  
  void Entity::stop()
  {
    if (speed_x_ &gt; 0)
      {
        accel_x_ = -1;
      }
  
    if (speed_x_ &lt; 0)
      {
        accel_x_ = 1;
      }
  
    if (speed_x_ &lt; 2.0f &amp;&amp; speed_x_ &gt; -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 &lt; top2)
      {
        return false;
      }
  
    if (top1 &gt; bottom2)
      {
        return false;
      }
  
    if (right1 &lt; left2)
      {
        return false;
      }
  
    if (left1 &gt; 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 &lt; end_y; i_y++)
      {
        for (int i_x = start_x; i_x &lt; 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_ &amp; ENTITY_FLAG_MAPONLY)
      {
      }
    else
      {
        for (int i = 0; i &lt; 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-&gt;type_id_ == TILE_TYPE_BLOCK)
      {
        return false;
      }
  
    return true;
  }
  
  bool valid_pos(Entity *e, int x, int y)
  {
    if ((this != e) &amp;&amp; (e != NULL) &amp;&amp; (e-&gt;dead_ == false) &amp;&amp;
        (e-&gt;flags_ ^ ENTITY_FLAG_MAPONLY) &amp;&amp;
        (e-&gt;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;
  }
  </code></pre>
  
  <p>thanks</p>
  
  <p>edit: i don't know why some of the indentation broke.  fixing it now.</p>