Player.cpp

Go to the documentation of this file.

#include "Player.h"
#include "Game.h"

Player::Player(string filename):useJoystick(false), mKeyMaps(), mJoyButtonMaps(), mJoyStickMaps()
{
        mInput = Input::getInput();
        //*

        //set up default hotkeys
        vector<SDLKey> keys = vector<SDLKey>();
        vector<JoyButton> joyButtons = vector<JoyButton>();
        vector<JoyStick> joySticks = vector<JoyStick>();
        //movement
        if(!useJoystick){
                keys.push_back(SDLK_w);
                mKeyMaps[MoveUp] = keys; keys.clear();
                keys.push_back(SDLK_s);
                mKeyMaps[MoveDown] = keys; keys.clear();
                keys.push_back(SDLK_a);
                mKeyMaps[MoveLeft] = keys; keys.clear();
                keys.push_back(SDLK_d);
                mKeyMaps[MoveRight] = keys; keys.clear();
        }
        else{
                joySticks.push_back(JoyLeft);//joystick JoyLeft is left
                mJoyStickMaps[MoveUp] = joySticks; joySticks.clear();
                joySticks.push_back(JoyLeft);//joystick JoyLeft is left
                mJoyStickMaps[MoveDown] = joySticks; joySticks.clear();
                joySticks.push_back(JoyLeft);//joystick JoyLeft is left
                mJoyStickMaps[MoveLeft] = joySticks; joySticks.clear();
                joySticks.push_back(JoyLeft);//joystick JoyLeft is left
                mJoyStickMaps[MoveRight] = joySticks; joySticks.clear();
        }
        //cursor
        if(!useJoystick){
                keys.push_back(SDLK_UP);
                mKeyMaps[CursorUp] = keys; keys.clear();
                keys.push_back(SDLK_DOWN);
                mKeyMaps[CursorDown] = keys; keys.clear();
                keys.push_back(SDLK_LEFT);
                mKeyMaps[CursorLeft] = keys; keys.clear();
                keys.push_back(SDLK_RIGHT);
                mKeyMaps[CursorRight] = keys; keys.clear();
        }
        else{
                joySticks.push_back(JoyRight);//joystick JoyRight is left
                mJoyStickMaps[CursorUp] = joySticks; joySticks.clear();
                joySticks.push_back(JoyRight);//joystick JoyRight is left
                mJoyStickMaps[CursorDown] = joySticks; joySticks.clear();
                joySticks.push_back(JoyRight);//joystick JoyRight is left
                mJoyStickMaps[CursorLeft] = joySticks; joySticks.clear();
                joySticks.push_back(JoyRight);//joystick JoyRight is left
                mJoyStickMaps[CursorRight] = joySticks; joySticks.clear();
        }
        //yes/no
        if(!useJoystick){
                keys.push_back(SDLK_RETURN);
                keys.push_back(SDLK_j);
                mKeyMaps[Accept] = keys; keys.clear();
                keys.push_back(SDLK_ESCAPE);
                keys.push_back(SDLK_k);
                mKeyMaps[Deny] = keys; keys.clear();
        }
        else{
                joyButtons.push_back(A);
                joyButtons.push_back(Start);
                mJoyButtonMaps[Accept] = joyButtons; joyButtons.clear();
                joyButtons.push_back(B);
                
                mJoyButtonMaps[Deny] = joyButtons; joyButtons.clear();
        }
        //esc
        if(!useJoystick){
                keys.push_back(SDLK_ESCAPE);
                keys.push_back(SDLK_k);
                mKeyMaps[Esc] = keys; keys.clear();
        }
        else{
                joyButtons.push_back(Select);
                mJoyButtonMaps[OpenMenu] = joyButtons; joyButtons.clear();
        }
        //menu
        if(!useJoystick){
                keys.push_back(SDLK_RETURN);
                keys.push_back(SDLK_ESCAPE);
                mKeyMaps[OpenMenu] = keys; keys.clear();
        }
        else{
        }
        //hotkeys
        if(!useJoystick){
                keys.push_back(SDLK_j);
                mKeyMaps[Action] = keys; keys.clear();
                keys.push_back(SDLK_k);
                mKeyMaps[HotKey1] = keys; keys.clear();
                keys.push_back(SDLK_l);
                mKeyMaps[HotKey2] = keys; keys.clear();
                keys.push_back(SDLK_SEMICOLON);
                mKeyMaps[HotKey3] = keys; keys.clear();
                keys.push_back(SDLK_1);
                mKeyMaps[HotKey4] = keys; keys.clear();
                keys.push_back(SDLK_2);
                mKeyMaps[HotKey5] = keys; keys.clear();
                keys.push_back(SDLK_3);
                mKeyMaps[HotKey6] = keys; keys.clear();
                keys.push_back(SDLK_4);
                mKeyMaps[HotKey7] = keys; keys.clear();
                keys.push_back(SDLK_5);
                mKeyMaps[HotKey8] = keys; keys.clear();
                keys.push_back(SDLK_6);
                mKeyMaps[HotKey9] = keys; keys.clear();
                keys.push_back(SDLK_7);
                mKeyMaps[HotKey10] = keys; keys.clear();
                keys.push_back(SDLK_8);
                mKeyMaps[HotKey11] = keys; keys.clear();
        }
        else{
        }
        //*/
}

