prj/cam/src/ai/aiutils.h

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6 ///////////////////////////////////////////////////////////////////////////////
   7 // $Header: r:/t2repos/thief2/src/ai/aiutils.h,v 1.20 2000/02/28 19:35:19 bfarquha Exp $
   8 //
   9 // Utility functions and wrappers to the outside world
  10 //
  11
  12 #ifndef __AIUTILS_H
  13 #define __AIUTILS_H
  14
  15 #pragma once
  16
  17 #include <dynarray.h>
  18
  19 #include <aitype.h>
  20 #include <aidist.h>
  21 #include <rand.h>
  22 #include <simtime.h>
  23
  24 F_DECLARE_INTERFACE(ITagFile);
  25
  26 ///////////////////////////////////////////////////////////////////////////////
  27
  28 inline void ProjectFromLocationOnZPlane(const mxs_vector & startLoc, float distance, floatang angle, mxs_vector * pResult)
  29 {
  30    pResult->x = startLoc.x + cos(angle.value) * distance;
  31    pResult->y = startLoc.y + sin(angle.value) * distance;
  32    pResult->z = startLoc.z;
  33 }
  34
  35 ///////////////////////////////////////////////////////////////////////////////
  36
  37 inline float AICompueZAngle(const mxs_vector & fromLoc, const mxs_vector & toLoc)
  38 {
  39    floatang result(0, 0, AIXYDistance(fromLoc, toLoc), ffabsf(fromLoc.z - toLoc.z));
  40    return ffabsf(result.value);
  41 }
  42
  43 ///////////////////////////////////////////////////////////////////////////////
  44
  45 #define kLineIntersect   0
  46 #define kLineNoIntersect 1
  47 #define kLineIdent       2
  48
  49 int GetXYIntersection(const mxs_vector & line1a, const mxs_vector & line1b,
  50                       const mxs_vector & line2a, const mxs_vector & line2b,
  51                       mxs_vector * pResult);
  52
  53 int GetXYSegmentIntersect(const mxs_vector & seg1a, const mxs_vector & seg1b,
  54                           const mxs_vector & seg2a, const mxs_vector & seg2b,
  55                           mxs_vector * pResult);
  56
  57 int GetXYLineSegIntersect(const mxs_vector & line1a, const mxs_vector & line1b,
  58                           const mxs_vector & seg2a, const mxs_vector & seg2b,
  59                           mxs_vector * pResult);
  60
  61 ///////////////////////////////////////////////////////////////////////////////
  62 //
  63 // Object manipulation
  64 //
  65
  66 typedef struct Position Position;
  67
  68 BOOL GetObjPosition(ObjID obj, Position * p);
  69 BOOL GetObjLocation(ObjID obj, mxs_vector * p);
  70 const mxs_vector * GetObjLocation(ObjID obj);
  71 BOOL GetObjFacing(ObjID obj, floatang * pFacing);
  72 void GetObjVelocity(ObjID obj, mxs_vector * p);
  73 void GetObjAngVelocity(ObjID obj, mxs_vector * p);
  74 void SetObjImpulse(ObjID obj, float x, float y, float z, float facing, BOOL rotating = TRUE);
  75
  76 typedef mxs_vector tAIFloorBBox[4];
  77 BOOL AIGetObjFloorBBox(ObjID object, tAIFloorBBox * pBBox, const mxs_vector * pAltLoc = NULL, const mxs_angvec * pAltFac = NULL);
  78
  79 BOOL AIGetPhysSphereZMinMax(ObjID object, float *pMinZ, float *pMaxZ);
  80
  81 ///////////////////////////////////////////////////////////////////////////////
  82 //
  83 // Door manipulation
  84 //
  85
  86 enum eAIDoorFlags
  87 {
  88    kAIDF_BlocksVision = 0x01,
  89    kAIDF_LargeDoor = 0x02
  90 };
  91
  92 struct sAIDoorInfo
  93 {
  94    ObjID    obj;
  95    unsigned flags;
  96 };
  97
  98 const cDynArray<sAIDoorInfo> & AIGetDoors();
  99 void AIUpdateDoors();
 100
 101 ///////////////////
 102
 103 BOOL AICanOpenDoor(ObjID ai, ObjID obj);
 104 BOOL AIDoorIsOpen(ObjID obj);
 105 void AIOpenDoor(ObjID ai, ObjID door);
 106 void AICloseDoor(ObjID ai, ObjID door, BOOL all=TRUE);
 107
 108 ///////////////////
 109
 110 struct sAIDoorBBox
 111 {
 112    ObjID        object;
 113    tAIFloorBBox bbox;
 114 };
 115
 116 void AIGetDoorFloorBBoxes(cDynArray<sAIDoorBBox> *);
 117
 118 ///////////////////////////////////////////////////////////////////////////////
 119
 120 #define AIGetTime()       GetSimTime()
 121 #define AIGetFrameTime()  GetSimFrameTime()
 122
 123 ///////////////////////////////////////////////////////////////////////////////
 124
 125 #define AIRandom(low, high) \
 126    RandRange(low, high)
 127
 128 ///////////////////////////////////////////////////////////////////////////////
 129 //
 130 // FUNCTION: AIDecide
 131 //
 132 // Most Dark AI decisions are intended to be based on simple comparisons
 133 // of choices with clear tie-breaking rules. In the case of a perfect tie,
 134 // the choice is random. This template function standardizes this process
 135 // for anyone in the AI who needs to make such decisions. To use it, you'll
 136 // simply need to write a sort function.
 137 //
 138 // Note the macro use and voids are here only to allow both Microsoft and
 139 // Watcom to both compile.
 140 //
 141 // The compare function prototype is:
 142 //  int MyCompare(tOption **, tOption **)
 143
 144 typedef int (*tAICompareFunc)(const void *, const void *);
 145
 146 ///////////////////////////////////////
 147
 148 #define AIDecide(ppOptions, nOptions, pfnCompare, pTieBreak) \
 149    _AIDecide(ppOptions, nOptions, ((tAICompareFunc)pfnCompare), (void *)(pTieBreak))
 150
 151 ///////////////////////////////////////
 152
 153 template <class tOption, class tCount>
 154 inline
 155 tOption * _AIDecide(tOption **     ppOptions,
 156                     tCount         nOptions,
 157                     tAICompareFunc pfnCompare,
 158                     void  *        pTieBreakVoid)
 159 {
 160    tOption ** ppFirstBest;
 161    tOption ** ppLastBest;
 162    tOption *  pTieBreak = (tOption *) pTieBreakVoid;
 163
 164    // Quick outs...
 165    if (!nOptions)
 166       return NULL;
 167
 168    if (nOptions == 1)
 169       return *ppOptions;
 170
 171    // First, sort the array. The best options will be at the end...
 172    qsort(ppOptions, nOptions, sizeof(tOption *), pfnCompare);
 173
 174    ppLastBest = ppOptions + (nOptions - 1);
 175
 176    // If the current activity is of equal value as the best, just keep on with that
 177    if (pTieBreak && (*pfnCompare)((const void *)(&pTieBreak), (const void *)(ppLastBest)) == 0)
 178       return pTieBreak;
 179
 180    // Now, check if we have equal options...
 181    ppFirstBest = ppLastBest;
 182
 183    while (ppFirstBest > ppOptions)
 184    {
 185       if ((*pfnCompare)(ppFirstBest - 1, ppLastBest) == 0)
 186          ppFirstBest--;
 187       else
 188          break;
 189    }
 190
 191    // If we have equal options, pick one at random
 192    int range = ppLastBest - ppFirstBest;
 193
 194    if (range == 0)
 195       return *ppLastBest;
 196
 197    return *(ppFirstBest + AIRandom(0, range));
 198 }
 199
 200 ///////////////////////////////////////////////////////////////////////////////
 201 //
 202 // CLASS: cAITimer; consolodation of AI's simple scheduling mechanism
 203 //
 204 // Times are set out as an enum to reduce phase shifting issues somewhat.
 205 //
 206
 207 enum eAITimerPeriod
 208 {
 209    kAIT_Min = 1,
 210
 211    kAIT_40Hz   = 25,
 212    kAIT_20Hz   = 50,
 213    kAIT_10Hz   = 100,
 214    kAIT_2Hz    = 500,
 215
 216    kAIT_1Sec   = 1000,
 217    kAIT_2Sec   = 2000,
 218    kAIT_10Sec  = 10000,
 219    kAIT_20Sec  = 20000,
 220
 221    kAIT_Infinite = 0x7fffffff,
 222
 223    // AI elements run 20 by default
 224    kAIT_Default = kAIT_20Hz,
 225    kAIT_Max = 0xffffffff,
 226 };
 227
 228 //
 229 // This is a type violation, but a mild one. If you really
 230 // want a nonstandard time, use this to make it
 231 //
 232 #define AICustomTime(t) ((eAITimerPeriod)(t))
 233
 234 class cAITimer
 235 {
 236 public:
 237    cAITimer(eAITimerPeriod period = kAIT_Default);
 238
 239    void Set(eAITimerPeriod period);
 240    void Reset();
 241
 242    BOOL Expired() const;
 243
 244    unsigned Remaining() const;
 245
 246    void Force();
 247    void Delay(unsigned delay);
 248
 249    void Save(ITagFile *);
 250    void Load(ITagFile *);
 251
 252 private:
 253    unsigned m_Expiration;
 254    unsigned m_Period;
 255 };
 256
 257 ///////////////////////////////////////////////////////////////////////////////
 258 //
 259 // Variant of timer used for "random" activity
 260 //
 261
 262 class cAIRandomTimer
 263 {
 264 public:
 265    cAIRandomTimer(unsigned low, unsigned high);
 266
 267    void Set(unsigned low, unsigned high);
 268    void Reset();
 269
 270    BOOL Expired() const;
 271
 272    unsigned Remaining() const;
 273
 274    void Force();
 275    void Delay(unsigned delay);
 276
 277    void Save(ITagFile *);
 278    void Load(ITagFile *);
 279
 280 private:
 281    unsigned m_Expiration;
 282    ushort   m_Low;
 283    ushort   m_High;
 284 };
 285
 286 ///////////////////////////////////////////////////////////////////////////////
 287 //
 288 // cAITimer inline functions
 289 //
 290
 291 inline cAITimer::cAITimer(eAITimerPeriod period)
 292  : m_Expiration(0),
 293    m_Period(period)
 294 {
 295 }
 296
 297 ///////////////////////////////////////
 298
 299 inline BOOL cAITimer::Expired() const
 300 {
 301   return (!m_Expiration || AIGetTime() > m_Expiration);
 302 }
 303
 304 ///////////////////////////////////////
 305
 306 inline unsigned cAITimer::Remaining() const
 307 {
 308    if (m_Expiration == kAIT_Infinite)
 309       return kAIT_Infinite;
 310
 311    unsigned time = AIGetTime();
 312
 313    if (!m_Expiration || time > m_Expiration)
 314       return 0;
 315
 316    return m_Expiration - time;
 317 }
 318
 319 ///////////////////////////////////////
 320
 321 inline void cAITimer::Reset()
 322 {
 323    m_Expiration = AIGetTime() + m_Period;
 324 }
 325
 326 ///////////////////////////////////////
 327
 328 inline void cAITimer::Force()
 329 {
 330    m_Expiration = 0;
 331 }
 332
 333 ///////////////////////////////////////
 334
 335 inline void cAITimer::Set(eAITimerPeriod period)
 336 {
 337    m_Period     = period;
 338    m_Expiration = AIGetTime() + m_Period;
 339 }
 340
 341 ///////////////////////////////////////
 342
 343 inline void cAITimer::Delay(unsigned delay)
 344 {
 345    m_Expiration = (delay == kAIT_Infinite) ? kAIT_Infinite : AIGetTime() + delay;
 346 }
 347
 348 ///////////////////////////////////////////////////////////////////////////////
 349 //
 350 // cAIRandomTimer inline functions
 351 //
 352
 353 inline cAIRandomTimer::cAIRandomTimer(unsigned low, unsigned high)
 354  : m_Expiration(0),
 355    m_Low((ushort)low),
 356    m_High((ushort)high)
 357 {
 358 }
 359
 360 ///////////////////////////////////////
 361
 362 inline BOOL cAIRandomTimer::Expired() const
 363 {
 364   return (m_High && (!m_Expiration || AIGetTime() > m_Expiration));
 365 }
 366
 367 ///////////////////////////////////////
 368
 369 inline unsigned cAIRandomTimer::Remaining() const
 370 {
 371    if (m_Expiration == kAIT_Infinite)
 372       return kAIT_Infinite;
 373
 374    unsigned time = AIGetTime();
 375
 376    if (!m_Expiration || time > m_Expiration)
 377       return 0;
 378
 379    return m_Expiration - time;
 380 }
 381
 382 ///////////////////////////////////////
 383
 384 inline void cAIRandomTimer::Reset()
 385 {
 386    m_Expiration = AIGetTime() + AIRandom(m_Low, m_High);
 387 }
 388
 389 ///////////////////////////////////////
 390
 391 inline void cAIRandomTimer::Force()
 392 {
 393    m_Expiration = 0;
 394 }
 395
 396 ///////////////////////////////////////
 397
 398 inline void cAIRandomTimer::Set(unsigned low, unsigned high)
 399 {
 400    m_Low = (ushort)low;
 401    m_High = (ushort)high;
 402    m_Expiration = AIGetTime() + AIRandom(m_Low, m_High);
 403 }
 404
 405 ///////////////////////////////////////
 406
 407 inline void cAIRandomTimer::Delay(unsigned delay)
 408 {
 409    m_Expiration = (delay == kAIT_Infinite) ? kAIT_Infinite : AIGetTime() + delay;
 410 }
 411
 412 ///////////////////////////////////////////////////////////////////////////////
 413
 414 void CalcArc(mxs_vector* pDir, float initVelocity, float gravity);
 415
 416 ///////////////////////////////////////////////////////////////////////////////
 417
 418 BOOL DoorIsBig(ObjID door);
 419
 420 #endif /* !__AIUTILS_H */