Turok 2 Script API

//---kexEnemyAIComponent modes---
//0 = Wait For Trigger
//1 = Start Delay Think
//2 = Start
//3 = move slow forward
//4 = move forward
//5 = Move Turn 180
//6 = Flee
//7 = Flee Turn 180
//8 = Evade Left
//9 = Evade Right
//10 = Idle (The main think mode)
//11 = Interactive idle
//12 = Alert
//13 = take cover
//14 = melee/combat attacks
//15 = leap attacks
//16 = dart attacks
//17 = weapon attacks
//18 = projectile attacks
//19 = Combo
//20 = Combo End attacks
//21 = Pickup Throw Object
//22 = Drop Object
//23 = Teleport Out (start teleport)
//24 = Teleport In (end teleport)
//25 = Teleport Chase (tick teleport)
//26 = Cloak Activate
//27 = Regenerate
//28 = Puff Up
//29 = Reaction Explosion
//30 = Reaction FallDown (Tranqulized anim start)
//31 = Reaction GetUp (Tranqulized anim wake up and feign death wake up)
//32 = Reaction Blinded
//33 = Reaction Shocked
//34 = Reaction Bore (goes to 50 Head Blown Off Death)
//35 = Reaction Bore Clunk
//36 = Wounded Generic
//37 = Wounded Left Arm
//38 = Wounded Right Arm
//39 = Ground To Air
//40 = Ground To Underwater
//41 = Air To Ground
//42 = Air To Underwater
//43 = Underwater To Ground
//44 = Underwater To Air
//45 = Feign Death (fall over anim to 31 Reaction GetUp)
//46 = Death
//47 = Extreme Death Part 1
//48 = Extreme Death
//49 = PFM Death
//50 = Head Blown Off Death (also used by bore)
//51 = Left Arm Blown Off Death
//52 = Right Arm Blown Off Death
//53 = Body Hole Death
//54 = Death Melt
//55 = Nuke Frozen (does fire effect and changes the actors color but does not explode)

//---kexGeneratorComponent modes---
// 0 = waiting
// 1 = produce object

//---kexPlatformComponent mods---
// 0 = waiting to start
// 1 = start
// 2 = reached dest
// 3 = returning

//---kexThrowableComponent modes---
// 0 = idle on ground
// 1 = pickup
// 2 = flying (needs to be set normally by enemyai or will crash game)

//---kexPuppet/Player modes---
// 0 = idle
// 1 = forward
// 2 = backward
// 3 = side left
// 4 = side right
// 5 = jumping
// 6 = ground land
// 7 = crouch
// 8 = crouch forward
// 9 = crouch backward
// 10 = ground death anim
// 11 = explode death anim
// 12 = water death anim
// 13 = water death anim idle loop
// 14 = ground death anim idle loop
// 15 = lava death anim
// 16 = quick sand death anim
// 17 = attack anim
// 18 = idle climb
// 19 = move climb
// 20 = falling death


//------------------------------------------------------------------------------------------------------------------------
| Globals
//------------------------------------------------------------------------------------------------------------------------
const bool IsMultiplayer(void) //in a multiplayer match online or offline
void DoPlayerWarp(const int playerID, const int warpTID, const int mapID = -1, const bool playWarpAnimation = false)
        //Example: DoPlayerWarp(0, 17401, kLevel_BlindOneBoss, true);
void SpawnShake(const kVec3& in directionPower, const kVec3& in origin, const float radius, bool sineWaveShake)
    //SpawnShake(kVec3(0, 0, fShake), self.Owner().Actor().Origin(), 10000, true);
void DefineMode(const kStr& in tableName, const uint32 modeID, const kStr& in setupHeader, const kStr& in tickHeader, const EnumClipFlags clipFlags, const uint32 animID, const kStr& in animHeader, const float animSpeed, const float animBlendSpeed, const uint32 endOffset, const uint32 modeFlags);
//void DefineMode(const kStr& in, const uint32, const kStr& in, const kStr& in, const uint32, const uint32, const kStr& in, const float, const float, const uint32, const uint32)
    //Example: DefineMode("ActionObjectModeTable", ACTIONOBJECT_MODE_TRIGGER,  "void MODE_TriggerSetup(void)", "void MODE_TriggerTick(void)",  CF_STATIC, 0, "int MODE_TriggerAnim(void)", 0, 0, 0, MF_NOROOTMOTION);
const float GAME_DELTA_TIME = 0.016667
const float GAME_SCALE = 10.240000
const float GAME_FRAME_TIME = 0.250000
const float GAME_FRAME_UNIT = 4.000000
const float GAME_SECONDS = 0.066667 (1 / 15th of a second)

//------------------------------------------------------------------------------------------------------------------------
| kNetwork Network
//------------------------------------------------------------------------------------------------------------------------
bool IsNetgame(void)
kActor@ GetNetActor(int16 netID)
kParticle@ GetNetParticle(int16 netID)
bool IsServer(void)
bool IsClient(void)
void TransmitToAll(void) //from server to clients. Call after NetSend writes

//------------------------------------------------------------------------------------------------------------------------
| NetRecv ///should only be called for client players (Network.IsNetgame() && Network.IsClient()) and read in the same order as was writen
//------------------------------------------------------------------------------------------------------------------------
int16 ReadInt16(void) //call in sent func
int32 ReadInt32(void) //call in sent func

//------------------------------------------------------------------------------------------------------------------------
| NetSend //only do these calls for the server player (Network.IsNetgame() && Network.IsServer())
//------------------------------------------------------------------------------------------------------------------------
void Clear(void); //call before WriteScriptHeader
void WriteScriptHeader(const kStr&in funcHeader) //call after Clear (only clients will recieve the ScriptHeader)
    //Example: NetSend::WriteScriptHeader("void NetworkRecvSpawnBoreController(void)");
void WriteInt16(int16) //call after WriteScriptHeader
void WriteInt32(int32) //call after WriteScriptHeader

//------------------------------------------------------------------------------------------------------------------------
| kSys Sys
//------------------------------------------------------------------------------------------------------------------------
void Print(const kStr &in message)
void Warning(const kStr &in message)
int VideoWidth(void)
int VideoHeight(void)
int Mouse_X(void)
int Mouse_Y(void)
const bool GetCvarValue(const kStr &in name, kStr &out result) //returns true if found cVar name

