prj/cam/src/shock/shkprop.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/shkprop.cpp,v 1.87 2000/02/19 13:25:58 toml Exp $
   7
   8 #include <shkprop.h>
   9
  10 #include <propert_.h>
  11 #include <dataops_.h>
  12 #include <gamestr.h>
  13 #include <prophash.h>
  14
  15 #include <sdesc.h>
  16 #include <sdesbase.h>
  17
  18 #include <combprop.h>
  19 #include <esnd.h>
  20
  21 #include <shkobjst.h>
  22 #include <shkwsprp.h>
  23 #include <shkrsprp.h>
  24 #include <shkspawn.h>
  25 #include <shkhazpr.h>
  26 #include <shkcurpr.h>
  27 #include <shkemail.h>
  28 #include <shkutils.h>
  29 #include <gunapi.h>
  30 #include <shkovrly.h>
  31 #include <shkovcst.h>
  32 #include <memall.h>
  33 #include <dbmem.h>   // must be last header!
  34
  35 /////////////////////////////////////////////////////////////
  36 // Object Name Type Property
  37 /////////////////////////////////////////////////////////////
  38 IIntProperty *gPropObjNameType;
  39
  40 static char *NameTypeNames[] = { "Normal", "Stack Count", "Log Title", "Weapon" };
  41 #define PROP_NAMETYPE_DESC "NameType"
  42
  43 static sPropertyDesc NameTypeDesc =
  44 {
  45    PROP_NAMETYPE_DESC, 0,
  46    NULL, 0, 0, // constraints, versions
  47    { "Obj", "Object Name Type" },
  48 };
  49
  50 static sFieldDesc NameTypeFields[] =
  51 {
  52    { "", kFieldTypeEnum, sizeof(int), 0, kFieldFlagUnsigned, 0, 4, 4, NameTypeNames},
  53 };
  54
  55 static sStructDesc NameTypeStructDesc =
  56 {
  57    PROP_NAMETYPE_DESC,
  58    sizeof(int),
  59    kStructFlagNone,
  60    sizeof(NameTypeFields)/sizeof(NameTypeFields[0]),
  61    NameTypeFields,
  62 };
  63
  64 static sPropertyTypeDesc NameTypeTypeDesc = {PROP_NAMETYPE_DESC, sizeof(int)};
  65
  66 /////////////////////////////////////////////////////////////
  67 // Object Name Property
  68 /////////////////////////////////////////////////////////////
  69
  70 IStringProperty* gPropObjName;
  71
  72 static sPropertyDesc ObjNameDesc =
  73 {
  74    PROP_OBJNAME_NAME, 0,
  75   NULL, 2, 1, // constraints, versions
  76   { "Obj", "Object name" },
  77 };
  78
  79 #define OBJ_NAME_IMPL kPropertyImplHash
  80
  81 // careful about overflow!!
  82 void ObjGetObjNameSubst(ObjID obj, char *text, int buflen)
  83 {
  84    cStr str;
  85
  86    eObjState objstate = ObjGetObjState(obj);
  87
  88    if (objstate == kObjStateUnresearched)
  89    {
  90       ShockStringFetch(text,buflen,"NameUnresearched","research");
  91    }
  92    else
  93    {
  94       AutoAppIPtr(GameStrings);
  95       str = pGameStrings->FetchObjString(obj, PROP_OBJNAME_NAME);
  96
  97       if (buflen < str.GetLength())
  98       {
  99          Warning(("ObjGetObjNameSubst: buffer len %d is too small!\n",buflen));
 100       }
 101
 102       strcpy(text,"");
 103
 104       if (gPropMapText->IsRelevant(obj))
 105       {
 106          const char *pStr;
 107          gPropMapText->Get(obj,&pStr);
 108          strcpy(text,pStr);
 109       }
 110       else
 111       {
 112          if (IProperty_IsRelevant(gPropObjNameType, obj))
 113          {
 114             int val;
 115             gPropObjNameType->Get(obj, &val);
 116             switch (val)
 117             {
 118             case 1: // %d for stack count
 119                if (IProperty_IsRelevant(gStackCountProp, obj) && IProperty_IsRelevant(gCombineTypeProp, obj))
 120                {
 121                   int val;
 122                   gStackCountProp->Get(obj,&val);
 123                   sprintf(text, str, val);
 124                }
 125                break;
 126             case 2: // %d for log title
 127                {
 128                   int usetype = 1; // logs
 129                   int level, which;
 130                   if (ShockFindLogData(obj, usetype, &level, &which) == S_OK)
 131                   {
 132                      char temp[255];
 133                      char levelname[32];
 134                      sprintf(levelname,"level%02d",level + 1);
 135                      ShockStringFetch(temp,sizeof(temp),"logname",levelname,which+1);
 136
 137                      sprintf(text, str, temp);
 138                   }
 139                }
 140                break;
 141             case 3: // %s for weapon condition
 142                {
 143                   char temp[255];
 144                   GunGetConditionString(obj,temp,sizeof(temp));
 145                   sprintf(text,str,temp); //(int)GunGetCondition(obj));
 146                }
 147                break;
 148             }
 149          }
 150
 151          // generic case if no name type, or we fail within our name type
 152          if (strlen(text) == 0)
 153             strcpy(text, str);
 154       }
 155    }
 156
 157    if ((objstate != kObjStateNormal) && (objstate != kObjStateUnresearched))
 158    {
 159       char temp[255];
 160       ShockStringFetch(temp,sizeof(temp),"ObjState","misc",objstate);
 161       strcat(text,temp);
 162    }
 163 }
 164
 165
 166 /////////////////////////////////////////////////////////////
 167 // Object Name Property
 168 /////////////////////////////////////////////////////////////
 169 IStringProperty* gPropObjShortName;
 170
 171 static sPropertyDesc ObjShortNameDesc =
 172 {
 173    PROP_OBJSHORTNAME_NAME, 0,
 174   NULL, 0, 0, // constraints, versions
 175   { "Obj", "Object short name" },
 176 };
 177
 178 // careful about overflow!!
 179 void ObjGetObjShortNameSubst(ObjID obj, char *text, int buflen)
 180 {
 181    cStr str;
 182
 183    eObjState objstate = ObjGetObjState(obj);
 184
 185    if (objstate == kObjStateUnresearched)
 186    {
 187       ShockStringFetch(text,buflen,"NameUnresearched","research");
 188    }
 189    else
 190    {
 191       AutoAppIPtr(GameStrings);
 192       str = pGameStrings->FetchObjString(obj, PROP_OBJSHORTNAME_NAME);
 193
 194       if (buflen < str.GetLength())
 195       {
 196          Warning(("ObjGetObjNameSubst: buffer len %d is too small!\n",buflen));
 197       }
 198
 199       strcpy(text,"");
 200
 201       if (IProperty_IsRelevant(gPropObjNameType, obj))
 202       {
 203          int val;
 204          gPropObjNameType->Get(obj, &val);
 205          switch (val)
 206          {
 207          case 1: // %d for stack count
 208             if (IProperty_IsRelevant(gStackCountProp, obj) && IProperty_IsRelevant(gCombineTypeProp, obj))
 209             {
 210                int val;
 211                gStackCountProp->Get(obj,&val);
 212                sprintf(text, str, val);
 213             }
 214             break;
 215          case 2: // %d for log title
 216             {
 217                int usetype = 1; // logs
 218                int level, which;
 219                if (ShockFindLogData(obj, usetype, &level, &which) == S_OK)
 220                {
 221                   char temp[255];
 222                   char levelname[32];
 223                   sprintf(levelname,"level%02d",level + 1);
 224                   ShockStringFetch(temp,sizeof(temp),"logname",levelname,which+1);
 225
 226                   sprintf(text, str, temp);
 227                }
 228             }
 229             break;
 230          case 3: // %s for weapon condition
 231             {
 232                char temp[255];
 233                GunGetConditionString(obj,temp,sizeof(temp));
 234                sprintf(text,str,temp); //(int)GunGetCondition(obj));
 235             }
 236             break;
 237          }
 238       }
 239
 240       // generic case if no name type, or we fail within our name type
 241       if (strlen(text) == 0)
 242          strcpy(text, str);
 243    }
 244
 245    /*
 246    if ((objstate != kObjStateNormal) && (objstate != kObjStateUnresearched))
 247    {
 248       char temp[255];
 249       ShockStringFetch(temp,sizeof(temp),"ObjState","misc",objstate);
 250       strcat(text,temp);
 251    }
 252    */
 253 }
 254
 255 /////////////////////////////////////////////////////////////
 256 // Look String Property
 257 /////////////////////////////////////////////////////////////
 258 IStringProperty* gPropObjLookString;
 259
 260 static sPropertyDesc ObjLookStringDesc =
 261 {
 262    PROP_OBJLOOKSTRING_NAME, 0,
 263   NULL, 0, 0, // constraints, versions
 264   { "Obj", "Object Look string" },
 265 };
 266
 267 BOOL ObjGetObjLookString(ObjID obj, const char **ppString)
 268 {
 269    Assert_(gPropObjLookString);
 270    return gPropObjLookString->Get(obj, ppString);
 271 }
 272
 273 /////////////////////////////////////////////////////////////
 274 // ExP property
 275 /////////////////////////////////////////////////////////////
 276
 277 IIntProperty* gPropExp;
 278
 279 static sPropertyDesc ExpDesc =
 280 {
 281   PROP_EXP_NAME, 0,
 282   NULL, 0, 0, // constraints, versions
 283   { "GameSys", "Exp" },
 284 };
 285
 286 #define EXP_IMPL kPropertyImplHash
 287
 288 int ObjGetExp(ObjID obj)
 289 {
 290    int exp = 0; // default value
 291    gPropExp->Get(obj,&exp);
 292    return exp;
 293 }
 294
 295 /////////////////////////////////////////////////////////////
 296 // Object Icon Property
 297 /////////////////////////////////////////////////////////////
 298
 299 ILabelProperty* gPropObjIcon;
 300
 301 static sPropertyDesc ObjIconDesc =
 302 {
 303    PROP_OBJICON_NAME, 0,
 304   NULL, 0, 0, // constraints, versions
 305   { "Obj", "Object icon" },
 306 };
 307
 308 #define OBJ_ICON_IMPL kPropertyImplLlist
 309
 310 BOOL ObjGetObjIcon(ObjID obj, Label **ppName)
 311 {
 312    Assert_(gPropObjIcon);
 313    Assert_(gPropObjBrokenIcon);
 314
 315    eObjState objstate;
 316    objstate = ObjGetObjState(obj);
 317    if (objstate == kObjStateBroken)
 318    {
 319       if (gPropObjBrokenIcon->Get(obj, ppName))
 320          return(TRUE);
 321       else
 322          return(gPropObjIcon->Get(obj, ppName));
 323    }
 324    else
 325       return gPropObjIcon->Get(obj, ppName);
 326
 327 }
 328
 329 void ObjSetObjIcon(ObjID obj, Label *pName)
 330 {
 331    Assert_(gPropObjIcon);
 332    gPropObjIcon->Set(obj, pName);
 333 }
 334
 335 ILabelProperty* gPropObjBrokenIcon;
 336
 337 static sPropertyDesc ObjBrokenIconDesc =
 338 {
 339    PROP_OBJBROKENICON_NAME, 0,
 340   NULL, 0, 0, // constraints, versions
 341   { "Obj", "Broken icon" },
 342 };
 343
 344 /////////////////////////////////////////////////////////////
 345 // Tech hacking / difficulty properties
 346 /////////////////////////////////////////////////////////////
 347
 348 ITechInfoProperty* gPropHackDiff;
 349 ITechInfoProperty* gPropRepairDiff;
 350 ITechInfoProperty* gPropModifyDiff;
 351 ITechInfoProperty* gPropModify2Diff;
 352 IStringProperty* gPropModify1Text;
 353 IStringProperty* gPropModify2Text;
 354 IStringProperty* gPropHackText;
 355
 356 static sPropertyDesc HackDiffDesc =
 357 {
 358   PROP_HACKDIFF_NAME, 0,
 359   NULL, 0, 0, // constraints, versions
 360   { "GameSys", "HackDiff" },
 361 };
 362
 363 static sPropertyDesc RepairDiffDesc =
 364 {
 365   PROP_REPAIRDIFF_NAME, 0,
 366   NULL, 0, 0, // constraints, versions
 367   { "GameSys", "RepairDiff" },
 368 };
 369
 370 static sPropertyDesc ModifyDiffDesc =
 371 {
 372   PROP_MODIFYDIFF_NAME, 0,
 373   NULL, 0, 0, // constraints, versions
 374   { "GameSys", "ModifyDiff" },
 375 };
 376
 377 static sPropertyDesc Modify2DiffDesc =
 378 {
 379   PROP_MODIFY2DIFF_NAME, 0,
 380   NULL, 0, 0, // constraints, versions
 381   { "GameSys", "Modify 2 Diff" },
 382 };
 383
 384 static sPropertyDesc Modify1TextDesc =
 385 {
 386   PROP_MODIFY1TEXT_NAME, 0,
 387   NULL, 0, 0, // constraints, versions
 388   { "GameSys", "Modification #1 Text" },
 389 };
 390
 391 static sPropertyDesc Modify2TextDesc =
 392 {
 393   PROP_MODIFY2TEXT_NAME, 0,
 394   NULL, 0, 0, // constraints, versions
 395   { "GameSys", "Modification #2 Text" },
 396 };
 397
 398 static sPropertyDesc HackTextDesc =
 399 {
 400   PROP_HACKTEXT_NAME, 0,
 401   NULL, 0, 0, // constraints, versions
 402   { "GameSys", "Hack Text" },
 403 };
 404
 405 #define HACKDIFF_IMPL kPropertyImplLlist
 406 #define REPAIRDIFF_IMPL kPropertyImplLlist
 407 #define MODIFYDIFF_IMPL kPropertyImplLlist
 408 #define MODIFY2DIFF_IMPL kPropertyImplLlist
 409 #define MODIFY1TEXT_IMPL kPropertyImplLlist
 410 #define MODIFY2TEXT_IMPL kPropertyImplLlist
 411 #define HACKTEXT_IMPL kPropertyImplLlist
 412
 413 /////////////////////////////////////////////////////////////
 414 // Loot property
 415 /////////////////////////////////////////////////////////////
 416
 417 ILootInfoProperty* gPropLoot;
 418
 419 static sPropertyDesc LootDesc =
 420 {
 421   PROP_LOOT_NAME, 0,
 422   NULL, 0, 0, // constraints, versions
 423   { "AI", "Loot" },
 424 };
 425
 426 #define LOOT_IMPL kPropertyImplLlist
 427
 428 ILabelProperty* gPropGuaranteedLoot;
 429
 430 static sPropertyDesc GuaranteedLootDesc =
 431 {
 432    PROP_GUARANTEEDLOOT_NAME, 0,
 433   NULL, 0, 0, // constraints, versions
 434   { "AI", "Borg Loot" },
 435 };
 436
 437 ILabelProperty* gPropReallyGuaranteedLoot;
 438
 439 static sPropertyDesc ReallyGuaranteedLootDesc =
 440 {
 441    PROP_REALLYGUARANTEEDLOOT_NAME, 0,
 442   NULL, 0, 0, // constraints, versions
 443   { "AI", "Guarantee Loot" },
 444 };
 445
 446 /////////////////////////////////////////////////////////////
 447 // Map obj props
 448 /////////////////////////////////////////////////////////////
 449
 450 ILabelProperty* gPropMapObjIcon;
 451
 452 static sPropertyDesc MapObjIconDesc =
 453 {
 454    "MapObjIcon", 0,
 455   NULL, 0, 0, // constraints, versions
 456   { "Obj", "Map Icon" },
 457 };
 458
 459 IBoolProperty* gPropMapObjRotate;
 460
 461 static sPropertyDesc MapObjRotateDesc =
 462 {
 463    "MapObjRotate", 0,
 464   NULL, 0, 0, // constraints, versions
 465   { "Obj", "Map Icon Rotated?" },
 466 };
 467
 468 IStringProperty* gPropMapText;
 469
 470 static sPropertyDesc MapTextDesc =
 471 {
 472    "MapText", 0,
 473    NULL, 0, 0, // constraints, versions
 474    { "Obj", "Map Text" },
 475 };
 476
 477 /////////////////////////////////////////////////////////////
 478 // Use Message Property
 479 /////////////////////////////////////////////////////////////
 480
 481 IStringProperty* gPropUseMessage;
 482
 483 static sPropertyDesc UseMessageDesc =
 484 {
 485    PROP_USEMESSAGE_NAME, 0,
 486    NULL, 0, 0, // constraints, versions
 487    { "Script", "Use Message" },
 488 };
 489
 490 /////////////////////////////////////////////////////////////
 491 // Use Message Property
 492 /////////////////////////////////////////////////////////////
 493
 494 IIntProperty* gPropMessageTime;
 495
 496 static sPropertyDesc MessageTimeDesc =
 497 {
 498    "MsgTime", 0,
 499    NULL, 0, 0, // constraints, versions
 500    { "Script", "Message Time" },
 501 };
 502
 503 /////////////////////////////////////////////////////////////
 504 // Stack Increment Property
 505 /////////////////////////////////////////////////////////////
 506
 507 IIntProperty* gPropStackIncrem;
 508
 509 static sPropertyDesc StackIncremDesc =
 510 {
 511    "StackInc", 0,
 512    NULL, 0, 0, // constraints, versions
 513    { "Obj", "Stack Increment" },
 514 };
 515
 516 /////////////////////////////////////////////////////////////
 517 // Recycler Value Property
 518 /////////////////////////////////////////////////////////////
 519 IIntProperty* gPropRecycle;
 520
 521 static sPropertyDesc RecycleDesc =
 522 {
 523    "Recycle", 0,
 524    NULL, 0, 0, // constraints, versions
 525    { "Obj", "Recycle Value" },
 526 };
 527
 528 /////////////////////////////////////////////////////////////
 529 // Locked Message Property
 530 /////////////////////////////////////////////////////////////
 531
 532 IStringProperty* gPropLockedMessage;
 533
 534 static sPropertyDesc LockedMessageDesc =
 535 {
 536    PROP_LOCKEDMESSAGE_NAME, 0,
 537    NULL, 0, 0, // constraints, versions
 538    { "Script", "Locked Message" },
 539 };
 540
 541 /////////////////////////////////////////////////////////////
 542 // HUD Duration property
 543 /////////////////////////////////////////////////////////////
 544
 545 IIntProperty* gPropHUDTime;
 546
 547 static sPropertyDesc HUDTimeDesc =
 548 {
 549    PROP_HUDTIME_NAME, 0,
 550    NULL, 0, 0, // constraints, versions
 551    { "Renderer", "HUD Duration" },
 552    kPropertyChangeLocally,
 553 };
 554
 555 /////////////////////////////////////////////////////////////
 556 // Allow HUD property
 557 /////////////////////////////////////////////////////////////
 558
 559 IBoolProperty* gPropAllowHUDSelect;
 560
 561 static sPropertyDesc HUDSelectDesc =
 562 {
 563    PROP_HUDSELECT_NAME, 0,
 564    NULL, 0, 0, // constraints, versions
 565    { "Obj", "HUD Selectable?" },
 566 };
 567
 568 /////////////////////////////////////////////////////////////
 569 // Hack Duration property
 570 /////////////////////////////////////////////////////////////
 571
 572 IBoolProperty* gPropShowHP;
 573
 574 static sPropertyDesc ShowHPDesc =
 575 {
 576    "ShowHP", 0,
 577    NULL, 0, 0, // constraints, versions
 578    { "Obj", "Show HP?" },
 579 };
 580
 581 /////////////////////////////////////////////////////////////
 582 // Hack Duration property
 583 /////////////////////////////////////////////////////////////
 584
 585 IIntProperty* gPropHackTime;
 586
 587 static sPropertyDesc HackTimeDesc =
 588 {
 589    PROP_HACKTIME_NAME, 0,
 590    NULL, 0, 0, // constraints, versions
 591    { "Player", "Hack Duration" },
 592 };
 593
 594 /////////////////////////////////////////////////////////////
 595 // Block frob property
 596 /////////////////////////////////////////////////////////////
 597
 598 IBoolProperty* gPropBlockFrob;
 599
 600 static sPropertyDesc BlockFrobDesc =
 601 {
 602    PROP_BLOCKFROB_NAME, 0,
 603    NULL, 0, 0, // constraints, versions
 604    { "Obj", "Block Frob?" },
 605 };
 606
 607 /////////////////////////////////////////////////////////////
 608 // Alarmed property
 609 /////////////////////////////////////////////////////////////
 610
 611 IBoolProperty* gPropAlarm;
 612
 613 static sPropertyDesc AlarmDesc =
 614 {
 615    PROP_ALARM_NAME, 0,
 616    NULL, 0, 0, // constraints, versions
 617    { "Gamesys", "Alarm On?" },
 618 };
 619
 620 /////////////////////////////////////////////////////////////
 621 // Use Message Property
 622 /////////////////////////////////////////////////////////////
 623
 624 IIntProperty* gPropMiniGames;
 625
 626 #define PROP_MINIGAMES_NAME   "MiniGames"
 627 static sPropertyDesc MiniGamesDesc =
 628 {
 629    PROP_MINIGAMES_NAME, 0,
 630    NULL, 0, 0, // constraints, versions
 631    { "Player", "Mini Games" },
 632 };
 633
 634 char *minigameflag_names[] = {
 635    "Index", "Slots", "Ping", "Swinekeeper", "OverWorld",
 636    "KaBacon", "Abyss", "Hogger", "TicTacToe", "Swine Hunter",
 637    "Pig Stacker", "Burro Hog", "Golf", "13", "14",
 638 };
 639
 640 static sFieldDesc miniGamesFields[] =
 641 {
 642    { "", kFieldTypeBits, sizeof(int), 0, kFieldFlagUnsigned, 0, 15, 15, minigameflag_names},
 643 };
 644
 645 static sStructDesc miniGamesStructDesc =
 646 {
 647    PROP_MINIGAMES_NAME,
 648    sizeof(int),
 649    kStructFlagNone,
 650    sizeof(miniGamesFields)/sizeof(miniGamesFields[0]),
 651    miniGamesFields,
 652 };
 653
 654 static sPropertyTypeDesc miniGamesTypeDesc = {PROP_MINIGAMES_NAME, sizeof(int)};
 655
 656 /////////////////////////////////////////////////////////////
 657 // Object State property
 658 /////////////////////////////////////////////////////////////
 659
 660 IIntProperty* gPropObjState;
 661
 662 static char* objStateNames[] =
 663 {
 664    "Normal", "Broken", "Destroyed", "Unresearched", "Locked"
 665 };
 666
 667 static sPropertyDesc objStateDesc =
 668 {
 669    PROP_OBJ_STATE_NAME, 0,
 670    NULL, 0, 0, // constraints, versions
 671    { "Obj", "State" },
 672    kPropertyProxyChangable,
 673 };
 674
 675 static sFieldDesc objStateFields[] =
 676 {
 677    { "", kFieldTypeEnum, sizeof(int), 0, kFieldFlagUnsigned, 0, 5, 5, objStateNames},
 678 };
 679
 680 static sStructDesc objStateStructDesc =
 681 {
 682    PROP_OBJ_STATE_NAME,
 683    sizeof(int),
 684    kStructFlagNone,
 685    sizeof(objStateFields)/sizeof(objStateFields[0]),
 686    objStateFields,
 687 };
 688
 689 eObjState ObjGetObjState(ObjID objID)
 690 {
 691    eObjState state = kObjStateNormal;
 692
 693    gPropObjState->Get(objID, &state);
 694    return state;
 695 }
 696
 697 void ObjSetObjState(ObjID objID, eObjState state)
 698 {
 699    char temp[255], text[255];
 700    cStr str;
 701
 702    gPropObjState->Set(objID, state);
 703
 704    if (state == kObjStateBroken)
 705    {
 706       // feedback text
 707       AutoAppIPtr(GameStrings);
 708       str = pGameStrings->FetchObjString(objID,PROP_OBJSHORTNAME_NAME);
 709       ShockStringFetch(temp,sizeof(temp),"WeaponBreaks","misc");
 710       sprintf(text,temp,str);
 711       ShockOverlayAddText(text, DEFAULT_MSG_TIME);
 712
 713       // feedback audio
 714       ESndPlay(&cTagSet("Event Breaking"), objID, OBJ_NULL);
 715    }
 716 }
 717
 718 static sPropertyTypeDesc objStateTypeDesc = {PROP_OBJ_STATE_NAME, sizeof(int)};
 719
 720 /////////////////////////////////////////////////////////////
 721 // Software property
 722 /////////////////////////////////////////////////////////////
 723
 724 static char *software_names[] =
 725 { "PDA", "Hack", "Modify", "Repair", "Research" };
 726
 727 IIntProperty* gPropSoftwareLevel;
 728 IIntProperty* gPropSoftwareType;
 729
 730 static sPropertyDesc SoftwareLevelDesc =
 731 {
 732    PROP_SOFTWARELEVEL_NAME, 0,
 733    NULL, 0, 0, // constraints, versions
 734    { "Obj", "Software Level" },
 735 };
 736
 737 static sPropertyDesc SoftwareTypeDesc =
 738 {
 739    PROP_SOFTWARETYPE_NAME, 0,
 740    NULL, 0, 0, // constraints, versions
 741    { "Obj", "Software Type" },
 742 };
 743
 744 static sFieldDesc softwareTypeFields[] =
 745 {
 746    { "", kFieldTypeEnum, sizeof(int), 0, kFieldFlagUnsigned, 0, 5, 5, software_names},
 747 };
 748
 749 static sStructDesc softwareTypeStructDesc =
 750 {
 751    PROP_SOFTWARETYPE_NAME,
 752    sizeof(int),
 753    kStructFlagNone,
 754    sizeof(softwareTypeFields)/sizeof(softwareTypeFields[0]),
 755    softwareTypeFields,
 756 };
 757
 758 static sPropertyTypeDesc softwareTypeTypeDesc = {PROP_SOFTWARETYPE_NAME, sizeof(int)};
 759
 760 /////////////////////////////////////////////////////////////
 761 IFloatProperty *gPropDelayTime;
 762
 763 static sPropertyDesc DelayTimeDesc =
 764 {
 765    PROP_DELAYTIME_NAME, 0,
 766    NULL, 0, 0, // constraints, versions
 767    { "Script", "Delay Time" },
 768 };
 769 /////////////////////////////////////////////////////////////
 770
 771 IEcologyInfoProperty *gPropEcology;
 772
 773 static sPropertyDesc EcologyDesc =
 774 {
 775    PROP_ECOLOGY_NAME, 0,
 776    NULL, 0, 0, // constraints, versions
 777    { "Script", "Ecology" },
 778 };
 779
 780 IIntProperty *gPropEcoType;
 781
 782 static sPropertyDesc EcoTypeDesc =
 783 {
 784    PROP_ECOTYPE_NAME, 0,
 785    NULL, 0, 0, // constraints, versions
 786    { "Script", "EcoType" },
 787 };
 788
 789 IIntProperty *gPropEcoState;
 790
 791 static sPropertyDesc EcoStateDesc =
 792 {
 793    PROP_ECOSTATE_NAME, 0,
 794    NULL, 0, 0, // constraints, versions
 795    { "Script", "EcoState" },
 796 };
 797
 798 /////////////////////////////////////////////////////////////
 799
 800 ISpawnInfoProperty *gPropSpawn;
 801
 802 static sPropertyDesc SpawnDesc =
 803 {
 804    PROP_SPAWN_NAME, 0,
 805    NULL, 0, 0, // constraints, versions
 806    { "Script", "Spawn" },
 807 };
 808
 809 /////////////////////////////////////////////////////////////
 810
 811 IVectorProperty *gPropShove;
 812
 813 static sPropertyDesc ShoveDesc =
 814 {
 815    PROP_SHOVE_NAME, 0,
 816    NULL, 0, 0, // constraints, versions
 817    { "Script", "Shove" },
 818 };
 819
 820 /////////////////////////////////////////////////////////////
 821
 822 IStringProperty *gPropHUDUse;
 823
 824 static sPropertyDesc HUDUseDesc =
 825 {
 826    PROP_HUDUSE_NAME, 0,
 827    NULL, 0, 0, // constraints, versions
 828    { "Obj", "HUD Use String" },
 829 };
 830
 831 /////////////////////////////////////////////////////////////
 832
 833 IFloatProperty *gPropRadAmbient;
 834
 835 static sPropertyDesc RadAmbientDesc =
 836 {
 837    PROP_RADAMBIENT_NAME, 0,
 838    NULL, 0, 0, // constraints, versions
 839    { "Player: Hazard", "Rad Ambient" },
 840 };
 841
 842 /////////////////////////////////////////////////////////////
 843
 844 IFloatProperty *gPropRadLevel;
 845
 846 static sPropertyDesc RadLevelDesc =
 847 {
 848    PROP_RADLEVEL_NAME, 0,
 849    NULL, 0, 0, // constraints, versions
 850    { "Gamesys", "Radiation Level" },
 851 };
 852
 853 /////////////////////////////////////////////////////////////
 854
 855 IFloatProperty *gPropRadDrain;
 856
 857 static sPropertyDesc RadDrainDesc =
 858 {
 859    PROP_RADDRAIN_NAME, 0,
 860    NULL, 0, 0, // constraints, versions
 861    { "Player: Hazard", "Rad Drain" },
 862 };
 863
 864 /////////////////////////////////////////////////////////////
 865
 866 IFloatProperty *gPropRadAbsorb;
 867
 868 static sPropertyDesc RadAbsorbDesc =
 869 {
 870    PROP_RADABSORB_NAME, 0,
 871    NULL, 0, 0, // constraints, versions
 872    { "Player: Hazard", "Rad Base Absorb" },
 873 };
 874
 875 /////////////////////////////////////////////////////////////
 876
 877 IFloatProperty *gPropRadRecover;
 878
 879 static sPropertyDesc RadRecoverDesc =
 880 {
 881    PROP_RADRECOVER_NAME, 0,
 882    NULL, 0, 0, // constraints, versions
 883    { "Player: Hazard", "Rad Recover Rate" },
 884 };
 885
 886 /////////////////////////////////////////////////////////////
 887
 888 IFloatProperty *gPropToxin;
 889
 890 static sPropertyDesc ToxinDesc =
 891 {
 892    PROP_TOXIN_NAME, 0,
 893    NULL, 0, 0, // constraints, versions
 894    { "Player: Hazard", "Toxin" },
 895 };
 896
 897 /////////////////////////////////////////////////////////////
 898
 899 IStringProperty *gPropWorldCursor;
 900
 901 static sPropertyDesc WorldCursorDesc =
 902 {
 903    PROP_WORLDCURSOR_NAME, 0,
 904    NULL, 0, 0, // constraints, versions
 905    { "Obj: Cursor", "World Cursor String" },
 906 };
 907
 908 IStringProperty *gPropInvCursor;
 909
 910 static sPropertyDesc InvCursorDesc =
 911 {
 912    PROP_INVCURSOR_NAME, 0,
 913    NULL, 0, 0, // constraints, versions
 914    { "Obj: Cursor", "Inv Cursor String" },
 915 };
 916
 917 IStringProperty *gPropUseCursor;
 918
 919 static sPropertyDesc UseCursorDesc =
 920 {
 921    PROP_USECURSOR_NAME, 0,
 922    NULL, 0, 0, // constraints, versions
 923    { "Obj: Cursor", "Use Cursor String" },
 924 };
 925
 926 static char *use_names[] =
 927 { "Generic", "Ammo", "Tech" };
 928
 929 IIntProperty *gPropUseType;
 930
 931 static sPropertyDesc UseTypeDesc =
 932 {
 933    PROP_USETYPE_NAME, 0,
 934    NULL, 0, 0, // constraints, versions
 935    { "Obj: Cursor", "Use Type" },
 936 };
 937
 938 static sFieldDesc useTypeFields[] =
 939 {
 940    { "", kFieldTypeEnum, sizeof(int), 0, kFieldFlagUnsigned, 0, 3, 3, use_names},
 941 };
 942
 943 static sStructDesc useTypeStructDesc =
 944 {
 945    PROP_USETYPE_NAME,
 946    sizeof(int),
 947    kStructFlagNone,
 948    sizeof(useTypeFields)/sizeof(useTypeFields[0]),
 949    useTypeFields,
 950 };
 951
 952 static sPropertyTypeDesc useTypeTypeDesc = {PROP_USETYPE_NAME, sizeof(int)};
 953
 954 /////////////////////////////////////////////////////////////
 955 IStringProperty *gPropConsumeType;
 956
 957 static sPropertyDesc ConsumeTypeDesc =
 958 {
 959    PROP_CONSUMETYPE_NAME, 0,
 960    NULL, 0, 0, // constraints, versions
 961    { "Script", "Consume Type" },
 962 };
 963
 964 /////////////////////////////////////////////////////////////
 965 IStringProperty *gPropMetapropType;
 966
 967 static sPropertyDesc MetapropTypeDesc =
 968 {
 969    PROP_METAPROPTYPE_NAME, 0,
 970    NULL, 0, 0, // constraints, versions
 971    { "Script", "Metaprop Type" },
 972 };
 973
 974 /////////////////////////////////////////////////////////////
 975 IStringProperty *gPropObjList;
 976
 977 static sPropertyDesc ObjListDesc =
 978 {
 979    PROP_OBJLIST_NAME, 0,
 980    NULL, 0, 0, // constraints, versions
 981    { "Script", "Objlist Arg" },
 982 };
 983
 984 /////////////////////////////////////////////////////////////
 985 IStringProperty *gPropSignalType;
 986
 987 static sPropertyDesc SignalTypeDesc =
 988 {
 989    PROP_SIGNALTYPE_NAME, 0,
 990    NULL, 0, 0, // constraints, versions
 991    { "Script", "Signal Type" },
 992 };
 993
 994 /////////////////////////////////////////////////////////////
 995
 996 IStringProperty *gPropQBName;
 997
 998 static sPropertyDesc QBNameDesc =
 999 {
1000    PROP_QBNAME_NAME, 0,
1001    NULL, 0, 0, // constraints, versions
1002    { "Script", "QB Name" },
1003 };
1004
1005 IIntProperty *gPropQBVal;
1006
1007 static sPropertyDesc QBValDesc =
1008 {
1009    PROP_QBVAL_NAME, 0,
1010    NULL, 0, 0, // constraints, versions
1011    { "Script", "QB Val" },
1012 };
1013
1014 /////////////////////////////////////////////////////////////
1015 IIntProperty *gPropShakeAmt;
1016
1017 static sPropertyDesc ShakeAmtDesc =
1018 {
1019    "ShakeAmt", 0,
1020    NULL, 0, 0, // constraints, versions
1021    { "Script", "Shake Strength" },
1022 };
1023
1024 /////////////////////////////////////////////////////////////
1025 IMapRefProperty *gPropMapRef;
1026
1027 static sPropertyDesc MapRefDesc =
1028 {
1029    "MapRef", 0,
1030    NULL, 0, 0, // constraints, versions
1031    { "Obj", "Map Ref Info" },
1032 };
1033
1034
1035 /////////////////////////////////////////////////////////////
1036 /* ------------------------------------------------------------ */
1037 // Tech Info (H,R,M) property description
1038
1039 // data ops
1040 class cTechInfoDataOps: public cClassDataOps<sTechInfo>
1041 {
1042 };
1043
1044 // storage class
1045 class cTechInfoStore: public cHashPropertyStore<cTechInfoDataOps>
1046 {
1047 };
1048
1049 // property implementation class
1050 class cTechInfoProperty: public cSpecificProperty<ITechInfoProperty, &IID_ITechInfoProperty, sTechInfo*, cTechInfoStore>
1051 {
1052    typedef cSpecificProperty<ITechInfoProperty, &IID_ITechInfoProperty, sTechInfo*, cTechInfoStore> cParent;
1053
1054 public:
1055    cTechInfoProperty(const sPropertyDesc* desc)
1056       : cParent(desc)
1057    {
1058    }
1059
1060    STANDARD_DESCRIBE_TYPE(sTechInfo);
1061
1062 };
1063
1064 ITechInfoProperty *g_TechInfoProperty;
1065
1066 static sFieldDesc TechInfoFields[] =
1067 {
1068    {"Success %", kFieldTypeInt, FieldLocation(sTechInfo, m_success), },
1069    {"Critical Fail %", kFieldTypeInt, FieldLocation(sTechInfo, m_critfail),},
1070    {"Cost", kFieldTypeFloat, FieldLocation(sTechInfo, m_cost),},
1071 };
1072
1073 static sStructDesc TechInfoStructDesc =
1074    StructDescBuild(sTechInfo, kStructFlagNone, TechInfoFields);
1075
1076 ITechInfoProperty *CreateTechInfoProperty(sPropertyDesc *desc,
1077                                                           ePropertyImpl impl)
1078 {
1079    StructDescRegister(&TechInfoStructDesc);
1080    return new cTechInfoProperty(desc);
1081 }
1082
1083 /* ------------------------------------------------------------ */
1084 // Map Reference marker data
1085
1086 // data ops
1087 class cMapRefDataOps: public cClassDataOps<sMapRef>
1088 {
1089 };
1090
1091 // storage class
1092 class cMapRefStore: public cHashPropertyStore<cMapRefDataOps>
1093 {
1094 };
1095
1096 // property implementation class
1097 class cMapRefProperty: public cSpecificProperty<IMapRefProperty, &IID_IMapRefProperty, sMapRef*, cMapRefStore>
1098 {
1099    typedef cSpecificProperty<IMapRefProperty, &IID_IMapRefProperty, sMapRef*, cMapRefStore> cParent;
1100
1101 public:
1102    cMapRefProperty(const sPropertyDesc* desc)
1103       : cParent(desc)
1104    {
1105    }
1106
1107    STANDARD_DESCRIBE_TYPE(sMapRef);
1108
1109 };
1110
1111 IMapRefProperty *g_MapRefProperty;
1112
1113 static sFieldDesc MapRefFields[] =
1114 {
1115    {"Map X", kFieldTypeInt, FieldLocation(sMapRef, m_x), },
1116    {"Map Y", kFieldTypeInt, FieldLocation(sMapRef, m_y), },
1117    {"Frame", kFieldTypeInt, FieldLocation(sMapRef, m_frame), },
1118 };
1119
1120 static sStructDesc MapRefStructDesc =
1121    StructDescBuild(sMapRef, kStructFlagNone, MapRefFields);
1122
1123 IMapRefProperty *CreateMapRefProperty(sPropertyDesc *desc,
1124                                                           ePropertyImpl impl)
1125 {
1126    StructDescRegister(&MapRefStructDesc);
1127    return new cMapRefProperty(desc);
1128 }
1129 /* ------------------------------------------------------------ */
1130 // Loot Info property description
1131
1132 // data ops
1133 class cLootInfoDataOps: public cClassDataOps<sLootInfo>
1134 {
1135 };
1136
1137 // storage class
1138 class cLootInfoStore: public cHashPropertyStore<cLootInfoDataOps>
1139 {
1140 };
1141
1142 // property implementation class
1143 class cLootInfoProperty: public cSpecificProperty<ILootInfoProperty, &IID_ILootInfoProperty, sLootInfo*, cLootInfoStore>
1144 {
1145    typedef cSpecificProperty<ILootInfoProperty, &IID_ILootInfoProperty, sLootInfo*, cLootInfoStore> cParent;
1146
1147 public:
1148    cLootInfoProperty(const sPropertyDesc* desc)
1149       : cParent(desc)
1150    {
1151    }
1152
1153    STANDARD_DESCRIBE_TYPE(sLootInfo);
1154
1155 };
1156
1157 ILootInfoProperty *g_LootInfoProperty;
1158
1159 static sFieldDesc LootInfoFields[] =
1160 {
1161    {"Number of Picks", kFieldTypeInt, FieldLocation(sLootInfo, m_numpicks), },
1162    {"1 - Item", kFieldTypeString, FieldLocation(sLootInfo, m_items[0]), },
1163    {"1 - Rarity", kFieldTypeInt, FieldLocation(sLootInfo, m_rarity[0]),},
1164    //{"1 - Value", kFieldTypeFloat, FieldLocation(sLootInfo, m_value[0]),},
1165    {"2 - Item", kFieldTypeString, FieldLocation(sLootInfo, m_items[1]), },
1166    {"2 - Rarity", kFieldTypeInt, FieldLocation(sLootInfo, m_rarity[1]),},
1167    //{"2 - Value", kFieldTypeFloat, FieldLocation(sLootInfo, m_value[1]),},
1168    {"3 - Item", kFieldTypeString, FieldLocation(sLootInfo, m_items[2]), },
1169    {"3 - Rarity", kFieldTypeInt, FieldLocation(sLootInfo, m_rarity[2]),},
1170    //{"3 - Value", kFieldTypeFloat, FieldLocation(sLootInfo, m_value[2]),},
1171    {"4 - Item", kFieldTypeString, FieldLocation(sLootInfo, m_items[3]), },
1172    {"4 - Rarity", kFieldTypeInt, FieldLocation(sLootInfo, m_rarity[3]),},
1173    //{"4 - Value", kFieldTypeFloat, FieldLocation(sLootInfo, m_value[3]),},
1174    {"5 - Item", kFieldTypeString, FieldLocation(sLootInfo, m_items[4]), },
1175    {"5 - Rarity", kFieldTypeInt, FieldLocation(sLootInfo, m_rarity[4]),},
1176    //{"5 - Value", kFieldTypeFloat, FieldLocation(sLootInfo, m_value[4]),},
1177    {"6 - Item", kFieldTypeString, FieldLocation(sLootInfo, m_items[5]), },
1178    {"6 - Rarity", kFieldTypeInt, FieldLocation(sLootInfo, m_rarity[5]),},
1179    //{"6 - Value", kFieldTypeFloat, FieldLocation(sLootInfo, m_value[5]),},
1180 };
1181
1182 static sStructDesc LootInfoStructDesc =
1183    StructDescBuild(sLootInfo, kStructFlagNone, LootInfoFields);
1184
1185 ILootInfoProperty *CreateLootInfoProperty(sPropertyDesc *desc,
1186                                                           ePropertyImpl impl)
1187 {
1188    StructDescRegister(&LootInfoStructDesc);
1189    return new cLootInfoProperty(desc);
1190 }
1191
1192 /////////////////////////////////////////////////////////////
1193
1194 IStringProperty* gPropSettingText1;
1195 IStringProperty* gPropSettingText2;
1196 IStringProperty* gPropSettingHead1;
1197 IStringProperty* gPropSettingHead2;
1198
1199 static sPropertyDesc SettingText1Desc =
1200 {
1201   PROP_SETTINGTEXT1_NAME, 0,
1202   NULL, 0, 0, // constraints, versions
1203   { "Gun", "Setting Text 1" },
1204 };
1205
1206 static sPropertyDesc SettingText2Desc =
1207 {
1208   PROP_SETTINGTEXT2_NAME, 0,
1209   NULL, 0, 0, // constraints, versions
1210   { "Gun", "Setting Text 2" },
1211 };
1212
1213 static sPropertyDesc SettingHead1Desc =
1214 {
1215   PROP_SETTINGHEAD1_NAME, 0,
1216   NULL, 0, 0, // constraints, versions
1217   { "Gun", "Setting Header 1" },
1218 };
1219
1220 static sPropertyDesc SettingHead2Desc =
1221 {
1222   PROP_SETTINGHEAD2_NAME, 0,
1223   NULL, 0, 0, // constraints, versions
1224   { "Gun", "Setting Header 2" },
1225 };
1226
1227 /////////////////////////////////////////////////////////////
1228 IIntProperty* gPropResearchTime;
1229 static sPropertyDesc ResearchTimeDesc =
1230 {
1231   PROP_RESEARCHTIME_NAME, 0,
1232   NULL, 0, 0, // constraints, versions
1233   { "Gamesys", "Research Time" },
1234 };
1235
1236 IStringProperty *gPropResearchText;
1237 static sPropertyDesc ResearchTextDesc =
1238 {
1239   PROP_RESEARCHTEXT_NAME, 0,
1240   NULL, 0, 0, // constraints, versions
1241   { "Gamesys", "Research Text" },
1242 };
1243
1244 /////////////////////////////////////////////////////////////
1245 IFloatProperty *gPropHackVisibility;
1246 static sPropertyDesc HackVisibilityDesc =
1247 {
1248   PROP_HACKVISIBILITY_NAME, 0,
1249   NULL, 0, 0, // constraints, versions
1250   { "Player", "Hack Visibility" },
1251 };
1252
1253 /////////////////////////////////////////////////////////////
1254 IFloatProperty *gPropEnergy;
1255 static sPropertyDesc EnergyDesc =
1256 {
1257   PROP_ENERGY_NAME, 0,
1258   NULL, 0, 0, // constraints, versions
1259   { "Obj: Energy", "Stored Energy" },
1260 };
1261
1262 IFloatProperty *gPropDrainRate;
1263 static sPropertyDesc DrainRateDesc =
1264 {
1265   PROP_DRAINRATE_NAME, 0,
1266   NULL, 0, 0, // constraints, versions
1267   { "Obj: Energy", "Drain Rate" },
1268 };
1269
1270 IFloatProperty *gPropDrainAmt;
1271 static sPropertyDesc DrainAmtDesc =
1272 {
1273   PROP_DRAINAMT_NAME, 0,
1274   NULL, 0, 0, // constraints, versions
1275   { "Obj: Energy", "Drain Amount" },
1276 };
1277
1278 /////////////////////////////////////////////////////////////
1279
1280 IIntProperty *gPropTripFlags;
1281 static sPropertyDesc tripFlagsDesc =
1282 {
1283    PROP_TRIPFLAGS_NAME, 0,
1284    NULL, 0, 0,
1285    { "Script", "Trap Control Flags" },
1286 };
1287
1288 char *tripflag_names[] =
1289 { "Enter", "Exit", "Mono", "Once", "Invert", "Player", "Alarm", "Shove", "ZapInside", "EasterEgg 1"};
1290
1291 static sFieldDesc tripFlagsFields[] =
1292 {
1293    { "", kFieldTypeBits, sizeof(int), 0, kFieldFlagUnsigned, 0, 10, 10, tripflag_names},
1294 };
1295
1296 static sStructDesc tripFlagsStructDesc =
1297 {
1298    PROP_TRIPFLAGS_NAME,
1299    sizeof(int),
1300    kStructFlagNone,
1301    sizeof(tripFlagsFields)/sizeof(tripFlagsFields[0]),
1302    tripFlagsFields,
1303 };
1304
1305 static sPropertyTypeDesc tripFlagsTypeDesc = {PROP_TRIPFLAGS_NAME, sizeof(int)};
1306
1307 /* ------------------------------------------------------------ */
1308 // Chem Info property description
1309
1310 // data ops
1311 class cChemInfoDataOps: public cClassDataOps<sChemInfo>
1312 {
1313 };
1314
1315 // storage class
1316 class cChemInfoStore: public cHashPropertyStore<cChemInfoDataOps>
1317 {
1318 };
1319
1320 // property implementation class
1321 class cChemInfoProperty: public cSpecificProperty<IChemInfoProperty, &IID_IChemInfoProperty, sChemInfo*, cChemInfoStore>
1322 {
1323    typedef cSpecificProperty<IChemInfoProperty, &IID_IChemInfoProperty, sChemInfo*, cChemInfoStore> cParent;
1324
1325 public:
1326    cChemInfoProperty(const sPropertyDesc* desc)
1327       : cParent(desc)
1328    {
1329    }
1330
1331    STANDARD_DESCRIBE_TYPE(sChemInfo);
1332
1333 };
1334
1335 static sFieldDesc ChemInfoFields[] =
1336 {
1337    {"1 - Item", kFieldTypeString, FieldLocation(sChemInfo, m_chem[0]), },
1338    {"1 - Time", kFieldTypeInt, FieldLocation(sChemInfo, m_time[0]),},
1339    {"2 - Item", kFieldTypeString, FieldLocation(sChemInfo, m_chem[1]), },
1340    {"2 - Time", kFieldTypeInt, FieldLocation(sChemInfo, m_time[1]),},
1341    {"3 - Item", kFieldTypeString, FieldLocation(sChemInfo, m_chem[2]), },
1342    {"3 - Time", kFieldTypeInt, FieldLocation(sChemInfo, m_time[2]),},
1343    {"4 - Item", kFieldTypeString, FieldLocation(sChemInfo, m_chem[3]), },
1344    {"4 - Time", kFieldTypeInt, FieldLocation(sChemInfo, m_time[3]),},
1345    {"5 - Item", kFieldTypeString, FieldLocation(sChemInfo, m_chem[4]), },
1346    {"5 - Time", kFieldTypeInt, FieldLocation(sChemInfo, m_time[4]),},
1347    {"6 - Item", kFieldTypeString, FieldLocation(sChemInfo, m_chem[5]), },
1348    {"6 - Time", kFieldTypeInt, FieldLocation(sChemInfo, m_time[5]),},
1349    {"7 - Item", kFieldTypeString, FieldLocation(sChemInfo, m_chem[6]), },
1350    {"7 - Time", kFieldTypeInt, FieldLocation(sChemInfo, m_time[6]),},
1351 };
1352
1353 static sStructDesc ChemInfoStructDesc =
1354    StructDescBuild(sChemInfo, kStructFlagNone, ChemInfoFields);
1355
1356 IChemInfoProperty *CreateChemInfoProperty(sPropertyDesc *desc,
1357                                                           ePropertyImpl impl)
1358 {
1359    StructDescRegister(&ChemInfoStructDesc);
1360    return new cChemInfoProperty(desc);
1361 }
1362
1363 static sPropertyDesc ChemDesc =
1364 {
1365   PROP_CHEMNEED_NAME, 0,
1366   NULL, 0, 0, // constraints, versions
1367   { "Gamesys", "Chemicals Needed" },
1368 };
1369
1370 IChemInfoProperty *gPropChemNeeded;
1371
1372 /* ------------------------------------------------------------ */
1373 // Ecology Info property description
1374
1375 // data ops
1376 class cEcologyInfoDataOps: public cClassDataOps<sEcologyInfo>
1377 {
1378 };
1379
1380 // storage class
1381 class cEcologyInfoStore: public cHashPropertyStore<cEcologyInfoDataOps>
1382 {
1383 };
1384
1385 // property implementation class
1386 class cEcologyInfoProperty: public cSpecificProperty<IEcologyInfoProperty, &IID_IEcologyInfoProperty, sEcologyInfo*, cEcologyInfoStore>
1387 {
1388    typedef cSpecificProperty<IEcologyInfoProperty, &IID_IEcologyInfoProperty, sEcologyInfo*, cEcologyInfoStore> cParent;
1389
1390 public:
1391    cEcologyInfoProperty(const sPropertyDesc* desc)
1392       : cParent(desc)
1393    {
1394    }
1395
1396    STANDARD_DESCRIBE_TYPE(sEcologyInfo);
1397
1398 };
1399
1400 IEcologyInfoProperty *g_EcologyInfoProperty;
1401
1402 static sFieldDesc EcologyInfoFields[] =
1403 {
1404    {"Period", kFieldTypeFloat, FieldLocation(sEcologyInfo, m_period), },
1405    {"Normal Min", kFieldTypeInt, FieldLocation(sEcologyInfo,m_mincount[0]), },
1406    {"Normal Max", kFieldTypeInt, FieldLocation(sEcologyInfo,m_maxcount[0]), },
1407    {"Normal Rand", kFieldTypeInt, FieldLocation(sEcologyInfo, m_randval[0]), },
1408    /*
1409    {"Hacked Min", kFieldTypeInt, FieldLocation(sEcologyInfo,m_mincount[1]), },
1410    {"Hacked Max", kFieldTypeInt, FieldLocation(sEcologyInfo,m_maxcount[1]), },
1411    {"Hacked Recovery", kFieldTypeFloat, FieldLocation(sEcologyInfo,m_recovery[1]), },
1412    {"Hacked Rand", kFieldTypeInt, FieldLocation(sEcologyInfo, m_randval[1]), },
1413    */
1414    {"Alert Min", kFieldTypeInt, FieldLocation(sEcologyInfo,m_mincount[2]), },
1415    {"Alert Max", kFieldTypeInt, FieldLocation(sEcologyInfo,m_maxcount[2]), },
1416    {"Alert Recovery", kFieldTypeFloat, FieldLocation(sEcologyInfo,m_recovery[2]), },
1417    {"Alert Rand", kFieldTypeInt, FieldLocation(sEcologyInfo, m_randval[2]), },
1418 };
1419
1420 static sStructDesc EcologyInfoStructDesc =
1421    StructDescBuild(sEcologyInfo, kStructFlagNone, EcologyInfoFields);
1422
1423 IEcologyInfoProperty *CreateEcologyInfoProperty(sPropertyDesc *desc,
1424                                                           ePropertyImpl impl)
1425 {
1426    StructDescRegister(&EcologyInfoStructDesc);
1427    return new cEcologyInfoProperty(desc);
1428 }
1429
1430 /////////////////////////////////////////////////////////////
1431 // Spawn Info property description
1432
1433 // data ops
1434 class cSpawnInfoDataOps: public cClassDataOps<sSpawnInfo>
1435 {
1436 };
1437
1438 // storage class
1439 class cSpawnInfoStore: public cHashPropertyStore<cSpawnInfoDataOps>
1440 {
1441 };
1442
1443 // property implementation class
1444 class cSpawnInfoProperty: public cSpecificProperty<ISpawnInfoProperty, &IID_ISpawnInfoProperty, sSpawnInfo*, cSpawnInfoStore>
1445 {
1446    typedef cSpecificProperty<ISpawnInfoProperty, &IID_ISpawnInfoProperty, sSpawnInfo*, cSpawnInfoStore> cParent;
1447
1448 public:
1449    cSpawnInfoProperty(const sPropertyDesc* desc)
1450       : cParent(desc)
1451    {
1452    }
1453
1454    STANDARD_DESCRIBE_TYPE(sSpawnInfo);
1455
1456 };
1457
1458 ISpawnInfoProperty *g_SpawnInfoProperty;
1459
1460 static char *flagBits[] =
1461 {
1462    "PopLimit",
1463    "PlrDist",
1464    "GotoLoc",
1465    "SelfMarker",
1466    "Raycast",
1467    "Farthest",
1468 };
1469
1470 static sFieldDesc SpawnInfoFields[] =
1471 {
1472    {"Type 1", kFieldTypeString, FieldLocation(sSpawnInfo, m_objs[0]), },
1473    {"Rarity 1", kFieldTypeInt, FieldLocation(sSpawnInfo, m_odds[0]),},
1474    {"Type 2", kFieldTypeString, FieldLocation(sSpawnInfo, m_objs[1]), },
1475    {"Rarity 2", kFieldTypeInt, FieldLocation(sSpawnInfo, m_odds[1]),},
1476    {"Type 3", kFieldTypeString, FieldLocation(sSpawnInfo, m_objs[2]), },
1477    {"Rarity 3", kFieldTypeInt, FieldLocation(sSpawnInfo, m_odds[2]),},
1478    {"Type 4", kFieldTypeString, FieldLocation(sSpawnInfo, m_objs[3]), },
1479    {"Rarity 4", kFieldTypeInt, FieldLocation(sSpawnInfo, m_odds[3]),},
1480    {"Flags", kFieldTypeBits, FieldLocation(sSpawnInfo, m_flags),kFieldFlagNone, 0, 6, 6, flagBits,},
1481    {"Supply", kFieldTypeInt, FieldLocation(sSpawnInfo, m_supply),},
1482 };
1483
1484 static sStructDesc SpawnInfoStructDesc =
1485    StructDescBuild(sSpawnInfo, kStructFlagNone, SpawnInfoFields);
1486
1487 ISpawnInfoProperty *CreateSpawnInfoProperty(sPropertyDesc *desc,
1488                                                           ePropertyImpl impl)
1489 {
1490    StructDescRegister(&SpawnInfoStructDesc);
1491    return new cSpawnInfoProperty(desc);
1492 }
1493
1494 /////////////////////////////////////////////////////////////
1495 // Automatically Pickupable object property
1496 /////////////////////////////////////////////////////////////
1497
1498 IBoolProperty* gPropAutoPickup;
1499
1500 static sPropertyDesc AutoPickupDesc =
1501 {
1502    PROP_AUTOPICKUP_NAME, 0,
1503    NULL, 0, 0, // constraints, versions
1504    { "Obj", "AutoPickup?" },
1505 };
1506
1507 /////////////////////////////////////////////////////////////
1508 // Plot critical object (prevent corpse deletion)
1509 /////////////////////////////////////////////////////////////
1510
1511 IBoolProperty* gPropPlotCritical;
1512
1513 static sPropertyDesc plotCriticalDesc =
1514 {
1515    PROP_PLOTCRITICAL_NAME, 0,
1516    NULL, 0, 0, // constraints, versions
1517    { "Obj", "Plot Critical?" },
1518 };
1519
1520 /////////////////////////////////////////////////////////////
1521 // Transluce Rate property
1522 /////////////////////////////////////////////////////////////
1523
1524 static sPropertyDesc transluceRateDesc =
1525 {
1526   PROP_TRANSLUCE_RATE, 0,
1527   NULL, 0, 0, // constraints, versions
1528   { "Renderer", "Transluce Rate" },
1529 };
1530
1531 /////////////////////////////////////////////////////////////
1532 void ShockPropertiesInit(void)
1533 {
1534    AutoAppIPtr(GameStrings);
1535
1536    gPropObjName = CreateStringProperty(&ObjNameDesc,OBJ_NAME_IMPL);
1537    pGameStrings->RegisterProp(PROP_OBJNAME_NAME,gPropObjName);
1538
1539    StructDescRegister(&NameTypeStructDesc);
1540    gPropObjNameType = CreateIntegralProperty(&NameTypeDesc, &NameTypeTypeDesc, kPropertyImplHash);
1541
1542    gPropObjShortName = CreateStringProperty(&ObjShortNameDesc,kPropertyImplHash);
1543    pGameStrings->RegisterProp(PROP_OBJSHORTNAME_NAME,gPropObjShortName);
1544
1545    gPropObjLookString = CreateStringProperty(&ObjLookStringDesc,kPropertyImplHash);
1546    pGameStrings->RegisterProp(PROP_OBJLOOKSTRING_NAME,gPropObjLookString);
1547
1548    gPropExp = CreateIntProperty(&ExpDesc,EXP_IMPL);
1549    gPropObjIcon = CreateLabelProperty(&ObjIconDesc,OBJ_ICON_IMPL);
1550    gPropObjBrokenIcon = CreateLabelProperty(&ObjBrokenIconDesc,kPropertyImplHash);
1551
1552    gPropMapRef = CreateMapRefProperty(&MapRefDesc, kPropertyImplHash);
1553
1554    gPropHackDiff = CreateTechInfoProperty(&HackDiffDesc,HACKDIFF_IMPL);
1555    gPropRepairDiff = CreateTechInfoProperty(&RepairDiffDesc,REPAIRDIFF_IMPL);
1556    gPropModifyDiff = CreateTechInfoProperty(&ModifyDiffDesc,MODIFYDIFF_IMPL);
1557    gPropModify2Diff = CreateTechInfoProperty(&Modify2DiffDesc,MODIFY2DIFF_IMPL);
1558
1559    gPropModify1Text = CreateStringProperty(&Modify1TextDesc,MODIFY1TEXT_IMPL);
1560    pGameStrings->RegisterProp(PROP_MODIFY1TEXT_NAME, gPropModify1Text);
1561    gPropModify2Text = CreateStringProperty(&Modify2TextDesc,MODIFY2TEXT_IMPL);
1562    pGameStrings->RegisterProp(PROP_MODIFY2TEXT_NAME, gPropModify2Text);
1563
1564    gPropHackText = CreateStringProperty(&HackTextDesc, HACKTEXT_IMPL);
1565    pGameStrings->RegisterProp(PROP_HACKTEXT_NAME, gPropHackText);
1566
1567    gPropUseMessage = CreateStringProperty(&UseMessageDesc, kPropertyImplHash);
1568    pGameStrings->RegisterProp(PROP_USEMESSAGE_NAME,gPropUseMessage);
1569    gPropMessageTime = CreateIntProperty(&MessageTimeDesc, kPropertyImplHash);
1570
1571    gPropStackIncrem = CreateIntProperty(&StackIncremDesc, kPropertyImplHash);
1572
1573    gPropLockedMessage = CreateStringProperty(&LockedMessageDesc, kPropertyImplHash);
1574    pGameStrings->RegisterProp(PROP_LOCKEDMESSAGE_NAME,gPropLockedMessage);
1575
1576    gPropHUDTime = CreateIntProperty(&HUDTimeDesc, kPropertyImplHash);
1577    gPropAllowHUDSelect = CreateBoolProperty(&HUDSelectDesc, kPropertyImplHash);
1578    gPropShowHP = CreateBoolProperty(&ShowHPDesc, kPropertyImplHash);
1579    gPropHackTime = CreateIntProperty(&HackTimeDesc, kPropertyImplHash);
1580
1581    gPropAlarm = CreateBoolProperty(&AlarmDesc, kPropertyImplHash);
1582    gPropBlockFrob = CreateBoolProperty(&BlockFrobDesc, kPropertyImplHash);
1583
1584    StructDescRegister(&objStateStructDesc);
1585    gPropObjState = CreateIntegralProperty(&objStateDesc, &objStateTypeDesc, kPropertyImplHash);
1586
1587    StructDescRegister(&softwareTypeStructDesc);
1588    gPropSoftwareType = CreateIntegralProperty(&SoftwareTypeDesc, &softwareTypeTypeDesc, kPropertyImplHash);
1589    gPropSoftwareLevel = CreateIntProperty(&SoftwareLevelDesc, kPropertyImplHash);
1590
1591    gPropDelayTime = CreateFloatProperty(&DelayTimeDesc, kPropertyImplHash);
1592
1593    gPropLoot = CreateLootInfoProperty(&LootDesc,LOOT_IMPL);
1594    gPropGuaranteedLoot = CreateLabelProperty(&GuaranteedLootDesc,kPropertyImplLlist);
1595    gPropReallyGuaranteedLoot = CreateLabelProperty(&ReallyGuaranteedLootDesc,kPropertyImplLlist);
1596
1597    gPropMapObjIcon = CreateLabelProperty(&MapObjIconDesc,kPropertyImplHash);
1598    gPropMapObjRotate = CreateBoolProperty(&MapObjRotateDesc,kPropertyImplHash);
1599    gPropMapText = CreateStringProperty(&MapTextDesc,kPropertyImplHash);
1600
1601    gPropSettingText1 = CreateStringProperty(&SettingText1Desc,kPropertyImplHash);
1602    gPropSettingText2 = CreateStringProperty(&SettingText2Desc,kPropertyImplHash);
1603    pGameStrings->RegisterProp(PROP_SETTINGTEXT1_NAME,gPropSettingText1);
1604    pGameStrings->RegisterProp(PROP_SETTINGTEXT2_NAME,gPropSettingText2);
1605
1606    gPropSettingHead1 = CreateStringProperty(&SettingHead1Desc,kPropertyImplHash);
1607    gPropSettingHead2 = CreateStringProperty(&SettingHead2Desc,kPropertyImplHash);
1608    pGameStrings->RegisterProp(PROP_SETTINGHEAD1_NAME,gPropSettingHead1);
1609    pGameStrings->RegisterProp(PROP_SETTINGHEAD2_NAME,gPropSettingHead2);
1610
1611    gPropResearchTime = CreateIntProperty(&ResearchTimeDesc, kPropertyImplHash);
1612    gPropResearchText = CreateStringProperty(&ResearchTextDesc, kPropertyImplHash);
1613    pGameStrings->RegisterProp(PROP_RESEARCHTEXT_NAME, gPropResearchText);
1614
1615    gPropChemNeeded = CreateChemInfoProperty(&ChemDesc,kPropertyImplHash);
1616
1617    gPropEcology = CreateEcologyInfoProperty(&EcologyDesc, kPropertyImplHash);
1618    gPropEcoType = CreateIntProperty(&EcoTypeDesc, kPropertyImplHash);
1619    gPropEcoState = CreateIntProperty(&EcoStateDesc, kPropertyImplHash);
1620
1621    gPropSpawn = CreateSpawnInfoProperty(&SpawnDesc, kPropertyImplHash);
1622
1623    gPropHackVisibility = CreateFloatProperty(&HackVisibilityDesc, kPropertyImplHash);
1624    gPropShove = CreateVectorProperty(&ShoveDesc, kPropertyImplHash);
1625
1626    gPropHUDUse = CreateStringProperty(&HUDUseDesc, kPropertyImplHash);
1627    pGameStrings->RegisterProp(PROP_HUDUSE_NAME, gPropHUDUse);
1628
1629    gPropRadAmbient = CreateFloatProperty(&RadAmbientDesc, kPropertyImplLlist);
1630    gPropRadLevel = CreateFloatProperty(&RadLevelDesc, kPropertyImplHash);
1631    gPropToxin = CreateFloatProperty(&ToxinDesc, kPropertyImplHash);
1632    gPropRadDrain = CreateFloatProperty(&RadDrainDesc, kPropertyImplLlist);
1633    gPropRadAbsorb = CreateFloatProperty(&RadAbsorbDesc, kPropertyImplLlist);
1634    gPropRadRecover = CreateFloatProperty(&RadRecoverDesc, kPropertyImplLlist);
1635
1636    gPropWorldCursor = CreateStringProperty(&WorldCursorDesc, kPropertyImplHash);
1637    pGameStrings->RegisterProp(PROP_WORLDCURSOR_NAME, gPropWorldCursor);
1638    gPropInvCursor = CreateStringProperty(&InvCursorDesc, kPropertyImplHash);
1639    pGameStrings->RegisterProp(PROP_INVCURSOR_NAME, gPropInvCursor);
1640    gPropUseCursor = CreateStringProperty(&UseCursorDesc, kPropertyImplHash);
1641    pGameStrings->RegisterProp(PROP_USECURSOR_NAME, gPropUseCursor);
1642
1643    StructDescRegister(&useTypeStructDesc);
1644    gPropUseType = CreateIntegralProperty(&UseTypeDesc, &useTypeTypeDesc, kPropertyImplHash);
1645    gPropAutoPickup = CreateBoolProperty(&AutoPickupDesc, kPropertyImplHash);
1646
1647    gPropEnergy = CreateFloatProperty(&EnergyDesc, kPropertyImplHash);
1648    gPropDrainRate = CreateFloatProperty(&DrainRateDesc, kPropertyImplHash);
1649    gPropDrainAmt = CreateFloatProperty(&DrainAmtDesc, kPropertyImplHash);
1650
1651    gPropConsumeType = CreateStringProperty(&ConsumeTypeDesc, kPropertyImplHash);
1652    gPropSignalType = CreateStringProperty(&SignalTypeDesc, kPropertyImplHash);
1653    gPropMetapropType = CreateStringProperty(&MetapropTypeDesc, kPropertyImplHash);
1654    gPropObjList = CreateStringProperty(&ObjListDesc, kPropertyImplHash);
1655
1656    gPropQBName = CreateStringProperty(&QBNameDesc, kPropertyImplHash);
1657    gPropQBVal = CreateIntProperty(&QBValDesc, kPropertyImplHash);
1658
1659    gPropShakeAmt = CreateIntProperty(&ShakeAmtDesc, kPropertyImplSparseHash);
1660
1661    gPropRecycle = CreateIntProperty(&RecycleDesc, kPropertyImplHash);
1662
1663    StructDescRegister(&tripFlagsStructDesc);
1664    gPropTripFlags = CreateIntegralProperty(&tripFlagsDesc, &tripFlagsTypeDesc, kPropertyImplHash);
1665
1666    StructDescRegister(&miniGamesStructDesc);
1667    gPropMiniGames = CreateIntegralProperty(&MiniGamesDesc, &miniGamesTypeDesc, kPropertyImplLlist);
1668
1669    gPropPlotCritical = CreateBoolProperty(&plotCriticalDesc, kPropertyImplHash);
1670
1671    CreateIntProperty(&transluceRateDesc, kPropertyImplHash);
1672 }