prj/cam/src/motion/crwpnapi.cpp

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6
   7 // $Header: r:/t2repos/thief2/src/motion/crwpnapi.cpp,v 1.2 2000/01/07 14:33:15 BODISAFA Exp $
   8
   9 // until this is propertized, this is completely shock/gamesys specific, sadly
  10 // if it were propertized, that would be way less true
  11
  12 // in particular, we would want a nethandweapon property, or something
  13 // which had all the data for a weapon converting from world to handheld
  14 // then at init time, we would scan that property and build our table
  15 // (which would just be obj->obj)
  16
  17 // at that point, we could pass that across, and the actual table data would
  18 // be in the property.
  19
  20 // if we did that, we could probably make this truly ghost, and not have the
  21 // shock dependancy we currently obviously have
  22
  23 #include <lg.h>
  24 #include <comtools.h>
  25 #include <appagg.h>
  26
  27 #include <crattach.h>
  28 #include <crwpnlst.h>
  29 #include <crwpnapi.h>
  30 #include <linkman.h>
  31 #include <linktype.h>
  32 #include <relation.h>
  33 #include <appagg.h>
  34 #include <linkbase.h>
  35 #include <matrix.h>
  36 #include <mxmat.h>
  37 #include <objsys.h>
  38 #include <objdef.h>
  39 #include <iobjsys.h>
  40
  41 #include <cretprop.h>
  42 #include <weapon.h>
  43 #include <objedit.h>
  44 #include <mprintf.h>
  45
  46 #include <refsys.h>
  47
  48 #include <crjoint.h> // Range checking on joints.
  49
  50 #include <creature.h>   // CreatureFromObj
  51
  52 // Drop object
  53 #include <physapi.h>
  54 #include <prjctile.h>
  55 #include <phnet.h>
  56 #include <traitman.h>
  57 #include <traitbas.h>
  58 #include <objquery.h>
  59 #include <aiapi.h>
  60
  61 #include <dbmem.h>
  62
  63 // for weapon object solving
  64 int  (*CreatureWeaponObjSwizzle) (ObjID weapon, int mode) = NULL;
  65 BOOL (*CreatureWeaponObjCreate)  (ObjID id, int mode)     = NULL;
  66 void (*CreatureWeaponObjDestroy) (ObjID id)               = NULL;
  67 void (*CreatureWeaponObjDrop)    (ObjID id)               = NULL;
  68
  69 // @TODO:  Bodisafa 12/9/1999
  70 // This needs to be in Dark & DeepC.
  71 BOOL CreatureWeaponCreate(ObjID id, int mode);
  72 void CreatureWeaponDestroy(ObjID id);
  73 int  CreatureWeaponSwizzle(ObjID id, int mode);
  74 void CreatureWeaponDrop(ObjID id);
  75
  76 // Init/Term
  77 void CreatureWeaponInit(void)
  78 {
  79    // @TODO:  Bodisafa 11/30/1999
  80    // This needs to be in Dark & DeepC.
  81    CreatureWeaponObjCreate  = CreatureWeaponCreate;
  82    CreatureWeaponObjDestroy = CreatureWeaponDestroy;
  83    CreatureWeaponObjSwizzle = CreatureWeaponSwizzle;
  84    CreatureWeaponObjDrop    = CreatureWeaponDrop;
  85
  86    CreatureWeaponListInit();
  87 }
  88
  89 void CreatureWeaponTerm(void)
  90 {
  91    CreatureWeaponListTerm();
  92 }
  93
  94 // @TODO:  Bodisafa 11/30/1999
  95 // ObjHasWeaponOffset checks should be reduced to the correct code flow.
  96 // Otherwise, we're doing too many redundant checks.
  97 // Assert in the other cases.
  98
  99 // Creature Weapon List
 100
 101 // GetWeaponIdForMode:  Returns the appropriate ObjID for the current mode.
 102 ObjID GetWeaponIdForMode(ObjID id, int mode)
 103 {
 104    if (id != OBJ_NULL && (ObjHasWeaponOffset(id)))
 105    {
 106       if (WeaponOffsetSetActive(id, mode))
 107       {
 108          int referenceID =  WeaponOffsetGetDest(id);
 109          if (referenceID != OBJ_NULL)
 110          {
 111             return referenceID;
 112          }
 113       }
 114    }
 115 //   Warning(("GetWeaponIdForMode: No weapon for object '%d' in mode '%d'\n", id, mode));
 116    return OBJ_NULL;
 117 }
 118
 119 // CreatureWeaponAttachWeapon: Hooks up creatures weapon for a given mode.
 120 // Input:
 121 // ppCreat     - Creature weapon information.
 122 // referenceID - Uses this ID to construct a new weapon.
 123 // mode        - What mode is the creature in?
 124 void CreatureWeaponAttachWeapon(sCreatureWeapon **ppCreat, int referenceID, int mode)
 125 {
 126    const sCreatureWeapon* pCW = *ppCreat;
 127
 128    if (!ObjHasWeaponOffset(pCW->obj))
 129    {
 130       mprintf("CreatureWeaponAttachWeapon:  returning - !WeaponOffsetProp\n");
 131       return;
 132    }
 133
 134    // Same weapon or we have this weapon attached.
 135    if (pCW->nWeapon == referenceID || (pCW->weaponObj == referenceID))
 136    {
 137 //      Warning(("CreatureWeaponAttachWeapon:  returning - nothing to do\n"));
 138       return;
 139    }
 140
 141    AutoAppIPtr_(ObjectSystem, pObjSys);
 142
 143    // If we currently holding a weapon, destroy it.
 144    if (pCW->weaponObj != OBJ_NULL)
 145    {
 146       mprintf("CreatureWeaponAttachWeapon:  destroying (%d,%d)\n", (*ppCreat)->nWeapon, referenceID);
 147       pObjSys->Destroy(pCW->weaponObj);
 148       (*ppCreat)->weaponObj = OBJ_NULL;
 149    }
 150
 151    (*ppCreat)->nWeapon = referenceID;
 152    (*ppCreat)->weaponObj = BeginObjectCreate(referenceID, kObjectConcrete);
 153    if ((*ppCreat)->weaponObj == OBJ_NULL)
 154    {
 155       Warning(("CreatureWeaponAttachWeapon: Failed to create weapon no object id %d\n", referenceID));
 156       return;
 157    }
 158
 159    EndObjectCreate(pCW->weaponObj);
 160
 161    sCreatureAttachInfo Info;
 162    memset(&Info,0,sizeof(Info));
 163
 164    if (WeaponOffsetSetActive(pCW->obj, mode))
 165    {
 166       Info.joint = WeaponOffsetGetJoint(pCW->obj);
 167       if (Info.joint >= 0 && Info.joint < kCJ_NumCreatureJoints)
 168       {
 169          mxs_vector* pTransform = WeaponOffsetGetTransform(pCW->obj);
 170
 171          Assert_(pTransform != NULL);
 172          mxs_trans trans = {pTransform[0].x, pTransform[0].y, pTransform[0].z,
 173                             pTransform[1].x, pTransform[1].y, pTransform[1].z,
 174                             pTransform[2].x, pTransform[2].y, pTransform[2].z,
 175                             pTransform[3].x, pTransform[3].y, pTransform[3].z};
 176
 177          mx_copy_trans(&Info.relTrans, &trans);
 178
 179          CreatureAttachItem(pCW->obj, pCW->weaponObj, &Info);
 180
 181          // Creatures don't support weapons with physics.
 182          CreatureMakeWeaponNonPhysical(pCW->obj, pCW->weaponObj);
 183
 184          // mprintf("Attach %s to %s\n",ObjWarnName(pCW->weaponObj),ObjWarnName(pCW->obj));
 185       }
 186    }
 187 }
 188
 189 inline BOOL WeaponSwizzle(ObjID id, ObjID referenceID, int mode)
 190 {
 191    // Nothing to do.
 192    if (!ObjHasWeaponOffset(id) || (referenceID == OBJ_NULL))
 193    {
 194       return FALSE;
 195    }
 196
 197    // We're on the way to the deathbed...or at least we're not feeling better yet.
 198    cCreature* pCreat = CreatureFromObj(id);
 199    if (pCreat == NULL)
 200    {
 201       return FALSE;
 202    }
 203
 204    IAI* pAI = AppGetObj(IAIManager)->GetAI(id);
 205    if (!pCreat->IsPhysical() || !PhysObjHasPhysics(id) || (pAI && pAI->IsDying()))
 206    {
 207       pAI->Release();
 208       return FALSE;
 209    }
 210
 211    if (pAI)
 212    {
 213       pAI->Release();
 214    }
 215
 216    sCreatureWeapon *pCW = CreatureWeaponGet(id);
 217
 218    // Verify referenceID is valid and creature weapon is in the list.
 219    if (pCW != NULL)
 220    {
 221       CreatureWeaponAttachWeapon(&pCW, referenceID, mode);
 222    }
 223    else if (CreatureWeaponObjCreate)
 224    {
 225       (*CreatureWeaponObjCreate)(id, mode);
 226    }
 227    return TRUE;
 228 }
 229
 230 int CreatureWeaponSwizzle(ObjID id, int mode)
 231 {
 232    // Get creature's reference ID for this mode.
 233    ObjID referenceID = GetWeaponIdForMode(id, mode);
 234    if (referenceID)
 235    {
 236       return WeaponSwizzle(id, referenceID, mode);
 237    }
 238    return FALSE;
 239 }
 240
 241 BOOL CreatureWeaponCreate(ObjID id, int mode)
 242 {
 243    if (!ObjHasWeaponOffset(id))
 244    {
 245       return FALSE;
 246    }
 247
 248    CreatureWeaponAdd(id);
 249    // Find and swizzle to this weapon.
 250    int referenceID = GetWeaponIdForMode(id, mode);
 251    if (referenceID == OBJ_NULL)
 252    {
 253       Warning(("CreatureWeaponCreate: Invalid referenceID for Object '%d'\n", id));
 254       return FALSE;
 255    }
 256    return WeaponSwizzle(id, referenceID, mode);
 257 }
 258
 259 void CreatureWeaponDestroy(ObjID id)
 260 {
 261    if (!ObjHasWeaponOffset(id))
 262    {
 263       return;
 264    }
 265
 266    sCreatureWeapon *pCW = CreatureWeaponGet(id);
 267    if (pCW)
 268    {
 269       LinkID linkID = (g_pCreatureAttachRelation->GetSingleLink(id, pCW->weaponObj));
 270       if (linkID)
 271       {
 272          g_pCreatureAttachRelation->Remove(linkID);
 273       }
 274
 275            CreatureDetachItem(id, pCW->weaponObj);
 276            DestroyObject(pCW->weaponObj);
 277            pCW->weaponObj = NULL;
 278       CreatureWeaponRem(id);
 279    }
 280
 281    // Totally safety - yes it is crude.
 282    ClearWeaponOffsetCache();
 283 }
 284
 285 #ifdef DEEPC
 286 // EXTERN void ThrowObj(ObjID o, ObjID src);
 287 static BOOL DoThrowObj(ObjID thrower, ObjID obj, float power)
 288 {
 289    if (CreatureExists(obj))
 290    {
 291       mxs_matrix orien;
 292       mxs_vector launch_pos;
 293       mxs_vector launch_dir;
 294       mxs_angvec launch_fac;
 295
 296       launch_fac = ObjPosGet(thrower)->fac;
 297       launch_fac.tx = 0;
 298       launch_fac.ty = 0;
 299       mx_ang2mat(&orien, &launch_fac);
 300
 301       mx_copy_vec(&launch_dir, &orien.vec[0]);
 302
 303       mx_scale_add_vec(&launch_pos, &ObjPosGet(thrower)->loc.vec, &launch_dir, 1.0);
 304
 305       launch_dir.z = 2.0;
 306
 307       ObjPosUpdate(obj, &launch_pos, &launch_fac);
 308
 309       VALIDATE_CREATURE_POS(FALSE);
 310
 311       CreatureMakeBallistic(obj, kCMB_Compressed);
 312
 313       if (!PhysObjValidPos(obj, NULL))
 314       {
 315          CreatureMakeNonBallistic(obj);
 316          CreatureMakeNonPhysical(obj);
 317
 318          VALIDATE_CREATURE_POS(TRUE);
 319
 320          return FALSE;
 321       }
 322
 323       VALIDATE_CREATURE_POS(TRUE);
 324
 325       // Set the make-non-physical-on-sleep flag
 326       //#define REMOVE_ON_SLEEP
 327 #ifdef REMOVE_ON_SLEEP
 328       cPhysTypeProp *pTypeProp;
 329       g_pPhysTypeProp->Get(obj, &pTypeProp);
 330       pTypeProp->remove_on_sleep = TRUE;
 331       g_pPhysTypeProp->Set(obj, pTypeProp);
 332 #endif
 333
 334       launchProjectile(thrower, obj, power / 6,PRJ_FLG_MASSIVE | PRJ_FLG_FROMPOS, NULL, &launch_dir, NULL);
 335
 336       return TRUE;
 337    }
 338    else
 339    {
 340 #ifdef NEW_NETWORK_ENABLED
 341       // @HACK: This really ought to wait until we see whether we have
 342       // successfully launched the thing before doing this. But the timing
 343       // of networking currently requires us to tell everyone that we're
 344       // physicalizing before we launch. We also need to super-hack this
 345       // with ForceContained, because otherwise the physicalize message
 346       // won't go through:
 347       PhysNetForceContainedMsgs(TRUE);
 348 //      PhysRegisterSphereDefault(obj);
 349 #endif
 350
 351       BOOL launched = (launchProjectile(thrower,obj,power,PRJ_FLG_PUSHOUT|PRJ_FLG_MASSIVE,NULL,NULL,NULL) != OBJ_NULL);
 352
 353 #ifdef NEW_NETWORK_ENABLED
 354       PhysNetBroadcastObjPosByObj(obj);
 355       PhysNetForceContainedMsgs(FALSE);
 356 #endif
 357
 358       return launched;
 359    }
 360 }
 361
 362 #endif // DEEPC
 363
 364 void CreatureWeaponDrop(ObjID id)
 365 {
 366    if (ObjHasWeaponOffset(id))
 367    {
 368       sCreatureWeapon *pCW = CreatureWeaponGet(id);
 369       Assert_(pCW != NULL);
 370
 371    // @TODO:  Bodisafa 12/7/1999
 372    // Game callback setup.
 373
 374 #ifdef DEEPC
 375
 376       // Using Old & New for old & new weapon.
 377       IObjectQuery* query = AppGetObj(ITraitManager)->Query(pCW->weaponObj, kTraitQueryAllArchetypes);
 378       if (query && !query->Done())
 379       {
 380          // Grab Old's parent.
 381          query->Next();
 382
 383          // We're at the top of the tree.  This should never happen.
 384          Assert_(!query->Done());
 385
 386          // Grab the Old's parent object id.
 387          ObjID parentWeaponId = query->Object();
 388
 389          // Create New as using Old's parent id.
 390          ObjID newWeaponId = BeginObjectCreate(parentWeaponId, kObjectConcrete);
 391          if (newWeaponId == OBJ_NULL)
 392          {
 393             Warning(("CreatureWeaponDrop: Failed to create throwing weapon object '%d'\n", newWeaponId));
 394             return;
 395          }
 396          EndObjectCreate(newWeaponId);
 397
 398          // Throw New.
 399          DoThrowObj(id, newWeaponId, 0.5);
 400       }
 401
 402       else
 403       {
 404          Warning(("CreatureWeaponDrop: No parent for weapon object '%d' \n", pCW->weaponObj));
 405       }
 406
 407       // Get rid of Old.
 408       if (CreatureWeaponObjDestroy)
 409       {
 410          (*CreatureWeaponObjDestroy)(id);
 411       }
 412
 413 #else
 414       CreatureDetachItem(id, pCW->weaponObj);
 415       // throw_obj()
 416 #endif // DEEPC
 417    }
 418 }
 419
 420 ///////////////////////
 421 // warning
 422 //   this has all essentially been desupported
 423 //   in that the code above has changed to work in the real code
 424 //   but none of this was changed for new calling conventions, names, etc...
 425 //
 426 // Bodisafa 12/3/1999: This should be happy now.
 427
 428 #if 0
 429
 430 static void CreatureWeaponOutput(sCreatureAttachInfo *pInfo)
 431 {
 432    mprintf("%g,%g,%g\n",pInfo->relTrans.mat.vec[0].x,pInfo->relTrans.mat.vec[0].y,pInfo->relTrans.mat.vec[0].z);
 433    mprintf("%g,%g,%g\n",pInfo->relTrans.mat.vec[1].x,pInfo->relTrans.mat.vec[1].y,pInfo->relTrans.mat.vec[1].z);
 434    mprintf("%g,%g,%g\n",pInfo->relTrans.mat.vec[2].x,pInfo->relTrans.mat.vec[2].y,pInfo->relTrans.mat.vec[2].z);
 435 }
 436
 437 static int nWeaponObjId;
 438
 439 static sCreatureWeapon CreatureWeapon;
 440
 441 void CreatureWeaponSetObj(int nObjid)
 442 {
 443    nWeaponObjId    = nObjid;
 444    CreatureWeapon.obj = nObjid;
 445 }
 446
 447 void
 448 CreatureWeaponRotX(float vD)
 449 {
 450    sCreatureAttachInfo *pInfo = CreatureAttachmentGet(CreatureWeapon.obj, nWeaponObjId, 0);
 451    if (pInfo == NULL)
 452    {
 453       mprintf("No info\n");
 454       return;
 455
 456    }
 457    mprintf("Rotate X by %g\n",vD);
 458    sMxMatrix matrix;
 459
 460    mx_copy_mat(&matrix,&(pInfo->relTrans.mat));
 461    mx_rot_x_mat_rad(&(pInfo->relTrans.mat),&matrix,(vD/180.0)*MX_REAL_PI);
 462
 463    CreatureWeaponOutput(pInfo);
 464 }
 465
 466
 467 void
 468 CreatureWeaponRotY(float vD)
 469 {
 470    sCreatureAttachInfo *pInfo = CreatureAttachmentGet(CreatureWeapon.obj, nWeaponObjId, 0);
 471    if (pInfo == NULL)
 472    {
 473       mprintf("No info\n");
 474       return;
 475
 476    }
 477    mprintf("Rotate Y by %g\n",vD);
 478    sMxMatrix matrix;
 479
 480    mx_copy_mat(&matrix,&(pInfo->relTrans.mat));
 481    mx_rot_y_mat_rad(&(pInfo->relTrans.mat),&matrix,(vD/180.0)*MX_REAL_PI);
 482
 483    CreatureWeaponOutput(pInfo);
 484 }
 485
 486 void CreatureWeaponRotZ(float vD)
 487 {
 488    sCreatureAttachInfo *pInfo = CreatureAttachmentGet(CreatureWeapon.obj, nWeaponObjId, 0);
 489    if (pInfo == NULL)
 490    {
 491       mprintf("No info\n");
 492       return;
 493
 494    }
 495    mprintf("Rotate Z by %g\n",vD);
 496    sMxMatrix matrix;
 497
 498    mx_copy_mat(&matrix,&(pInfo->relTrans.mat));
 499    mx_rot_z_mat_rad(&(pInfo->relTrans.mat),&matrix,(vD/180.0)*MX_REAL_PI);
 500
 501    CreatureWeaponOutput(pInfo);
 502 }
 503
 504 void CreatureWeaponTransX(float vD)
 505 {
 506    sCreatureAttachInfo *pInfo = CreatureAttachmentGet(CreatureWeapon.obj, nWeaponObjId, 0);
 507    if (pInfo == NULL)
 508    {
 509       mprintf("No info\n");
 510       return;
 511
 512    }
 513    mprintf("Translate X by %g\n",vD);
 514    pInfo->relTrans.vec.x += vD;
 515 }
 516
 517 void CreatureWeaponTransY(float vD)
 518 {
 519    sCreatureAttachInfo *pInfo = CreatureAttachmentGet(CreatureWeapon.obj, nWeaponObjId, 0);
 520    if (pInfo == NULL)
 521    {
 522       mprintf("No info\n");
 523       return;
 524
 525    }
 526    mprintf("Translate Y by %g\n",vD);
 527    pInfo->relTrans.vec.y += vD;
 528 }
 529
 530 void CreatureWeaponTransZ(float vD)
 531 {
 532    sCreatureAttachInfo *pInfo = CreatureAttachmentGet(CreatureWeapon.obj, nWeaponObjId, 0);
 533
 534    if (pInfo == NULL)
 535    {
 536       mprintf("No info\n");
 537       return;
 538
 539    }
 540    mprintf("Translate Z by %g\n",vD);
 541    pInfo->relTrans.vec.z += vD;
 542 }
 543
 544 void
 545 CreatureWeaponDump()
 546 {
 547    sCreatureAttachInfo *pInfo = CreatureAttachmentGet(CreatureWeapon.obj, nWeaponObjId, 0);
 548    if (pInfo == NULL)
 549    {
 550       mprintf("No info\n");
 551       return;
 552
 553    }
 554
 555    FILE *pFile = fopen("weapon.txt","a+");
 556    fprintf(pFile,"************************\n");
 557    fprintf(pFile,"%g,%g,%g\n",pInfo->relTrans.mat.vec[0].x,pInfo->relTrans.mat.vec[0].y,pInfo->relTrans.mat.vec[0].z);
 558    fprintf(pFile,"%g,%g,%g\n",pInfo->relTrans.mat.vec[1].x,pInfo->relTrans.mat.vec[1].y,pInfo->relTrans.mat.vec[1].z);
 559    fprintf(pFile,"%g,%g,%g\n",pInfo->relTrans.mat.vec[2].x,pInfo->relTrans.mat.vec[2].y,pInfo->relTrans.mat.vec[2].z);
 560    fprintf(pFile,"%g,%g,%g\n",pInfo->relTrans.vec.x,pInfo->relTrans.vec.y,pInfo->relTrans.vec.z);
 561    fclose(pFile);
 562 }
 563
 564 #endif
 565
 566