//------------------------------------------------------------------------------------------------------------------------
| Event Functions to ScriptObject
//------------------------------------------------------------------------------------------------------------------------
void OnBeginLevel(void) //never gets called?
void OnTick(void)
void OnEndLevel(void) //never gets called?
void OnSpawn(void)
void OnPreDamage(kDamageInfo& in dmgInfo) //called before OnDamage and OnDeath
void OnDamage(kDamageInfo& in dmgInfo)
    //called after OnDeath and OnPreDamage.
    //Health is reduced after this is called which means after an OnDeath call the remaining Health will always be negative of the damage taken.
    //This is never called if an actor of the same Type() ID damages another actor of the same Type() ID. But PreDamage is still called.
void OnLevelLoad(kDictMem@ pDict) //called when actor is placed on the map in the editor and the map is loaded. Not called when Loading a save game.
void OnDeath(kDamageInfo& in dmgInfo) //called after OnPreDamage and before OnDamage.
void OnTouch(kActor@ pInstigator)
void OnTrigger(kActor@ pInstigator, const int msg)
void UserEvent(const float x, const float y, const float z, const float f1, const float f2, const float f3, const float f4)
void OnCollide(kActor@ pCollider)
void OnSerialize(kDict& out dict)
void OnDeserialize(kDict& in dict)

//------------------------------------------------------------------------------------------------------------------------
| Execution Order of Event Startup Functions:
//------------------------------------------------------------------------------------------------------------------------
.ctor
OnLevelLoad     <-- when actor was placed in editor. Not called on Deserialize. Not called for Player actor.
OnDeserialize   <-- if loaded a saved game
OnSpawn         <-- Only called for actors loaded from map and the player(called twice for player in MP because of bug)
OnTick

//------------------------------------------------------------------------------------------------------------------------
| Event Functions to ScriptObject (kWeapon)
//------------------------------------------------------------------------------------------------------------------------
void OnBeginFire()
void OnFire()
void OnEndFire()
void OnLower()
void OnRaise()
void OnHoldster()
void OnFiredParticleFromAnim(kParticle@ particle)

//------------------------------------------------------------------------------------------------------------------------
| kDamageInfo
//------------------------------------------------------------------------------------------------------------------------
float hits //damage
kParticle@ particle
kActor@ inflictor
kActor@ source
kActor@ target
uint boneFlags
int boneID
uint flags //EnumDamageFlags
float radius
bool opEquals(const ?&in)
const bool opEquals(const ref &in)

//------------------------------------------------------------------------------------------------------------------------
| kActorIterator
//------------------------------------------------------------------------------------------------------------------------
kActor@ GetNext(void)
    //Example to iterate through all actors in the map:
        //kActorIterator cIterator;
        //kActor@ pActor;
        //while(!((@pActor = cIterator.GetNext()) is null))
        //{
            //do something with pActor
        //}

//------------------------------------------------------------------------------------------------------------------------
| kAnimTrackComponent
//------------------------------------------------------------------------------------------------------------------------
kActor @Owner(void)
void Toggle(const bool isVisible)
const int NumFrames(void)
const int CurrentFrame(void)
void Set(const int animID, float animSpeed, int animStateFlags)
void Blend(const int animID, float animSpeed, float blendSpeed, int animStateFlags)
bool CheckAnimID(const int animID) //returns true if animID exists in the actors animations
bool IsPlaying(const int animID)
const float TrackTime(void)
const float PlayTime(void)
void Resume(void)
void Pause(void)
void Stop(void)
const int PlayingID(void)
const const bool CycleCompleted(void)
const bool Looping(void)
const bool Blending(void)
const bool Stopped(void)
uint &MovementClipFlags(void)
int &Flags(void) //EnumAnimStateFlags
void SetLastFrame(const bool execActions = false) //if execActions is true, runs all key frame actions that are event types UnBlock and Block only.
void ChangeSpeed(const float speed)
const uint AnimCount(void)

//------------------------------------------------------------------------------------------------------------------------
| kRenderMeshComponent
//------------------------------------------------------------------------------------------------------------------------
void ToggleHotPoint(const int fxType, const bool showFx)
    //fx types:
    //1 = on fire (needs to be called ontick for continuous caught on fire effect)
    //3 = death blood (normally is set automatically when dying and turns off when death animation is complete)
    //6 = bore head blood gushing
void SetAttachedMeshVisibility(const uint meshID, const bool visible)
void SwapOutMesh(const int meshID)
int& AltTexture(void) //set to -1 = first texture, 0 = second ...
uint8& Flags(void) //EnumRenderMeshComponentFlags
kVec3& HeadTrackPos(void)
bool& CanFlinch(void)
uint32& FxFlags(void)
void SetScale(const int nodeID, const kVec3& in scale)
void SetRotationOffset(const int nodeID, const float angle, const float xMul, const float yMul, const float zMul)
//Example:
    //self.RenderMeshComponent().SetRotationOffset(m_gunNode, self.Pitch(), 1, 0, 0);
    //self.RenderMeshComponent().SetRotationOffset(1, Math::Deg2Rad(m_spinAngle), 0, 1, 0);

//------------------------------------------------------------------------------------------------------------------------
| kWorldComponent
//------------------------------------------------------------------------------------------------------------------------
float &WallRadius(void)
float &Radius(void)
int16 &Flags(void) //EnumWorldComponentFlags
float &DeadHeight(void)
float &HeightOffset(void)
float &Height(void)
float &TouchRadius(void)
void SetNearestPosition(const kVec3&in origin) //sets this actor to the best possible position and updates region
void SetRegion(const int regionIndex, const bool callDelegates = true) //If true, then it will invoke the OnEnterRegion and OnExitRegion delegate callbacks if the regionIndex is not in the same area
bool HasCollision(void) //returns true if flags WCF_NONSOLID is off and radius is > 0
void LinkArea(void) //Links owner object to a new area node (used for actor-actor collision)
const bool FindRegionAtOrigin(const kVec3&in origin, const bool callDelegates = true) //Will attempt to find a region in which given coordinates are contained inside. Returns false if no region was found
const int RegionIndex(void) //Returns the index of the current region
const int16 GetNearPositionAndRegionIndex(const kVec3&in pos, kVec3&out posResult, const uint enumClipFlags = CF_NEARREGIONTEST) //returns the regionIndex.
float& FloorHeight(void)
kActor@ Owner()
void HitScan(kClipInfo&out clipInfo, const kVec3&in origin, const kVec3&in targetOrigin, const uint EnumClipFlags, const float fScale = 0)

