Source/Objects/Person.hpp

   1 /*
   2 Copyright (C) 2003, 2010 - Wolfire Games
   3 Copyright (C) 2010-2017 - Lugaru contributors (see AUTHORS file)
   4
   5 This file is part of Lugaru.
   6
   7 Lugaru is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 Lugaru is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #ifndef _PERSON_HPP_
  22 #define _PERSON_HPP_
  23
  24 #include "Animation/Animation.hpp"
  25 #include "Animation/Skeleton.hpp"
  26 #include "Audio/Sounds.hpp"
  27 #include "Environment/Terrain.hpp"
  28 #include "Graphic/gamegl.hpp"
  29 #include "Graphic/Models.hpp"
  30 #include "Graphic/Sprite.hpp"
  31 #include "Math/XYZ.hpp"
  32 #include "Objects/Weapons.hpp"
  33
  34 #include <cmath>
  35 #include <memory>
  36
  37 #define passivetype 0
  38 #define guardtype 1
  39 #define searchtype 2
  40 #define attacktype 3
  41 #define attacktypecutoff 4
  42 #define playercontrolled 5
  43 #define gethelptype 6
  44 #define getweapontype 7
  45 #define pathfindtype 8
  46
  47 enum person_type
  48 {
  49     rabbittype = 0,
  50     wolftype = 1
  51 };
  52
  53 struct InvalidPersonException : public exception {
  54    const char * what () const throw () {
  55       return "Invalid weapon number";
  56    }
  57 };
  58
  59 class PersonType
  60 {
  61 public:
  62     // head, body, arms, legs
  63     XYZ proportions[4];
  64     animation_type animRun;
  65     animation_type animRunning;
  66     animation_type animCrouch;
  67     animation_type animStop;
  68     animation_type animLanding;
  69     animation_type animLandingHard;
  70     animation_type animFightIdle;
  71     animation_type animBounceIdle;
  72     animation_type animTalkIdle;
  73
  74     sound_type soundsAttack[4];
  75     sound_type soundsTalk[2];
  76
  77     std::string figureFileName;
  78     std::string lowFigureFileName;
  79     std::string clothesFileName;
  80     std::string modelFileNames[7];
  81     std::string lowModelFileName;
  82     std::string modelClothesFileName;
  83
  84     std::vector<std::string> skins;
  85
  86     GLubyte bloodText[512 * 512 * 3] = { 0 };
  87
  88     PersonType();
  89     bool hasAnimTalkIdle();
  90
  91     static std::vector<PersonType> types;
  92     static void Load();
  93 };
  94
  95 class Person : public enable_shared_from_this<Person>
  96 {
  97 private:
  98     float proportions[4];
  99
 100 public:
 101     static std::vector<std::shared_ptr<Person>> players;
 102
 103     int whichpatchx;
 104     int whichpatchz;
 105
 106     // animCurrent and animTarget are used to interpolate between different animations
 107     // (and for a bunch of other things).
 108     // animations interpolate with one another at various speeds.
 109     // animTarget seems to determine the combat state?
 110     int animCurrent;
 111     int animTarget;
 112
 113     // frameCurrent and frameTarget are used to interpolate between the frames of an animation
 114     // (e.g. the crouched animation has only two frames, lerped back and forth slowly).
 115     // animations advance at various speeds.
 116     int frameCurrent;
 117     int frameTarget;
 118
 119     int oldanimCurrent;
 120     int oldanimTarget;
 121     int oldframeCurrent;
 122     int oldframeTarget;
 123
 124     int howactive;
 125
 126     float parriedrecently;
 127
 128     bool superruntoggle;
 129
 130     int lastattack, lastattack2, lastattack3;
 131
 132     XYZ currentoffset, targetoffset, offset;
 133     float target;
 134     float transspeed;
 135
 136     XYZ realoldcoords;
 137     XYZ oldcoords;
 138     XYZ coords;
 139     XYZ velocity;
 140
 141     //~ XYZ proportionhead;
 142     //~ XYZ proportionlegs;
 143     //~ XYZ proportionarms;
 144     //~ XYZ proportionbody;
 145
 146     float unconscioustime;
 147
 148     bool immobile;
 149
 150     float velspeed;
 151     float targetyaw;
 152     float targetrot;
 153     float rot;
 154     float oldrot;
 155     float lookyaw;
 156     float lookpitch;
 157     float yaw;
 158     float pitch;
 159     float lowyaw;
 160     float tilt;
 161     float targettilt;
 162     float tilt2;
 163     float targettilt2;
 164     bool rabbitkickenabled;
 165
 166     float bloodloss;
 167     float bleeddelay;
 168     float skiddelay;
 169     float skiddingdelay;
 170     float deathbleeding;
 171     float tempdeltav;
 172
 173     float damagetolerance;
 174     float damage;
 175     float permanentdamage;
 176     float superpermanentdamage;
 177     float lastcollide;
 178     /* Seems to be 0 = alive, 1 = unconscious, 2 = dead */
 179     int dead;
 180
 181     float jumppower;
 182     bool onground;
 183
 184     int wentforweapon;
 185
 186     bool calcrot;
 187
 188     XYZ facing;
 189
 190     float bleeding;
 191     float bleedx, bleedy;
 192     int direction;
 193     float texupdatedelay;
 194
 195     float headyaw, headpitch;
 196     float targetheadyaw, targetheadpitch;
 197
 198     bool onterrain;
 199     bool pause;
 200
 201     float grabdelay;
 202
 203     std::shared_ptr<Person> victim;
 204     bool hasvictim;
 205
 206     float updatedelay;
 207     float normalsupdatedelay;
 208
 209     bool jumpstart;
 210
 211     bool forwardkeydown;
 212     bool forwardstogglekeydown;
 213     bool rightkeydown;
 214     bool leftkeydown;
 215     bool backkeydown;
 216     bool jumpkeydown;
 217     bool jumptogglekeydown;
 218     bool crouchkeydown;
 219     bool crouchtogglekeydown;
 220     bool drawkeydown;
 221     bool drawtogglekeydown;
 222     bool throwkeydown;
 223     bool throwtogglekeydown;
 224     bool attackkeydown;
 225     bool feint;
 226     bool lastfeint;
 227     bool headless;
 228
 229     float crouchkeydowntime;
 230     float jumpkeydowntime;
 231     bool freefall;
 232
 233
 234     float turnspeed;
 235
 236     int aitype;
 237     float aiupdatedelay;
 238     float losupdatedelay;
 239     int ally;
 240     float collide;
 241     float collided;
 242     float avoidcollided;
 243     bool loaded;
 244     bool whichdirection;
 245     float whichdirectiondelay;
 246     bool avoidsomething;
 247     XYZ avoidwhere;
 248     float blooddimamount;
 249
 250     float staggerdelay;
 251     float blinkdelay;
 252     float twitchdelay;
 253     float twitchdelay2;
 254     float twitchdelay3;
 255     float lefthandmorphness;
 256     float righthandmorphness;
 257     float headmorphness;
 258     float chestmorphness;
 259     float tailmorphness;
 260     float targetlefthandmorphness;
 261     float targetrighthandmorphness;
 262     float targetheadmorphness;
 263     float targetchestmorphness;
 264     float targettailmorphness;
 265     int lefthandmorphstart, lefthandmorphend;
 266     int righthandmorphstart, righthandmorphend;
 267     int headmorphstart, headmorphend;
 268     int chestmorphstart, chestmorphend;
 269     int tailmorphstart, tailmorphend;
 270
 271     float weaponmissdelay;
 272     float highreversaldelay;
 273     float lowreversaldelay;
 274
 275     int creature;
 276
 277     unsigned id;
 278
 279     Skeleton skeleton;
 280
 281     float speed;
 282     float scale;
 283     float power;
 284     float speedmult;
 285
 286     float protectionhead;
 287     float protectionhigh;
 288     float protectionlow;
 289     float armorhead;
 290     float armorhigh;
 291     float armorlow;
 292     bool metalhead;
 293     bool metalhigh;
 294     bool metallow;
 295
 296     int numclothes;
 297     char clothes[10][256];
 298     float clothestintr[10];
 299     float clothestintg[10];
 300     float clothestintb[10];
 301
 302     bool landhard;
 303     bool bled;
 304     bool spurt;
 305     bool onfire;
 306     float onfiredelay;
 307     float burnt;
 308
 309     float flamedelay;
 310
 311     int playerdetail;
 312
 313     int num_weapons;
 314     int weaponids[4];
 315     /* Key of weaponids which is the weapon in hand, if any. -1 otherwise.
 316      * Always 0 or -1 as activeweapon is moved to position 0 when taken */
 317     int weaponactive;
 318     int weaponstuck;
 319     /* 0 or 1 to say if weapon is stuck in the front or the back  */
 320     int weaponstuckwhere;
 321
 322     int numwaypoints;
 323     XYZ waypoints[90];
 324     int waypointtype[90];
 325     float pausetime;
 326
 327     XYZ headtarget;
 328     float interestdelay;
 329
 330     XYZ finalfinaltarget;
 331     XYZ finaltarget;
 332     int finalpathfindpoint;
 333     int targetpathfindpoint;
 334     int lastpathfindpoint;
 335     int lastpathfindpoint2;
 336     int lastpathfindpoint3;
 337     int lastpathfindpoint4;
 338
 339     int waypoint;
 340
 341     XYZ lastseen;
 342     float lastseentime;
 343     float lastchecktime;
 344     float stunned;
 345     float surprised;
 346     float runninghowlong;
 347     int occluded;
 348     int lastoccluded;
 349     int laststanding;
 350     int escapednum;
 351
 352     float speechdelay;
 353     float neckspurtdelay;
 354     float neckspurtparticledelay;
 355     float neckspurtamount;
 356
 357     int whichskin;
 358     bool rabbitkickragdoll;
 359
 360     Animation tempanimation;
 361
 362     bool jumpclimb;
 363
 364     Person();
 365     Person(FILE*, int, unsigned);
 366
 367     void skeletonLoad(bool clothes = false);
 368
 369     // convenience functions
 370     inline Joint& joint(int bodypart) { return skeleton.joints[skeleton.jointlabels[bodypart]]; }
 371     inline XYZ& jointPos(int bodypart) { return joint(bodypart).position; }
 372     inline XYZ& jointVel(int bodypart) { return joint(bodypart).velocity; }
 373     inline AnimationFrame& currentFrame() { return Animation::animations.at(animCurrent).frames.at(frameCurrent); }
 374     inline AnimationFrame& targetFrame() { return Animation::animations.at(animTarget).frames.at(frameTarget); }
 375
 376     void setProportions(float, float, float, float);
 377     XYZ getProportion(int part) const;
 378
 379     void CheckKick();
 380     void CatchFire();
 381     void DoBlood(float howmuch, int which);
 382     void DoBloodBig(float howmuch, int which);
 383     bool DoBloodBigWhere(float howmuch, int which, XYZ where);
 384
 385     bool wasIdle() { return animation_bits[animCurrent] & ab_idle; }
 386     bool isIdle() { return animation_bits[animTarget] & ab_idle; }
 387     int getIdle();
 388
 389     bool isSitting() { return animation_bits[animTarget] & ab_sit; }
 390
 391     bool isSleeping() { return animation_bits[animTarget] & ab_sleep; }
 392
 393     bool wasCrouch() { return animation_bits[animCurrent] & ab_crouch; }
 394     bool isCrouch() { return animation_bits[animTarget] & ab_crouch; }
 395     int getCrouch();
 396
 397     bool wasStop() { return animation_bits[animCurrent] & ab_stop; }
 398     bool isStop() { return animation_bits[animTarget] & ab_stop; }
 399     int getStop();
 400
 401     bool wasSneak();
 402     bool isSneak();
 403     int getSneak();
 404
 405     bool wasRun() { return animation_bits[animCurrent] & ab_run; }
 406     bool isRun() { return animation_bits[animTarget] & ab_run; }
 407     int getRun();
 408
 409     bool wasLanding() { return animation_bits[animCurrent] & ab_land; }
 410     bool isLanding() { return animation_bits[animTarget] & ab_land; }
 411     int getLanding();
 412
 413     bool wasLandhard() { return animation_bits[animCurrent] & ab_landhard; }
 414     bool isLandhard() { return animation_bits[animTarget] & ab_landhard; }
 415     int getLandhard();
 416
 417     bool wasFlip() { return animation_bits[animCurrent] & ab_flip; }
 418     bool isFlip() { return animation_bits[animTarget] & ab_flip; }
 419
 420     bool isWallJump() { return animation_bits[animTarget] & ab_walljump; }
 421     void Reverse();
 422     void DoDamage(float howmuch);
 423     void DoHead();
 424     void DoMipmaps() {
 425         skeleton.drawmodel.textureptr.bind();
 426         glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
 427         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, skeleton.skinsize, skeleton.skinsize, 0, GL_RGB, GL_UNSIGNED_BYTE, &skeleton.skinText[0]);
 428     }
 429
 430     int SphereCheck(XYZ *p1, float radius, XYZ *p, XYZ *move, float *rotate, Model *model);
 431     int DrawSkeleton();
 432     void Puff(int whichlabel);
 433     void FootLand(bodypart whichfoot, float opacity);
 434     void DoStuff();
 435     void setTargetAnimation(int);
 436     void DoAnimations();
 437     void RagDoll(bool checkcollision);
 438
 439     void takeWeapon (int weaponId);
 440
 441     bool addClothes(const int& clothesId);
 442     void addClothes();
 443
 444     void doAI();
 445 };
 446
 447 const int maxplayers = 10;
 448
 449 #endif