qcsrc/common/animdecide.qc

   1 // implicit anim state
   2 .float anim_implicit_state;
   3 .float anim_implicit_time;
   4
   5 // actions
   6 .float anim_lower_action;
   7 .float anim_lower_time;
   8 .float anim_upper_action;
   9 .float anim_upper_time;
  10
  11 // player animation data for this model
  12 // each vector is as follows:
  13 // _x = startframe
  14 // _y = numframes
  15 // _z = framerate
  16 .vector anim_die1; // player dies
  17 .vector anim_die2; // player dies differently
  18 .vector anim_draw; // player pulls out a weapon
  19 .vector anim_duckwalk; // player walking while crouching
  20 .vector anim_duckjump; // player jumping from a crouch
  21 .vector anim_duckidle; // player idling while crouching
  22 .vector anim_idle; // player standing
  23 .vector anim_jump; // player jump
  24 .vector anim_pain1; // player flinches from pain
  25 .vector anim_pain2; // player flinches from pain, differently
  26 .vector anim_shoot; // player shoots
  27 .vector anim_taunt; // player taunts others (FIXME: no code references this)
  28 .vector anim_run; // player running forward
  29 .vector anim_runbackwards; // player running backward
  30 .vector anim_strafeleft; // player shuffling left quickly
  31 .vector anim_straferight; // player shuffling right quickly
  32 .vector anim_forwardright; // player running forward and right
  33 .vector anim_forwardleft; // player running forward and left
  34 .vector anim_backright; // player running backward and right
  35 .vector anim_backleft; // player running back and left
  36 .vector anim_melee; // player doing the melee action
  37 .vector anim_duck; // player doing the melee action
  38 .vector anim_duckwalkbackwards;
  39 .vector anim_duckwalkstrafeleft;
  40 .vector anim_duckwalkstraferight;
  41 .vector anim_duckwalkforwardright;
  42 .vector anim_duckwalkforwardleft;
  43 .vector anim_duckwalkbackright;
  44 .vector anim_duckwalkbackleft;
  45
  46 void animdecide_init(entity e)
  47 {
  48         self.anim_die1 = animfixfps(self, '0 1 0.5'); // 2 seconds
  49         self.anim_die2 = animfixfps(self, '1 1 0.5'); // 2 seconds
  50         self.anim_draw = animfixfps(self, '2 1 3');
  51         self.anim_duckwalk = animfixfps(self, '4 1 1');
  52         self.anim_duckjump = '5 1 100'; // NOTE: zym anims keep playing until changed, so this only has to start the anim, landing will end it
  53         self.anim_duckidle = animfixfps(self, '6 1 1');
  54         self.anim_idle = animfixfps(self, '7 1 1');
  55         self.anim_jump = '8 1 100'; // NOTE: zym anims keep playing until changed, so this only has to start the anim, landing will end it
  56         self.anim_pain1 = animfixfps(self, '9 1 2'); // 0.5 seconds
  57         self.anim_pain2 = animfixfps(self, '10 1 2'); // 0.5 seconds
  58         self.anim_shoot = animfixfps(self, '11 1 5'); // analyze models and set framerate
  59         self.anim_taunt = animfixfps(self, '12 1 0.33');
  60         self.anim_run = animfixfps(self, '13 1 1');
  61         self.anim_runbackwards = animfixfps(self, '14 1 1');
  62         self.anim_strafeleft = animfixfps(self, '15 1 1');
  63         self.anim_straferight = animfixfps(self, '16 1 1');
  64         self.anim_forwardright = animfixfps(self, '19 1 1');
  65         self.anim_forwardleft = animfixfps(self, '20 1 1');
  66         self.anim_backright = animfixfps(self, '21 1 1');
  67         self.anim_backleft  = animfixfps(self, '22 1 1');
  68         self.anim_melee = animfixfps(self, '23 1 1');
  69         self.anim_duckwalkbackwards = animfixfps(self, '24 1 1');
  70         self.anim_duckwalkstrafeleft = animfixfps(self, '25 1 1');
  71         self.anim_duckwalkstraferight = animfixfps(self, '26 1 1');
  72         self.anim_duckwalkforwardright = animfixfps(self, '27 1 1');
  73         self.anim_duckwalkforwardleft = animfixfps(self, '28 1 1');
  74         self.anim_duckwalkbackright = animfixfps(self, '29 1 1');
  75         self.anim_duckwalkbackleft  = animfixfps(self, '30 1 1');
  76 }
  77
  78 #define ANIMPRIO_IDLE 0
  79 #define ANIMPRIO_STATIC 1
  80 #define ANIMPRIO_ACTIVE 2
  81 #define ANIMPRIO_DEAD 3
  82
  83 vector animdecide_getupperanim(entity e)
  84 {
  85         // is there an action?
  86         vector outframe = '-1 0 0';
  87         switch(e.anim_upper_action)
  88         {
  89                 case ANIMACTION_DRAW: outframe = e.anim_draw; break;
  90                 case ANIMACTION_PAIN1: outframe = e.anim_pain1; break;
  91                 case ANIMACTION_PAIN2: outframe = e.anim_pain2; break;
  92                 case ANIMACTION_SHOOT: outframe = e.anim_shoot; break;
  93                 case ANIMACTION_TAUNT: outframe = e.anim_taunt; break;
  94                 case ANIMACTION_MELEE: outframe = e.anim_melee; break;
  95         }
  96         if(outframe_x >= 0)
  97         {
  98                 if(time <= e.anim_upper_time + outframe_y / outframe_z)
  99                 {
 100                         // animation is running!
 101                         return vec3(outframe_x, e.anim_upper_time, ANIMPRIO_ACTIVE);
 102                 }
 103         }
 104         float t = max(e.anim_time, e.anim_implicit_time);
 105         // or, decide the anim by state
 106         // but all states are for lower body!
 107         return vec3(e.anim_idle_x, t, ANIMPRIO_IDLE);
 108 }
 109
 110 vector animdecide_getloweranim(entity e)
 111 {
 112         // death etc.
 113         if(e.anim_state & ANIMSTATE_FROZEN)
 114                 return vec3(e.anim_idle_x, e.anim_time, ANIMPRIO_DEAD);
 115         if(e.anim_state & ANIMSTATE_DEAD1)
 116                 return vec3(e.anim_die1_x, e.anim_time, ANIMPRIO_DEAD);
 117         if(e.anim_state & ANIMSTATE_DEAD2)
 118                 return vec3(e.anim_die2_x, e.anim_time, ANIMPRIO_DEAD);
 119
 120         // is there an action?
 121         vector outframe = '-1 0 0';
 122         switch(e.anim_lower_action)
 123         {
 124                 case ANIMACTION_JUMP: if(e.anim_state & ANIMSTATE_DUCK) outframe = e.anim_duckjump; else outframe = e.anim_jump; break;
 125         }
 126         if(outframe_x >= 0)
 127         {
 128                 if(time <= e.anim_lower_time + outframe_y / outframe_z)
 129                 {
 130                         // animation is running!
 131                         return vec3(outframe_x, e.anim_lower_time, ANIMPRIO_ACTIVE);
 132                 }
 133         }
 134         float t = max(e.anim_time, e.anim_implicit_time);
 135         // or, decide the anim by state
 136         if(e.anim_state & ANIMSTATE_DUCK)
 137         {
 138                 switch(self.anim_implicit_state & (ANIMIMPLICITSTATE_FORWARD | ANIMIMPLICITSTATE_BACKWARDS | ANIMIMPLICITSTATE_LEFT | ANIMIMPLICITSTATE_RIGHT))
 139                 {
 140                         case ANIMIMPLICITSTATE_FORWARD:
 141                                 return vec3(e.anim_duckwalk_x, t, ANIMPRIO_ACTIVE);
 142                         case ANIMIMPLICITSTATE_BACKWARDS:
 143                                 return vec3(e.anim_duckwalkbackwards_x, t, ANIMPRIO_ACTIVE);
 144                         case ANIMIMPLICITSTATE_RIGHT:
 145                                 return vec3(e.anim_duckwalkstraferight_x, t, ANIMPRIO_ACTIVE);
 146                         case ANIMIMPLICITSTATE_LEFT:
 147                                 return vec3(e.anim_duckwalkstrafeleft_x, t, ANIMPRIO_ACTIVE);
 148                         case ANIMIMPLICITSTATE_FORWARD | ANIMIMPLICITSTATE_RIGHT:
 149                                 return vec3(e.anim_duckwalkforwardright_x, t, ANIMPRIO_ACTIVE);
 150                         case ANIMIMPLICITSTATE_FORWARD | ANIMIMPLICITSTATE_LEFT:
 151                                 return vec3(e.anim_duckwalkforwardleft_x, t, ANIMPRIO_ACTIVE);
 152                         case ANIMIMPLICITSTATE_BACKWARDS | ANIMIMPLICITSTATE_RIGHT:
 153                                 return vec3(e.anim_duckwalkbackright_x, t, ANIMPRIO_ACTIVE);
 154                         case ANIMIMPLICITSTATE_BACKWARDS | ANIMIMPLICITSTATE_LEFT:
 155                                 return vec3(e.anim_duckwalkbackleft_x, t, ANIMPRIO_ACTIVE);
 156                         default:
 157                                 return vec3(e.anim_duckidle_x, t, ANIMPRIO_STATIC);
 158                 }
 159         }
 160         else if(e.anim_implicit_state & ANIMIMPLICITSTATE_RUN)
 161         {
 162                 switch(self.anim_implicit_state & (ANIMIMPLICITSTATE_FORWARD | ANIMIMPLICITSTATE_BACKWARDS | ANIMIMPLICITSTATE_LEFT | ANIMIMPLICITSTATE_RIGHT))
 163                 {
 164                         case ANIMIMPLICITSTATE_FORWARD:
 165                                 return vec3(e.anim_run_x, t, ANIMPRIO_ACTIVE);
 166                         case ANIMIMPLICITSTATE_BACKWARDS:
 167                                 return vec3(e.anim_runbackwards_x, t, ANIMPRIO_ACTIVE);
 168                         case ANIMIMPLICITSTATE_RIGHT:
 169                                 return vec3(e.anim_straferight_x, t, ANIMPRIO_ACTIVE);
 170                         case ANIMIMPLICITSTATE_LEFT:
 171                                 return vec3(e.anim_strafeleft_x, t, ANIMPRIO_ACTIVE);
 172                         case ANIMIMPLICITSTATE_FORWARD | ANIMIMPLICITSTATE_RIGHT:
 173                                 return vec3(e.anim_forwardright_x, t, ANIMPRIO_ACTIVE);
 174                         case ANIMIMPLICITSTATE_FORWARD | ANIMIMPLICITSTATE_LEFT:
 175                                 return vec3(e.anim_forwardleft_x, t, ANIMPRIO_ACTIVE);
 176                         case ANIMIMPLICITSTATE_BACKWARDS | ANIMIMPLICITSTATE_RIGHT:
 177                                 return vec3(e.anim_backright_x, t, ANIMPRIO_ACTIVE);
 178                         case ANIMIMPLICITSTATE_BACKWARDS | ANIMIMPLICITSTATE_LEFT:
 179                                 return vec3(e.anim_backleft_x, t, ANIMPRIO_ACTIVE);
 180                         default:
 181                                 return vec3(e.anim_run_x, t, ANIMPRIO_STATIC);
 182                 }
 183         }
 184         return vec3(e.anim_idle_x, t, ANIMPRIO_IDLE);
 185 }
 186
 187 void animdecide_setimplicitstate(entity e)
 188 {
 189         float s;
 190         s = 0;
 191
 192         makevectors(self.angles);
 193         if(self.velocity * v_forward > 0)
 194                 s |= ANIMIMPLICITSTATE_FORWARD;
 195         if(self.velocity * v_forward < 0)
 196                 s |= ANIMIMPLICITSTATE_BACKWARDS;
 197         if(self.velocity * v_right > 0)
 198                 s |= ANIMIMPLICITSTATE_RIGHT;
 199         if(self.velocity * v_right < 0)
 200                 s |= ANIMIMPLICITSTATE_LEFT;
 201         if(vlen(self.velocity) > 100)
 202                 s |= ANIMIMPLICITSTATE_RUN;
 203
 204         // TODO infer jumping too!
 205 }
 206 void animdecide_setframes(entity e, float support_blending)
 207 {
 208         animdecide_setimplicitstate(e);
 209         // _x: frame
 210         // _y: priority
 211         // _z: start time
 212         vector upper = animdecide_getupperanim(e);
 213         vector lower = animdecide_getloweranim(e);
 214         if(upper_y > lower_y)
 215                 lower = upper;
 216         else if(lower_y > upper_y)
 217                 upper = lower;
 218         if(support_blending)
 219         {
 220                 self.frame = upper_x;
 221                 self.frame1time = upper_z;
 222                 self.frame2 = lower_x;
 223                 self.frame2time = lower_z;
 224         }
 225         else
 226         {
 227                 self.frame = upper_x;
 228                 self.frame1time = upper_z;
 229         }
 230 }
 231
 232 void animdecide_setstate(entity e, float newstate, float restart)
 233 {
 234         if(!restart)
 235                 if(newstate == e.anim_state)
 236                         return;
 237         e.anim_state = newstate;
 238         e.anim_time = time;
 239 }
 240 void animdecide_setaction(entity e, float action, float restart)
 241 {
 242         if(action < 0)
 243         {
 244                 if(!restart)
 245                         if(action == e.anim_lower_action)
 246                                 return;
 247                 e.anim_lower_action = action;
 248                 e.anim_lower_time = time;
 249         }
 250         else
 251         {
 252                 if(!restart)
 253                         if(action == e.anim_upper_action)
 254                                 return;
 255                 e.anim_upper_action = action;
 256                 e.anim_upper_time = time;
 257         }
 258 }