//------------------------------------------------------------------------------------------------------------------------
| kModeStateComponent
//------------------------------------------------------------------------------------------------------------------------
void ForgetAnimState(void) //forget its current anim. Will allow any animation to override, including the one that's being played already.
int32& PrevMode(void)
const int32 Mode(void)
float& ModeTime(void) //Time this mode has been ticking since the current mode was setup. (15.0f = 1 second)
bool SetMode(const int modeID, const bool restart = false) //If restart is true the setup callback for the mode will be called
void AssignModeTable(const kStr&in modeTableName) //Assign a Mode Table that was created with DefineMode

//------------------------------------------------------------------------------------------------------------------------
| kMovementComponent
//------------------------------------------------------------------------------------------------------------------------
float& AirFriction(void)
float& Friction(void)
float& Mass(void)
kVec3& Velocity(void)
uint& Flags(void) //EnumMovementComponentFlags
float& WaterGravity(void)
float& Gravity(void)
float& WaterFriction(void)
uint& ClipFlags(void) //EnumClipFlags

//------------------------------------------------------------------------------------------------------------------------
| kEnemyAIComponent
//------------------------------------------------------------------------------------------------------------------------
const uint32 CommonFlags(void) //EnumEnemyAICommonFlags
uint32& SpawnFlags(void) //EnumEnemyAIGeneralFlags
const float GetAvoidanceAngle(const kVec3&in lookAtLocation, const float radius)
void Turn(const float maxSpeed, const float angle)
const bool HasOverrideTarget(void) //returns true if a different actor(enemy or player) becomes a higher priority target (from taking damage from this override target)
void GetMovementInfo(void)
kAITargetInfo& SightTarget(void) //target to attack
kAITargetInfo& PathTarget(void) //target to move to
void SetNoUpdateTarget(const bool ignorePlayerPath, const bool ignorePlayerSight) //SetNoUpdateTarget(const bool bPathInfo, const bool bSightInfo);
    //if ignorePlayerPath is true ignores pathing to player (goes to default behaviour - go back and stand at spawn position and if has path(set in editor with pathpoints) then start the path over again
    //if ignorePlayerSight is true ignores sight/attacking to player (goes to default behaviour - can attack other targets that are set with SetTarget() or the OverrideTarget that gets set internally. OverrideTarget takes priority.)
void GetTargetInfo(const bool pathInfo, const bool sightInfo)
    //if pathInfo is true PathTarget() will return updated info
    //if sightInfo is true SightTarget() will return updated info

//------------------------------------------------------------------------------------------------------------------------
| kAITargetInfo
//------------------------------------------------------------------------------------------------------------------------
void Reset(void) //clears all data in this kAITargetInfo
kActor@ Target(void)
void SetTarget(kActor@)
int m_eType //EnumEnemyAITargetTypes
float m_fDist
kVec3 m_vDeltaTargetPos
kVec3 m_vTargetPos
float m_fDeltaAngle
float m_fDistXY

//------------------------------------------------------------------------------------------------------------------------
| kClipInfo
//------------------------------------------------------------------------------------------------------------------------
float fraction //returns the 0.0 - 1.0 range of the point of intersection from start to end trace. (If fraction is == 1.0 then no intersection occured.)
int contactRegion
int impactType
kVec3 vInterceptVector //Returns the vector that intersected the collided geometry
kVec3 vContactNormal //Returns the normalized vector of the collided surface
uint clipResult //EnumClipFlags - specifies the type of intersection
bool bHitWater
int16 wBoneType
int16 wBoneID
kWorldComponent@ pContactCollider //handle pointer to colliders WorldComponent (null if none was collided)

//------------------------------------------------------------------------------------------------------------------------
| Enums
//------------------------------------------------------------------------------------------------------------------------
EnumDamageFlags
DF_NORMAL = 1 << 0
DF_VIOLENT = 1 << 1
DF_EXPLOSIVE = 1 << 2
DF_EXTREME = 1 << 3
DF_LAVA = 1 << 4
DF_DROWN = 1 << 5
DF_SEVER = 1 << 6
DF_FALLDEATH = 1 << 7
DF_HAZARD = 1 << 8

EnumPlayerFlags
PF_NOCLIP = 1 << 0
PF_FLY = 1 << 1
PF_DEAD = 1 << 2
PF_GOD = 1 << 3
PF_JUMPING = 1 << 4
PF_HASJUMPED = 1 << 5
PF_INWARPAREA = 1 << 6
PF_CLIMBTHRUST = 1 << 7
PF_NOAIRFRICTION = 1 << 8
PF_CRAWLING = 1 << 9
//PF_FALLINGDEATHPIT = 1 << 10
//PF_FLOATCAM = 1 << 11 (not defined)
//PF_CLIMBTILTWOBBLE = 1 << 12 (not defined)
//PF_LERPTOSURFACE = 1 << 13 ((not defined) - is swimming above the water like (T1 INBETWEEN)
//PF_OXYGENOUT = 1 << 14
//PF_LOCKWEAPON = 1 << 15 (not defined - can't change weapon) //PF_RIDINGSOMETHING
//PF_SHOCKED = 1 < 16
//PF_ISSCARY = 1 << 17
//PF_HIDEWEAPON = 1 << 18 (not defined - Hides the weapon model) //PF_INDEATHCINEMATIC
//PF_SPECTATING = 1 << 19 (not defined)
//PF_NOWEAPONSPICKUPS = 1 << 20
//PF_NOWEAPON = 1 << 21 (not defined - hides weapon and disables weapon switching and firing)
//PF_DEMIGOD = 1 << 22 (not defined - When damaged health will not go below 1 - can still die by death pits)

EnumAnimStateFlags
ANF_BLEND = 1 << 0
ANF_LOOP = 1 << 1
ANF_STOPPED = 1 << 2
ANF_NOINTERRUPT = 1 << 3
ANF_ROOTMOTION = 1 << 4
ANF_PAUSED = 1 << 5
ANF_CYCLECOMPLETED = 1 << 6
ANF_LINEARBLEND = 1 << 7
ANF_NOACCUMULATION = 1 << 8

