source: code/branches/3DPacman_FS19/src/modules/pacman/PacmanBrown.cc @ 12320

        
#include "PacmanBrown.h"

#include "core/CoreIncludes.h"
#include "BulletDynamics/Dynamics/btRigidBody.h"

        
        namespace orxonox{

                RegisterClass(PacmanBrown);

                PacmanBrown::PacmanBrown(Context* context) : PacmanGhost(context){

        RegisterObject(PacmanBrown);
          
    }

    /**
    @brief
        Method for creating a ghost through XML.
    */
    void PacmanBrown::XMLPort(Element& xmlelement, XMLPort::Mode mode)
    {
        SUPER(PacmanBrown, XMLPort, xmlelement, mode);
    }


int PacmanBrown::absoluteDistance(Vector3 pos1, Vector3 pos2){


        Ogre::Vector3 diffVector;
        diffVector.x=pos2.x-pos1.x;
        diffVector.y=pos2.y-pos1.y; //should always be 0
        diffVector.z=pos2.z-pos1.z;
        int result = sqrt((diffVector.x)*(diffVector.x)+(diffVector.z)*(diffVector.z));
        return result;
    }


        void PacmanBrown::tick(float dt)
    {
        SUPER(PacmanGhost, tick, dt);

        this->actuelposition = this->getPosition();
        
        //Stop, if target arrived
        if((abs(this->actuelposition.x - this->target_x)<0.5) && (abs(this->actuelposition.z - this->target_z)<0.5)){
                 this->ismoving = false;
        }

        //Move, if ghost hasn't arrived yet
        if(this->ismoving){
            if(!(abs(this->actuelposition.z-target_z)<0.5)) {
                velocity = Vector3(0,0,-sgn(this->actuelposition.z-this->target_z));
                move(dt, actuelposition, velocity);
            }    
            if(!(abs(this->actuelposition.x-target_x)<0.5)){
                velocity = Vector3(-sgn(this->actuelposition.x-this->target_x),0,0);
                move(dt, actuelposition, velocity);
            }
        }
        
        //Check on which position the ghost has arrived and set new target
        else{

                while(lockmove){};
            lockmove = true;

                //do brown behavior
                //put everything needed here

            Vector3 brownPos=Vector3(this->target_x, 10, this->target_z);

            if(absoluteDistance(this->lastPlayerPassedPoint, this->actuelposition)<50){
                //no idea if 50 is large enough 

                //if near player, flee

                this->isFleeing=true;
                Vector3 nextMove=getShortestPath( brownPos,Vector3(-215, 10, -195));
                setNewTargetGhost(nextMove);

            }

            else if((this->isFleeing==true)&&(brownPos!=Vector3(-215,10,-195))){
                //if fleeing, continue to flee
             Vector3 nextMove = getShortestPath(brownPos, Vector3(-215, 10, -195));
             setNewTargetGhost(nextMove);
        }
            else if ((this->isFleeing==true)&&(brownPos==Vector3(-215,10,-195))){
                //if fleeing and reached flee point, go back near player
            this->isFleeing=false;
            Vector3 nextMove = getShortestPath(brownPos, this->lastPlayerPassedPoint);
            setNewTargetGhost(nextMove);
        }
            else{
                //if not fleeing and not near player, go near player
                Vector3 nextMove = getShortestPath(brownPos, this->lastPlayerPassedPoint);
            setNewTargetGhost(nextMove);
            }
        }




                /*if((this->fleeing==true)&&(this->actuelposition!=(-215,10,-195))){
            //if fleeing, then go to corner map if not already there
                        fleeMode();
                }
                else{ // else go next to pacman

                        if(absoluteDistance(this->pos, player.pos)<10){//no idea if 10 ok
                //if near player, flee away
                fleemode();
                                }
                        else{ //go to neighboor of player nearest to brown pacman

                        //first find nearest neighboor point of player to brown pacman
                        //we can maybe call getShortestPath recursively to do so

player.pos.nearestneighboor=findPlayerNeighboorNearestToPacman(player.neighboors);
//btw the array player.neighboor can be defined with a big list as we
//already did several times for similar things

                Vector3 nextMove = getShortestPath(this->actuelposition, player.pos.nearestneighboor);
                setNewTargetBrown(nextMove);
                        }

                }*/
            lockmove=false; //NEVER FORGET THIS ONE !!!
   
        }
    }



    













        /*int graphDistance(Vector3 start, Vector3 goal){

        Vector3 differenceVector= Vector3(abs(goal.x-start.x), 0,abs(goal.z-start.z));

        return differenceVector.x+differenceVector.z;
    }*/

        /*void setNewTargetBrown(Vector3 goalToGo){

                                        this->target_x = goalToGo.x;
                    this->target_z = goalToGo.z; 
                    this->ismoving = true;
        }*/



        /*int PacmanBrown::absoluteDistance(Vector3 pos1, Vector3 pos2){


                Vector3 diffVector;
                diffVector.x=pos2-pos1;
                diffVector.y=pos2-pos1; //should always be 0
                diffVector.z=pos2-pos1;
                int result = sqrt((diffVector.x)*(diffVector.x)+(diffVector.z)*(diffVector.z));
                return result;
        }*/


        /*void fleeMode(){ //flees to corner of the map

                Vector3 cornerPos = Vector3(-215,10,-195); //let's take this. We can still change
                Vector3 nextMove = getShortestPath(this->actuelposition, cornerPos);
                setNewTargetGhost(nextMove);

                //while(this->actuelposition!=cornerPos){
        
                continue moving and each time find next point to go until
                we reach the corner
                }
        }*/


        /*Vector3 goAdjacentOfPlayer(Vector neighboorsOfPlayer[]){
                //find ,nearest to brown, player neighboor 

                int besTotDist=-1;
                Vector3 curPos=this->pos;
                Vector3  predPos;
                Vector3 chosenNeighbor;

                for(int i=0; i < 4; i++){
                        int totDist=0;

                        if(neighboorsOfPlayer[i]!=0){
                                while(curPos!=neighboorsOfPlayer[i]){

                                        predPos=curPos;
                                        curPos = getShortestPath(curPos, neighboorsOfPlayer[i]);
                                        totDist+=graphDistance(curPos,predPos);

                                }
                        }

                        if(besTotDist==-1){
                                besTotDist=totDist;
                                chosenNeighbor=neighboorsOfPlayer[i];
                        }
                        else if(besTotDist>totDist){
                                besTotDist=totDist;
                                chosenNeighbor=neighboorsOfPlayer[i];
                        }
                }
                return chosenNeighbor;

        }*/


        /*Vector3 findPlayerNeighboorNearestToPacman(Vector3 neighboorArray[]){
                //uh, i think it does the same think as the function above

        Vector3 nextMove;
        int distCost=-1;
        for(int i=0; i < 4; i++){
                int totDist=0;
                Vector3 newCandidate=this->actuelposition;
                Vector3 predPos;

            if(neighboorArray[i]!=NULL){
                while(nextMove!=neighboorArray[i]){
                        predPos=newCandidate;
                        newCandidate=getShortestPath(newCandidate, neighboorArray[i]);
                        totDist+=graphDistance(predPos, newCandidate);
                    }

                    if(distCost==-1){
                distCost=totDist;
                nextMove=gneighboorArray[i];
                    }
                    else if(totDist<distCost){
                distCost=totDist;
                nextMove=neighboorArray[i];
                    }
            }
        }
        return nextMove;

    }*/