C:/Documents and Settings/mtauraso/Desktop/proj3/projectX/Person.cpp

Go to the documentation of this file.

#include <iostream>

#include "Person.h"
#include "List.h"
#include "CollisionHandler.h"
#include "CommandManager.h"
#include "Command.h"
#include "glfuncs.h"
#include "bullet.h"
#include "level.h"
#include "ShowOneSprite.h"
#include "Screen.h"


using namespace std;

/*Person::Person()
:_xVelocity(0),_yVelocity(0),_maxVel(850),_jumping(true), _wallJump(0), 
_gravity(3), _accel(40), _groundDrag(-1.2), _airDrag(-0.3),
_xDirection( LEFT ),
_yDirection( MIDDLE )
{
        // FIXME  make this general
        _id = "goudy";
        _type = PERSON;

        _collidable = true;

        // FIXME  these should be set based on the levels spawn point
        _box.x = 400;
        _box.y = 400;

        // FIXME this filename should be set based on the type of person it is eventually
        _sprite = Sprite::loadSprite("stickman.png");
        _box.w = _sprite->width();
        _box.h = _sprite->height();

        _previousX = _box.x;
        _previousY = _box.y;

//      CollisionHandler::instance()->registerObject(this);
}*/

Person::Person(List* personInfo, int x, int y)
:Object(personInfo,x,y),
 _xVelocity(0),
 _yVelocity(0),
 _maxXVel(850),

// _jumping(true),

 _maxYVel(800),
 _maxFallRate(700),

 _crouching( false ),
// _wallJump(0), 
 _gravity(2), 
 _accel(40),
 _airAccel(20),
 _groundDrag(-2.5), 
 _airDrag(-0.3),
 _xDirection( LEFT ),
 _yDirection( MIDDLE ), 
 _state( JUMPING ), 
 _health(2), 
 _waitShoot(15), 
 _framesSinceShoot(0),
 _jumpTimer(0),
 _bulletSpeed(500),
 _maxJumpTime(15)
{
        _collidable = true;

        load(personInfo);

        _previousX = _box.x;
        _previousY = _box.y;
}

void Person::load(List *personInfo)
{
        while( !personInfo->empty())
        {
                List * current = personInfo->firstList();
                
                if(current->firstString() == "maxXVel")
                        _maxXVel = current->rest()->firstInt();

                if(current->firstString() == "maxYVel")
                        _maxYVel = current->rest()->firstInt();

                if(current->firstString() == "maxFallRate")
                        _maxFallRate = current->rest()->firstInt();
                
                if(current->firstString() == "gravity")
                        _gravity = current->rest()->firstInt();

                if(current->firstString() == "accel")
                        _accel = current->rest()->firstInt();

                if(current->firstString() == "airAccel")
                        _airAccel = current->rest()->firstInt();

                if(current->firstString() == "groundDrag")
                        _groundDrag = current->rest()->firstDouble();

                if(current->firstString() == "airDrag")
                        _airDrag = current->rest()->firstDouble();

                if(current->firstString () == "sprite")
                        _sprite = Sprite::loadSprite( current->rest()->firstString() );

                if(current->firstString () == "waitShoot")
                        _waitShoot = current->rest()->firstInt();

                if(current->firstString () == "bulletSpeed")
                        _bulletSpeed = current->rest()->firstInt();

                if(current->firstString () == "maxJumpTime")
                        _maxJumpTime = current->rest()->firstInt();
                
                if(current->firstString () == "health")
                        _health = current->rest()->firstInt();

                personInfo = personInfo ->rest();
        }

        _box.w = _sprite->width();
        _box.h = _sprite->height();
}

void Person::collide( Object* o )
{
        if(     (o->getType() == TILE)|| (o->getType() == DOOR) ||
                ((_type == PLAYER)&&(o->getType() == ENEMY ))||
                ((_type == ENEMY)&&(o->getType() == PLAYER ))
                )
        {
                int x,y;
                if( _previousX != _box.x){

                        //If you're pressing against a wall, get ready to jump off the wall in the opposite direction
                        /*if(_xVelocity != 0)
                        {
                                _jumping = false;
                                _wallJump = -(_xVelocity / abs(_xVelocity));
                        }*/

                        glfuncs::intersectX(o->getBox(),_box,&x);
                        _box.x += x;
                        _xVelocity = 0;
                }
                if( _previousY != _box.y){

                        //When you hit the ground, reset these
                        /*if(_yVelocity > 0)
                        {
                                _jumping = false;
                                _wallJump = 0;
                        }*/

                        glfuncs::intersectY(o->getBox(),_box,&y);
                        _box.y += y;
                        _yVelocity = 0;
                }
        }
}

void Person::draw()
{
        ShowOneSprite* s = (ShowOneSprite*)_sprite;
        s->setDirection( _xDirection ); 
        
        switch( _state )
        {
        case STANDING:
                s->show( 0 );
                break;
        case RUNNING:
                s->show( 1 );
                break;
        case JUMPING:
                s->show( 2 );
                break;
        case FALLING:
                s->show( 3 );
                break;
        default:
                s->show( 0 );
                break;
        }
        s->draw(_box.x,_box.y);
}