EnumActorFlags
AF_NODAMAGE = 1 << 0 // cannot receive damage
AF_HIDDEN = 1 << 1 // does not render and may not perform collision checks
AF_DEAD = 1 << 2 // set when health is <= 0 and OnDeath has been called
AF_TRIGGERED = 1 << 3 // set when activated by something. mainly used to avoid self-recursion
//AF_POSTLEVELSPAWN = 1 << 4 // set if actor has been spawned during a play session. used to do special initialization for components
AF_ALLOWTRACKING = 1 << 5 // can be tracked by weapon trackers
AF_NOINFLICTDAMAGE = 1 << 6 // same as AF_NODAMAGE except it is cleared every tick if set. used for special case events
//AF_SELECTED = 1 << 7 // object is selected in editor
AF_CASTSHADOW = 1 << 8 // cast shadow
AF_NOGENERATE = 1 << 9 // cannot generate actors via Actor Factory
//AF_DIFFICULTY_EASY = 1 << 10 // appears on easy difficulty
//AF_DIFFICULTY_NORMAL = 1 << 11 // appears on normal difficulty
//AF_DIFFICULTY_HARD = 1 << 12 // appears on hard difficulty
//AF_DIFFICULTY_HARDCORE = 1 << 13 // appears on hardcore diffuclty
AF_IMPORTANT = 1 << 14 // special-case. highlights/appears on player's hud (objective points, interactables, etc)
AF_DESERIALIZED = 1 << 15 // set when being loaded from a save game. cleared on the next tick call
AF_FULLSHADOWRESOLUTION = 1 << 16 // forces the shadow map at the highest possible resolution
AF_HIDEINCINEMATICS = 1 << 17 // don't draw if a cinematic is playing
AF_EVENTSPAWNED = 1 << 18 // spawned via special action event
AF_HASTRIGGERLISTENER = 1 << 19
AF_HASRESETRLISTENER = 1 << 20
AF_HASSHOTLISTENER = 1 << 21
AF_HASDEATHLISTENER = 1 << 22
AF_HASCOLLIDELISTENER = 1 << 23

EnumClipFlags
CF_CLIPEDGES = 1 << 0 // clip movement against edges that don't link to regions
CF_IGNOREBLOCKERS = 1 << 1 // don't clip edges belonging to blocking regions
CF_DROPOFF = 1 << 2 // allows passing through platforms or ledges
CF_NOENTERWATER = 1 << 3 // block all edges that links to a water region
CF_NOEXITWATER = 1 << 4 // block all edges that links to a non-water region
CF_NOCLIPSTATICS = 1 << 5 // don't collide with static models
CF_NOCLIPACTORS = 1 << 6 // don't collide with dynamic objects/actors
CF_ALLOWCLIMB = 1 << 7 // collide with regions flagged as climbable
CF_ALLOWCRAWL = 1 << 8 // collide with regions flagged as crawlable
CF_COLLIDECORPSES = 1 << 9 // clip against actors flagged as dead
CF_NOBACKFACECULLING = 1 << 10 // trace both front and back sides of a surface (hitscan only)
CF_COLLIDEWATER = 1 << 11 // clip movement against the water surface
CF_USEWALLRADIUS = 1 << 12 // clip and project movement away from walls based on wall radius
CF_GREASESLIDEOBJECTS = 1 << 13 // always keep movement projected away from collided objects
CF_ALLOWRESTRICTEDAREAS = 1 << 14 // don't collide with edges belonging to a restricted region
CF_CHECKLINKEDBRIDGES = 1 << 15 // do extensive checks against overlapping bridge regions
CF_POLYCOLLISION = 1 << 16 // clip movement against all model polygons of an object (hitscan only)
CF_TRACKGROUND = 1 << 17 // keep movement vector parallel with the ground
CF_WALKWALLS = 1 << 18 // allow entering wall regions by walking into it
CF_TESTONLY = 1 << 19 // simple test case. does one iteration and restores moving object's status when done
CF_COLLIDECEILING = 1 << 20 // clip against ceiling regions
CF_COLLIDEFLOOR = 1 << 21 // clip against floor regions
CF_COLLIDEJOINTS = 1 << 22 // clip against render mesh bones (hitscan only)
CF_CANLANDONOBJECTS = 1 << 23 // prevents ejecting collider away from object
CF_NOEXITRESTRICTEDAREAS = 1 << 24 // clips against non-restricted regions
CF_ALLOWPLAYERRESTRICTED = 1 << 25 // don't collide with edges linked to player blocking regions
CF_NOEXITPLAYERRESTRICTED = 1 << 26 // clip against non-player blocking regions
CF_NOENTERLAVA = 1 << 27 // clip against edges linked to lava regions
CF_NOEXITLAVA = 1 << 28 // clip against edges linked to non-lava regions
CF_NOENTERSWAMP = 1 << 29 // clip against edges linked to swamp regions
CF_NOEXITSWAMP = 1 << 30 // clip against edges linked to non-swamp regions
CF_EXPANDJOINTNODES = 1 << 31 // expand joint bounding boxes for head, body, arm and legs
CF_DEAD_CHARACTER = CF_CLIPEDGES | CF_DROPOFF | CF_COLLIDECORPSES | CF_USEWALLRADIUS | CF_CHECKLINKEDBRIDGES | CF_TRACKGROUND | CF_COLLIDECEILING | CF_ALLOWPLAYERRESTRICTED //34771461
CF_CHARACTER_UNDERWATER = CF_CLIPEDGES | CF_DROPOFF | CF_USEWALLRADIUS | CF_CHECKLINKEDBRIDGES | CF_TRACKGROUND | CF_COLLIDECEILING | CF_ALLOWPLAYERRESTRICTED | CF_NOENTERSWAMP //705859589
CF_CHARACTER_FLYING = CF_CLIPEDGES | CF_DROPOFF | CF_NOENTERWATER | CF_USEWALLRADIUS | CF_CHECKLINKEDBRIDGES | CF_TRACKGROUND | CF_COLLIDECEILING | CF_ALLOWPLAYERRESTRICTED | CF_NOENTERSWAMP //705859597
CF_CHARACTER = CF_CLIPEDGES | CF_NOENTERWATER | CF_USEWALLRADIUS | CF_CHECKLINKEDBRIDGES | CF_TRACKGROUND | CF_ALLOWPLAYERRESTRICTED | CF_NOENTERSWAMP //704811017
CF_RAYCAST = CF_CLIPEDGES | CF_DROPOFF | CF_ALLOWCRAWL | CF_ALLOWRESTRICTEDAREAS | CF_CHECKLINKEDBRIDGES | CF_WALKWALLS | CF_TESTONLY | CF_ALLOWPLAYERRESTRICTED  //34390277
CF_STATIC = CF_CLIPEDGES | CF_DROPOFF | CF_NOCLIPSTATICS | CF_NOCLIPACTORS | CF_ALLOWCRAWL | CF_ALLOWRESTRICTEDAREAS | CF_ALLOWPLAYERRESTRICTED  //33571173
CF_NEARREGIONTEST = CF_CLIPEDGES | CF_IGNOREBLOCKERS | CF_DROPOFF | CF_NOCLIPSTATICS | CF_NOCLIPACTORS | CF_ALLOWRESTRICTEDAREAS | CF_CHECKLINKEDBRIDGES | CF_WALKWALLS | CF_TESTONLY | CF_ALLOWPLAYERRESTRICTED   //34390119
CF_PARTICLE = CF_CLIPEDGES | CF_IGNOREBLOCKERS | CF_DROPOFF | CF_ALLOWCRAWL | CF_COLLIDECORPSES | CF_COLLIDEWATER | CF_ALLOWRESTRICTEDAREAS | CF_CHECKLINKEDBRIDGES | CF_COLLIDECEILING | CF_COLLIDEFLOOR | CF_ALLOWPLAYERRESTRICTED  //36752135
CF_SIMPLE_OBJECT = CF_CLIPEDGES | CF_DROPOFF | CF_NOCLIPACTORS | CF_CHECKLINKEDBRIDGES | CF_COLLIDECEILING | CF_COLLIDEFLOOR | CF_NOENTERLAVA | CF_NOENTERSWAMP  //674267205

