prj/cam/src/shock/shkpsipr.cpp

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6 // $Header: r:/t2repos/thief2/src/shock/shkpsipr.cpp,v 1.13 1999/11/19 14:58:39 adurant Exp $
   7
   8 #include <shkpsipr.h>
   9
  10 #include <propert_.h>
  11 #include <dataops_.h>
  12 #include <prophash.h>
  13
  14 #include <sdesc.h>
  15 #include <sdesbase.h>
  16
  17 #include <relation.h>
  18 #include <linkbase.h>
  19
  20 #include <shkplcst.h>
  21 #include <nzprutil.h>
  22 #include <shkpsibs.h>
  23 #include <shkpsipw.h>
  24
  25 // for esnd cut 'n paste
  26 #include <property.h>
  27 #include <propbase.h>
  28 #include <propface.h>
  29 #include <propfac_.h>
  30 #include <proplist.h>
  31 #include <objnotif.h>
  32
  33 // must be last header
  34 #include <dbmem.h>
  35
  36 ///////////////////////////////////////////////////////
  37 // Teleport link
  38
  39 IRelation *g_pPsiTeleportLinks;
  40
  41 static sRelationDesc psiTeleportDesc = { "Teleport", 0, 0, 0 };
  42 static sRelationDataDesc noDataDesc = { "None", 0 };
  43
  44 //////////////////////////////////////////////////
  45 // Psi Power desc
  46 //
  47
  48 IPsiPowerProperty *g_pPsiPowerProperty;
  49
  50 typedef cSpecificProperty<IPsiPowerProperty, &IID_IPsiPowerProperty, sPsiPower*, cHashPropertyStore<cClassDataOps<sPsiPower> > > cPsiPowerPropertyBase;
  51
  52 // property implementation class
  53 class cPsiPowerProperty: public cPsiPowerPropertyBase
  54 {
  55 public:
  56    cPsiPowerProperty(const sPropertyDesc* desc)
  57       : cPsiPowerPropertyBase(desc)
  58    {
  59    }
  60
  61    STANDARD_DESCRIBE_TYPE(sPsiPower);
  62
  63 };
  64
  65 char* psiTypeNames[] =
  66 {
  67    "Shot",
  68    "Shield",
  69    "One-Shot",
  70    "Sustained",
  71    "Cursor Target"
  72 };
  73
  74 static sFieldDesc psiPowerFields[] =
  75 {
  76    { "Power", kFieldTypeEnum, FieldLocation(sPsiPower, m_power), kFieldFlagUnsigned, 0, kPsiMax, kPsiMax, psiPowerNames},
  77    { "Type", kFieldTypeEnum, FieldLocation(sPsiPower, m_type), kFieldFlagUnsigned, 0, kPsiTypeMax, kPsiTypeMax, psiTypeNames},
  78    { "Start Cost", kFieldTypeInt, FieldLocation(sPsiPower, m_startCost), },
  79    { "Data 1", kFieldTypeFloat, FieldLocation(sPsiPower, m_data[0]), },
  80    { "Data 2", kFieldTypeFloat, FieldLocation(sPsiPower, m_data[1]), },
  81    { "Data 3", kFieldTypeFloat, FieldLocation(sPsiPower, m_data[2]), },
  82    { "Data 4", kFieldTypeFloat, FieldLocation(sPsiPower, m_data[3]), },
  83 };
  84
  85 static sStructDesc psiPowerStructDesc =
  86    StructDescBuild(sPsiPower, kStructFlagNone, psiPowerFields);
  87
  88 IPsiPowerProperty *CreatePsiPowerProperty(sPropertyDesc *desc,
  89                                                           ePropertyImpl impl)
  90 {
  91    StructDescRegister(&psiPowerStructDesc);
  92    return new cPsiPowerProperty(desc);
  93 }
  94
  95 static sPropertyDesc psiPowerDesc =
  96 {
  97    PROP_PSI_POWER_DESC,
  98    kPropertyNoInherit,
  99    NULL,
 100    1,    // version
 101    0,
 102    {"Psi", "Power Description"},
 103 };
 104
 105 void PsiPowerPropertyInit()
 106 {
 107    g_pPsiPowerProperty = CreatePsiPowerProperty(&psiPowerDesc, kPropertyImplDense);
 108 }
 109
 110 //////////////////////////////////////////////////
 111 // Psi Shield desc
 112 //
 113
 114 IPsiShieldProperty *g_pPsiShieldProperty;
 115
 116 typedef cSpecificProperty<IPsiShieldProperty, &IID_IPsiShieldProperty, sPsiShield*, cHashPropertyStore<cClassDataOps<sPsiShield> > > cPsiShieldPropertyBase;
 117
 118 // property implementation class
 119 class cPsiShieldProperty: public cPsiShieldPropertyBase
 120 {
 121 public:
 122    cPsiShieldProperty(const sPropertyDesc* desc)
 123       : cPsiShieldPropertyBase(desc)
 124    {
 125    }
 126
 127    STANDARD_DESCRIBE_TYPE(sPsiShield);
 128
 129 };
 130
 131 static sFieldDesc psiShieldFields[] =
 132 {
 133    {"Base Time", kFieldTypeInt, FieldLocation(sPsiShield, m_baseTime), },
 134    {"Add Time", kFieldTypeInt, FieldLocation(sPsiShield, m_addTime), },
 135    {"Base Int", kFieldTypeInt, FieldLocation(sPsiShield, m_baseInt), },
 136 };
 137
 138 static sStructDesc psiShieldStructDesc =
 139    StructDescBuild(sPsiShield, kStructFlagNone, psiShieldFields);
 140
 141 IPsiShieldProperty *CreatePsiShieldProperty(sPropertyDesc *desc,
 142                                                           ePropertyImpl impl)
 143 {
 144    StructDescRegister(&psiShieldStructDesc);
 145    return new cPsiShieldProperty(desc);
 146 }
 147
 148 static sPropertyDesc psiShieldDesc =
 149 {
 150    PROP_PSI_SHIELD_DESC,
 151    kPropertyNoInherit,
 152    NULL,
 153    1,    // version
 154    0,
 155    {"Psi", "Shield Description"},
 156 };
 157
 158 sPsiShield defaultPsiShield =
 159 {
 160    0, 0, 0,
 161 };
 162
 163 void PsiShieldPropertyInit()
 164 {
 165    g_pPsiShieldProperty = CreatePsiShieldProperty(&psiShieldDesc, kPropertyImplDense);
 166 }
 167
 168 //////////////////////////////////////////////////
 169 // Psi State desc
 170 //
 171
 172 IPsiStateProperty *g_pPsiStateProperty;
 173
 174 typedef cSpecificProperty<IPsiStateProperty, &IID_IPsiStateProperty, cPsiState*, cHashPropertyStore<cNoZeroDataOps<cPsiState> > > cPsiStatePropertyBase;
 175
 176 // property implementation class
 177 class cPsiStateProperty: public cPsiStatePropertyBase
 178 {
 179 public:
 180    cPsiStateProperty(const sPropertyDesc* desc)
 181       : cPsiStatePropertyBase(desc)
 182    {
 183    }
 184
 185    STANDARD_DESCRIBE_TYPE(cPsiState);
 186
 187 };
 188
 189 static sFieldDesc psiStateFields[] =
 190 {
 191    { "", kFieldTypeEnum, FieldLocation(cPsiState, m_currentPower), kFieldFlagUnsigned|kFieldFlagNotEdit, 0, kPsiMax+1, kPsiMax+1, psiPowerNames},
 192    {"Current Points", kFieldTypeInt, FieldLocation(cPsiState, m_points), },
 193    {"Max Points", kFieldTypeInt, FieldLocation(cPsiState, m_maxPoints), },
 194 };
 195
 196 static sStructDesc PsiStateStructDesc =
 197    StructDescBuild(cPsiState, kStructFlagNone, psiStateFields);
 198
 199 IPsiStateProperty *CreatePsiStateProperty(sPropertyDesc *desc,
 200                                                           ePropertyImpl impl)
 201 {
 202    StructDescRegister(&PsiStateStructDesc);
 203    return new cPsiStateProperty(desc);
 204 }
 205
 206 static sPropertyDesc psiStateDesc =
 207 {
 208    PROP_PSI_STATE_DESC,
 209    kPropertyInstantiate,
 210    NULL,
 211    1,    // version
 212    0,
 213    {"Psi", "State"},
 214 };
 215
 216 sPsiState defaultPsiState =
 217 {
 218    kPsiNone,
 219    0,
 220    0,
 221 };
 222
 223 cPsiState::cPsiState()
 224 {
 225    *this = *(cPsiState*)(&defaultPsiState);
 226 }
 227
 228 void PsiStatePropertyInit()
 229 {
 230    g_pPsiStateProperty = CreatePsiStateProperty(&psiStateDesc, kPropertyImplDense);
 231 }
 232
 233 sPsiState* PsiStateGet(ObjID objID)
 234 {
 235    cPsiState *pPsiState;
 236
 237    if (g_pPsiStateProperty->Get(objID, &pPsiState))
 238       return pPsiState;
 239    else
 240       return &defaultPsiState;
 241 }
 242
 243 void PsiStateSetCurrentPower(ObjID objID, ePsiPowers power)
 244 {
 245    cPsiState *pPsiState;
 246
 247    if (g_pPsiStateProperty->Get(objID, &pPsiState))
 248    {
 249       pPsiState->m_currentPower = power;
 250       g_pPsiStateProperty->Set(objID, pPsiState);
 251    }
 252 }
 253
 254 void PsiStateSetPoints(ObjID objID, float points)
 255 {
 256    cPsiState *pPsiState;
 257    if (g_pPsiStateProperty->Get(objID, &pPsiState))
 258    {
 259       pPsiState->m_points = points;
 260       g_pPsiStateProperty->Set(objID, pPsiState);
 261    }
 262 }
 263
 264 void PsiStateSetMaxPoints(ObjID objID, float maxPoints)
 265 {
 266    cPsiState *pPsiState;
 267    if (g_pPsiStateProperty->Get(objID, &pPsiState))
 268    {
 269       pPsiState->m_maxPoints = maxPoints;
 270       g_pPsiStateProperty->Set(objID, pPsiState);
 271    }
 272 }
 273
 274 /////////////////////////////////////////////////
 275 IIntProperty *g_PsiOverloadProperty;
 276 IIntProperty *g_PsiOverload2Property;
 277
 278 BOOL PsiOverloaded(ObjID obj, ePsiPowers which)
 279 {
 280    int powers;
 281    // this is kind of grody...
 282    if (which < 32)
 283    {
 284       g_PsiOverloadProperty->Get(obj, &powers);
 285       return(powers & (1 << which));
 286    }
 287    else
 288    {
 289       g_PsiOverload2Property->Get(obj, &powers);
 290       return(powers & (1 << (which - 32)));
 291    }
 292 }
 293
 294 void PsiSetOverload(ObjID obj, ePsiPowers which, BOOL val)
 295 {
 296    int powers;
 297    if (which < 32)
 298    {
 299       g_PsiOverloadProperty->Get(obj, &powers);
 300       if (val)
 301          powers = powers | (1 << which);
 302       else
 303          powers = powers & (~(1 << which));
 304       g_PsiOverloadProperty->Set(obj, powers);
 305    }
 306    else
 307    {
 308       g_PsiOverload2Property->Get(obj, &powers);
 309       if (val)
 310          powers = powers | (1 << (which - 32));
 311       else
 312          powers = powers & (~(1 << which));
 313       g_PsiOverload2Property->Set(obj, powers);
 314    }
 315 }
 316
 317 #define PROP_PSIOVERLOAD_DESC "PsiOverDesc"
 318 static sPropertyDesc PsiOverloadDesc = { PROP_PSIOVERLOAD_DESC, 0, NULL, 1, 0, {"Player", "Overload State"}, };
 319 #define PROP_PSIOVERLOAD2_DESC "PsiOver2Desc"
 320 static sPropertyDesc PsiOverload2Desc = { PROP_PSIOVERLOAD2_DESC, 0, NULL, 1, 0, {"Player", "Overload State 2"}, };
 321
 322 /////////////////////////////////////////////////
 323 IIntProperty *g_PsiRadarProperty;
 324 #define PROP_PSIRADAR_DESC "PsiRadar"
 325 static sPropertyDesc PsiRadarDesc = { PROP_PSIRADAR_DESC, 0, NULL, 1, 0, {"Psi", "Radar Type"}, };
 326
 327 static char* RadarNames[] =
 328 {
 329    "None","Enemy", "Powerup",
 330 };
 331
 332 static sFieldDesc RadarFields[] =
 333 {
 334    { "", kFieldTypeEnum, sizeof(int), 0, kFieldFlagUnsigned, 0, 3, 3, RadarNames},
 335 };
 336
 337 static sPropertyTypeDesc RadarTypeDesc = {PROP_PSIRADAR_DESC, sizeof(int)};
 338
 339 static sStructDesc RadarStructDesc =
 340 {
 341    PROP_PSIRADAR_DESC,
 342    sizeof(int),
 343    kStructFlagNone,
 344    sizeof(RadarFields)/sizeof(RadarFields[0]),
 345    RadarFields,
 346 };
 347
 348 /////////////////////////////////////////////////
 349
 350 IFloatProperty *g_PsiAlchemyProperty;
 351 #define PROP_PSIALCHEMY_DESC "Alchemy"
 352 static sPropertyDesc PsiAlchemyDesc = { PROP_PSIALCHEMY_DESC, 0, NULL, 1, 0, {"Psi", "Alchemy Val"}, };
 353
 354 /////////////////////////////////////////////////
 355
 356 IIntProperty *g_PsiFabricateProperty;
 357 #define PROP_PSIFabricate_DESC "Fabricate"
 358 static sPropertyDesc PsiFabricateDesc = { PROP_PSIFabricate_DESC, 0, NULL, 1, 0, {"Psi", "Fabricate Quantity"}, };
 359
 360 /////////////////////////////////////////////////
 361
 362 IIntProperty *g_PsiFabCostProperty;
 363 static sPropertyDesc PsiFabCostDesc = { "FabCost", 0, NULL, 1, 0, {"Psi", "Fabricate Cost"}, };
 364
 365 /////////////////////////////////////////////////
 366
 367 IBoolProperty *g_pPsiNotPullableProperty;
 368 #define PROP_PSINOTPULL_DESC "NotPullable"
 369 static sPropertyDesc PsiNotPullableDesc = { PROP_PSINOTPULL_DESC, 0, NULL, 1, 0, {"Psi", "NotPullable"}, };
 370
 371 /////////////////////////////////////////////////
 372
 373 static sFieldDesc g_Fields [] =
 374 {
 375    { "1: Tags", kFieldTypeString,
 376      FieldLocation(sESndTagList, m_TagStrings) },
 377 };
 378
 379 static sStructDesc g_ListStruct
 380   = StructDescBuild(sESndTagList, kStructFlagNone, g_Fields);
 381
 382 static IESndTagProperty* g_pESndPsiProp = NULL;
 383
 384 struct sOpsList : public sESndTagList
 385 {
 386    sOpsList()
 387    {
 388       m_pTagSet = new cTagSet;
 389       m_TagStrings[0] = '\0';
 390    }
 391
 392    sOpsList(const sESndTagList& dat)
 393    {
 394       strncpy(m_TagStrings,dat.m_TagStrings,sizeof(m_TagStrings));
 395       m_pTagSet = new cTagSet(m_TagStrings);
 396    }
 397
 398    sOpsList(const sOpsList& dat)
 399    {
 400       strncpy(m_TagStrings,dat.m_TagStrings,sizeof(m_TagStrings));
 401       m_pTagSet = new cTagSet(m_TagStrings);
 402    }
 403
 404    sOpsList& operator=(const sOpsList& dat)
 405    {
 406       strncpy(m_TagStrings,dat.m_TagStrings,sizeof(m_TagStrings));
 407       m_pTagSet->FromString(m_TagStrings);
 408       return *this;
 409    }
 410
 411    ~sOpsList()
 412    {
 413       delete m_pTagSet;
 414    }
 415
 416 } ;
 417
 418 class cESndTagOps : public cClassDataOps<sOpsList>
 419 {
 420    typedef cClassDataOps<sOpsList> cParent;
 421 public:
 422
 423    cESndTagOps() : cParent(kNoFlags) {} ;
 424    STDMETHOD(Read)(THIS_ sDatum* dat, IDataOpsFile* file, int version)
 425    {
 426       if (!dat->value)
 427          *dat = New();
 428       sOpsList* list = (sOpsList*)dat->value;
 429       sESndTagList tmp;
 430       memset(&tmp,0,sizeof(tmp));
 431       // we derive from cClassDataOps, thus version == size;
 432       int sz = (version < sizeof(tmp)) ? version : sizeof(tmp);
 433       Verify(file->Read(&tmp,sz) == sz);
 434       *list = tmp;
 435       return S_OK;
 436    }
 437
 438 };
 439
 440 class cESndTagStore : public cListPropertyStore<cESndTagOps>
 441 {
 442 };
 443
 444 class cESndTagProperty : public cSpecificProperty<IESndTagProperty,
 445    &IID_IESndTagProperty, sESndTagList*, cESndTagStore>
 446
 447 {
 448    typedef cSpecificProperty<IESndTagProperty,
 449                              &IID_IESndTagProperty,
 450                              sESndTagList*,
 451                              cESndTagStore> cParent;
 452
 453 public:
 454    cESndTagProperty(const sPropertyDesc* desc)
 455       : cParent(desc)
 456    {
 457    }
 458
 459    STANDARD_DESCRIBE_TYPE(sESndTagList);
 460 };
 461
 462
 463 static sPropertyDesc g_PsiPropDesc =
 464 {
 465    PROP_ESND_PSI_NAME,
 466    0,
 467    NULL,
 468    0,0, // verison
 469    { "Schema", "Psi Tags" },
 470 };
 471
 472 EXTERN BOOL ObjGetESndPsi(ObjID obj, sESndTagList **pData)
 473 {
 474    Assert_(g_pESndPsiProp);
 475    return g_pESndPsiProp->Get(obj, pData);
 476 }
 477
 478
 479 EXTERN BOOL ObjSetESndPsi(ObjID obj, sESndTagList *pData)
 480 {
 481    Assert_(g_pESndPsiProp);
 482    return g_pESndPsiProp->Set(obj, pData);
 483 }
 484
 485 /////////////////////////////////////////////////
 486
 487 void PsiPropertiesInit(void)
 488 {
 489    PsiPowerPropertyInit();
 490    PsiStatePropertyInit();
 491    PsiShieldPropertyInit();
 492    g_PsiOverloadProperty = CreateIntProperty(&PsiOverloadDesc, kPropertyImplVerySparse);
 493    g_PsiOverload2Property = CreateIntProperty(&PsiOverload2Desc, kPropertyImplVerySparse);
 494
 495    StructDescRegister(&RadarStructDesc);
 496    g_PsiRadarProperty = CreateIntegralProperty(&PsiRadarDesc, &RadarTypeDesc, kPropertyImplLlist); // kPropertyImplDense);
 497
 498    g_PsiAlchemyProperty = CreateFloatProperty(&PsiAlchemyDesc, kPropertyImplDense);
 499    g_PsiFabricateProperty = CreateIntProperty(&PsiFabricateDesc, kPropertyImplDense);
 500    g_PsiFabCostProperty = CreateIntProperty(&PsiFabCostDesc, kPropertyImplDense);
 501    g_pPsiNotPullableProperty = CreateBoolProperty(&PsiNotPullableDesc, kPropertyImplDense);
 502
 503    g_pESndPsiProp = new cESndTagProperty(&g_PsiPropDesc);
 504
 505    // links
 506    g_pPsiTeleportLinks = CreateStandardRelation(&psiTeleportDesc, &noDataDesc, (kQCaseSetSourceKnown));
 507 }
 508
 509 /////////////////////////////////////////////////
 510
 511 void PsiPropertiesTerm(void)
 512 {
 513    SafeRelease(g_pPsiPowerProperty);
 514    SafeRelease(g_pPsiStateProperty);
 515    SafeRelease(g_pPsiShieldProperty);
 516    SafeRelease(g_PsiOverloadProperty);
 517    SafeRelease(g_PsiOverload2Property);
 518    SafeRelease(g_PsiRadarProperty);
 519    SafeRelease(g_PsiAlchemyProperty);
 520    SafeRelease(g_PsiFabricateProperty);
 521    SafeRelease(g_pPsiTeleportLinks);
 522    SafeRelease(g_pPsiNotPullableProperty);
 523    SafeRelease(g_pESndPsiProp);
 524 }