void Person::update()
{
        // Check that the person is still alive
        if( _health <= 0 )
        {       
                die();
                return;
        }
        
        _framesSinceShoot++;

        //If you had the chance to walljump, but moved away from the wall, you're now just falling
        /*if((_wallJump * _xVelocity) > 0)
        {
                _wallJump = 0;
                _jumping = true;
        }*/

        //if(_yVelocity > 0)
        //{
        //      //you are falling, you shouldn't be allowed to jump until you hit something
        //      _jumping = true;
        //}
        
        _box.x += (_xVelocity/Screen::FRAMERATE);
        CollisionHandler::instance()->checkCollision(this);
        _previousX = _box.x;

        
        _box.y += (_yVelocity/Screen::FRAMERATE);
        CollisionHandler::instance()->checkCollision(this);
        _previousY = _box.y;

        //A little bit of drag force
        if(_xVelocity != 0)
        {
                if(!touchingBelow())
                        incrVelocity((_xVelocity/abs(_xVelocity)) * _airDrag * 1000/Screen::FRAMERATE, 0);
                else
                        incrVelocity((_xVelocity/abs(_xVelocity)) * _groundDrag * 1000/Screen::FRAMERATE, 0);
        }
        //_yVelocity -= _yVelocity *0.3;

        // breakVel is the least amount of velocity the person can have 
        // before moving at least 1 pixel
        int breakVel = Screen::FRAMERATE;
        if( abs(_yVelocity) < breakVel )
        {
                if( _state != JUMPING )
                        _state = STANDING;
        } else if( _yVelocity < -breakVel )
        {
                _state = JUMPING;
        } else if( _yVelocity > breakVel )
        {
                _state = FALLING;
        }

        incrVelocity(0,_gravity * 1000/Screen::FRAMERATE);
}

void Person::incrVelocity(int xVel, int yVel)
{
        if(abs(_xVelocity + xVel) < _maxXVel)
                _xVelocity += xVel;
        else
                _xVelocity < 0 ? _xVelocity = -_maxXVel : _xVelocity = _maxXVel;


        if(abs(_yVelocity + yVel) < _maxFallRate)
                _yVelocity += yVel;
        else
                _yVelocity < 0 ? _yVelocity = -_maxFallRate : _yVelocity = _maxFallRate; 
}

int Person::getAccel()
{
        if(!touchingBelow())
                return _airAccel;

        return _accel;
}

void Person::jump(xDirection xDir)
{
        //Don't allow player or scripts to jump if they are already jumping.
        /*if(!_jumping && _jumpReset)
        {
                //If you're jumping straight off the ground
                if(_wallJump == 0)
                {
                        
                }
                //If you're jumping off of some wall
                else if(_wallJump/abs(_wallJump) == xDir)
                {
                        _xVelocity = _wallJump * .8 * _maxXVel;
                        _yVelocity = -.9 * _maxYVel;
                }
                _jumping = true;
                _jumpTimer = 0;
                _jumpReset = false;
        }
        else if(_jumping && _jumpTimer < _maxJumpTime && _wallJump == 0)
        {
                _yVelocity = -_maxYVel;
                _jumpTimer ++;
        }*/

        //we're on top of something, we can jump
        if( touchingBelow() && _jumpReset )
        {
                _yVelocity = -_maxYVel;
                //_jumping = true;
                _jumpTimer = 0;
                _jumpReset = false;
                _wallJumpReset = false;
        }
        // we're touching a wall and have changed direction in the last timestep.
        // we can walljump
        else if(  (_wallJumpReset&& _xDirection == RIGHT && _prevXDirection == LEFT && touchingLeft() ) 
                        ||(_wallJumpReset && _xDirection == LEFT && _prevXDirection == RIGHT && touchingRight() )
                        )
        {
                _xVelocity = (int)_xDirection * .8 * _maxXVel;
                _yVelocity = -.9 * _maxYVel;
                _jumpReset = false;
                _wallJumpReset = false;
        }
        else if(!_jumpReset && _jumpTimer < _maxJumpTime)
        {
                _yVelocity = -_maxYVel;
                _jumpTimer ++;
        }

}

void Person::jumpReset()
{
        _jumpReset = true;
        _wallJumpReset = true;
        _jumpTimer = _maxJumpTime;
}

void Person::shoot()
{
        
        if(_framesSinceShoot >= _waitShoot)
        {
                Level::instance()->registerObject( new Bullet( this, _bulletSpeed, _xDirection, _yDirection ) );
                _framesSinceShoot = 0;
        }
}

void Person::crouch()
{
        _crouching = true;
        _box.h /= 2;
        _box.y += _box.h;
        _sprite->setHeight( _box.h );
}
void Person::uncrouch()
{
        if( !touchingAbove())
        {
                _crouching = false;
                _box.y -= _box.h;
                _box.h *= 2;
                _sprite->setHeight( _box.h );
        }
}

void Person::die()
{
        _collidable = false;
        Level::instance()->scheduleDelete( this );
}


bool Person::touchingAbove()
{
        _box.y--;
        vector<Object *> objs = CollisionHandler::ObjsColliding( this );
        _box.y++;
        return !objs.empty();
}
bool Person::touchingBelow()
{
        _box.y++;
        vector<Object *> objs = CollisionHandler::ObjsColliding( this );
        _box.y--;
        return !objs.empty();
}
bool Person::touchingLeft()
{
        _box.x--;
        vector<Object *> objs = CollisionHandler::ObjsColliding( this );
        _box.x++;
        return !objs.empty();
}
bool Person::touchingRight()
{
        _box.x++;
        vector<Object *> objs = CollisionHandler::ObjsColliding( this );
        _box.x--;
        return !objs.empty();
}

---