EnumModeFlags
MF_INVINCIBLE = 1 << 0
MF_HEADTRACK = 1 << 1
MF_CLEARMOVEMENT = 1 << 2
MF_NO_BLEND = 1 << 3
MF_IDLE = 1 << 4
MF_CLEARLOOPSOUNDS = 1 << 5
MF_NOACCUMULATION = 1 << 6
MF_NOROOTMOTION = 1 << 7
MF_SCRIPT = 1 << 8

EnumRenderMeshComponentFlags
RMCF_RENDER_AS_WEAPON = 1 << 0
RMCF_CLOAKED = 1 << 1
RMCF_HEADTRACK = 1 << 2
RMCF_TINYMODE = 1 << 3
RMCF_WAGGLE = 1 << 4
RMCF_SHOCKED = 1 << 5
RMCF_STICKMODE = 1 << 6
RMCF_NOEXPANDJOINTS = 1 << 7

EnumWorldComponentFlags
WCF_NONSOLID = 1 << 0
WCF_INVOKE_COLLIDE_CALLBACK = 1 << 1
WCF_ON_PLATFORM = 1 << 2
WCF_NO_CLAMP_TO_FLOOR = 1 << 3
WCF_ON_WATER = 1 << 4
WCF_UNDER_WATER = 1 << 5
WCF_ABOVE_WATER = 1 << 6
WCF_IN_SHALLOW_WATER = 1 << 7
WCF_IN_ANTIGRAVITY = 1 << 8
WCF_AT_CLIMBING_SURFACE = 1 << 9
WCF_ON_CROUCH_ENTEREXIT = 1 << 10
WCF_ON_CROUCH = 1 << 11
WCF_JUST_ENTERED_DEATH_REGION = 1 << 12
WCF_TRACK_GROUND = 1 << 13
WCF_WALK_WALLS = 1 << 14 //(not defined)
WCF_ENTERED_FALL_DEATH_REGION = 1 << 15 //(not defined)

EnumEnemyAICommonFlags (not defined)
//EAICF_LEADER = 1 << 0
//EAICF_FOLLOWER = 1 << 1
//EAICF_PASS_ON_LEADERSHIP = 1 << 2
//EAICF_FREE_FOLLOWERS = 1 << 3
//EAICF_USE_LEASH = 1 << 4
//EAICF_RESPAWN = 1 << 5
//EAICF_TELEPORT = 1 << 6
//EAICF_CAN_BE_BLINDED = 1 << 7
//EAICF_CAN_BE_SHOCKED = 1 << 8
//EAICF_CAN_BE_TRANQUALIZED = 1 << 9
//EAICF_CAN_BE_BORED = 1 << 10
//EAICF_LINK_TRIGGERED = 1 << 11
//EAICF_INVISIBLE = 1 << 12
//EAICF_CAN_BE_BORE_TRACKED = 1 << 13
//EAICF_FACE_START_ON_LEASH = 1 << 14
//EAICF_RESTRICTVISION = 1 << 15
//EAICF_VANISH_ON_DEATH = 1 << 16
//EAICF_FEIGN_DEATH = 1 << 17
//EAICF_HURT_BY_SUNFIRE = 1 << 18
//EAICF_NO_FLINCHING = 1 << 19
//EAICF_CAN_CLOAK = 1 << 20
//EAICF_AUTO_TRIGGER = 1 << 21

EnumEnemyAIGeneralFlags
EAIGF_CLIMBUP = 1 << 0
EAIGF_DROPOFF = 1 << 1
EAIGF_ENTERWATER = 1 << 2
EAIGF_EXITWATER = 1 << 3
EAIGF_ENTERLAVA = 1 << 4
EAIGF_EXITLAVA = 1 << 5
EAIGF_PICKUP_ON_GROUND = 1 << 6
EAIGF_PICKUP_ON_AIR = 1 << 7
EAIGF_PICKUP_ON_WATER = 1 << 8
EAIGF_ENTERRESTRICTED = 1 << 9
EAIGF_EXITRESTRICTED = 1 << 10
EAIGF_ENTERSWAMP = 1 << 11
EAIGF_EXITSWAMP = 1 << 12
EAIGF_ENTERCROUCH = 1 << 13
EAIGF_EXITCROUCH = 1 << 14
EAIGF_ATTACK_LANDED = 1 << 15
EAIGF_STUN_LOCKED = 1 << 16
EAIGF_NO_UPDATE_SIGHT_TARGET = 1 << 17 //(not defined)
EAIGF_NO_UPDATE_PATH_TARGET  = 1 << 18 //(not defined)
EAIGF_NO_FACE_TARGET =  = 1 << 19 //(not defined)