Player::Player(map<Player::InputAction, vector<SDLKey>> mKeyMaps)
{
        mKeyMaps = mKeyMaps;
}

Player::Player(map<Player::InputAction, vector<JoyStick>> joyMaps, map<Player::InputAction, vector<JoyButton>> buttonMaps, int moveJoy )
{
        mJoyButtonMaps = buttonMaps;
        mJoyStickMaps = joyMaps;
}

void Player::Control(WorldObject* wo){
        mObjects.push_back(wo);
}

void Player::RemoveControl(WorldObject* wo){
        foritr(obj, mObjects){
                if(*obj==wo){
                        mObjects.erase(obj);
                }
        }
}

void Player::RemoveControl(string woName){
        foritr(obj, mObjects){
                if((*obj)->getName()==woName){
                        mObjects.erase(obj);
                }
        }
}

WorldObject* Player::getObject(string name)
{
        for(unsigned int i = 0, size = mObjects.size(); i < size; i++){
                if (mObjects[i]->getName() == name){
                        return mObjects[i];
                }
        }

        return NULL;
}

WorldObject* Player::getObject(unsigned int index)
{
        return index < mObjects.size() ? mObjects[index] : NULL;
}

vector<WorldObject*> Player::getObjects()
{
        return mObjects;
}

vector<WorldObject*> Player::getObjects(string name, int count)
{
        vector<WorldObject*> objects = vector<WorldObject*>();

        for(unsigned int i=0; i < mObjects.size(); i++) {
                if(count > 0 && objects.size() == count)
                        return objects;
                if(mObjects[i]->getName() == name)
                        objects.push_back(mObjects[i]);
        }
        
        return objects;         //if a valid object wasn't found, return empty
}

Point2D Player::getAveragePosition()
{       
        Point2D sum;
        
        for (unsigned int i = 0, size = mObjects.size(); i < size; i++){
                sum += mObjects[i]->getPosition();
        }

        return ( sum / mObjects.size() );
}

Point2D Player::getAveragePosition(string name)
{       
        WorldObject* object = getObject(name);
        
        return object->getPosition();
}

Point2D Player::getAveragePosition(vector<int> indices)
{
        Point2D sum;

        for (unsigned int i = 0; i < indices.size(); i++){
                sum += mObjects[indices[i]]->getPosition();
        }

        return ( sum / indices.size() );
}

Point2D Player::getAveragePosition(vector<string> names)
{
        Point2D sum;
        int count = 0;

        for (unsigned int i = 0; i < names.size(); i++){
                vector<WorldObject*> objects = getObjects(names[i]);
                for (unsigned int j = 0; j < objects.size(); j++){
                        sum += objects[j]->getPosition();
                        count++;
                }
        }

        return ( sum / count);
}

void Player::setPosition(double x, double y)
{       
        Point2D centroid = getAveragePosition();
        double dx, dy;

        dx = x - centroid.x;
        dy = y - centroid.y;

        move(dx, dy);
}

void Player::setPosition(Point2D pos)
{
        Point2D centroid = getAveragePosition();
        double dx, dy;

        dx = pos.x - centroid.x;
        dy = pos.y - centroid.y;

        move(dx, dy);
}

