summaryrefslogtreecommitdiff
path: root/src/being.h
blob: 143f3eec503bf1a125cd9f38961fd41a61e24a5f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
/*
 *  The ManaPlus Client
 *  Copyright (C) 2004-2009  The Mana World Development Team
 *  Copyright (C) 2009-2010  The Mana Developers
 *  Copyright (C) 2011  The ManaPlus Developers
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef BEING_H
#define BEING_H

#ifdef __GNUC__
#define A_UNUSED  __attribute__ ((unused))
#else
#define A_UNUSED
#endif

#include "actorsprite.h"
#include "configlistener.h"
#include "equipment.h"
#include "map.h"
#include "particlecontainer.h"
#include "position.h"
#include "vector.h"

#include <guichan/color.hpp>

#include <SDL_types.h>

#include <map>
#include <set>
#include <string>
#include <vector>

#define FIRST_IGNORE_EMOTE 14
#define STATUS_EFFECTS 32

#define SPEECH_TIME 500
#define SPEECH_MIN_TIME 200
#define SPEECH_MAX_TIME 800

class AnimatedSprite;
class BeingCacheEntry;
class Being;
class BeingInfo;
class FlashText;
class Guild;
class Inventory;
class ItemInfo;
class Item;
class Particle;
class Party;
class SpeechBubble;
class Text;

struct Position;

extern volatile int cur_time;

enum Gender
{
    GENDER_MALE = 0,
    GENDER_FEMALE = 1,
    GENDER_UNSPECIFIED = 2
};


class BeingEquipBackend : public Equipment::Backend
{
    public:
        BeingEquipBackend(Being *being);

        virtual ~BeingEquipBackend();

        Item *getEquipment(int index) const;

        void clear();

        void setEquipment(int index, Item *item);

    private:
        Item *mEquipment[EQUIPMENT_SIZE];
        Being *mBeing;
};

class Being : public ActorSprite, public ConfigListener
{
    public:
        friend class BeingEquipBackend;
        friend class LocalPlayer;

        enum FLAGS
        {
            FLAG_SHOP = 1,
            FLAG_AWAY = 2,
            FLAG_INACTIVE = 4,
            FLAG_SPECIAL = 128 + 64
        };

        /**
         * Action the being is currently performing
         * WARNING: Has to be in sync with the same enum in the Being class
         * of the server!
         */
        enum Action
        {
            STAND = 0,
            MOVE,
            ATTACK,
            SIT,
            DEAD,
            HURT,
            SPAWN
        };

        enum Speech
        {
            NO_SPEECH = 0,
            TEXT_OVERHEAD,
            NO_NAME_IN_BUBBLE,
            NAME_IN_BUBBLE
        };

        enum AttackType
        {
            HIT = 0x00,
            CRITICAL = 0x0a,
            MULTI = 0x08,
            REFLECT = 0x04,
            FLEE = 0x0b
        };

        enum Reachable
        {
            REACH_UNKNOWN = 0,
            REACH_YES = 1,
            REACH_NO = 2
        };

        /**
         * Directions, to be used as bitmask values
         */
        enum BeingDirection
        {
            DOWN = 1,
            LEFT = 2,
            UP = 4,
            RIGHT = 8
        };

        /**
         * Constructor.
         *
         * @param id      a unique being id
         * @param subtype partly determines the type of the being
         * @param map     the map the being is on
         */
        Being(int id, Type type, Uint16 subtype, Map *map);

        virtual ~Being();

        Type getType() const
        { return mType; }

        /**
         * Removes all path nodes from this being.
         */
        void clearPath();

        /**
         * Returns the time spent in the current action.
         */
        int getActionTime() const
        { return mActionTime; }

        /**
         * Set the current action time.
         * @see Ea::BeingHandler that set it to tick time.
         */
        void setActionTime(int actionTime)
        { mActionTime = actionTime; }

        /**
         * Makes this being take the next tile of its path.
         * TODO: Used by eAthena only?
         */
        virtual void nextTile();

        /**
         * Get the current X pixel offset.
         * TODO: Used by eAthena only?
         */
        int getXOffset() const
        { return getOffset(LEFT, RIGHT); }

        /**
         * Get the current Y pixel offset.
         * TODO: Used by eAthena only?
         */
        int getYOffset() const
        { return getOffset(UP, DOWN); }

        /**
         * Creates a path for the being from current position to ex and ey
         */
        void setDestination(int ex, int ey);

        /**
         * Returns the destination for this being.
         */
        const Vector &getDestination() const
        { return mDest; }

        /**
         * Returns the tile x coord
         */
        int getTileX() const
        { return mX; }

        /**
         * Returns the tile y coord
         */
        int getTileY() const
        { return mY; }

        /**
         * Sets the tile x and y coord
         */
        void setTileCoords(int x, int y)
        { mX = x; mY = y; }

        /**
         * Puts a "speech balloon" above this being for the specified amount
         * of time.
         *
         * @param text The text that should appear.
         * @param time The amount of time the text should stay in milliseconds.
         */
        void setSpeech(const std::string &text, int time = 0);

        /**
         * Puts a damage bubble above this being.
         *
         * @param attacker the attacking being
         * @param damage the amount of damage recieved (0 means miss)
         * @param type the attack type
         */
        void takeDamage(Being *attacker, int damage, AttackType type);

        /**
         * Handles an attack of another being by this being.
         *
         * @param victim the victim being
         * @param damage the amount of damage dealt (0 means miss)
         * @param type the attack type
         */
        virtual void handleAttack(Being *victim, int damage, AttackType type);

        const ItemInfo *getEquippedWeapon() const
        { return mEquippedWeapon; }

        /**
         * Returns the name of the being.
         */
        const std::string &getName() const
        { return mName; }

        /**
         * Sets the name for the being.
         *
         * @param name The name that should appear.
         */
        void setName(const std::string &name);

        bool getShowName() const
        { return mShowName; }

        void setShowName(bool doShowName);

        /**
         * Sets the name of the party the being is in. Shown in BeingPopup.
         */
        void setPartyName(const std::string &name)
        { mPartyName = name; }

        const std::string &getPartyName() const
        { return mPartyName; }

        const std::string &getGuildName() const
        { return mGuildName; }

        /**
         * Sets the name of the primary guild the being is in. Shown in
         * BeingPopup (eventually).
         */
        void setGuildName(const std::string &name);

        void setGuildPos(const std::string &pos);

        /**
         * Adds a guild to the being.
         */
        void addGuild(Guild *guild);

        /**
         * Removers a guild from the being.
         */
        void removeGuild(int id);

        /**
         * Returns a pointer to the specified guild that the being is in.
         */
        Guild *getGuild(const std::string &guildName) const;

        /**
         * Returns a pointer to the specified guild that the being is in.
         */
        Guild *getGuild(int id) const;

        /**
         * Returns a pointer to the specified guild that the being is in.
         */
        Guild *getGuild() const;

        /**
         * Returns all guilds the being is in.
         */
        const std::map<int, Guild*> &getGuilds() const
        { return mGuilds; }

        /**
         * Removes all guilds the being is in.
         */
        void clearGuilds();

        /**
         * Get number of guilds the being belongs to.
         */
        short getNumberOfGuilds() const
        { return static_cast<short>(mGuilds.size()); }

        bool isInParty() const
        { return mParty != NULL; }

        void setParty(Party *party);

        void setGuild(Guild *guild);

        void updateGuild();

        Party *getParty() const
        { return mParty; }

        int getSpritesCount()
        { return static_cast<int>(size()); }

        /**
         * Sets visible equipments for this being.
         */
        void setSprite(unsigned int slot, int id,
                       std::string color = "",
                       unsigned char colorId = 1, bool isWeapon = false,
                       bool isTempSprite = false);

        void setSpriteID(unsigned int slot, int id);

        void setSpriteColor(unsigned int slot, const std::string &color = "");

        /**
         * Get the number of hairstyles implemented
         */
        static int getNumOfHairstyles()
        { return mNumberOfHairstyles; }

        /**
         * Get the number of layers used to draw the being
         */
        int getNumberOfLayers() const;

        /**
         * Performs being logic.
         */
        virtual void logic();

        /**
         * Draws the speech text above the being.
         */
        void drawSpeech(int offsetX, int offsetY);

        /**
         * Draws the emotion picture above the being.
         */
        void drawEmotion(Graphics *graphics, int offsetX, int offsetY);

        Uint16 getSubType() const
        { return mSubType; }

         /**
          * Set Being's subtype (mostly for view for monsters and NPCs)
          */
        void setSubtype(Uint16 subtype);

        const BeingInfo *getInfo() const
        { return mInfo; }

        TargetCursorSize getTargetCursorSize() const;

        int getTargetOffsetX() const;

        int getTargetOffsetY() const;

        /**
         * Gets the way the object is blocked by other objects.
         */
        virtual unsigned char getWalkMask() const;

        /**
         * Gets the way the monster blocks pathfinding for other objects
         */
        Map::BlockType getBlockType() const;

        /**
         * Sets the walk speed.
         * in pixels per second for eAthena,
         * in tiles per second for Manaserv.
         */
        void setWalkSpeed(Vector speed)
        { mWalkSpeed = speed; }

        /**
         * Gets the walk speed.
         * in pixels per second for eAthena,
         * in tiles per second for Manaserv (0.1 precision).
         */
        Vector getWalkSpeed() const
        { return mWalkSpeed; }

        /**
         * Sets the attack speed.
         * @todo In what unit?
         */
        void setAttackSpeed(int speed)
        { mAttackSpeed = speed; }

        /**
         * Gets the attack speed.
         * @todo In what unit?
         */
        int getAttackSpeed() const
        { return mAttackSpeed; }

        /**
         * Sets the current action.
         */
        virtual void setAction(Action action, int attackType = 0);

        /**
         * Get the being's action currently performed.
         */
        Action getCurrentAction() const
        { return mAction; }

        /**
         * Returns whether this being is still alive.
         */
        bool isAlive() const
        { return mAction != DEAD; }

        /**
         * Returns the current direction.
         */
        Uint8 getDirection() const
        { return mDirection; }

        /**
         * Sets the current direction.
         */
        virtual void setDirection(Uint8 direction);

        virtual void setDirectionDelayed(Uint8 direction)
        { mDirectionDelayed = direction; }

        Uint8 getDirectionDelayed()
        { return mDirectionDelayed; }

        /**
         * Returns the direction the being is facing.
         */
        SpriteDirection getSpriteDirection() const
        { return SpriteDirection(mSpriteDirection); }

        void setPosition(const Vector &pos);

        /**
         * Overloaded method provided for convenience.
         *
         * @see setPosition(const Vector &pos)
         */
        inline void setPosition(float x, float y, float z = 0.0f)
        { setPosition(Vector(x, y, z)); }

        /**
         * Returns the horizontal size of the current base sprite of the being.
         */
        virtual int getWidth() const;

        /**
         * Returns the vertical size of the current base sprite of the being.
         */
        virtual int getHeight() const;

        /**
         * Returns the being's pixel radius used to detect collisions.
         */
        virtual int getCollisionRadius() const;

        /**
         * Shoots a missile particle from this being, to target being
         */
        void fireMissile(Being *target, const std::string &particle);

        /**
         * Returns the path this being is following. An empty path is returned
         * when this being isn't following any path currently.
         */
        const Path &getPath() const
        { return mPath; }

        int getDistance()
        { return mDistance; }

        void setDistance(int n)
        { mDistance = n; }

        /**
         * Set the Emoticon type and time displayed above
         * the being.
         */
        void setEmote(Uint8 emotion, int emote_time);

        /**
         * Get the current Emoticon type displayed above
         * the being.
         */
        int getEmotion() const
        { return mEmotion; }

        virtual void drawSprites(Graphics* graphics, int posX, int posY) const;

        virtual void drawSpritesSDL(Graphics* graphics,
                                    int posX, int posY) const;

        void drawHpBar(Graphics *graphics, int x, int y,
                       int maxHP, int hp, int damage, int color1, int color2,
                       int width, int height) const;

        static void load();

        virtual void optionChanged(const std::string &value);

        void flashName(int time);

        int getDamageTaken() const
        { return mDamageTaken; }

        void setDamageTaken(int damage)
        { mDamageTaken = damage; }

        void updateName();

        void setLevel(int n)
        { mLevel = n; }

        virtual int getLevel() const
        { return mLevel; }

        void setIsReachable(int n)
        { mIsReachable = n; }

        int isReachable()
        { return mIsReachable; }

        static void reReadConfig();

        static BeingCacheEntry* getCacheEntry(int id);

        void addToCache();

        bool updateFromCache();

        /**
         * Sets the gender of this being.
         */
        virtual void setGender(Gender gender);

        Gender getGender() const
        { return mGender; }

        /**
         * Whether or not this player is a GM.
         */
        bool isGM() const
        { return mIsGM; }

        /**
         * Triggers whether or not to show the name as a GM name.
         */
        void setGM(bool gm);

        bool canTalk();

        void talkTo();

        static bool isTalking();

        bool draw(Graphics *graphics, int offsetX, int offsetY) const;

        bool drawSpriteAt(Graphics *graphics, int x, int y) const;

        void setMoveTime()
        { mMoveTime = cur_time; }

        void setAttackTime()
        { mAttackTime = cur_time; }

        void setTalkTime()
        { mTalkTime = cur_time; }

        void setTestTime()
        { mTestTime = cur_time; }

        void setOtherTime()
        { mOtherTime = cur_time; }

        unsigned int getMoveTime() const
        { return mMoveTime; }

        unsigned int getAttackTime() const
        { return mAttackTime; }

        unsigned int getTalkTime() const
        { return mTalkTime; }

        unsigned int getTestTime() const
        { return mTestTime; }

        unsigned int getOtherTime() const
        { return mOtherTime; }

        void resetCounters();

        virtual void updateColors();

        void setEnemy(bool n)
        { mEnemy = n; }

        const std::string &getIp() const
        { return mIp; }

        void setIp(std::string ip)
        { mIp = ip; }

        unsigned int getPvpRank() const
        { return mPvpRank; }

        void setPvpRank(unsigned int rank)
        { mPvpRank = rank; }

        void setHP(int n);

        void setMaxHP(int hp);

        int getHP()
        { return mHP; }

        Uint8 calcDirection(int dstX, int dstY) const;

        Uint8 calcDirection() const;

        void setAttackDelay(int n)
        { mAttackDelay = n; }

        int getAttackDelay()
        { return mAttackDelay; }

        int getMinHit()
        { return mMinHit; }

        void setMinHit(int n)
        { mMinHit = n; }

        int getMaxHit()
        { return mMaxHit; }

        void setMaxHit(int n)
        { mMaxHit = n; }

        int getCriticalHit()
        { return mCriticalHit; }

        void setCriticalHit(int n)
        { mCriticalHit = n; }

        void updateHit(int amount);

        Equipment *getEquipment();

        void undressItemById(int id);

        int getGoodStatus()
        { return mGoodStatus; }

        void setGoodStatus(int n)
        { mGoodStatus = n; }

        std::string getGenderSign() const;

        std::string getGenderSignWithSpace() const;

        void updateComment();

        std::string getComment()
        { return mComment; }

        void setComment(std::string n)
        { mComment = n; }

        static void clearCache();

        static std::string loadComment(const std::string &name);

        static void saveComment(const std::string &name,
                                const std::string &comment);

        bool isAdvanced()
        { return mAdvanced; }

        void setAdvanced(bool n)
        { mAdvanced = n; }

        bool isShopEnabled()
        { return mShop; }

    protected:
        /**
         * Sets the new path for this being.
         */
        void setPath(const Path &path);

        /**
         * Updates name's location.
         */
        virtual void updateCoords();

        void recalcSpritesOrder();

        void showName();

        BeingInfo *mInfo;

        int mActionTime;      /**< Time spent in current action */

        int mEmotion;         /**< Currently showing emotion */
        int mEmotionTime;     /**< Time until emotion disappears */
        /** Time until the last speech sentence disappears */
        int mSpeechTime;

        int mAttackType;
        int mAttackSpeed;     /**< Attack speed */

        Action mAction;       /**< Action the being is performing */
        Uint16 mSubType;      /**< Subtype (graphical view, basically) */

        Uint8 mDirection;               /**< Facing direction */
        Uint8 mDirectionDelayed;        /**< Facing direction */

        Uint8 mSpriteDirection;         /**< Facing direction */
        std::string mName;              /**< Name of character */
        std::string mPartyName;
        std::string mGuildName;

        /**
         * Holds a text object when the being displays it's name, 0 otherwise
         */
        FlashText *mDispName;
        const gcn::Color *mNameColor;
        bool mShowName;

        /** Engine-related infos about weapon. */
        const ItemInfo *mEquippedWeapon;

        static int mNumberOfHairstyles; /** Number of hair styles in use */

        Path mPath;
        std::string mSpeech;
        Text *mText;
        const gcn::Color *mTextColor;

        int mLevel;
        Vector mDest;  /**< destination coordinates. */

        std::vector<int> mSpriteIDs;
        std::vector<std::string> mSpriteColors;
        std::vector<int> mSpriteColorsIds;
        Gender mGender;

        // Character guild information
        std::map<int, Guild*> mGuilds;
        Party *mParty;

        bool mIsGM;

    private:

        /**
         * Calculates the offset in the given directions.
         * If walking in direction 'neg' the value is negated.
         * TODO: Used by eAthena only?
         */
        int getOffset(char pos, char neg) const;

        int searchSlotValue(std::vector<int> &slotRemap, int val);

        void searchSlotValueItr(std::vector<int>::iterator &it, int &idx,
                                std::vector<int> &slotRemap, int val);

        const Type mType;

        /** Speech Bubble components */
        SpeechBubble *mSpeechBubble;

        /**
         * Walk speed for x and y movement values.
         * In pixels per second for eAthena,
         * In pixels per ticks for Manaserv.
         * @see MILLISECONDS_IN_A_TICK
         */
        Vector mWalkSpeed;

        int mX, mY;   /**< Position in tile */

        int mDamageTaken;
        int mHP;
        int mMaxHP;
        int mDistance;
        int mIsReachable; /**< 0 - unknown, 1 - reachable, 2 - not reachable*/
        int mGoodStatus;

        static int mUpdateConfigTime;
        static unsigned int mConfLineLim;
        static int mSpeechType;
        static bool mHighlightMapPortals;
        static bool mHighlightMonsterAttackRange;
        static bool mLowTraffic;
        static bool mDrawHotKeys;
        static bool mShowBattleEvents;
        static bool mShowMobHP;
        static bool mShowOwnHP;
        static bool mShowGender;
        static bool mShowLevel;
        static bool mShowPlayersStatus;

        unsigned int mMoveTime;
        unsigned int mAttackTime;
        unsigned int mTalkTime;
        unsigned int mTestTime;
        unsigned int mOtherTime;
        bool mErased;
        bool mEnemy;
        std::string mIp;
        int mAttackDelay;
        int mMinHit;
        int mMaxHit;
        int mCriticalHit;
        unsigned int mPvpRank;
        int *mSpriteRemap;
        int *mSpriteHide;
        std::string mComment;
        bool mGotComment;
        bool mAdvanced;
        bool mShop;
        bool mAway;
        bool mInactive;
};

extern std::list<BeingCacheEntry*> beingInfoCache;

#endif