EnumMovementComponentFlags
MCF_NO_GRAVITY = 1 << 0
MCF_FALLING = 1 << 1
MCF_ALLOW_SLIDING = 1 << 2
MCF_SLIDING = 1 << 3
MCF_UNDERWATER = 1 << 4
MCF_DISABLE_AIR_FRICTION_UNTIL_LAND = 1 << 5
MCF_PROCESS_MOVEMENT = 1 << 6

ParticleFlags (undefined 0,1 flags?)
FXF_HIT_GROUND = 1 << 0 // Unused
FXF_HIT_WALL = 1 << 1 // Unused
FXF_PERMANENT = 1 << 2
FXF_NOCOLLISION = 1 << 3
FXF_ONE_FRAME_ONLY = 1 << 4
FXF_NO_INBETWEENS = 1 << 5
FXF_STICK_CHAR = 1 << 6
FXF_STICK_STATIC = 1 << 7
FXF_NO_SOUND = 1 << 8
FXF_ATTACH_TO_PLAYER = 1 << 9
FXF_BLOOD = 1 << 10
FXF_UNDERWATER = 1 << 11
FXF_BECAME_PICKUP = 1 << 12
FXF_ALTERNATE_BLOOD = 1 << 13
FXF_DREW_BLOOD = 1 << 14
FXF_DREW_BLOOD_GREEN = 1 << 15
FXF_PASSON = FXF_NO_SOUND | FXF_UNDERWATER //2304

EnumPlayerButtons
BC_ATTACK = 1 << 0
BC_JUMP = 1 << 1
BC_FORWARD = 1 << 2
BC_BACKWARD = 1 << 3
BC_STRAFELEFT = 1 << 4
BC_STRAFERIGHT = 1 << 5
//BC_CROUCH = 1 << 6 (Not defined for some reason)
BC_ALTFIRE = 1 << 7
BC_SCOPEZOOMIN = 1 << 8
BC_SCOPEZOOMOUT = 1 << 9
//BC_WEAPONWHEEL1 = 1 << 10 //(Not defined)
//BC_WEAPONWHEEL2 = 1 << 11 //(Not defined)

EnumEnemyAITargetTypes
EAITT_ATTACKER = 0
EAITT_FLEE = 1
EAITT_LEADER = 2
EAITT_LEASH = 3
EAITT_PATH = 4
EAITT_OBJECT = 5
EAITT_DEATH = 6
EAITT_COVER = 7

EnumDifficulty
DIFFICULTY_EASY = 0
DIFFICULTY_NORMAL = 1
DIFFICULTY_HARD = 2
DIFFICULTY_HARDCORE = 3

EnumPlaneSide (unused?)
PSIDE_ON = 0
PSIDE_BACK = 0
PSIDE_FRONT = 0

//------------------------------------------------------------------------------------------------------------------------
| kDict, kDictMem
//------------------------------------------------------------------------------------------------------------------------
const bool HasKey(const kStr &in key) //kDict only
void Add(const kStr &in key, const kStr &in value) //kDict only
void SetValue(const kStr &in key, const kStr &in value) //kDict only
void Empty(void) //removes all keys/values //kDict only
bool GetFloat(const kStr &in key, float &out floatResult, const float defaultValue = 0) //returns true if successful
bool GetVector(const kStr &in key, kVec3 &out vectorResult) //returns true if successful
bool GetString(const kStr &in key, kStr &out stringResult) //returns true if successful
bool GetBool(const kStr &in key, bool &out boolResult, const bool defaultValue = false) //returns true if successful
bool GetInt(const kStr &in key, int &out intResult, const int defaultValue = 0) //returns true if successful

//------------------------------------------------------------------------------------------------------------------------
| kDefManager
//------------------------------------------------------------------------------------------------------------------------
const uint EntryCount(void)
kDictMem @GetEntry(const kStr &in key)
    //Returns the def data from the key name or null if key not found
void LoadFile(const kStr &in localFilePath, bool = false)
    //Example: LoadFile("Defs/MyDef.txt");
void LoadFilesInDirectory(const kStr &in localDirectoryPath, const kStr &in fileExtension, bool = false)
    //Loads all files in the directory and it's sub directories
    //Example: LoadFilesInDirectory("Defs/MyDefs/", "txt");

//------------------------------------------------------------------------------------------------------------------------
| kIndexDefManager
//------------------------------------------------------------------------------------------------------------------------
const uint EntryCount(void)
int FindHighestIndex(void) //returns the 0 if no entries
kDictMem @GetEntry(const int index)
    //Returns the def data using an index value or null if key not found
void LoadFile(const kStr &in localFilePath, bool = false)
void LoadFilesInDirectory(const kStr &in localDirectoryPath, const kStr &in fileExtension, bool = false)
    //Loads all files in the directory and it's sub directories
    //Example: LoadFilesInDirectory("Defs/MyDefs/", "txt");

//------------------------------------------------------------------------------------------------------------------------
| kSelectionListFloat
//------------------------------------------------------------------------------------------------------------------------
kSelectionListFloat &opAssign(const kSelectionListFloat &in)
const uint GetNumEntries(void)
int& Select(const bool)
void AddItem(int, const int)

//------------------------------------------------------------------------------------------------------------------------
| kSelectionListInt
//------------------------------------------------------------------------------------------------------------------------
kSelectionListInt &opAssign(const kSelectionListInt &in)
const uint GetNumEntries(void)
int& Select(const bool)
void AddItem(int, const int)

//------------------------------------------------------------------------------------------------------------------------
| kHud Hud (barIDs range from 0 to 1)
//------------------------------------------------------------------------------------------------------------------------
void DisableBar(const uint8 barID)
void UpdateBar(const uint8 barID, const uint32 value)
void SetBar(const uint8 barID, const uint8 red, const uint8 green, const uint8 blue, const uint8 alpha, const uint32 value) //alpha does nothing
void AddMessage(const int localizedTextID, const int visibleTime = 120) //visibleTime: (In frames) most likely to be 60 = 1 second
void AddMessage(const kStr&in message, const int visibleTime = 120)

//------------------------------------------------------------------------------------------------------------------------
| kGame Game
//------------------------------------------------------------------------------------------------------------------------
const int16 ActiveMapID(void)
void PlayMusic(const int musicID)
void PlayVoice(const int voiceID)

