Changeset 53

Show
Ignore:
Timestamp:
01/29/09 23:34:16 (11 years ago)
Author:
inferiorminion
Message:

Bug #19: Team Caterpillar
 https://bugs.castleparadox.com/show_bug.cgi?id=19

Location:
src
Files:
6 modified

Legend:

Unmodified
Added
Removed
  • src/gui/GLUTWindow.cpp

    r45 r53  
    11#include <gui/GLUTWindow.h> 
    22#include <gui/OpenGL.h> 
     3#include <internal/HeroInstance.h> 
     4#include <vector> 
    35#ifdef _WIN32 
    46#include <GL/glut.h> 
     
    2224                internalState.currentMap = rpg->getStartMap(); 
    2325                internalState.initMap(); 
    24                 internalState.leader = rpg->getStartPoint(); 
    25                 internalState.camera = internalState.leader; 
    26                 internalState.move(internalState.leader.getX() / Maptile::WIDTH, internalState.leader.getY() / Maptile::HEIGHT); 
     26                internalState.camera = rpg->getStartPoint(); 
     27                for(int i = 0; i < 4; i++ ) { 
     28                        internalState.Party[i] = new HeroInstance(); 
     29                        internalState.Party[i]->setHero(rpg->getHero(i)); 
     30                        internalState.Party[i]->setPosition(internalState.camera); 
     31                        internalState.Party[i]->setDirection(0); 
     32                        internalState.Party[i]->setFrame(0); 
     33                        internalState.Party[i]->setSpeed(4); 
     34                } 
     35                internalState.move(internalState.camera.getX() / Maptile::WIDTH, internalState.camera.getY() / Maptile::HEIGHT); 
    2736                internalState.moved(); 
    2837        } else { 
     
    173182 
    174183void GLUTWindow::specialKeys(int key, int x, int y) { 
    175         int currX = internalState.leader.getX() / Maptile::WIDTH; 
    176         int currY = internalState.leader.getY() / Maptile::HEIGHT; 
     184        HeroInstance* leader = internalState.getLeader(); 
     185        Point2D leaderPosition = leader->getPosition(); 
     186        int currX = leaderPosition.getX() / Maptile::WIDTH; 
     187        int currY = leaderPosition.getY() / Maptile::HEIGHT; 
    177188        switch ( internalState.currMode ) { 
    178189                case State::BATTLE: 
     
    187198                                                        internalState.move(currX, currY); 
    188199                                                } 
    189                                                 internalState.leaderDirection = NPCLocation::RIGHT; 
     200                                                leader->setDirection(NPCLocation::RIGHT); 
    190201                                        } 
    191202                                        break; 
     
    195206                                                        internalState.move(currX, currY); 
    196207                                                } 
    197                                                 internalState.leaderDirection = NPCLocation::LEFT; 
     208                                                leader->setDirection(NPCLocation::LEFT); 
    198209                                        } 
    199210                                        break; 
     
    203214                                                        internalState.move(currX, currY); 
    204215                                                } 
    205                                                 internalState.leaderDirection = NPCLocation::DOWN; 
     216                                                leader->setDirection(NPCLocation::DOWN); 
    206217                                        } 
    207218                                        break; 
     
    211222                                                        internalState.move(currX, currY); 
    212223                                                } 
    213                                                 internalState.leaderDirection = NPCLocation::UP; 
     224                                                leader->setDirection(NPCLocation::UP); 
    214225                                        } 
    215226                                        break; 
  • src/gui/Window.cpp

    r52 r53  
    4545                                                                internalState.initMap(); 
    4646                                                                internalState.clearTrail(); 
    47                                                                 internalState.move(internalState.leader.getX() / Maptile::WIDTH, internalState.leader.getY() / Maptile::HEIGHT); 
     47                                                                Point2D leader = internalState.getLeader()->getPosition(); 
     48                                                                internalState.move(leader.getX() / Maptile::WIDTH, leader.getY() / Maptile::HEIGHT); 
    4849                                                                internalState.moved(); 
    4950                                                        } 
     
    307308 
    308309void Window::drawHeroLayer(int centerX, int centerY, int offsetX, int offsetY, int tileWidth, int tileHeight, int walkaboutOffset, int height) { 
    309         Hero* h = rpg->getHero(0); 
    310         g->draw(Drawable::WALKABOUT, internalState.leader.getX() + ( tileWidth - centerX ) * Maptile::WIDTH - offsetX, internalState.leader.getY() + ( tileHeight - centerY ) * Maptile::HEIGHT + walkaboutOffset - offsetY, height, WalkaboutGraphics::WIDTH, WalkaboutGraphics::HEIGHT, h->getWalkaboutSprite(), h->getWalkaboutPalette(), internalState.leaderDirection, internalState.leaderFrame); 
     310        for(int i = internalState.Party.size() - 1; i >= 0; i-- ) { 
     311                if( internalState.Party[i] != NULL ) { 
     312                        Hero* teammate = internalState.Party[i]->getHero(); 
     313                        Point2D position = internalState.Party[i]->getPosition(); 
     314                        g->draw(Drawable::WALKABOUT, position.getX() + ( tileWidth - centerX ) * Maptile::WIDTH - offsetX, position.getY() + ( tileHeight - centerY ) * Maptile::HEIGHT + walkaboutOffset - offsetY, height, WalkaboutGraphics::WIDTH, WalkaboutGraphics::HEIGHT, teammate->getWalkaboutSprite(), teammate->getWalkaboutPalette(), internalState.Party[i]->getDirection(), internalState.Party[i]->getFrame()); 
     315                } 
     316        }        
    311317} 
    312318 
  • src/include/internal/HeroInstance.h

    r24 r53  
    33 
    44#include <rpg/Hero.h> 
     5#include <internal/Point2D.h> 
    56 
    67/** An instance of a Hero in game. 
    78 * A Hero with specific experience and stats. 
    89 */ 
    9 class HeroInstance : public Hero { 
     10class HeroInstance { 
    1011        public: 
    1112                /** Default Constructor. 
     
    1718                 */ 
    1819                HeroInstance(const HeroInstance& h); 
    19                  
     20                /** Get the Hero Reference Object. 
     21                 * Retrieve the reference Hero object from which this HeroInstance is derived 
     22                 * @return The reference Hero Object 
     23                 */ 
     24                Hero* getHero(); 
     25                /** Set the Hero Reference Object. 
     26                 * Set the Hero refernce object used by this HeroInstance 
     27                 * @param[in] hero The Hero object to be referenced 
     28                 */ 
     29                void setHero(Hero* hero); 
     30                /** Get Hero's Position. 
     31                 * Retrieve the Hero's current position, in pixels, on the map 
     32                 * @return The Hero's current position, in pixels, on the map 
     33                 */ 
     34                Point2D getPosition(); 
     35                /** Set the Hero's Position. 
     36                 * Set the Hero's current position, in pixels, on the map 
     37                 * @param[in] position The Hero's new position 
     38                 */ 
     39                void setPosition(Point2D position); 
     40                /** Get Hero's Direction. 
     41                 * Retrieve the direction in which the Hero is currently facing 
     42                 * @return The direction in which the Hero is currently facing 
     43                 */ 
     44                INT getDirection(); 
     45                /** Set the Hero's Direction. 
     46                 * Set the direction in which the Hero is currently facing 
     47                 * @param[in] direction The new direction in which the Hero is facing 
     48                 */ 
     49                void setDirection(INT direction); 
     50                /** Get the Hero's Speed. 
     51                 * Retrieve the current speed at which the Hero is moving 
     52                 * @return The speed at which the Hero is moving 
     53                 */ 
     54                INT getSpeed(); 
     55                /** Set the Hero's Speed. 
     56                 * Set the speed at which the Hero is moving 
     57                 * @param[in] The new speed at which the Hero is moving 
     58                 */ 
     59                void setSpeed(INT speed); 
     60                /** Get the Hero's Walking Frame. 
     61                 * Retrieve the walking frame currently used by the Hero 
     62                 * @return The walking frame currently used by the Hero 
     63                 */ 
     64                INT getFrame(); 
     65                /** Set the Hero's Walking Frame. 
     66                 * Set the walking frame to display when drawing the Hero 
     67                 * @param[in] frame The walking frame to display when drawing the Hero 
     68                 */ 
     69                void setFrame(INT frame); 
     70         
    2071        private: 
     72                /** Hero Reference 
     73                 * The Hero object this HeroInstance is created out of 
     74                 */ 
     75                Hero* hero; 
    2176                /** Current Level. 
    2277                 * The Hero's current level 
     
    2782                 */ 
    2883                INT currExp; 
    29                  
     84                /** Current Position on Map. 
     85                 * The Hero's current position, in pixels, on the map 
     86                 */ 
     87                Point2D position; 
     88                /** Current Hero Direction. 
     89                 * The direction the current Hero is facing 
     90                 */ 
     91                INT direction; 
     92                /** Current Hero Speed. 
     93                 * The Speed at which the current Hero walks 
     94                 */ 
     95                INT speed; 
     96                /** Current Hero Frame. 
     97                 * The Walking Frame for the current Hero 
     98                 */ 
     99                INT frame; 
    30100}; 
    31101 
  • src/include/internal/State.h

    r45 r53  
    44#include <internal/Point2D.h> 
    55#include <internal/EnemyInstance.h> 
     6#include <internal/HeroInstance.h> 
    67#include <rpg/RPG.h> 
    78#include <compat.h> 
    8 #include <queue> 
     9#include <deque> 
    910using namespace std; 
    1011 
     
    6465                 */ 
    6566                void clearTrail(); 
     67                /** Retrieve Position from Party Trail. 
     68                 * Retrieves the position within the Party Trail specified by the provided index 
     69                 * @param index The Party Trail position index 
     70                 * @return Party Trail position 
     71                 */ 
     72                Point2D getTrailPosition(const int index); 
    6673                /** Init the map. 
    6774                 * Sets the NPC Layer map up 
     
    141148                 */ 
    142149                EnemyInstance* getEnemyInstance(int index); 
     150                /** Get Party Leader. 
     151                 * Retrieve the HeroInstance leading the caterpillar party 
     152                 * @return HeroInstance leading the caterpillar party 
     153                 */ 
     154                HeroInstance* getLeader(); 
     155                /** Get the Caterpillar Party. 
     156                 * Retrieve the Caterpillar Party 
     157                 * @return The Caterpillar Party 
     158                 */ 
     159                vector <HeroInstance*> & getCaterpillarParty(); 
    143160                /** Reset Battle Trigger. 
    144161                 * Reset the Random Battle Trigger to a number between 60 and 100 
     
    157174                 */ 
    158175                int currentTextbox; 
    159                 /** Current Hero Position. 
    160                  * The leader's position in pixels 
    161                  */ 
    162                 Point2D leader; 
    163                 /** Current Hero Direction. 
    164                  * The direction the current Hero is facing 
    165                  */ 
    166                 INT leaderDirection; 
    167                 /** Current Hero Frame. 
    168                  * The Walking Frame for the current Hero 
    169                  */ 
    170                 INT leaderFrame; 
    171                 /**Current Hero Speed. 
    172                  * The Speed at which the current Hero walks 
    173                  */ 
    174                 INT leaderSpeed; 
    175176                /** Current Camera Position. 
    176177                 * The the central focus of the camera in pixels 
     
    185186                 */ 
    186187                int gold; 
     188                /** HeroInstance Array. 
     189                 * Vectory containing the caterpillar party 
     190                 */ 
     191                vector <HeroInstance*> Party; 
    187192                 
    188193        private: 
     
    199204                 * Stores the movement trail for the Hero Party 
    200205                 */ 
    201                 queue<Point2D> heroTrail; 
     206                deque<Point2D> heroTrail; 
    202207                /** Loaded RPG. 
    203208                 * Pointer to the loaded RPG file 
  • src/internal/HeroInstance.cpp

    r24 r53  
    66} 
    77 
    8 HeroInstance::HeroInstance(const HeroInstance& h) : Hero(h) { 
     8HeroInstance::HeroInstance(const HeroInstance& h) { 
    99        currLevel = h.currLevel; 
    1010        currExp = h.currExp; 
    1111} 
     12 
     13Hero* HeroInstance::getHero() { 
     14        return hero; 
     15} 
     16 
     17void HeroInstance::setHero(Hero* h) { 
     18        hero = h; 
     19} 
     20 
     21Point2D HeroInstance::getPosition() { 
     22        return position; 
     23} 
     24 
     25void HeroInstance::setPosition(Point2D p) { 
     26        position.setX(p.getX()); 
     27        position.setY(p.getY()); 
     28} 
     29 
     30INT HeroInstance::getDirection() { 
     31        return direction; 
     32} 
     33 
     34void HeroInstance::setDirection(INT d) { 
     35        direction = d; 
     36} 
     37 
     38INT HeroInstance::getSpeed() { 
     39        return speed; 
     40} 
     41 
     42void HeroInstance::setSpeed(INT s) { 
     43        speed = s; 
     44} 
     45 
     46INT HeroInstance::getFrame() { 
     47        return frame; 
     48} 
     49 
     50void HeroInstance::setFrame(INT f) { 
     51        frame = f; 
     52} 
  • src/internal/State.cpp

    r50 r53  
    77State::State() { 
    88        zoom = 1; 
    9         leaderDirection = 0; 
    10         leaderFrame = 0; 
    11         leaderSpeed = 4; 
     9        Party.resize(4, NULL); 
    1210        movement = false; 
    1311} 
     
    1715        currentMap = s.currentMap; 
    1816        currentTextbox = s.currentTextbox; 
    19         leader = s.leader; 
    20         leaderDirection = s.leaderDirection; 
    21         leaderFrame = s.leaderFrame; 
    22         leaderSpeed = s.leaderSpeed; 
    2317        camera = s.camera; 
    2418        zoom = s.zoom; 
     
    3024        DoorLayer = s.DoorLayer; 
    3125        Tags = s.Tags; 
     26        Enemies = s.Enemies; 
     27        Party = s.Party; 
    3228        selectedColor = State::SELECTED_1; 
    3329} 
     
    4440        movement = true; 
    4541        if ( heroTrail.size() == 4 ) { 
    46                 heroTrail.pop(); 
    47         } 
    48         heroTrail.push(Point2D(x * Maptile::WIDTH,y * Maptile::HEIGHT)); 
     42                heroTrail.pop_back(); 
     43        } 
     44        heroTrail.push_front(Point2D(x * Maptile::WIDTH,y * Maptile::HEIGHT)); 
    4945} 
    5046 
     
    198194                } 
    199195        } 
    200         Point2D destination = heroTrail.back(); 
    201         if ( leader != destination ) { 
    202                 if ( leader.getX() < destination.getX() ) { 
    203                         leaderDirection = NPCLocation::RIGHT; 
    204                         leader.setX(leader.getX() + leaderSpeed); 
    205                 } else if ( leader.getX() > destination.getX() ) { 
    206                          leaderDirection = NPCLocation::LEFT; 
    207                          leader.setX(leader.getX() - leaderSpeed); 
    208                 } 
    209                 if ( leader.getY() < destination.getY() ) { 
    210                         leaderDirection = NPCLocation::DOWN; 
    211                         leader.setY(leader.getY() + leaderSpeed); 
    212                 } else if ( leader.getY() > destination.getY() ) { 
    213                          leaderDirection = NPCLocation::UP; 
    214                          leader.setY(leader.getY() - leaderSpeed); 
    215                 } 
    216                 leaderFrame++; 
    217                 if ( leaderFrame == 2 ) { 
    218                         leaderFrame = 0; 
    219                 } 
    220         } 
    221         camera = leader; 
     196        int position = 0; 
     197        int leader = -1; 
     198        for(int i = 0; i < 4; i++ ) { 
     199                if( Party[i] != NULL ) { 
     200                        if( leader == -1 ) { 
     201                                leader = i; 
     202                        } 
     203                        Point2D destination = getTrailPosition(position++); 
     204                        Point2D currentPosition = Party[i]->getPosition(); 
     205                        if ( currentPosition != destination ) { 
     206                                if ( currentPosition.getX() < destination.getX() ) { 
     207                                        Party[i]->setDirection(NPCLocation::RIGHT); 
     208                                        currentPosition.setX(currentPosition.getX() + Party[i]->getSpeed()); 
     209                                } else if ( currentPosition.getX() > destination.getX() ) { 
     210                                         Party[i]->setDirection(NPCLocation::LEFT); 
     211                                         currentPosition.setX(currentPosition.getX() - Party[i]->getSpeed()); 
     212                                } 
     213                                if ( currentPosition.getY() < destination.getY() ) { 
     214                                        Party[i]->setDirection(NPCLocation::DOWN); 
     215                                        currentPosition.setY(currentPosition.getY() + Party[i]->getSpeed()); 
     216                                } else if ( currentPosition.getY() > destination.getY() ) { 
     217                                         Party[i]->setDirection(NPCLocation::UP); 
     218                                         currentPosition.setY(currentPosition.getY() - Party[i]->getSpeed()); 
     219                                } 
     220                                Party[i]->setPosition(currentPosition); 
     221                                if( Party[i]->getFrame() == 1 ) { 
     222                                        Party[i]->setFrame(0); 
     223                                } else { 
     224                                        Party[i]->setFrame(1); 
     225                                } 
     226                        } 
     227                } 
     228        } 
     229        camera = Party[leader]->getPosition(); 
    222230} 
    223231 
     
    331339bool State::useDoor() { 
    332340        Map* map = rpg->getMap(currentMap); 
     341        Point2D leader = getLeader()->getPosition(); 
    333342        int x = leader.getX()/Maptile::WIDTH, y = leader.getY()/Maptile::HEIGHT; 
    334343        int door = DoorLayer[x][y]; 
     
    338347                        currentMap = (*i)->destinationMap; 
    339348                        leader = rpg->getMap(currentMap)->doors[(*i)->destinationDoor].getPixelPosition(); 
     349                        // Set all Heros to start on the door and wipe out the caterpillar trail 
     350                        for(int j = 0; j < Party.size(); j++) { 
     351                                if( Party[j] != NULL ) { 
     352                                        Party[j]->setPosition(leader); 
     353                                } 
     354                        } 
     355                        clearTrail(); 
    340356                        camera = leader; 
    341357                        return true; 
     
    346362 
    347363void State::useNPC(NPC::Activation a) { 
     364        Point2D leader = getLeader()->getPosition(); 
    348365        int x = leader.getX()/Maptile::WIDTH; 
    349366        int y = leader.getY()/Maptile::HEIGHT; 
    350367        Map* map = rpg->getMap(currentMap); 
    351368        if( a == NPC::USE ) { 
    352                 switch( leaderDirection ) { 
     369                switch( getLeader()->getDirection() ) { 
    353370                        case NPCLocation::UP: 
    354371                                if( y > 0 ) { 
     
    401418 
    402419bool State::standing() { 
    403         return leader == heroTrail.back(); 
     420        return getLeader()->getPosition() == heroTrail.front(); 
    404421} 
    405422 
     
    408425                movement = false; 
    409426                Map* m = rpg->getMap(currentMap); 
     427                Point2D leader = getLeader()->getPosition(); 
    410428                int formationSet = m->foemap.getTile(leader.getX()/Maptile::WIDTH, leader.getY()/Maptile::HEIGHT); 
    411429                if ( formationSet ) { 
     
    422440 
    423441void State::clearTrail() { 
    424         while ( heroTrail.empty() ) { 
    425                 heroTrail.pop(); 
    426         } 
     442        heroTrail.clear(); 
     443} 
     444 
     445Point2D State::getTrailPosition(const int index) { 
     446        if( heroTrail.size() >= index + 1 ) { 
     447                return heroTrail[index]; 
     448        } 
     449        return heroTrail[heroTrail.size() - 1]; 
    427450} 
    428451 
     
    554577} 
    555578 
     579HeroInstance* State::getLeader() { 
     580        for( int i = 0; i < Party.size(); i++ ) { 
     581                if( Party[i] != NULL ) { 
     582                        return Party[i]; 
     583                } 
     584        } 
     585} 
     586 
    556587void State::resetBattleTrigger() { 
    557588        battleTrigger = rand() % 40 + 60;