2 additional AI turn actions

game/game/constants.h

@@ -383,7 +383,9 @@ enum Action:uint32_t {
   AI_PointAt,
   AI_StopPointAt,
   AI_PrintScreen,
-  AI_LookAt
+  AI_LookAt,
+  AI_WhirlToNpc,
+  AI_TurnAway,
   };
 
 

game/game/gamescript.cpp

@@ -242,7 +242,9 @@ void GameScript::initCommon() {
   bindExternal("ai_lookatnpc",                   &GameScript::ai_lookatnpc);
   bindExternal("ai_removeweapon",                &GameScript::ai_removeweapon);
   bindExternal("ai_unreadyspell",                &GameScript::ai_unreadyspell);
+  bindExternal("ai_turnaway",                    &GameScript::ai_turnaway);
   bindExternal("ai_turntonpc",                   &GameScript::ai_turntonpc);
+  bindExternal("ai_whirlaround",                 &GameScript::ai_whirlaround);
   bindExternal("ai_outputsvm",                   &GameScript::ai_outputsvm);
   bindExternal("ai_outputsvm_overlay",           &GameScript::ai_outputsvm_overlay);
   bindExternal("ai_startstate",                  &GameScript::ai_startstate);
@@ -2920,13 +2922,27 @@ void GameScript::ai_unreadyspell(std::shared_ptr<zenkit::INpc> npcRef) {
     npc->aiPush(AiQueue::aiRemoveWeapon());
   }
 
+void GameScript::ai_turnaway(std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> npcRef) {
+  auto npc  = findNpc(npcRef);
+  auto self = findNpc(selfRef);
+  if(self!=nullptr)
+    self->aiPush(AiQueue::aiTurnAway(npc));
+  }
+
 void GameScript::ai_turntonpc(std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> npcRef) {
   auto npc  = findNpc(npcRef);
   auto self = findNpc(selfRef);
   if(self!=nullptr)
     self->aiPush(AiQueue::aiTurnToNpc(npc));
   }
 
+void GameScript::ai_whirlaround(std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> npcRef) {
+  auto npc  = findNpc(npcRef);
+  auto self = findNpc(selfRef);
+  if(self!=nullptr)
+    self->aiPush(AiQueue::aiWhirlToNpc(npc));
+  }
+
 void GameScript::ai_outputsvm(std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> targetRef, std::string_view name) {
   auto target = findNpc(targetRef);
   auto self   = findNpc(selfRef);

game/game/gamescript.h

@@ -374,7 +374,9 @@ class GameScript final {
     void ai_lookatnpc        (std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> npcRef);
     void ai_removeweapon     (std::shared_ptr<zenkit::INpc> npcRef);
     void ai_unreadyspell     (std::shared_ptr<zenkit::INpc> npcRef);
+    void ai_turnaway         (std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> npcRef);
     void ai_turntonpc        (std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> npcRef);
+    void ai_whirlaround      (std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> npcRef);
     void ai_outputsvm        (std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> targetRef, std::string_view name);
     void ai_outputsvm_overlay(std::shared_ptr<zenkit::INpc> selfRef, std::shared_ptr<zenkit::INpc> targetRef, std::string_view name);
     void ai_startstate       (std::shared_ptr<zenkit::INpc> selfRef, int func, int state, std::string_view wp);

game/game/playercontrol.cpp

@@ -1087,7 +1087,7 @@ void PlayerControl::processAutoRotate(Npc& pl, float& rot, uint64_t dt) {
       float step = float(pl.world().script().guildVal().turn_speed[gl]);
       if(actrl[ActGeneric])
         step*=2.f;
-      pl.rotateTo(dp.x,dp.z,step,false,dt);
+      pl.rotateTo(dp.x,dp.z,step,AnimationSolver::TurnType::Std,dt);
       rot = pl.rotation();
       }
     }

game/graphics/mdlvisual.cpp

@@ -588,7 +588,8 @@ const Animation::Sequence* MdlVisual::startAnimAndGet(Npc& npc, AnimationSolver:
                                                       uint8_t comb,
                                                       WeaponState st, WalkBit wlk) {
   // for those use MdlVisual::setRotation
-  assert(a!=AnimationSolver::Anim::RotL && a!=AnimationSolver::Anim::RotR);
+  assert(a!=AnimationSolver::Anim::RotL && a!=AnimationSolver::Anim::RotR &&
+         a!=AnimationSolver::Anim::WhirlL && a!=AnimationSolver::Anim::WhirlR);
 
   if(a==AnimationSolver::InteractIn ||
      a==AnimationSolver::InteractOut ||
@@ -651,6 +652,8 @@ const Animation::Sequence* MdlVisual::startAnimAndGet(Npc& npc, AnimationSolver:
         bs = BS_RUN;
     case AnimationSolver::Anim::RotL:
     case AnimationSolver::Anim::RotR:
+    case AnimationSolver::Anim::WhirlL:
+    case AnimationSolver::Anim::WhirlR:
       break;
     case AnimationSolver::Anim::Fall:
     case AnimationSolver::Anim::FallDeep:
@@ -740,7 +743,11 @@ bool MdlVisual::startAnim(Npc &npc, WeaponState st) {
   }
 
 void MdlVisual::setAnimRotate(Npc &npc, int dir) {
-  skInst->setAnimRotate(solver,npc,fgtMode,dir);
+  skInst->setAnimRotate(solver,npc,fgtMode,AnimationSolver::TurnType::Std,dir);
+  }
+
+void MdlVisual::setAnimWhirl(Npc &npc, int dir) {
+  skInst->setAnimRotate(solver,npc,fgtMode,AnimationSolver::TurnType::Whirl,dir);
   }
 
 void MdlVisual::interrupt() {

game/graphics/mdlvisual.h

@@ -100,6 +100,7 @@ class MdlVisual final {
     bool                           hasAnim        (std::string_view scheme) const;
     void                           stopWalkAnim   (Npc &npc);
     void                           setAnimRotate  (Npc &npc, int dir);
+    void                           setAnimWhirl   (Npc &npc, int dir);
 
     void                           interrupt();
     WeaponState                    fightMode() const { return fgtMode; }

game/graphics/mesh/animationsolver.cpp

@@ -277,6 +277,34 @@ const Animation::Sequence* AnimationSolver::implSolveAnim(AnimationSolver::Anim
       return solveFrm("T_%sWALKWTURNR",st);
     return solveFrm("T_%sRUNTURNR",st);
     }
+  // Whirl around
+  if(a==WhirlL) {
+    // Whirling in water should not happen, but just to make sure
+    if(bool(wlkMode & WalkBit::WM_Dive))
+      return solveFrm("T_DIVETURNL");
+    if(bool(wlkMode & WalkBit::WM_Swim))
+      return solveFrm("T_SWIMTURNL");
+
+    // whirling is only used in G1, but the script function is present
+    // in all games. In G2 all models except the human also have the
+    // needed animation.
+    const Animation::Sequence* s = solveFrm("T_SURPRISE_CCW");
+    if(s==nullptr)
+      s = solveFrm("T_%sRUNTURNL",st);
+    return s;
+    }
+  if(a==WhirlR) {
+    // Whirling in water should not happen, but just to make sure
+    if(bool(wlkMode & WalkBit::WM_Dive))
+      return solveFrm("T_DIVETURNR");
+    if(bool(wlkMode & WalkBit::WM_Swim))
+      return solveFrm("T_SWIMTURNR");
+
+    const Animation::Sequence* s = solveFrm("T_SURPRISE_CW");
+    if(s==nullptr)
+      s = solveFrm("T_%sRUNTURNR",st);
+    return s;
+    }
   // Jump regular
   if(a==Jump)
     return solveFrm("S_JUMP");

game/graphics/mesh/animationsolver.h

@@ -28,6 +28,8 @@ class AnimationSolver final {
       MoveR,
       RotL,
       RotR,
+      WhirlL,
+      WhirlR,
       Fall,
       FallDeep,
       FallDeepA,
@@ -70,6 +72,12 @@ class AnimationSolver final {
       MagNoMana
       };
 
+    enum TurnType : uint8_t {
+      Std = 0,
+      None,
+      Whirl,
+      };
+
     struct Overlay final {
       const Skeleton* skeleton=nullptr;
       uint64_t        time    =0;

game/graphics/mesh/pose.cpp

@@ -812,7 +812,7 @@ Vec2 Pose::headRotation() const {
   return Vec2(headRotX,headRotY);
   }
 
-void Pose::setAnimRotate(const AnimationSolver &solver, Npc &npc, WeaponState fightMode, int dir) {
+void Pose::setAnimRotate(const AnimationSolver &solver, Npc &npc, WeaponState fightMode, AnimationSolver::TurnType turn, int dir) {
   const Animation::Sequence *sq = nullptr;
   if(dir==0) {
     if(rotation!=nullptr) {
@@ -823,11 +823,15 @@ void Pose::setAnimRotate(const AnimationSolver &solver, Npc &npc, WeaponState fi
     }
   if(bodyState()!=BS_STAND)
     return;
-  if(dir<0) {
-    sq = solver.solveAnim(AnimationSolver::Anim::RotL,fightMode,npc.walkMode(),*this);
+
+  enum AnimationSolver::Anim ani;
+  if(turn==AnimationSolver::TurnType::Whirl) {
+    ani = (dir<0)?AnimationSolver::Anim::WhirlL:AnimationSolver::Anim::WhirlR;
     } else {
-    sq = solver.solveAnim(AnimationSolver::Anim::RotR,fightMode,npc.walkMode(),*this);
+    ani = (dir<0)?AnimationSolver::Anim::RotL:AnimationSolver::Anim::RotR;
     }
+
+  sq = solver.solveAnim(ani,fightMode,npc.walkMode(),*this);
   if(rotation!=nullptr) {
     if(sq!=nullptr && rotation->name==sq->name)
       return;

game/graphics/mesh/pose.h

@@ -7,6 +7,7 @@
 
 #include "game/constants.h"
 #include "animation.h"
+#include "animationsolver.h"
 #include "resources.h"
 
 class Skeleton;
@@ -84,7 +85,7 @@ class Pose final {
 
     void               setHeadRotation(float dx, float dz);
     Tempest::Vec2      headRotation() const;
-    void               setAnimRotate(const AnimationSolver &solver, Npc &npc, WeaponState fightMode, int dir);
+    void               setAnimRotate(const AnimationSolver &solver, Npc &npc, WeaponState fightMode, AnimationSolver::TurnType turn, int dir);
     auto               setAnimItem(const AnimationSolver &solver, Npc &npc, std::string_view scheme, int state) -> const Animation::Sequence*;
     bool               stopItemStateAnim(const AnimationSolver &solver, uint64_t tickCount);
 

game/world/aiqueue.cpp

@@ -98,13 +98,27 @@ AiQueue::AiAction AiQueue::aiRemoveWeapon() {
   return a;
   }
 
+AiQueue::AiAction AiQueue::aiTurnAway(Npc *other) {
+  AiAction a;
+  a.act    = AI_TurnAway;
+  a.target = other;
+  return a;
+  }
+
 AiQueue::AiAction AiQueue::aiTurnToNpc(Npc *other) {
   AiAction a;
   a.act    = AI_TurnToNpc;
   a.target = other;
   return a;
   }
 
+AiQueue::AiAction AiQueue::aiWhirlToNpc(Npc *other) {
+  AiAction a;
+  a.act    = AI_WhirlToNpc;
+  a.target = other;
+  return a;
+  }
+
 AiQueue::AiAction AiQueue::aiGoToNpc(Npc *other) {
   AiAction a;
   a.act    = AI_GoToNpc;

game/world/aiqueue.h

@@ -46,7 +46,9 @@ class AiQueue {
     static AiAction aiLookAtNpc(Npc* other);
     static AiAction aiStopLookAt();
     static AiAction aiRemoveWeapon();
+    static AiAction aiTurnAway (Npc *other);
     static AiAction aiTurnToNpc(Npc *other);
+    static AiAction aiWhirlToNpc(Npc *other);
     static AiAction aiGoToNpc  (Npc *other);
     static AiAction aiGoToNextFp(std::string_view fp);
     static AiAction aiStartState(ScriptFn stateFn, int behavior, Npc *other, Npc* victim, std::string_view wp);