//------------------------------------------------------------------------------------------------------------------------
| kCinemaPlayer CinemaPlayer
//------------------------------------------------------------------------------------------------------------------------
void StartCinema(const kStr&in cinemaScriptPath)
void StopCinema(void)
const bool PathTrackPlaying(void)
const bool Playing(void)
const bool Enabled(void)

//------------------------------------------------------------------------------------------------------------------------
| kEvent Event
//------------------------------------------------------------------------------------------------------------------------
void RunAction(kActor@ source, kActor@ target, const int actionID, const kVec3&in origin, const float arg1 = 0, const float arg2 = 0, const float arg3 = 0, const float arg4 = 0, const float arg5 = 0, const float arg6 = 0, const float arg7 = 0, const float arg8 = 0)
    //Example from door script: Event.RunAction(self, null, ACTION_UNBLOCK, Math::vecZero);
    //Example of user event/script: Event.RunAction(self, null, ACTION_USER, Math::vecZero, 1, 2, 3, 4);

//------------------------------------------------------------------------------------------------------------------------
| kActorFactory ActorFactory
//------------------------------------------------------------------------------------------------------------------------
kActor@ Spawn(const int32 actorID, const kVec3& in origin, const float yaw, const float pitch, const float roll, const bool = true, const int16 regionIndex = -1)

//------------------------------------------------------------------------------------------------------------------------
| kParticleFactory ParticleFactory
//------------------------------------------------------------------------------------------------------------------------
kParticle@ Spawn(const int particleID, kActor@ actor, const kVec3&in localPos, const kQuat&in rotation, const kVec3&in)
kParticle@ Spawn(const kStr&in particleName, kActor@ owner, const kQuat&in rotation, const kVec3&in pos)
kParticle@ Spawn(const int particleID, kActor@ owner, const kQuat&in rotation, const kVec3&in pos)

//------------------------------------------------------------------------------------------------------------------------
| kWorld World
//------------------------------------------------------------------------------------------------------------------------
void SetGlobalAmbience(const int soundID) //sets the ambience sound effect ID

//------------------------------------------------------------------------------------------------------------------------
| kPuppet
//------------------------------------------------------------------------------------------------------------------------
kPlayer &PlayerOwner(void)
uint &PlayerFlags(void)

//------------------------------------------------------------------------------------------------------------------------
| kParticle
//------------------------------------------------------------------------------------------------------------------------
kActor &Owner(void)
kVec3 &Direction(void)
const bool IsSticking(void)
void Kill(void)
const float LifeFrames(void)
kVec3 &Velocity(void)
int16 &NetID(void)
const bool IsStale(void)
const int ParticleType(void)

//------------------------------------------------------------------------------------------------------------------------
| kWeapon : kActor
//------------------------------------------------------------------------------------------------------------------------
kPlayer &Owner(void)
void LockControls(const bool lock)
const bool ScopeReady(void)
kParticle @FireProjectile(const kStr &in particlePath, const kVec3 &in localOrigin)

//------------------------------------------------------------------------------------------------------------------------
| kPlayer LocalPlayer
//------------------------------------------------------------------------------------------------------------------------
kPlayerInventory @Inventory(void)
kWeapon @WeaponActor(void)
kPuppet @Actor(void)
const uint16 ButtonHeldTime(const int buttonID) //returns the number of frames the button has been held down
//Button IDs:
    //0 = fire
    //1 = jump
    //2 = Forward
    //3 = Backward
    //4 = STRAFELEFT
    //5 = STRAFERIGHT
    //6 = CROUCH
    //7 = AltFire (Always returns 0)
    //8 = BC_SCOPEZOOMIN
    //9 = BC_SCOPEZOOMOUT
const uint16 Buttons(void)
const int GetAltAmmo(const int weaponID)
const int GetAmmo(const int weaponID)
void ConsumeAltAmmo(const int amount) //reduces alt ammo by <amount> for the current equipped weapon
void ConsumeAmmo(const int amount) //reduces ammo by <amount> for the current equipped weapon
const int CurrentWeaponID(void)
bool GiveWeapon(const int weaponID, const int ammoAmount)
const bool HasWeapon(const int weaponID)
const bool HasAltAmmo(const int weaponID)
const bool HasAmmo(const int weaponID)

//------------------------------------------------------------------------------------------------------------------------
| kActor
//------------------------------------------------------------------------------------------------------------------------
kVec3 &Origin(void)
kAngle &Yaw(void)
kAngle &Pitch(void)
kAngle &Roll(void)
kParticle @CastToParticle(void)
kActor @CastToActor(void)
bool InstanceOf(const kStr &in actorDefName)
kVec3 &Scale(void)
kActor @GetTarget(void) //CastToParticle to return a kParticle
void SetTarget(kParticle@)
void SetTarget(kActor@)
kPuppet @CastToPuppet(void)
int16 &NetID(void)
float GetDeltaFromPoint(const kVec3&in point) //returns deltaAngle
kVec3 LocalVectorToWorldSpace(const kVec3&in localVector)
void Remove(void)
int &TriggerMessageID(void)
int &TriggerData(void)
void Trigger(kActor@ triggerer) //Calls OnTrigger with the passed in actor use null if no actor
int32 &TID(void) //Tag ID
int &Type(void) //Actor ID
float &Health(void)
void PlaySound(const int soundID)
void PlaySound(const kStr &in soundPath)
uint32 &Flags(void) //EnumActorFlags
void StopLoopingSounds(void)
void StopSound(void)
void PlayLoopingSound(const int soundID)
void PlayLoopingSound(const kStr &in soundPath)
void Mark(const bool isPersistent) //MarkPersistentBit
const bool IsMarked(void)
void SignalOff(void)
void SignalOn(void)
void AddToGallery(void) //enables viewing of the actor in the gallery? (by the actors def name?)
void GenerateActors(const uint actorFlags, const uint flagSet) //flagset is 0 or 1
kDictMem @Definition(void)
const int GameTicks(void)
const bool Deserialized(void)
void RunFxEvent(const kStr &in fxEventName)
    //Example: RunFxEvent("Blink").
void EnableComponent(const kStr &in, const bool)
void AddComponent(const kStr &in, const bool)
const bool HasComponent(const kStr &in)
kAnimTrackComponent @AnimTrackComponent(void)
kWorldComponent @WorldComponent(void)
kEnemyAIComponent @EnemyAIComponent(void)
kMovementComponent @MovementComponent(void)
kModeStateComponent @ModeStateComponent(void)
kRenderMeshComponent @RenderMeshComponent(void)
void InflictDamage(kDamageInfo &in dmgInfo)
const bool IsStale(void)

