Skip to content

VOBS & Triggers

Jump to bottom
Try edited this page May 27, 2022 · 3 revisions

zCVob

struct zCVob {
    string presetName;
    bBox   bbox3DWS;
    zMat3  trafoOSToWSRot;
    zVec3  trafoOSToWSPos;
    string vobName;
    string visual;
    bool   showVisual;
    enum   visualCamAlign;
    #if GOTHIC1  
    bool  cdStatic;
    bool  cdDyn;
    bool  staticVob;
    enum  dynamicShadow;
    #endif
    enum   visualAniMode;
    #if GOTHIC2  
    float  visualAniModeStrength;
    float  vobFarClipZScale;
    bool   cdStatic;
    bool   cdDyn;
    bool   staticVob;
    bool   dynamicShadow;
    float  zBias;
    bool   isAmbient;
    #endif
    };

zCVobLevelCompo

struct zCVobLevelCompo : zCVob {};

oCItem

struct oCItem : zCVob {
    instance itemInstance;
    };

oCMOB

struct oCMOB : zCVob {
    string focusName;
    int    hitpoints;
    int    damage;
    bool   moveable;
    bool   takeable;
    bool   focusOverride;
    enum   soundMaterial;
    string visualDestroyed;
    string owner;
    string ownerGuild;
    bool   isDestroyed;
    };

oCMobInter

struct oCMobInter : oCMOB {
    int    stateNum;
    string triggerTarget;
    string useWithItem;
    string conditionFunc;
    string onStateFunc;
    bool   rewind;
    };

oCMobBed

struct oCMobBed : oCMobInter {};

oCMobFire

// Not implemented
struct oCMobFire : oCMobInter {
    string fireSlot;
    string fireVobtreeName;
    };

oCMobLadder

// Not implemented
struct oCMobLadder : oCMobInter {};

oCMobSwitch

struct oCMobSwitch : oCMobInter {};

oCMobWheel

// Not implemented
struct oCMobWheel : oCMobInter {};

oCMobDoor

struct oCMobDoor : oCMobInter {
    bool locked;
    string keyInstance;
    string pickLockStr;
    };

zCPFXControler

struct zCPFXControler : zCVob {
    string pfxName;
    bool   killVobWhenDone;
    bool   pfxStartOn;
    };

zCVobAnimate

struct zCVobAnimate : zCVob {
    bool startOn;
    };

zCVobLensFlare

struct zCVobLensFlare : zCVob {
    string lensflareFX;
    };

zCVobLight

struct zCVobLight : zCVob {
    string lightPresetInUse;
    enum   lightType;
    float  range;
    color  color;
    float  spotConeAngle;
    bool   lightStatic;
    enum   lightQuality;
    string lensflareFX;
#if (lightStatic == true)
       bool   turnedOn;
       string rangeAniScale;
       float  rangeAniFPS;
       bool   rangeAniSmooth;
       string colorAniList;
       float  colorAniFPS;
       bool   colorAniSmooth;
#  if GOTHIC2
       bool   canMove;
#  endif
#endif
    };

zCVobSpot

struct zCVobSpot : zCVob {};

zCVobStartpoint

struct zCVobStartpoint : zCVob {};

zCVobSound

struct zCVobSound : zCVob {
    float  sndVolume;
    enum   sndMode;
    float  sndRandDelay;
    float  sndRandDelayVar;
    bool   sndStartOn;
    bool   sndAmbient3D;
    bool   sndObstruction;
    float  sndConeAngle;
    enum   sndVolType;
    float  sndRadius;
    string sndName;
    };

zCVobSoundDaytime

struct zCVobSoundDaytime : zCVobSound {
    float  sndStartTime;
    float  sndEndTime;
    string sndName2;
    };

oCZoneMusic

struct oCZoneMusic : zCVob {
    bool  enabled;
    int   priority;
    bool  ellipsoid;
    float reverbLevel;
    float volumeLevel;
    bool  loop;
    };

oCZoneMusicDefault

struct oCZoneMusicDefault : oCZoneMusic {};

zCZoneZFog

struct zCZoneZFog : zCVob {
    float fogRangeCenter;
    float innerRangePerc;
    color fogColor;
#if GOTHIC2
    bool fadeOutSky;
    bool overrideColor;
#endif
    };

zCZoneZFogDefault

struct zCZoneZFogDefault : zCZoneZFog {};

zCZoneVobFarPlane

struct zCZoneVobFarPlane : zCVob {
    float vobFarPlaneZ;
    float innerRangePerc;
    };

zCZoneVobFarPlane