void Player::move(double dx, double dy)
{       
        for(unsigned int i = 0, size = mObjects.size(); i < size; i++){
                mObjects[i]->move(dx, dy);
        }
}

void Player::move(Point2D direction)
{
        for(unsigned int i = 0, size = mObjects.size(); i < size; i++){
                mObjects[i]->move(direction);
        }
}

void Player::moveTowards(Point2D point)
{
        for(unsigned int i = 0, size = mObjects.size(); i < size; i++){
                mObjects[i]->moveTowards(point);
        }
}

void Player::setTransparency(float f)
{
        for (unsigned int i = 0, size = mObjects.size(); i < size; i++){
                mObjects[i]->setTransparency(f);
        }
}

void Player::changeTransparency(float df)
{       
        for (unsigned int i = 0, size = mObjects.size(); i < size; i++){
                float f = mObjects[i]->getTransparency() + df;

                mObjects[i]->setTransparency(f);
        }
}

bool Player::getAllPressed(Player::InputAction act)
{
        Level* l = Game::game()->getCurrentLevel();
        for(unsigned int i=0, end = l->getNumPlayers(); i < end; ++i){
                Player* p = l->getPlayer(i);
                if(p->pressed(act))
                        return true;
        }
        return false;
}

bool Player::getAllTriggered(Player::InputAction act, int ms)
{
        Level* l = Game::game()->getCurrentLevel();
        for(unsigned int i=0, end = l->getNumPlayers(); i < end; ++i){
                Player* p = l->getPlayer(i);
                if(p->triggered(act,ms))
                        return true;
        }
        return false;
}

Point2D Player::getAllMovement(Player::InputAction act)
{
        Point2D dir;
        Level* l = Game::game()->getCurrentLevel();
        for(unsigned int i=0, end = l->getNumPlayers(); i < end; ++i){
                Player* p = l->getPlayer(i);
                dir+= p->getMovement(act);
        }
        return dir;
}

bool Player::triggered(Player::InputAction act, int ms)
{
        bool retval = false;
        if(useJoystick){
                vector<JoyButton> vals = mJoyButtonMaps[act];
                for(unsigned int i=0, end = vals.size(); i<end;++i){
                        retval = retval || mInput->triggered(vals[i]);
                }
        }
        else{
                vector<SDLKey> vals = mKeyMaps[act];
                for(unsigned int i=0, end = vals.size(); i<end;++i){
                        retval = retval || mInput->triggered(vals[i]);
                }
        }
        return retval;
}

bool Player::doubleTapped(Player::InputAction act, int ms)
{
        bool retval = false;
        if(useJoystick){
                vector<JoyButton> vals = mJoyButtonMaps[act];
                for(unsigned int i=0, end = vals.size(); i<end;++i){
                        retval = retval || mInput->doubleTapped(vals[i]);
                }
        }
        else{
                vector<SDLKey> vals = mKeyMaps[act];
                for(unsigned int i=0, end = vals.size(); i<end;++i){
                        retval = retval || mInput->doubleTapped(vals[i]);
                }
        }
        return retval;
}

Point2D Player::getMovement(Player::InputAction act)
{
        if(useJoystick){
                return act==Move?mInput->getJoyMovement(JoyLeft):act==Cursor?mInput->getJoyMovement(JoyRight):mInput->getJoyMovement(DPad);
        }
        else{
                return act==Move?
                        Point2D(
                                pressed(MoveRight)?1:
                                pressed(MoveLeft)?-1:0,
                                pressed(MoveUp)?-1:
                                pressed(MoveDown)?1:0):
                        act==Cursor?
                        Point2D(
                                pressed(CursorRight)?1:
                                pressed(CursorLeft)?-1:0,
                                pressed(CursorUp)?-1:
                                pressed(CursorDown)?1:0):
                                Input::getMousePos();
        }
}

bool Player::pressed(InputAction act)
{
        bool retval = false;
        if(useJoystick){
                vector<JoyButton> vals = mJoyButtonMaps[act];
                for(int i=0,end=vals.size(); i<end;++i){
                        retval = retval || mInput->pressed(vals[i]);
                }
        }
        else{
                vector<SDLKey> vals = mKeyMaps[act];
                for(int i=0,end=vals.size(); i<end;++i){
                        retval = retval || mInput->pressed(vals[i]);
                }
        }
        return retval;
}