//------------------------------------------------------------------------------------------------------------------------
| kPlayerInventory
//------------------------------------------------------------------------------------------------------------------------
const int GetCount(const int itemID) //returns the amount of these items that are in the inventory
const bool HasBeenPickedUpBefore(const int itemID) //returns true when you have at least one of this item in your inventory
const int Take(const int itemID)
const bool Give(const int itemID)
void Reset(void) //clears all inventory items

//------------------------------------------------------------------------------------------------------------------------
| Math
//------------------------------------------------------------------------------------------------------------------------
float Tan(float)
float Cos(float)
float Sin(float)
float Sqrt(float)
float ACos(float)
float Fabs(float)
float ATan2(float, float)
float Log(float)
float Floor(float)
float Ceil(float)
int Abs(int)
float InvSqrt(float)
float Rad2Deg(float rads)
float Deg2Rad(float degs)
float Pow(float, float)
uint8 RandByte(void) //0..255
int Rand(void) //0..32767
int SysRand(void) //0..32767
float RandFloat(void) //0..1
float RandCFloat(void) //-1..1
int RandMax(const int) //exclusive
float RandRange(const float, const float)
float IncMax(const float, const float, const float)
float Accelerate(const float, const float, const float)
float NLerp(const float, const float, const float)
float Lerp(float start, const float end, const float time)
void Clamp(float &out, const float, const float)
float HermiteBlend(const float, const float, const float)
float SmoothStep(const float, const float, const float)
float CosArc(const float)
float CosTween(const float)
kVec3 vecZero
float pi
float Max(const float, const float)
float Min(const float, const float)

//------------------------------------------------------------------------------------------------------------------------
| kQuat (Same as Turok1)
//------------------------------------------------------------------------------------------------------------------------
void Constructor(float x, float y, float z, float w)
void Constructor(float w, kVec3 &in)
void Constructor(const kQuat &in)
kQuat opMul(const kQuat &in)
kQuat opSub(const kQuat &in)
kQuat opAdd(const kQuat &in)
kQuat &Normalize(void)
const kVec3 &opMulAssign(const kQuat &in)
kVec3 opMul(const kQuat &in)
kQuat &opAssign(const kQuat &in)
float w

//------------------------------------------------------------------------------------------------------------------------
| kAngle (Same as Turok1)
//------------------------------------------------------------------------------------------------------------------------
void Constructor(float)
void Constructor(const kAngle &in)
kQuat ToQuat(void)
const float w
float Interpolate(const float, const float)
float Diff(const kAngle &in)
float Diff(const float)
kAngle &opSubAssign(const float)
kAngle opSub(const float)
const kAngle &opAddAssign(const float)
kAngle opAdd(const float)
const kAngle &opSubAssign(kAngle &in)
kAngle opSub(const kAngle &in)
kAngle &opAddAssign(const kAngle &in)
kAngle opAdd(const kAngle &in)
float opImplConv(void)
kAngle opNeg(void)
kAngle &opAssign(const kAngle &in)
kAngle &opAssign(const float)

//------------------------------------------------------------------------------------------------------------------------
| kPlane
//------------------------------------------------------------------------------------------------------------------------
void Constructor(const kVec3&in, const kVec3&in)
void Constructor(const kVec3&in, const kVec3&in, const kVec3&in)
void Constructor(const float, const float, const float, const float)
const float Dot(const kPlane&in)
const float Dot(const kVec3&in)
const kVec3 &Normal(void)
const int PointOnSide(const kVec3&in)
const bool IsFacing(const float)
const float ToYaw(void)
const float Distance(const kVec3&in)

//------------------------------------------------------------------------------------------------------------------------
| kVec3
//------------------------------------------------------------------------------------------------------------------------
void Constructor(const kVec3 &in)
void Constructor(float, float, float)
kQuat ToQuaternion(void)
kVec3 &Normalize(void)
float UnitSq(void)
float Unit(void)
float Dot(const kVec3 &in)
kVec3 Cross(const kVec3 &in)
float ToYaw(void)
kStr ToString(void)
float DistanceSq(const kVec3 &in)
const float Distance(const kVec3 &in)
const kVec3 Lerp(const kVec3 &in, const float)
const void Set(const float, const float, const float)
void Clear(void)
float ToPitch(void)
kVec3 &Randomize(const float)
kVec3 &Reflect(const kVec3 &in, const float)
kVec3 &Project(const kVec3 &in, const float)
kVec3 &Lerp(const kVec3 &in, const float)
kVec3 &opAddAssign(const kVec3 &in)
kVec3 opAdd(const kVec3 &in)
kVec3 &QuadraticCurve(const kVec3 &in, const float, const kVec3 &in, const kVec3 &in)
kVec3 &CubicCurve(const kVec3 &in, const float, const kVec3 &in)
kVec3 opMul(const kVec3 &in)
kVec3 &opSubAssign(const kVec3 &in)
kVec3 opSub(const kVec3 &in)
kVec3 opNeg(void)
kVec3 opDiv(const kVec3 &in)
kVec3 &opMulAssign(const float)
kVec3 &opMulAssign(const kVec3 &in)
kVec3 opMul(const float val)
float opIndex(uint)
kVec3 &opAssign(const kVec3 &in)
kVec3 &opDivAssign(const kVec3 &in)
kVec3 opDiv(const float val)
float z
float y
float x
float opIndex(uint)

//------------------------------------------------------------------------------------------------------------------------
| kStr
//------------------------------------------------------------------------------------------------------------------------
void Constructor(const kStr &in)
int IndexOf(const kStr &in)
uint Hash(void)
int Atoi(void)
float Atof(void)
kStr &ToUpper(void)
kStr &ToLower(void)
int8 opIndex(const int)
kStr &opAssign(const kStr &in)
kStr opAdd(const kStr &in)
kStr opAdd(bool)
kStr opAdd(int)
kStr opAdd(float)
kStr &opAddAssign(const kStr &in)
kStr &opAddAssign(bool)

//------------------------------------------------------------------------------------------------------------------------
| AngelScript Arrays
| http://www.angelcode.com/angelscript/sdk/docs/manual/doc_datatypes_arrays.html
//------------------------------------------------------------------------------------------------------------------------