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

        
#include "PacmanBrown.h"

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

        
        namespace orxonox{

                RegisterClass(PacmanBrown);

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

        RegisterObject(PacmanBrown);

        this->target_x=0;
        this->target_z=15;
        this->lastPlayerPassedPoint=Vector3(0,0,0); //Vector3(70,10,-135);
          
    }

    /**
    @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){


        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();


        for(int u=0; u < 67; u++){//always check if player passed a point
            if(jeanfindpos(this->getPlayerPos(), possibleposition[u])){
            this->lastPlayerPassedPoint=possibleposition[u];
                    }
            }

        
        //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);
            }
        }
        else if(this->lastPlayerPassedPoint==Vector3(0,0,0)){
            //as long as the player has not started the game,
            //i.e. lastPlayerPastPoint is (0,0,0), brown pacman
            //cannot possibly move, because it needs the position
            //of the player to move accordingly

            this->ismoving=false;
            std::cout<<"weie"<<endl;
        }
        
        //Check on which position the ghost has arrived and set new target
        else{
            std::cout<<"naye"<<endl;
                while(lockmove){};
            lockmove = true;

                //do brown behavior
                //put everything needed here

            Vector3 brownPos=Vector3(this->target_x, 10, this->target_z);
            std::cout<<brownPos<<endl;

            
            if(this->isFleeing==true){
                if(findpos(brownPos, Vector3(-215,10,-195))){
                    this->isFleeing=false;
                    //Vector3 nextMoveP = getShortestPath(brownPos, this->lastPlayerPassedPoint);
                    //this->setNewTargetGhost(nextMoveP);
                }
                else{
                    Vector3 nextMoveP = getShortestPath(brownPos, Vector3(-215,10,-195));
                    this->setNewTargetGhost(nextMoveP);
                }

            }
            else {
                    Vector3 arrayPlaNeig[4];

                    findNeighboorPositions(this->lastPlayerPassedPoint, arrayPlaNeig, possibleposition);
                    if(isAdjacentToPlayerLastPastPoint(brownPos, arrayPlaNeig)){
                        this->isFleeing=true;
                    }
                    else{
                        Vector3 nextMove = getShortestPath(brownPos, this->lastPlayerPassedPoint);        
                        setNewTargetGhost(nextMove);
                    }

            }
            std::cout<<this->isFleeing<<endl;


            /*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)&&(!findpos(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)&&(findpos(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->isFleeing){
                std::cout<<"fleeing"<<endl;
            }
        }*/




                /*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 !!!
   
        }
}


    bool PacmanBrown::isAdjacentToPlayerLastPastPoint(Vector3 pacmanBrownPos, Vector3 arrayForNeighborPositions[]){
            //return true if brownPacman is on an adjacent position to the last
            //point visited by the player. return false otherwise.

            for(int i =0; i < 4; i++){
                if(arrayForNeighborPositions[i]!=Vector3(0,0,0)){
                    if(findpos(pacmanBrownPos, arrayForNeighborPositions[i])){
                        return true;
                    }
                }
            }
            return false;
        }



        void PacmanBrown::findNeighboorPositions(Vector3 actuelposition, Vector3 adjacentPositions[], Vector3 positionArray[]){      
            //this function should put in adjacentPosition[] the neighboors of lastPlayerPastPoint

            if(findpos(actuelposition,possibleposition[0])){
                

                adjacentPositions[0]=positionArray[1]; //graphVertex(possibleposition[1]);  //need to do it everywhere !!!
                adjacentPositions[1]=positionArray[17]; //graphVertex(possibleposition[17]);
                adjacentPositions[2]=positionArray[19]; //graphVertex(possibleposition[19]); //maybe a vector would be more suitable ?
            }
            else if(findpos(actuelposition,possibleposition[1])){
                adjacentPositions[0]=positionArray[0]; //graphVertex(possibleposition[0]);
                adjacentPositions[1]=positionArray[2]; //graphVertex(possibleposition[2]);
            }
            else if(findpos(actuelposition,possibleposition[2])){
                adjacentPositions[0]=positionArray[1]; //graphVertex(possibleposition[1]);
                adjacentPositions[1]=positionArray[3]; //graphVertex(possibleposition[3]);
            }
            else if(findpos(actuelposition,possibleposition[3])){
                adjacentPositions[0]=positionArray[2]; //graphVertex(possibleposition[2]);
                adjacentPositions[1]=positionArray[4]; //graphVertex(possibleposition[4]);
                adjacentPositions[2]=positionArray[5]; //graphVertex(possibleposition[5]);
            }
            else if(findpos(actuelposition,possibleposition[4])){
                adjacentPositions[0]=positionArray[3]; //graphVertex(possibleposition[3]);
                adjacentPositions[1]=positionArray[6]; //graphVertex(possibleposition[6]);
            }
            else if(findpos(actuelposition,possibleposition[5])){
                adjacentPositions[0]=positionArray[3]; //graphVertex(possibleposition[3]);
                adjacentPositions[1]=positionArray[7]; //graphVertex(possibleposition[7]);
            }
            else if(findpos(actuelposition,possibleposition[6])){
                adjacentPositions[0]=positionArray[4]; //graphVertex(possibleposition[4]);
                adjacentPositions[1]=positionArray[9]; //graphVertex(possibleposition[9]);
                adjacentPositions[2]=positionArray[26]; //graphVertex(possibleposition[26]);
            }
            else if(findpos(actuelposition,possibleposition[7])){
                adjacentPositions[0]=positionArray[5]; //graphVertex(possibleposition[5]);
                adjacentPositions[1]=positionArray[8]; //graphVertex(possibleposition[8]);
            }
            else if(findpos(actuelposition,possibleposition[8])){
                adjacentPositions[0]=positionArray[7]; //graphVertex(possibleposition[7]);
                adjacentPositions[1]=positionArray[9]; //graphVertex(possibleposition[9]);
            }
            else if(findpos(actuelposition,possibleposition[9])){
                adjacentPositions[0]=positionArray[6]; //graphVertex(possibleposition[6]);
                adjacentPositions[1]=positionArray[8]; //graphVertex(possibleposition[8]);
                adjacentPositions[2]=positionArray[10]; //graphVertex(possibleposition[10]);
                adjacentPositions[3]=positionArray[38]; //graphVertex(possibleposition[38]);
            }
            else if(findpos(actuelposition,possibleposition[10])){
                adjacentPositions[0]=positionArray[9]; //graphVertex(possibleposition[9]);
                adjacentPositions[1]=positionArray[11]; //graphVertex(possibleposition[11]);
                adjacentPositions[2]=positionArray[45]; //graphVertex(possibleposition[45]);
            }
            else if(findpos(actuelposition,possibleposition[11])){
                adjacentPositions[0]=positionArray[10]; //graphVertex(possibleposition[10]);
                adjacentPositions[1]=positionArray[12]; //graphVertex(possibleposition[12]);
                adjacentPositions[2]=positionArray[13]; //graphVertex(possibleposition[13]);
            }
            else if(findpos(actuelposition,possibleposition[12])){
                adjacentPositions[0]=positionArray[11]; //graphVertex(possibleposition[11]);
                adjacentPositions[1]=positionArray[14]; //graphVertex(possibleposition[14]);
            }
            else if(findpos(actuelposition,possibleposition[13])){
                adjacentPositions[0]=positionArray[11]; //graphVertex(possibleposition[11]);
                adjacentPositions[1]=positionArray[14]; //graphVertex(possibleposition[14]);
                adjacentPositions[2]=positionArray[16]; //graphVertex(possibleposition[16]);
                adjacentPositions[3]=positionArray[61]; //graphVertex(possibleposition[61]);
            }
            else if(findpos(actuelposition,possibleposition[14])){
                adjacentPositions[0]=positionArray[12]; //graphVertex(possibleposition[12]);
                adjacentPositions[1]=positionArray[13]; //graphVertex(possibleposition[13]);
                adjacentPositions[2]=positionArray[15]; //graphVertex(possibleposition[15]);
            }
            else if(findpos(actuelposition,possibleposition[15])){
                adjacentPositions[0]=positionArray[14]; //graphVertex(possibleposition[14]);
                adjacentPositions[1]=positionArray[16]; //graphVertex(possibleposition[16]);
            }
            else if(findpos(actuelposition,possibleposition[16])){
                adjacentPositions[0]=positionArray[13]; //graphVertex(possibleposition[13]);
                adjacentPositions[1]=positionArray[15]; //graphVertex(possibleposition[15]);
                adjacentPositions[2]=positionArray[62]; //graphVertex(possibleposition[62]);
            }
            else if(findpos(actuelposition,possibleposition[17])){
                adjacentPositions[0]=positionArray[0]; //graphVertex(possibleposition[0]);
                adjacentPositions[1]=positionArray[25]; //graphVertex(possibleposition[25]);
            }
            else if(findpos(actuelposition,possibleposition[18])){
                adjacentPositions[0]=positionArray[19]; //graphVertex(possibleposition[19]);
                adjacentPositions[1]=positionArray[24]; //graphVertex(possibleposition[24]);                
            }
            else if(findpos(actuelposition,possibleposition[19])){
                adjacentPositions[0]=positionArray[0]; //graphVertex(possibleposition[0]);
                adjacentPositions[1]=positionArray[18]; //graphVertex(possibleposition[18]);
                adjacentPositions[2]=positionArray[20]; //graphVertex(possibleposition[20]);
                         }
            else if(findpos(actuelposition,possibleposition[20])){
                adjacentPositions[0]=positionArray[19]; //graphVertex(possibleposition[19]);
                adjacentPositions[1]=positionArray[21]; //graphVertex(possibleposition[21]);
                       }
            else if(findpos(actuelposition,possibleposition[21])){
                adjacentPositions[0]=positionArray[20]; //graphVertex(possibleposition[20]);
                adjacentPositions[1]=positionArray[22]; //graphVertex(possibleposition[22]);
                       }
            else if(findpos(actuelposition,possibleposition[22])){
                adjacentPositions[0]=positionArray[21]; //graphVertex(possibleposition[21]);
                adjacentPositions[1]=positionArray[23]; //graphVertex(possibleposition[23]);
                adjacentPositions[2]=positionArray[31]; //graphVertex(possibleposition[31]);
                          }
            else if(findpos(actuelposition,possibleposition[23])){
                adjacentPositions[0]=positionArray[22]; //graphVertex(possibleposition[22]);
                adjacentPositions[1]=positionArray[30]; //graphVertex(possibleposition[30]);
                       }
            else if(findpos(actuelposition,possibleposition[24])){
                adjacentPositions[0]=positionArray[18]; //graphVertex(possibleposition[18]);
                adjacentPositions[1]=positionArray[29]; //graphVertex(possibleposition[29]);
                       }
            else if(findpos(actuelposition,possibleposition[25])){
                adjacentPositions[0]=positionArray[17]; //graphVertex(possibleposition[17]);
                adjacentPositions[1]=positionArray[26]; //graphVertex(possibleposition[26]);
                       }
            else if(findpos(actuelposition,possibleposition[26])){
                adjacentPositions[0]=positionArray[6]; //graphVertex(possibleposition[6]);
                adjacentPositions[1]=positionArray[25]; //graphVertex(possibleposition[25]);
                adjacentPositions[2]=positionArray[27]; //graphVertex(possibleposition[27]);
                         }
            else if(findpos(actuelposition,possibleposition[27])){
                adjacentPositions[0]=positionArray[26]; //graphVertex(possibleposition[26]);
                adjacentPositions[1]=positionArray[28]; //graphVertex(possibleposition[28]);
                adjacentPositions[2]=positionArray[37]; //graphVertex(possibleposition[37]);
                          }
            else if(findpos(actuelposition,possibleposition[28])){
                adjacentPositions[0]=positionArray[27]; //graphVertex(possibleposition[27]);
                adjacentPositions[1]=positionArray[29]; //graphVertex(possibleposition[29]);
                adjacentPositions[2]=positionArray[36]; //graphVertex(possibleposition[36]);
                          }
            else if(findpos(actuelposition,possibleposition[29])){
                adjacentPositions[0]=positionArray[24]; //graphVertex(possibleposition[24]);
                adjacentPositions[1]=positionArray[28]; //graphVertex(possibleposition[28]);
                adjacentPositions[2]=positionArray[30]; //graphVertex(possibleposition[30]);
                          }
            else if(findpos(actuelposition,possibleposition[30])){
                adjacentPositions[0]=positionArray[23]; //graphVertex(possibleposition[23]);
                adjacentPositions[1]=positionArray[29]; //graphVertex(possibleposition[29]);
                adjacentPositions[2]=positionArray[34]; //graphVertex(possibleposition[34]);
                          }
            else if(findpos(actuelposition,possibleposition[31])){
                adjacentPositions[0]=positionArray[22]; //graphVertex(possibleposition[22]);
                adjacentPositions[1]=positionArray[32]; //graphVertex(possibleposition[32]);
                       }
            else if(findpos(actuelposition,possibleposition[32])){
                adjacentPositions[0]=positionArray[31]; //graphVertex(possibleposition[31]);
                adjacentPositions[1]=positionArray[33]; //graphVertex(possibleposition[33]);
                       }
            else if(findpos(actuelposition,possibleposition[33])){
                adjacentPositions[0]=positionArray[32]; //graphVertex(possibleposition[32]);
                adjacentPositions[1]=positionArray[34]; //graphVertex(possibleposition[34]);
                       }
            else if(findpos(actuelposition,possibleposition[34])){
                adjacentPositions[0]=positionArray[30]; //graphVertex(possibleposition[30]);
                adjacentPositions[1]=positionArray[33]; //graphVertex(possibleposition[33]);
                adjacentPositions[2]=positionArray[35]; //graphVertex(possibleposition[35]);
                adjacentPositions[3]=positionArray[42]; //graphVertex(possibleposition[42]);
                
            }
            else if(findpos(actuelposition,possibleposition[35])){
                adjacentPositions[0]=positionArray[34]; //graphVertex(possibleposition[34]);
                adjacentPositions[1]=positionArray[36]; //graphVertex(possibleposition[36]);
                adjacentPositions[2]=positionArray[41]; //graphVertex(possibleposition[41]);
                          }
            else if(findpos(actuelposition,possibleposition[36])){
                adjacentPositions[0]=positionArray[28]; //graphVertex(possibleposition[28]);
                adjacentPositions[1]=positionArray[35]; //graphVertex(possibleposition[35]);
                       }
            else if(findpos(actuelposition,possibleposition[37])){
                adjacentPositions[0]=positionArray[27]; //graphVertex(possibleposition[27]);
                adjacentPositions[1]=positionArray[38]; //graphVertex(possibleposition[38]);
                       }
            else if(findpos(actuelposition,possibleposition[38])){
                adjacentPositions[0]=positionArray[9]; //graphVertex(possibleposition[9]);
                adjacentPositions[1]=positionArray[37]; //graphVertex(possibleposition[37]);
                adjacentPositions[2]=positionArray[39]; //graphVertex(possibleposition[39]);
                         }
            else if(findpos(actuelposition,possibleposition[39])){
                adjacentPositions[0]=positionArray[38]; //graphVertex(possibleposition[38]);
                adjacentPositions[1]=positionArray[40]; //graphVertex(possibleposition[40]);
                adjacentPositions[2]=positionArray[45]; //graphVertex(possibleposition[45]);
                          }
            else if(findpos(actuelposition,possibleposition[40])){
                adjacentPositions[0]=positionArray[39]; //graphVertex(possibleposition[39]);
                adjacentPositions[1]=positionArray[41]; //graphVertex(possibleposition[41]);
            }
            else if(findpos(actuelposition,possibleposition[41])){
                adjacentPositions[0]=positionArray[35]; //graphVertex(possibleposition[35]);
                adjacentPositions[1]=positionArray[43]; //graphVertex(possibleposition[43]);
                       }
            else if(findpos(actuelposition,possibleposition[42])){
                adjacentPositions[0]=positionArray[34]; //graphVertex(possibleposition[34]);
                adjacentPositions[1]=positionArray[43]; //graphVertex(possibleposition[43]);
                adjacentPositions[2]=positionArray[54]; //graphVertex(possibleposition[54]);
                          }
            else if(findpos(actuelposition,possibleposition[43])){
                adjacentPositions[0]=positionArray[41]; //graphVertex(possibleposition[41]);
                adjacentPositions[1]=positionArray[46]; //graphVertex(possibleposition[46]);
                       }
            else if(findpos(actuelposition,possibleposition[44])){
                adjacentPositions[0]=positionArray[40]; //graphVertex(possibleposition[40]);
                adjacentPositions[1]=positionArray[66]; //graphVertex(possibleposition[66]);
                       }
            else if(findpos(actuelposition,possibleposition[45])){
                adjacentPositions[0]=positionArray[10]; //graphVertex(possibleposition[10]);
                adjacentPositions[1]=positionArray[39]; //graphVertex(possibleposition[39]);
                adjacentPositions[2]=positionArray[49]; //graphVertex(possibleposition[49]);
                          }
            else if(findpos(actuelposition,possibleposition[46])){
                adjacentPositions[0]=positionArray[43]; //graphVertex(possibleposition[43]);
                adjacentPositions[1]=positionArray[47]; //graphVertex(possibleposition[47]);
                       }
            else if(findpos(actuelposition,possibleposition[47])){
                adjacentPositions[0]=positionArray[46]; //graphVertex(possibleposition[46]);
                adjacentPositions[1]=positionArray[52]; //graphVertex(possibleposition[52]);
                adjacentPositions[2]=positionArray[66]; //graphVertex(possibleposition[66]);
                          }
            else if(findpos(actuelposition,possibleposition[48])){
                adjacentPositions[0]=positionArray[49]; //graphVertex(possibleposition[49]);
                adjacentPositions[1]=positionArray[51]; //graphVertex(possibleposition[51]);
                adjacentPositions[2]=positionArray[66]; //graphVertex(possibleposition[66]);
                          }
            else if(findpos(actuelposition,possibleposition[49])){
                adjacentPositions[0]=positionArray[45]; //graphVertex(possibleposition[45]);
                adjacentPositions[1]=positionArray[48]; //graphVertex(possibleposition[48]);
                       }
            else if(findpos(actuelposition,possibleposition[50])){
                adjacentPositions[0]=positionArray[51]; //graphVertex(possibleposition[51]);
                adjacentPositions[1]=positionArray[61]; //graphVertex(possibleposition[61]);
                       }
            else if(findpos(actuelposition,possibleposition[51])){
                adjacentPositions[0]=positionArray[48]; //graphVertex(possibleposition[48]);
                adjacentPositions[1]=positionArray[50]; //graphVertex(possibleposition[50]);
                       }
            else if(findpos(actuelposition,possibleposition[52])){
                adjacentPositions[0]=positionArray[47]; //graphVertex(possibleposition[47]);
                adjacentPositions[1]=positionArray[53]; //graphVertex(possibleposition[53]);
                       }
            else if(findpos(actuelposition,possibleposition[53])){
                adjacentPositions[0]=positionArray[52]; //graphVertex(possibleposition[52]);
                adjacentPositions[1]=positionArray[58]; //graphVertex(possibleposition[58]);
                       }
            else if(findpos(actuelposition,possibleposition[54])){
                adjacentPositions[0]=positionArray[42]; //graphVertex(possibleposition[42]);
                adjacentPositions[1]=positionArray[55]; //graphVertex(possibleposition[55]);
                adjacentPositions[2]=positionArray[57]; //graphVertex(possibleposition[57]);
                          }
            else if(findpos(actuelposition,possibleposition[55])){
                adjacentPositions[0]=positionArray[54]; //graphVertex(possibleposition[54]);
                adjacentPositions[1]=positionArray[56]; //graphVertex(possibleposition[56]);
                       }
            else if(findpos(actuelposition,possibleposition[56])){
                adjacentPositions[0]=positionArray[55]; //graphVertex(possibleposition[55]);
                adjacentPositions[1]=positionArray[57]; //graphVertex(possibleposition[57]);
                adjacentPositions[2]=positionArray[65]; //graphVertex(possibleposition[65]);
                          }
            else if(findpos(actuelposition,possibleposition[57])){
                adjacentPositions[0]=positionArray[54]; //graphVertex(possibleposition[54]);
                adjacentPositions[1]=positionArray[56]; //graphVertex(possibleposition[56]);
                adjacentPositions[2]=positionArray[58]; //graphVertex(possibleposition[58]);
                adjacentPositions[3]=positionArray[64]; //graphVertex(possibleposition[64]);
                
            }
            else if(findpos(actuelposition,possibleposition[58])){
                adjacentPositions[0]=positionArray[53]; //graphVertex(possibleposition[53]);
                adjacentPositions[1]=positionArray[57]; //graphVertex(possibleposition[57]);
                adjacentPositions[2]=positionArray[59]; //graphVertex(possibleposition[59]);
                          }
            else if(findpos(actuelposition,possibleposition[59])){
                adjacentPositions[0]=positionArray[58]; //graphVertex(possibleposition[58]);
                adjacentPositions[1]=positionArray[59]; //graphVertex(possibleposition[59]);
                adjacentPositions[2]=positionArray[63]; //graphVertex(possibleposition[63]);
                          }
            else if(findpos(actuelposition,possibleposition[60])){
                adjacentPositions[0]=positionArray[59]; //graphVertex(possibleposition[59]);
                adjacentPositions[1]=positionArray[61]; //graphVertex(possibleposition[61]);
                adjacentPositions[2]=positionArray[62]; //graphVertex(possibleposition[62]);
                          }
            else if(findpos(actuelposition,possibleposition[61])){
                adjacentPositions[0]=positionArray[13]; //graphVertex(possibleposition[13]);
                adjacentPositions[1]=positionArray[50]; //graphVertex(possibleposition[50]);
                adjacentPositions[2]=positionArray[60]; //graphVertex(possibleposition[60]);
                          }
            else if(findpos(actuelposition,possibleposition[62])){
                adjacentPositions[0]=positionArray[16]; //graphVertex(possibleposition[16]);
                adjacentPositions[1]=positionArray[60]; //graphVertex(possibleposition[60]);
                       }
            else if(findpos(actuelposition,possibleposition[63])){
                adjacentPositions[0]=positionArray[59]; //graphVertex(possibleposition[59]);
                adjacentPositions[1]=positionArray[64]; //graphVertex(possibleposition[64]);
                       }
            else if(findpos(actuelposition,possibleposition[64])){
                adjacentPositions[0]=positionArray[57]; //graphVertex(possibleposition[57]);
                adjacentPositions[1]=positionArray[63]; //graphVertex(possibleposition[63]);
                adjacentPositions[2]=positionArray[65]; //graphVertex(possibleposition[65]);
                          }
            else if(findpos(actuelposition,possibleposition[65])){
                adjacentPositions[0]=positionArray[56]; //graphVertex(possibleposition[56]);
                adjacentPositions[1]=positionArray[64]; //graphVertex(possibleposition[64]);
                       }
            else if(findpos(actuelposition,possibleposition[66])){
                adjacentPositions[0]=positionArray[47]; //graphVertex(possibleposition[47]);
                adjacentPositions[1]=positionArray[48]; //graphVertex(possibleposition[48]);
                       }
    }



}









        /*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;

    }*/