Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 12316


Ignore:
Timestamp:
Apr 20, 2019, 5:22:51 PM (2 months ago)
Author:
peterf
Message:

Red Pacman seems to work partially

Location:
code/branches/3DPacman_FS19/src/modules/pacman
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • code/branches/3DPacman_FS19/src/modules/pacman/CMakeLists.txt

    r12304 r12316  
    88  PacmanRandom.cc
    99  PacmanRed.cc
    10   getShortestPath.cc
    1110)
    1211
  • code/branches/3DPacman_FS19/src/modules/pacman/Pacman.cc

    r12313 r12316  
    7575
    7676
    77     PacmanGhost* ghosts[4];
     77    PacmanGhost* ghosts[8];
    7878
    7979
    8080    void Pacman::tick(float dt)
    8181    {
     82
    8283        SUPER(Pacman, tick, dt);
     84
    8385
    8486        //Needed for gameover
  • code/branches/3DPacman_FS19/src/modules/pacman/PacmanGhost.cc

    r12304 r12316  
    3535{
    3636
     37
     38    struct PacmanGhost::graphVertex {
     39
     40        public:
     41
     42            Vector3 position;
     43            graphVertex *adjacentVertices[4]; //neighbooring vertices
     44
     45            //would a vector of vector storing the neighboors not be more suitable ?
     46
     47            int shortestDistanceToStart; //actual shortest distance to start point
     48            graphVertex* actuelPredecessor; //the predecessor giving the for now shortest
     49                                            //path to start
     50            graphVertex* currentNearestNonVisitedNeighboor;
     51            bool alreadyVisited;
     52            graphVertex(){ //default constructor
     53                position=0;
     54                shortestDistanceToStart= std::numeric_limits<int>::max();
     55                actuelPredecessor=nullptr;
     56                alreadyVisited=false;
     57                for(int kl =0; kl <4;kl++){
     58                    adjacentVertices[kl]=nullptr;  //first put all position in array listing neighboors to 0
     59                }
     60            }
     61            graphVertex(Vector3 wantedPosition){  //normal constructor
     62                position=wantedPosition;
     63                shortestDistanceToStart= std::numeric_limits<int>::max(); //default distance is infinity
     64                actuelPredecessor=nullptr;
     65                alreadyVisited=false;
     66                for(int kl =0; kl <4;kl++){
     67                    adjacentVertices[kl]=nullptr;  //first put all position in array listing neighboors to 0
     68                }
     69            }
     70            graphVertex& operator = (const graphVertex &rightSide){
     71            this->position=rightSide.position;
     72    this->shortestDistanceToStart=rightSide.shortestDistanceToStart;
     73            this->actuelPredecessor=rightSide.actuelPredecessor;
     74    this->currentNearestNonVisitedNeighboor=rightSide.currentNearestNonVisitedNeighboor;
     75    this->alreadyVisited=rightSide.alreadyVisited;
     76   
     77            return *this;
     78        }
     79
     80        };
     81
     82
     83    static PacmanGhost::graphVertex listOfVertices[67];
     84
    3785    //Check if there is a collision
    3886        bool findpos(Vector3 one, Vector3 other){
     
    69117        RegisterObject(PacmanGhost);
    70118
     119        //this->pathAlgorithm = new GetShortestPathAlgorithm;
     120
     121
    71122        this->velocity = Vector3(0, 0, 0);
    72123
     
    80131        this->target_x = actuelposition.x;
    81132        this->target_z = actuelposition.z;
     133
     134        //this->lastPlayerPassedPoint=Vector3(185,10,150); //no idea what to put
    82135
    83136    }
     
    89142    PacmanGhost::~PacmanGhost()
    90143    {
    91         // Deletes the controller if the object was initialized and the pointer to the controller is not NULL.
     144        // Deletes the controller if the object was initialized and the pointer to the controller is not nullptr.
    92145    }
    93146
     
    171224    }
    172225
    173     Vector3 PacmanGhost::setPureArrayPos(Vector3 &posToSet){
     226    /*Vector3 PacmanGhost::setPureArrayPos(Vector3 &posToSet){
    174227        //given that the position of a pacman is generally not "neat",
    175228        //we need to set it to the nearest point on the map
     
    180233        }
    181234        return possibleposition[i];
     235    }*/
     236
     237    Vector3 PacmanGhost::getPlayerPos()
     238    {
     239        for (PacmanGelb* player : ObjectList<PacmanGelb>())
     240        {
     241            return player->getWorldPosition();
     242        }
     243        return Vector3(0,0,0); //default, should not be used
     244   
     245    }
     246
     247
     248
     249
     250    ///
     251    //// getShortestPath   /////////
     252    ///
     253
     254       
     255       
     256
     257        Vector3 PacmanGhost::getShortestPath(Vector3 start, Vector3 goal){
     258        //this function should then somehow produce the algorithm and call all other functions
     259        //and finally return the best neighboor of the actual position of the pacman
     260       
     261
     262    graphVertex listOfVerticesM[67]; //our list of all possible graphs
     263    graphVertex* actualVertex;// = new graphVertex(); //we will walk through the array with a pointer
     264   
     265        if(start==goal){ // basic case
     266            return start;
     267        }
     268
     269        for(int an=0; an < 67; an++){
     270      listOfVerticesM[an]= graphVertex(possibleposition[an]); //same position order as in other file
     271    if(start==possibleposition[an]){
     272     actualVertex= &listOfVerticesM[an]; //our pointer points to the graph with position start in array
     273    //cout<<an<<endl;
     274            }
     275        }
     276
     277        actualVertex->alreadyVisited=true; //our start point is now visited
     278        actualVertex->shortestDistanceToStart=0; //At our start point, distance from start is 0
     279        findNeighboorVertices(actualVertex->position, actualVertex->adjacentVertices, listOfVerticesM);
     280        // second parameter is an array ! //third is our global array
     281
     282        while(actualVertex->position!=goal){
     283            for(int h=0;h < 4; h++){
     284                if(actualVertex->adjacentVertices[h]!=nullptr){ //check all neighboors of our current graphVertex
     285 
     286         //h=2 and 3 never reached
     287                    updateShortestDistanceToStart(*actualVertex, *actualVertex->adjacentVertices[h]);
     288                } //we "update" the neighboors of our new visited vertex
     289       
     290            }
     291           
     292            actualVertex=findNextVertexToConsider(listOfVerticesM);
     293            actualVertex->alreadyVisited=true;
     294    //cout<<actualVertex->position<<endl;
     295            if(actualVertex->position!=goal){
     296                findNeighboorVertices(actualVertex->position, actualVertex->adjacentVertices, listOfVerticesM);
     297                //we find the neighboors of our new visited vertex
     298                }
     299        }
     300
     301    //cout<<"meuejeeke"<<endl; never reached
     302
     303        //we should have reached our goal at this point
     304
     305        while(actualVertex->actuelPredecessor->actuelPredecessor!=nullptr){ //the predecessor of our predecessor
     306            actualVertex=actualVertex->actuelPredecessor;
     307        }
     308        // the predecessor is our starting point, in other words we are now on an
     309        //adjacent vertex of the start
     310
     311        return actualVertex->position; //we return the position of this - adjacent to start - vertex
     312    }
     313
     314//end of getShortestPath
     315
     316
     317    int PacmanGhost::graphDistance(Vector3 start, Vector3 goal){
     318    //cout<<hgj++<<endl;
     319        Vector3 differenceVector= Vector3(abs(goal.x-start.x), 0,abs(goal.z-start.z));
     320
     321        return differenceVector.x+differenceVector.z;
     322    }
     323
     324    void PacmanGhost::updateShortestDistanceToStart(graphVertex &vertex, graphVertex &neighboor){
     325        //apply this method to all non visited neighboors of a vertex.
     326        // This method should always be run on a vertex after we marked it as visited.
     327        if(neighboor.alreadyVisited==false){ //we only consider non visited neighboors.
     328            if((vertex.shortestDistanceToStart!=std::numeric_limits<int>::max())&&
     329        (neighboor.shortestDistanceToStart > vertex.shortestDistanceToStart +
     330                graphDistance(vertex.position, neighboor.position))){ //need to consider overflow case !
     331       
     332                neighboor.shortestDistanceToStart= vertex.shortestDistanceToStart +
     333                graphDistance(vertex.position, neighboor.position);
     334                neighboor.actuelPredecessor = &vertex;
     335            }
     336        }
     337    }
     338
     339    void PacmanGhost::findNearestNonVisitedNeighboor (graphVertex &vertex){
     340            //find nearest non visited neighboor of a given already visited vertex
     341        int shortestDistance = -1;
     342        graphVertex* nearestNonVisitedNeighboor=nullptr;//=graphVertex(); //by default there is not any.
     343        //Also, if all neighboors are already visited, we return nullptr, i.e. there is no
     344        //nearest non visited neighboor.
     345        for(int i=0; i < 4; i++){
     346            if((vertex.adjacentVertices[i]!=nullptr)&&(vertex.adjacentVertices[i]->alreadyVisited==false)){
     347                if(shortestDistance==-1){   //(concerns line above) we want a non visited neighboor
     348                    shortestDistance= graphDistance(vertex.position, vertex.adjacentVertices[i]->position);
     349                    nearestNonVisitedNeighboor=vertex.adjacentVertices[i]; //warning, both sides are pointer adresses !
     350    //cout<<shortestDistance<<endl;
     351                }
     352                else if(graphDistance(vertex.position, vertex.adjacentVertices[i]->position)<shortestDistance){
     353                    shortestDistance= graphDistance(vertex.position, vertex.adjacentVertices[i]->position);
     354                    nearestNonVisitedNeighboor=vertex.adjacentVertices[i]; //warning, both sides are pointer adresses !
     355        //cout<<(hgj++)%4<<endl;
     356                }
     357            }
     358        }
     359        vertex.currentNearestNonVisitedNeighboor = nearestNonVisitedNeighboor; //warning, both sides are pointer adresses !
     360    //cout<<hgj++<<endl;
     361    }
     362
     363
     364    PacmanGhost::graphVertex* PacmanGhost::findNextVertexToConsider(graphVertex listOfVerticesP[]){ //find next, nearest from start, non visited vertex in our listOfVertices array
     365
     366        int shortestDistance = -1;
     367        graphVertex* nextVertexToConsider;
     368
     369        for(int i=0; i < 67; i++){ //we loop over all possible positions
     370
     371            if(listOfVerticesP[i].alreadyVisited==true){ //vertex should already be visited
     372
     373                findNearestNonVisitedNeighboor(listOfVerticesP[i]); //we update nearest neighboor
     374                //of all visited vertices given that one of the nearest neighboor of a visited
     375                // vertex is now also visited because it was chosen as next optimal vertex
     376
     377                if(listOfVerticesP[i].currentNearestNonVisitedNeighboor!=nullptr){ //we want a candidate!
     378                if(shortestDistance==-1){ //our first possible candidate
     379
     380            shortestDistance=graphDistance(listOfVerticesP[i].position,
     381            listOfVerticesP[i].currentNearestNonVisitedNeighboor->position) +
     382            listOfVerticesP[i].shortestDistanceToStart;
     383
     384            nextVertexToConsider=listOfVerticesP[i].currentNearestNonVisitedNeighboor;
     385    //adress of nextVertexToConsider is that of pointer currentNearestNonVisitedNeighboor
     386
     387                }
     388                else if(shortestDistance > graphDistance(listOfVerticesP[i].position,
     389                listOfVerticesP[i].currentNearestNonVisitedNeighboor->position) +
     390                    listOfVerticesP[i].shortestDistanceToStart){//if better candidate than our first candidate available
     391
     392            shortestDistance=graphDistance(listOfVerticesP[i].position,
     393            listOfVerticesP[i].currentNearestNonVisitedNeighboor->position) +
     394            listOfVerticesP[i].shortestDistanceToStart;
     395
     396            nextVertexToConsider=listOfVerticesP[i].currentNearestNonVisitedNeighboor;
     397    //we dont need the & because we are not giving the adress of the array element
     398    //listOfVerticesP[i] but that of the pointer currentNearestNonVisitedNeighboor
     399                    }
     400                }
     401            }
     402            //we want after all to return the nearest non visited neighboor
     403        }
     404
     405        return nextVertexToConsider; //returns adress nextVertexToConsider is pointing to in array
     406    }
     407
     408    //////////////////////////////////////////////////////////////////////////////////////////////
     409
     410    //if vertex already visited, call function on it and reapeat until you reach non visited vertex
     411    // ---> not sure if a good idea because we risk infinite loop
     412
     413    //-215 -185 -135 -70 -20 0 20 70 135 185 215
     414
     415    //-195 -135 -85 -35 15 60 105 150 195 245
     416
     417    void PacmanGhost::findNeighboorVertices(Vector3 actuelposition, graphVertex* adjacentVertices[], graphVertex listOfVerticesP2[]){     
     418
     419
     420            if(findpos(actuelposition,possibleposition[0])){
     421                // we should use listOfVerticesP2[i] instead of possibleposition[i] I think
     422                // so that all neighboors are "the same"
     423                adjacentVertices[0]=&listOfVerticesP2[1]; //graphVertex(possibleposition[1]);  //need to do it everywhere !!!
     424                adjacentVertices[1]=&listOfVerticesP2[17]; //graphVertex(possibleposition[17]);
     425                adjacentVertices[2]=&listOfVerticesP2[19]; //graphVertex(possibleposition[19]); //maybe a vector would be more suitable ?
     426            }
     427            else if(findpos(actuelposition,possibleposition[1])){
     428                adjacentVertices[0]=&listOfVerticesP2[0]; //graphVertex(possibleposition[0]);
     429                adjacentVertices[1]=&listOfVerticesP2[2]; //graphVertex(possibleposition[2]);
     430            }
     431            else if(findpos(actuelposition,possibleposition[2])){
     432                adjacentVertices[0]=&listOfVerticesP2[1]; //graphVertex(possibleposition[1]);
     433                adjacentVertices[1]=&listOfVerticesP2[3]; //graphVertex(possibleposition[3]);
     434            }
     435            else if(findpos(actuelposition,possibleposition[3])){
     436                adjacentVertices[0]=&listOfVerticesP2[2]; //graphVertex(possibleposition[2]);
     437                adjacentVertices[1]=&listOfVerticesP2[4]; //graphVertex(possibleposition[4]);
     438                adjacentVertices[2]=&listOfVerticesP2[5]; //graphVertex(possibleposition[5]);
     439            }
     440            else if(findpos(actuelposition,possibleposition[4])){
     441                adjacentVertices[0]=&listOfVerticesP2[3]; //graphVertex(possibleposition[3]);
     442                adjacentVertices[1]=&listOfVerticesP2[6]; //graphVertex(possibleposition[6]);
     443            }
     444            else if(findpos(actuelposition,possibleposition[5])){
     445                adjacentVertices[0]=&listOfVerticesP2[3]; //graphVertex(possibleposition[3]);
     446                adjacentVertices[1]=&listOfVerticesP2[7]; //graphVertex(possibleposition[7]);
     447            }
     448            else if(findpos(actuelposition,possibleposition[6])){
     449                adjacentVertices[0]=&listOfVerticesP2[4]; //graphVertex(possibleposition[4]);
     450                adjacentVertices[1]=&listOfVerticesP2[9]; //graphVertex(possibleposition[9]);
     451                adjacentVertices[2]=&listOfVerticesP2[26]; //graphVertex(possibleposition[26]);
     452            }
     453            else if(findpos(actuelposition,possibleposition[7])){
     454                adjacentVertices[0]=&listOfVerticesP2[5]; //graphVertex(possibleposition[5]);
     455                adjacentVertices[1]=&listOfVerticesP2[8]; //graphVertex(possibleposition[8]);
     456            }
     457            else if(findpos(actuelposition,possibleposition[8])){
     458                adjacentVertices[0]=&listOfVerticesP2[7]; //graphVertex(possibleposition[7]);
     459                adjacentVertices[1]=&listOfVerticesP2[9]; //graphVertex(possibleposition[9]);
     460            }
     461            else if(findpos(actuelposition,possibleposition[9])){
     462                adjacentVertices[0]=&listOfVerticesP2[6]; //graphVertex(possibleposition[6]);
     463                adjacentVertices[1]=&listOfVerticesP2[8]; //graphVertex(possibleposition[8]);
     464                adjacentVertices[2]=&listOfVerticesP2[10]; //graphVertex(possibleposition[10]);
     465                adjacentVertices[3]=&listOfVerticesP2[38]; //graphVertex(possibleposition[38]);
     466            }
     467            else if(findpos(actuelposition,possibleposition[10])){
     468                adjacentVertices[0]=&listOfVerticesP2[9]; //graphVertex(possibleposition[9]);
     469                adjacentVertices[1]=&listOfVerticesP2[11]; //graphVertex(possibleposition[11]);
     470                adjacentVertices[2]=&listOfVerticesP2[45]; //graphVertex(possibleposition[45]);
     471            }
     472            else if(findpos(actuelposition,possibleposition[11])){
     473                adjacentVertices[0]=&listOfVerticesP2[10]; //graphVertex(possibleposition[10]);
     474                adjacentVertices[1]=&listOfVerticesP2[12]; //graphVertex(possibleposition[12]);
     475                adjacentVertices[2]=&listOfVerticesP2[13]; //graphVertex(possibleposition[13]);
     476            }
     477            else if(findpos(actuelposition,possibleposition[12])){
     478                adjacentVertices[0]=&listOfVerticesP2[11]; //graphVertex(possibleposition[11]);
     479                adjacentVertices[1]=&listOfVerticesP2[14]; //graphVertex(possibleposition[14]);
     480            }
     481            else if(findpos(actuelposition,possibleposition[13])){
     482                adjacentVertices[0]=&listOfVerticesP2[11]; //graphVertex(possibleposition[11]);
     483                adjacentVertices[1]=&listOfVerticesP2[14]; //graphVertex(possibleposition[14]);
     484                adjacentVertices[2]=&listOfVerticesP2[16]; //graphVertex(possibleposition[16]);
     485                adjacentVertices[3]=&listOfVerticesP2[61]; //graphVertex(possibleposition[61]);
     486            }
     487            else if(findpos(actuelposition,possibleposition[14])){
     488                adjacentVertices[0]=&listOfVerticesP2[12]; //graphVertex(possibleposition[12]);
     489                adjacentVertices[1]=&listOfVerticesP2[13]; //graphVertex(possibleposition[13]);
     490                adjacentVertices[2]=&listOfVerticesP2[15]; //graphVertex(possibleposition[15]);
     491            }
     492            else if(findpos(actuelposition,possibleposition[15])){
     493                adjacentVertices[0]=&listOfVerticesP2[14]; //graphVertex(possibleposition[14]);
     494                adjacentVertices[1]=&listOfVerticesP2[16]; //graphVertex(possibleposition[16]);
     495            }
     496            else if(findpos(actuelposition,possibleposition[16])){
     497                adjacentVertices[0]=&listOfVerticesP2[13]; //graphVertex(possibleposition[13]);
     498                adjacentVertices[1]=&listOfVerticesP2[15]; //graphVertex(possibleposition[15]);
     499                adjacentVertices[2]=&listOfVerticesP2[62]; //graphVertex(possibleposition[62]);
     500            }
     501            else if(findpos(actuelposition,possibleposition[17])){
     502                adjacentVertices[0]=&listOfVerticesP2[0]; //graphVertex(possibleposition[0]);
     503                adjacentVertices[1]=&listOfVerticesP2[25]; //graphVertex(possibleposition[25]);
     504            }
     505            else if(findpos(actuelposition,possibleposition[18])){
     506                adjacentVertices[0]=&listOfVerticesP2[19]; //graphVertex(possibleposition[19]);
     507                adjacentVertices[1]=&listOfVerticesP2[24]; //graphVertex(possibleposition[24]);               
     508            }
     509            else if(findpos(actuelposition,possibleposition[19])){
     510                adjacentVertices[0]=&listOfVerticesP2[0]; //graphVertex(possibleposition[0]);
     511                adjacentVertices[1]=&listOfVerticesP2[18]; //graphVertex(possibleposition[18]);
     512                adjacentVertices[2]=&listOfVerticesP2[20]; //graphVertex(possibleposition[20]);
     513                         }
     514            else if(findpos(actuelposition,possibleposition[20])){
     515                adjacentVertices[0]=&listOfVerticesP2[19]; //graphVertex(possibleposition[19]);
     516                adjacentVertices[1]=&listOfVerticesP2[21]; //graphVertex(possibleposition[21]);
     517                       }
     518            else if(findpos(actuelposition,possibleposition[21])){
     519                adjacentVertices[0]=&listOfVerticesP2[20]; //graphVertex(possibleposition[20]);
     520                adjacentVertices[1]=&listOfVerticesP2[22]; //graphVertex(possibleposition[22]);
     521                       }
     522            else if(findpos(actuelposition,possibleposition[22])){
     523                adjacentVertices[0]=&listOfVerticesP2[21]; //graphVertex(possibleposition[21]);
     524                adjacentVertices[1]=&listOfVerticesP2[23]; //graphVertex(possibleposition[23]);
     525                adjacentVertices[2]=&listOfVerticesP2[31]; //graphVertex(possibleposition[31]);
     526                          }
     527            else if(findpos(actuelposition,possibleposition[23])){
     528                adjacentVertices[0]=&listOfVerticesP2[22]; //graphVertex(possibleposition[22]);
     529                adjacentVertices[1]=&listOfVerticesP2[30]; //graphVertex(possibleposition[30]);
     530                       }
     531            else if(findpos(actuelposition,possibleposition[24])){
     532                adjacentVertices[0]=&listOfVerticesP2[18]; //graphVertex(possibleposition[18]);
     533                adjacentVertices[1]=&listOfVerticesP2[29]; //graphVertex(possibleposition[29]);
     534                       }
     535            else if(findpos(actuelposition,possibleposition[25])){
     536                adjacentVertices[0]=&listOfVerticesP2[17]; //graphVertex(possibleposition[17]);
     537                adjacentVertices[1]=&listOfVerticesP2[26]; //graphVertex(possibleposition[26]);
     538                       }
     539            else if(findpos(actuelposition,possibleposition[26])){
     540                adjacentVertices[0]=&listOfVerticesP2[6]; //graphVertex(possibleposition[6]);
     541                adjacentVertices[1]=&listOfVerticesP2[25]; //graphVertex(possibleposition[25]);
     542                adjacentVertices[2]=&listOfVerticesP2[27]; //graphVertex(possibleposition[27]);
     543                         }
     544            else if(findpos(actuelposition,possibleposition[27])){
     545                adjacentVertices[0]=&listOfVerticesP2[26]; //graphVertex(possibleposition[26]);
     546                adjacentVertices[1]=&listOfVerticesP2[28]; //graphVertex(possibleposition[28]);
     547                adjacentVertices[2]=&listOfVerticesP2[37]; //graphVertex(possibleposition[37]);
     548                          }
     549            else if(findpos(actuelposition,possibleposition[28])){
     550                adjacentVertices[0]=&listOfVerticesP2[27]; //graphVertex(possibleposition[27]);
     551                adjacentVertices[1]=&listOfVerticesP2[29]; //graphVertex(possibleposition[29]);
     552                adjacentVertices[2]=&listOfVerticesP2[36]; //graphVertex(possibleposition[36]);
     553                          }
     554            else if(findpos(actuelposition,possibleposition[29])){
     555                adjacentVertices[0]=&listOfVerticesP2[24]; //graphVertex(possibleposition[24]);
     556                adjacentVertices[1]=&listOfVerticesP2[28]; //graphVertex(possibleposition[28]);
     557                adjacentVertices[2]=&listOfVerticesP2[30]; //graphVertex(possibleposition[30]);
     558                          }
     559            else if(findpos(actuelposition,possibleposition[30])){
     560                adjacentVertices[0]=&listOfVerticesP2[23]; //graphVertex(possibleposition[23]);
     561                adjacentVertices[1]=&listOfVerticesP2[29]; //graphVertex(possibleposition[29]);
     562                adjacentVertices[2]=&listOfVerticesP2[34]; //graphVertex(possibleposition[34]);
     563                          }
     564            else if(findpos(actuelposition,possibleposition[31])){
     565                adjacentVertices[0]=&listOfVerticesP2[22]; //graphVertex(possibleposition[22]);
     566                adjacentVertices[1]=&listOfVerticesP2[32]; //graphVertex(possibleposition[32]);
     567                       }
     568            else if(findpos(actuelposition,possibleposition[32])){
     569                adjacentVertices[0]=&listOfVerticesP2[31]; //graphVertex(possibleposition[31]);
     570                adjacentVertices[1]=&listOfVerticesP2[33]; //graphVertex(possibleposition[33]);
     571                       }
     572            else if(findpos(actuelposition,possibleposition[33])){
     573                adjacentVertices[0]=&listOfVerticesP2[32]; //graphVertex(possibleposition[32]);
     574                adjacentVertices[1]=&listOfVerticesP2[34]; //graphVertex(possibleposition[34]);
     575                       }
     576            else if(findpos(actuelposition,possibleposition[34])){
     577                adjacentVertices[0]=&listOfVerticesP2[30]; //graphVertex(possibleposition[30]);
     578                adjacentVertices[1]=&listOfVerticesP2[33]; //graphVertex(possibleposition[33]);
     579                adjacentVertices[2]=&listOfVerticesP2[35]; //graphVertex(possibleposition[35]);
     580                adjacentVertices[3]=&listOfVerticesP2[42]; //graphVertex(possibleposition[42]);
     581               
     582            }
     583            else if(findpos(actuelposition,possibleposition[35])){
     584                adjacentVertices[0]=&listOfVerticesP2[34]; //graphVertex(possibleposition[34]);
     585                adjacentVertices[1]=&listOfVerticesP2[36]; //graphVertex(possibleposition[36]);
     586                adjacentVertices[2]=&listOfVerticesP2[41]; //graphVertex(possibleposition[41]);
     587                          }
     588            else if(findpos(actuelposition,possibleposition[36])){
     589                adjacentVertices[0]=&listOfVerticesP2[28]; //graphVertex(possibleposition[28]);
     590                adjacentVertices[1]=&listOfVerticesP2[35]; //graphVertex(possibleposition[35]);
     591                       }
     592            else if(findpos(actuelposition,possibleposition[37])){
     593                adjacentVertices[0]=&listOfVerticesP2[27]; //graphVertex(possibleposition[27]);
     594                adjacentVertices[1]=&listOfVerticesP2[38]; //graphVertex(possibleposition[38]);
     595                       }
     596            else if(findpos(actuelposition,possibleposition[38])){
     597                adjacentVertices[0]=&listOfVerticesP2[9]; //graphVertex(possibleposition[9]);
     598                adjacentVertices[1]=&listOfVerticesP2[37]; //graphVertex(possibleposition[37]);
     599                adjacentVertices[2]=&listOfVerticesP2[39]; //graphVertex(possibleposition[39]);
     600                         }
     601            else if(findpos(actuelposition,possibleposition[39])){
     602                adjacentVertices[0]=&listOfVerticesP2[38]; //graphVertex(possibleposition[38]);
     603                adjacentVertices[1]=&listOfVerticesP2[40]; //graphVertex(possibleposition[40]);
     604                adjacentVertices[2]=&listOfVerticesP2[45]; //graphVertex(possibleposition[45]);
     605                          }
     606            else if(findpos(actuelposition,possibleposition[40])){
     607                adjacentVertices[0]=&listOfVerticesP2[39]; //graphVertex(possibleposition[39]);
     608                adjacentVertices[1]=&listOfVerticesP2[41]; //graphVertex(possibleposition[41]);
     609            }
     610            else if(findpos(actuelposition,possibleposition[41])){
     611                adjacentVertices[0]=&listOfVerticesP2[35]; //graphVertex(possibleposition[35]);
     612                adjacentVertices[1]=&listOfVerticesP2[43]; //graphVertex(possibleposition[43]);
     613                       }
     614            else if(findpos(actuelposition,possibleposition[42])){
     615                adjacentVertices[0]=&listOfVerticesP2[34]; //graphVertex(possibleposition[34]);
     616                adjacentVertices[1]=&listOfVerticesP2[43]; //graphVertex(possibleposition[43]);
     617                adjacentVertices[2]=&listOfVerticesP2[54]; //graphVertex(possibleposition[54]);
     618                          }
     619            else if(findpos(actuelposition,possibleposition[43])){
     620                adjacentVertices[0]=&listOfVerticesP2[41]; //graphVertex(possibleposition[41]);
     621                adjacentVertices[1]=&listOfVerticesP2[46]; //graphVertex(possibleposition[46]);
     622                       }
     623            else if(findpos(actuelposition,possibleposition[44])){
     624                adjacentVertices[0]=&listOfVerticesP2[40]; //graphVertex(possibleposition[40]);
     625                adjacentVertices[1]=&listOfVerticesP2[66]; //graphVertex(possibleposition[66]);
     626                       }
     627            else if(findpos(actuelposition,possibleposition[45])){
     628                adjacentVertices[0]=&listOfVerticesP2[10]; //graphVertex(possibleposition[10]);
     629                adjacentVertices[1]=&listOfVerticesP2[39]; //graphVertex(possibleposition[39]);
     630                adjacentVertices[2]=&listOfVerticesP2[49]; //graphVertex(possibleposition[49]);
     631                          }
     632            else if(findpos(actuelposition,possibleposition[46])){
     633                adjacentVertices[0]=&listOfVerticesP2[43]; //graphVertex(possibleposition[43]);
     634                adjacentVertices[1]=&listOfVerticesP2[47]; //graphVertex(possibleposition[47]);
     635                       }
     636            else if(findpos(actuelposition,possibleposition[47])){
     637                adjacentVertices[0]=&listOfVerticesP2[46]; //graphVertex(possibleposition[46]);
     638                adjacentVertices[1]=&listOfVerticesP2[52]; //graphVertex(possibleposition[52]);
     639                adjacentVertices[2]=&listOfVerticesP2[66]; //graphVertex(possibleposition[66]);
     640                          }
     641            else if(findpos(actuelposition,possibleposition[48])){
     642                adjacentVertices[0]=&listOfVerticesP2[49]; //graphVertex(possibleposition[49]);
     643                adjacentVertices[1]=&listOfVerticesP2[51]; //graphVertex(possibleposition[51]);
     644                adjacentVertices[2]=&listOfVerticesP2[66]; //graphVertex(possibleposition[66]);
     645                          }
     646            else if(findpos(actuelposition,possibleposition[49])){
     647                adjacentVertices[0]=&listOfVerticesP2[45]; //graphVertex(possibleposition[45]);
     648                adjacentVertices[1]=&listOfVerticesP2[48]; //graphVertex(possibleposition[48]);
     649                       }
     650            else if(findpos(actuelposition,possibleposition[50])){
     651                adjacentVertices[0]=&listOfVerticesP2[51]; //graphVertex(possibleposition[51]);
     652                adjacentVertices[1]=&listOfVerticesP2[61]; //graphVertex(possibleposition[61]);
     653                       }
     654            else if(findpos(actuelposition,possibleposition[51])){
     655                adjacentVertices[0]=&listOfVerticesP2[48]; //graphVertex(possibleposition[48]);
     656                adjacentVertices[1]=&listOfVerticesP2[50]; //graphVertex(possibleposition[50]);
     657                       }
     658            else if(findpos(actuelposition,possibleposition[52])){
     659                adjacentVertices[0]=&listOfVerticesP2[47]; //graphVertex(possibleposition[47]);
     660                adjacentVertices[1]=&listOfVerticesP2[53]; //graphVertex(possibleposition[53]);
     661                       }
     662            else if(findpos(actuelposition,possibleposition[53])){
     663                adjacentVertices[0]=&listOfVerticesP2[52]; //graphVertex(possibleposition[52]);
     664                adjacentVertices[1]=&listOfVerticesP2[58]; //graphVertex(possibleposition[58]);
     665                       }
     666            else if(findpos(actuelposition,possibleposition[54])){
     667                adjacentVertices[0]=&listOfVerticesP2[42]; //graphVertex(possibleposition[42]);
     668                adjacentVertices[1]=&listOfVerticesP2[55]; //graphVertex(possibleposition[55]);
     669                adjacentVertices[2]=&listOfVerticesP2[57]; //graphVertex(possibleposition[57]);
     670                          }
     671            else if(findpos(actuelposition,possibleposition[55])){
     672                adjacentVertices[0]=&listOfVerticesP2[54]; //graphVertex(possibleposition[54]);
     673                adjacentVertices[1]=&listOfVerticesP2[56]; //graphVertex(possibleposition[56]);
     674                       }
     675            else if(findpos(actuelposition,possibleposition[56])){
     676                adjacentVertices[0]=&listOfVerticesP2[55]; //graphVertex(possibleposition[55]);
     677                adjacentVertices[1]=&listOfVerticesP2[57]; //graphVertex(possibleposition[57]);
     678                adjacentVertices[2]=&listOfVerticesP2[65]; //graphVertex(possibleposition[65]);
     679                          }
     680            else if(findpos(actuelposition,possibleposition[57])){
     681                adjacentVertices[0]=&listOfVerticesP2[54]; //graphVertex(possibleposition[54]);
     682                adjacentVertices[1]=&listOfVerticesP2[56]; //graphVertex(possibleposition[56]);
     683                adjacentVertices[2]=&listOfVerticesP2[58]; //graphVertex(possibleposition[58]);
     684                adjacentVertices[3]=&listOfVerticesP2[64]; //graphVertex(possibleposition[64]);
     685               
     686            }
     687            else if(findpos(actuelposition,possibleposition[58])){
     688                adjacentVertices[0]=&listOfVerticesP2[53]; //graphVertex(possibleposition[53]);
     689                adjacentVertices[1]=&listOfVerticesP2[57]; //graphVertex(possibleposition[57]);
     690                adjacentVertices[2]=&listOfVerticesP2[59]; //graphVertex(possibleposition[59]);
     691                          }
     692            else if(findpos(actuelposition,possibleposition[59])){
     693                adjacentVertices[0]=&listOfVerticesP2[58]; //graphVertex(possibleposition[58]);
     694                adjacentVertices[1]=&listOfVerticesP2[59]; //graphVertex(possibleposition[59]);
     695                adjacentVertices[2]=&listOfVerticesP2[63]; //graphVertex(possibleposition[63]);
     696                          }
     697            else if(findpos(actuelposition,possibleposition[60])){
     698                adjacentVertices[0]=&listOfVerticesP2[59]; //graphVertex(possibleposition[59]);
     699                adjacentVertices[1]=&listOfVerticesP2[61]; //graphVertex(possibleposition[61]);
     700                adjacentVertices[2]=&listOfVerticesP2[62]; //graphVertex(possibleposition[62]);
     701                          }
     702            else if(findpos(actuelposition,possibleposition[61])){
     703                adjacentVertices[0]=&listOfVerticesP2[13]; //graphVertex(possibleposition[13]);
     704                adjacentVertices[1]=&listOfVerticesP2[50]; //graphVertex(possibleposition[50]);
     705                adjacentVertices[2]=&listOfVerticesP2[60]; //graphVertex(possibleposition[60]);
     706                          }
     707            else if(findpos(actuelposition,possibleposition[62])){
     708                adjacentVertices[0]=&listOfVerticesP2[16]; //graphVertex(possibleposition[16]);
     709                adjacentVertices[1]=&listOfVerticesP2[60]; //graphVertex(possibleposition[60]);
     710                       }
     711            else if(findpos(actuelposition,possibleposition[63])){
     712                adjacentVertices[0]=&listOfVerticesP2[59]; //graphVertex(possibleposition[59]);
     713                adjacentVertices[1]=&listOfVerticesP2[64]; //graphVertex(possibleposition[64]);
     714                       }
     715            else if(findpos(actuelposition,possibleposition[64])){
     716                adjacentVertices[0]=&listOfVerticesP2[57]; //graphVertex(possibleposition[57]);
     717                adjacentVertices[1]=&listOfVerticesP2[63]; //graphVertex(possibleposition[63]);
     718                adjacentVertices[2]=&listOfVerticesP2[65]; //graphVertex(possibleposition[65]);
     719                          }
     720            else if(findpos(actuelposition,possibleposition[65])){
     721                adjacentVertices[0]=&listOfVerticesP2[56]; //graphVertex(possibleposition[56]);
     722                adjacentVertices[1]=&listOfVerticesP2[64]; //graphVertex(possibleposition[64]);
     723                       }
     724            else if(findpos(actuelposition,possibleposition[66])){
     725                adjacentVertices[0]=&listOfVerticesP2[47]; //graphVertex(possibleposition[47]);
     726                adjacentVertices[1]=&listOfVerticesP2[48]; //graphVertex(possibleposition[48]);
     727                       }
    182728    }
    183729
  • code/branches/3DPacman_FS19/src/modules/pacman/PacmanGhost.h

    r12304 r12316  
    3636#include "worldentities/ControllableEntity.h"
    3737
     38#include "Pacman.h"
     39#include "GetShortestPathAlgorithm.h"
     40
    3841namespace orxonox {
    3942
     
    4346
    4447
    45     struct graphVertex;
    46     void findNeighboorVertices(Vector3 actuelposition, graphVertex adjacentVertices[]);
    47     void updateShortestDistanceToStart(graphVertex &vertex, graphVertex &neighboor);
    48     graphVertex findNextVertexToConsider(graphVertex[]);
    4948
    50     extern graphVertex listOfVertices[];
    5149
    5250
     
    8381            bool lockmove = false;
    8482
    85         Vector3 getShortestPath(Vector3 start, Vector3 goal);
     83        /*Vector3 getShortestPath(Vector3 start, Vector3 goal);
    8684
    8785        Vector3 setPureArrayPos(Vector3 &posToSet);
    8886
    89             private:
     87        */Vector3 getPlayerPos();
     88
     89        Vector3 playerPos;
     90
     91        Vector3 lastPlayerPassedPoint;/*
     92
     93        //Vector3 pathAlgorithm;
     94
     95    public: //HACK
     96
     97    struct graphVertex;
     98    void findNeighboorVertices(Vector3 actuelposition, graphVertex* adjacentVertices[]);
     99    void updateShortestDistanceToStart(graphVertex &vertex, graphVertex &neighboor);
     100    void findNearestNonVisitedNeighboor (graphVertex &vertex);
     101    int graphDistance(Vector3 start, Vector3 goal);
     102
     103    graphVertex* findNextVertexToConsider(graphVertex listOfVerticesP[]);*/
     104
     105    struct graphVertex;
     106    void findNeighboorVertices(Vector3 actuelposition, graphVertex* adjacentVertices[], graphVertex listOfVerticesP2[]);
     107    void updateShortestDistanceToStart(graphVertex &vertex, graphVertex &neighboor);
     108    void findNearestNonVisitedNeighboor (graphVertex &vertex);
     109    int graphDistance(Vector3 start, Vector3 goal);
     110
     111    graphVertex* findNextVertexToConsider(graphVertex listOfVerticesP[]);
     112    Vector3 getShortestPath(Vector3 start, Vector3 goal);
     113
     114
    90115    };
    91116
  • code/branches/3DPacman_FS19/src/modules/pacman/PacmanRandom.cc

    r12304 r12316  
    262262                this->resetGhost(); //Shouldn't happen...
    263263            } //End of Position table
    264                 lockmove = false;
     264                lockmove = false;  //never forget this one !!!!
    265265            }
    266266       
  • code/branches/3DPacman_FS19/src/modules/pacman/PacmanRed.cc

    r12304 r12316  
    44#include "core/CoreIncludes.h"
    55#include "BulletDynamics/Dynamics/btRigidBody.h"
     6
     7
    68
    79        namespace orxonox{
     
    1214
    1315        RegisterObject(PacmanRed);
     16        this->target_x=0;
     17        this->target_z=15;
     18        this->lastPlayerPassedPoint=Vector3(70,10,-135);
    1419         
    1520    }
     
    2530    }
    2631
     32    /*void PacmanRed::setPlayerPos(Vector3 _playerPos)
     33    {
     34        this->playerPos = _playerPos;
     35    }*/
     36
     37    bool PacmanRed::jeanfindpos(Vector3 one, Vector3 other){
     38       if((abs(one.x - other.x)<15) && (abs(one.y - other.y)<15) && (abs(one.z - other.z)<15)) return true;
     39        return false;
     40        }
     41
    2742    void PacmanRed::tick(float dt)
    2843    {
     
    3045
    3146        this->actuelposition = this->getPosition();
     47
     48        for(int u=0; u < 67; u++){//always check if player passed a point
     49            if(jeanfindpos(this->getPlayerPos(), possibleposition[u])){
     50            this->lastPlayerPassedPoint=possibleposition[u];
     51                    }
     52            }
     53
    3254       
    3355        //Stop, if target arrived
     
    5577
    5678                //do red behavior
     79            //Use target_x and target_z for position of red pacman
    5780
    58             Vector3 purePos = setPureArrayPos(this->actuelposition);
    59             //find nearest position on the map to red pos if pacman does not move,
    60             //i.e. reached a point on the map
    61             //Why not simply use target_x and target_z ??????
     81            Vector3 redPos=Vector3(this->target_x, 10, this->target_z);
     82            //nextMove(this->getPlayerPos(), redPos);
    6283
    63             nextMove(purePos, player.actuelposition);
    64             //how do we access the PLAYER variable ??????
    6584
    66             //also, player.lastPassedPoint is maybe better
     85            if(this->actuelposition!=lastPlayerPassedPoint){
     86                //std::cout<<this->target_x<<" "<<this->target_z<<endl;
     87                std::cout<<redPos<<endl;
     88                std::cout<<this->lastPlayerPassedPoint<<endl;
     89                //getShortestPath(Vector3(-215,10,-195),Vector3(70,10,-135));
     90                //getShortestPath(redPos, lastPlayerPassedPoint);
     91            nextMove(redPos, lastPlayerPassedPoint);
     92            }/*
     93            else{// red pacman is at lastPlayerPassedPoint
     94            nextMove(this->getPlayerPos(), redPos);
     95            }*/
     96
     97            //setNewTargetRed(Vector3(70,10,-85));
     98            //std::cout<<this->target_x<<" "<<target_z<<endl;
     99            //std::cout<<"meuh"<<endl;
     100            //std::cout<<this->actuelposition;
     101
     102            lockmove=false; //NEVER FORGET THIS ONE !!!!!!!
    67103        }
    68104       
     
    78114
    79115
    80         void PacmanRed::nextMove(Vector3 playerPos, Vector3 redPos){
    81                 Vector3 nextTarget;
     116        void PacmanRed::nextMove( Vector3 redPosP, Vector3 playerPos){
     117       
     118        Vector3 nextTarget;
    82119
    83         nextTarget = getShortestPath(playerPos, redPos);
     120           nextTarget = getShortestPath(redPosP, playerPos);
    84121       
    85         setNewTargetRed(nextTarget);
     122           setNewTargetRed(nextTarget);
    86123        }
    87124
  • code/branches/3DPacman_FS19/src/modules/pacman/PacmanRed.h

    r12304 r12316  
    2424                        void mainBehaviourRed();
    2525
     26                        bool jeanfindpos(Vector3 one, Vector3 other);
     27
    2628
    2729
Note: See TracChangeset for help on using the changeset viewer.