struct zCZoneVobFarPlaneDefault : zCZoneVobFarPlane {};

zCCodeMaster

// Partial implementation: no order
struct zCCodeMaster : zCVob {
    string   triggerTarget;
    bool     orderRelevant;
    bool     firstFalseIsFailure;
    string   triggerTargetFailure;
    bool     untriggeredCancels;
    string[] slaveVobName;
    };

zCTrigger

struct zCTrigger : zCVob {
    string  triggerTarget;
    uint8_t flags;
    uint8_t filterFlags;
    string  respondToVobName;
    int     numCanBeActivated;
    float   retriggerWaitSec;
    float   damageThreshold;
    float   fireDelaySec;
    };

oCCSTrigger

using oCCSTrigger = zCTrigger;

zCMover

struct zKeyFrame final {
    float3 pos={};
    float4 rotation={};  // Quaternion
    };
// Partial implementation: no animation
struct zCMover : zCTrigger {
    enum        moverBehavior;
    float       touchBlockerDamage;
    float       stayOpenTimeSec;
    bool        moverLocked;
    bool        autoLinkEnabled;
#if GOTHIC2
    bool        autoRotate;
#endif    
    uint16_t    numKeyframes;
#if numKeyframes>0
    float       moveSpeed;
    enum        posLerpType;
    enum        speedType;
    zKeyFrame[] keyframes;
#endif
    string      sfxOpenStart;
    string      sfxOpenEnd;
    string      sfxMoving;
    string      sfxCloseStart;
    string      sfxCloseEnd;
    string      sfxLock;
    string      sfxUnlock;
    string      sfxUseLocked;
    };

zCMoverControler

struct zCMoverControler : zCVob {
    string triggerTarget;
#if GOTHIC1
   enum moverMessage;
#else
   byte moverMessage;
#endif
    int gotoFixedKey;
    };

oCTriggerScript

struct oCTriggerScript : zCTrigger {
    string scriptFunc;
    };

zCTriggerList

struct zCTriggerList::Entry final {
#if GOTHIC2
    string triggerTarget{id};
#else
    string slaveVobName{id};
#endif
    float  fireDelay{id};
    };

struct zCTriggerList : zCTrigger {
    int32   listProcess;
    Entry[] list;
    };

oCTriggerChangeLevel

struct oCTriggerChangeLevel : zCTrigger {
    string levelName;
    string startVobName;
    };

zCTriggerWorldStart

struct zCTriggerWorldStart : zCTrigger {
    string triggerTarget;
    bool   fireOnlyFirstTime;
    };

zCMessageFilter

struct zCMessageFilter : zCVob {
    string triggerTarget;
    enum   onTrigger;
    enum   onUntrigger;
    };

zCTouchDamage

struct zCTouchDamage : zCVob {
    float damage;
    bool  Barrier;
    bool  Blunt;
    bool  Edge;
    bool  Fire;
    bool  Fly;
    bool  Magic;
    bool  Point;
    bool  Fall;
    float damageRepeatDelaySec;
    float damageVolDownScale;
    enum  damageCollType;
    };

oCTouchDamage

struct oCTouchDamage : zCTouchDamage {};

zCTriggerUntouch

struct zCTriggerUntouch : zCVob {
    string triggerTarget;
    };

zCCSCamera

struct zCCamTrj_KeyFrame : zCVob {
    float time;
    float angleRollDeg
    float camFOVScale
    enum  motionType
    enum  motionTypeFOV
    enum  motionTypeRoll
    enum  motionTypeTimeScale
    float tension
    float bias
    float continuity
    float timeScale
    bool  timeIsFixed
    zMAT4 originalPose;
    };
    
struct zCCSCamera : zCVob {
    zCCamTrj_KeyFrame[] frames = this->zCVob::childVobs;
    enum   camTrjFOR;
    enum   targetTrjFOR;
    enum   loopMode;
    enum   splLerpMode;
    bool   ignoreFORVobRotCam;
    bool   ignoreFORVobRotTarget;
    bool   adaptToSurroundings;
    bool   easeToFirstKey;
    bool   easeFromLastKey;
    float  totalTime;
    string autoCamFocusVobName;
    bool   autoCamPlayerMovable;
    bool   autoCamUntriggerOnLastKey;
    float  autoCamUntriggerOnLastKeyDelay;
    int    numPos;
    int    numTargets;
    };

zCEarthquake

struct zCEarthquake : zCVob {
    float radius;
    float timeSec;
    zVEC3 amplitudeCM;
    };

Clone this wiki locally