Witcher Wiki
Don't have an account?
Register
Register
Witcher Wiki
Witcher Wiki
14,206
pages
in: The Witcher 3 modding documentation

Witcher 3 Global Functions

Edit

This is a list of all global functions dumped from the game script files. See talk page for more info on how to dump the games functions yourself.

Other Global Functions

Witcher 3 has modifiers on global functions that make the modified functions accessible in various contexts, these functions are documented in the following pages:

Globally Accessible Objects

While not technically global functions, these objects are maintained by the game and are accessible from the global scope. You can find the list of these objects in "%WITCHER3PATH%/bin/redscripts.ini".

theGame : CR4Game
theServer : CServerInterface
thePlayer : CR4Player
theCamera : CCamera
theUI : CGuiWitcher
theSound : CScriptSoundSystem
theDebug : CDebugAttributesManager
theTimer : CTimerScriptKeyword
theInput : CInputManager

Global Functions

LoadCSV

import function LoadCSV(filePath : string) : C2dArray
Parameters:
filePath : string
Returns:
C2dArray
Path:
/core/2DArray.ws

ArrayFindMaxF

function ArrayFindMaxF(a : array<float>) : int
Parameters:
a : array<float>
Returns:
int
Path:
/core/array.ws

ArrayMaskedFindMaxF

function ArrayMaskedFindMaxF(a : array<float>, thresholdVal : float) : int
Parameters:
a : array<float>
thresholdVal : float
Returns:
int
Path:
/core/array.ws

ArrayFindMinF

function ArrayFindMinF(a : array<float>) : int
Parameters:
a : array<float>
Returns:
int
Path:
/core/array.ws

ArrayFindMinIndexInt

function ArrayFindMinIndexInt(a : array<int>) : int
Parameters:
a : array<int>
Returns:
int
Path:
/core/array.ws

ArrayFindMinInt

function ArrayFindMinInt(a : array<int>) : int
Parameters:
a : array<int>
Returns:
int
Path:
/core/array.ws

ArrayFindMaxInt

function ArrayFindMaxInt(a : array<int>) : int
Parameters:
a : array<int>
Returns:
int
Path:
/core/array.ws

ArraySortNames

function ArraySortNames(out names : array<name>)
Parameters:
out names : array<name>
Path:
/core/array.ws

ArraySortNamesByKey

function ArraySortNamesByKey(out names : array<name>, out keys : array<int>)
Parameters:
out names : array<name>
out keys : array<int>
Path:
/core/array.ws

ArraySortNamesByKeyQSort

function ArraySortNamesByKeyQSort(out names : array<name>, out keys : array<int>, start : int, stop : int)
Parameters:
out names : array<name>
out keys : array<int>
start : int
stop : int
Path:
/core/array.ws

ArraySortNPCsByKey

function ArraySortNPCsByKey(out actors : array<CNewNPC>, out keys : array<int>)
Parameters:
out actors : array<CNewNPC>
out keys : array<int>
Path:
/core/array.ws

ArraySortNPCsByKeyQSort

function ArraySortNPCsByKeyQSort(out actors : array<CNewNPC>, out keys : array<int>, start : int, stop : int)
Parameters:
out actors : array<CNewNPC>
out keys : array<int>
start : int
stop : int
Path:
/core/array.ws

ArraySortInts

import function ArraySortInts(out arrayToSort : array<int>)
Parameters:
out arrayToSort : array<int>
Path:
/core/array.ws

ArraySortFloats

import function ArraySortFloats(out arrayToSort : array<float>)
Parameters:
out arrayToSort : array<float>
Path:
/core/array.ws

ArraySortStrings

import function ArraySortStrings(out arrayToSort : array<string>)
Parameters:
out arrayToSort : array<string>
Path:
/core/array.ws

ArrayOfNamesAppend

function ArrayOfNamesAppend(out first : array<name>, second : array<name>)
Parameters:
out first : array<name>
second : array<name>
Path:
/core/array.ws

ArrayOfNamesAppendUnique

function ArrayOfNamesAppendUnique(out first : array<name>, second : array<name>)
Parameters:
out first : array<name>
second : array<name>
Path:
/core/array.ws

ArrayOfNamesPushBackUnique

function ArrayOfNamesPushBackUnique(out arr : array<name>, val : name)
Parameters:
out arr : array<name>
val : name
Path:
/core/array.ws

ArrayOfActorsAppend

function ArrayOfActorsAppend(out first : array<CActor>, second : array<CActor>)
Parameters:
out first : array<CActor>
second : array<CActor>
Path:
/core/array.ws

ArrayOfActorsAppendArrayOfGameplayEntities

function ArrayOfActorsAppendArrayOfGameplayEntities(out first : array<CActor>, second : array<CGameplayEntity>)
Parameters:
out first : array<CActor>
second : array<CGameplayEntity>
Path:
/core/array.ws

ArrayOfIdsAppend

function ArrayOfIdsAppend(out first : array<SItemUniqueId>, second : array<SItemUniqueId>)
Parameters:
out first : array<SItemUniqueId>
second : array<SItemUniqueId>
Path:
/core/array.ws

ArrayOfIdsAppendUnique

function ArrayOfIdsAppendUnique(out first : array<SItemUniqueId>, second : array<SItemUniqueId>)
Parameters:
out first : array<SItemUniqueId>
second : array<SItemUniqueId>
Path:
/core/array.ws

ArrayOfGameplayEntitiesAppendArrayOfActorsUnique

function ArrayOfGameplayEntitiesAppendArrayOfActorsUnique(out first : array<CGameplayEntity>, second : array<CActor>)
Parameters:
out first : array<CGameplayEntity>
second : array<CActor>
Path:
/core/array.ws

ArrayOfGameplayEntitiesAppendUnique

function ArrayOfGameplayEntitiesAppendUnique(out first : array<CGameplayEntity>, second : array<CGameplayEntity>)
Parameters:
out first : array<CGameplayEntity>
second : array<CGameplayEntity>
Path:
/core/array.ws

ArrayOfNamesCount

function ArrayOfNamesCount(arr : array<name>, item : name) : int
Parameters:
arr : array<name>
item : name
Returns:
int
Path:
/core/array.ws

ArrayOfNamesRemoveAll

function ArrayOfNamesRemoveAll(out arr : array<name>, item : name)
Parameters:
out arr : array<name>
item : name
Path:
/core/array.ws

EngineTimeFromFloat

import function EngineTimeFromFloat(seconds : float) : EngineTime
Parameters:
seconds : float
Returns:
EngineTime
Path:
/core/engineTime.ws

EngineTimeToFloat

import function EngineTimeToFloat(time : EngineTime) : float
Parameters:
time : EngineTime
Returns:
float
Path:
/core/engineTime.ws

EngineTimeToString

import function EngineTimeToString(time : EngineTime) : string
Parameters:
time : EngineTime
Returns:
string
Path:
/core/engineTime.ws

Pi

function Pi() : float
Returns:
float
Path:
/core/math.ws

RandRange

import function RandRange(max : int, optional min : int) : int
Parameters:
max : int
optional min : int
Returns:
int
Path:
/core/math.ws

RandDifferent

import function RandDifferent(lastValue : int, optional range : int) : int
Parameters:
lastValue : int
optional range : int
Returns:
int
Path:
/core/math.ws

RandF

import function RandF() : float
Returns:
float
Path:
/core/math.ws

RandRangeF

import function RandRangeF(max : float, optional min : float) : float
Parameters:
max : float
optional min : float
Returns:
float
Path:
/core/math.ws

RandNoiseF

import function RandNoiseF(seed : int, max : float, optional min : float) : float
Parameters:
seed : int
max : float
optional min : float
Returns:
float
Path:
/core/math.ws

Abs

import function Abs(a : int) : int
Parameters:
a : int
Returns:
int
Path:
/core/math.ws

Min

import function Min(a, b : int) : int
Parameters:
a
b : int
Returns:
int
Path:
/core/math.ws

Max

import function Max(a, b : int) : int
Parameters:
a
b : int
Returns:
int
Path:
/core/math.ws

Clamp

import function Clamp(v, min, max : int) : int
Parameters:
v
min
max : int
Returns:
int
Path:
/core/math.ws

Deg2Rad

import function Deg2Rad(deg : float) : float
Parameters:
deg : float
Returns:
float
Path:
/core/math.ws

Rad2Deg

import function Rad2Deg(rad : float) : float
Parameters:
rad : float
Returns:
float
Path:
/core/math.ws

AbsF

import function AbsF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

SgnF

function SgnF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

ModF

function ModF(a : float, b : float) : float
Parameters:
a : float
b : float
Returns:
float
Path:
/core/math.ws

SinF

import function SinF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

AsinF

import function AsinF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

CosF

import function CosF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

AcosF

import function AcosF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

TanF

import function TanF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

AtanF

import function AtanF(a, b : float) : float
Parameters:
a
b : float
Returns:
float
Path:
/core/math.ws

ExpF

import function ExpF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

PowF

import function PowF(a, x : float) : float
Parameters:
a
x : float
Returns:
float
Path:
/core/math.ws

LogF

import function LogF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

SqrtF

import function SqrtF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

SqrF

import function SqrF(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

CalcSeed

import function CalcSeed(object : IScriptable) : int
Parameters:
object : IScriptable
Returns:
int
Path:
/core/math.ws

MinF

import function MinF(a, b : float) : float
Parameters:
a
b : float
Returns:
float
Path:
/core/math.ws

MaxF

import function MaxF(a, b : float) : float
Parameters:
a
b : float
Returns:
float
Path:
/core/math.ws

ClampF

import function ClampF(v, min, max : float) : float
Parameters:
v
min
max : float
Returns:
float
Path:
/core/math.ws

LerpF

import function LerpF(alpha, a, b : float, optional clamp : bool) : float
Parameters:
alpha
a
b : float
optional clamp : bool
Returns:
float
Path:
/core/math.ws

CeilF

import function CeilF(a : float) : int
Parameters:
a : float
Returns:
int
Path:
/core/math.ws

FloorF

import function FloorF(a : float) : int
Parameters:
a : float
Returns:
int
Path:
/core/math.ws

RoundF

import function RoundF(a : float) : int
Parameters:
a : float
Returns:
int
Path:
/core/math.ws

RoundMath

function RoundMath(f : float) : int
Parameters:
f : float
Returns:
int
Path:
/core/math.ws

RoundTo

function RoundTo(f : float, decimal : int) : float
Parameters:
f : float
decimal : int
Returns:
float
Path:
/core/math.ws

ReinterpretIntAsFloat

import function ReinterpretIntAsFloat(a : int) : float
Parameters:
a : int
Returns:
float
Path:
/core/math.ws

AngleNormalize

import function AngleNormalize(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

AngleNormalize180

function AngleNormalize180(a : float) : float
Parameters:
a : float
Returns:
float
Path:
/core/math.ws

LerpAngleF

function LerpAngleF(alpha, a, b : float) : float
Parameters:
alpha
a
b : float
Returns:
float
Path:
/core/math.ws

AngleDistance

import function AngleDistance(target, current : float) : float
Parameters:
target
current : float
Returns:
float
Path:
/core/math.ws

AngleApproach

import function AngleApproach(target, cur, step : float) : float
Parameters:
target
cur
step : float
Returns:
float
Path:
/core/math.ws

NodeToNodeAngleDistance

function NodeToNodeAngleDistance(target, current : CNode) : float
Parameters:
target
current : CNode
Returns:
float
Path:
/core/math.ws

VecDot2D

import function VecDot2D(a, b : Vector) : float
Parameters:
a
b : Vector
Returns:
float
Path:
/core/math.ws

VecDot

import function VecDot(a, b : Vector) : float
Parameters:
a
b : Vector
Returns:
float
Path:
/core/math.ws

VecCross

import function VecCross(a, b : Vector) : Vector
Parameters:
a
b : Vector
Returns:
Vector
Path:
/core/math.ws

VecLength2D

import function VecLength2D(a : Vector) : float
Parameters:
a : Vector
Returns:
float
Path:
/core/math.ws

VecLengthSquared

import function VecLengthSquared(a : Vector) : float
Parameters:
a : Vector
Returns:
float
Path:
/core/math.ws

VecLength

import function VecLength(a : Vector) : float
Parameters:
a : Vector
Returns:
float
Path:
/core/math.ws

VecNormalize2D

import function VecNormalize2D(a : Vector) : Vector
Parameters:
a : Vector
Returns:
Vector
Path:
/core/math.ws

VecNormalize

import function VecNormalize(a : Vector) : Vector
Parameters:
a : Vector
Returns:
Vector
Path:
/core/math.ws

VecRand2D

import function VecRand2D() : Vector
Returns:
Vector
Path:
/core/math.ws

VecRand

import function VecRand() : Vector
Returns:
Vector
Path:
/core/math.ws

VecRingRand

function VecRingRand(minRadius, maxRadius : float) : Vector
Parameters:
minRadius
maxRadius : float
Returns:
Vector
Path:
/core/math.ws

VecConeRand

function VecConeRand(coneDir, coneAngle, minRadius, maxRadius : float) : Vector
Parameters:
coneDir
coneAngle
minRadius
maxRadius : float
Returns:
Vector
Path:
/core/math.ws

VecRingRandStatic

function VecRingRandStatic(seed : int, minRadius, maxRadius : float) : Vector
Parameters:
seed : int
minRadius
maxRadius : float
Returns:
Vector
Path:
/core/math.ws

VecMirror

import function VecMirror(dir, normal : Vector) : Vector
Parameters:
dir
normal : Vector
Returns:
Vector
Path:
/core/math.ws

VecDistance

import function VecDistance(from, to : Vector) : float
Parameters:
from
to : Vector
Returns:
float
Path:
/core/math.ws

VecDistanceSquared

import function VecDistanceSquared(from, to : Vector) : float
Parameters:
from
to : Vector
Returns:
float
Path:
/core/math.ws

VecDistance2D

import function VecDistance2D(from, to : Vector) : float
Parameters:
from
to : Vector
Returns:
float
Path:
/core/math.ws

VecDistanceSquared2D

import function VecDistanceSquared2D(from, to : Vector) : float
Parameters:
from
to : Vector
Returns:
float
Path:
/core/math.ws

VecDistanceToEdge

import function VecDistanceToEdge(point, a, b : Vector) : float
Parameters:
point
a
b : Vector
Returns:
float
Path:
/core/math.ws

VecNearestPointOnEdge

import function VecNearestPointOnEdge(point, a, b : Vector) : Vector
Parameters:
point
a
b : Vector
Returns:
Vector
Path:
/core/math.ws

VecToRotation

import function VecToRotation(dir : Vector) : EulerAngles
Parameters:
dir : Vector
Returns:
EulerAngles
Path:
/core/math.ws

VecHeading

import function VecHeading(dir : Vector) : float
Parameters:
dir : Vector
Returns:
float
Path:
/core/math.ws

VecFromHeading

import function VecFromHeading(heading : float) : Vector
Parameters:
heading : float
Returns:
Vector
Path:
/core/math.ws

VecTransform

import function VecTransform(m : Matrix, point : Vector) : Vector
Parameters:
m : Matrix
point : Vector
Returns:
Vector
Path:
/core/math.ws

VecTransformDir

import function VecTransformDir(m : Matrix, point : Vector) : Vector
Parameters:
m : Matrix
point : Vector
Returns:
Vector
Path:
/core/math.ws

VecTransformH

import function VecTransformH(m : Matrix, point : Vector) : Vector
Parameters:
m : Matrix
point : Vector
Returns:
Vector
Path:
/core/math.ws

VecGetAngleBetween

import function VecGetAngleBetween(from : Vector, to : Vector) : float
Parameters:
from : Vector
to : Vector
Returns:
float
Path:
/core/math.ws

VecGetAngleDegAroundAxis

import function VecGetAngleDegAroundAxis(dirA : Vector, dirB : Vector, axis : Vector) : float
Parameters:
dirA : Vector
dirB : Vector
axis : Vector
Returns:
float
Path:
/core/math.ws

VecProjectPointToPlane

import function VecProjectPointToPlane(p1 : Vector, p2 : Vector, p3 : Vector, toProject : Vector) : Vector
Parameters:
p1 : Vector
p2 : Vector
p3 : Vector
toProject : Vector
Returns:
Vector
Path:
/core/math.ws

VecRotateAxis

import function VecRotateAxis(vector : Vector, axis : Vector, angle : float) : Vector
Parameters:
vector : Vector
axis : Vector
angle : float
Returns:
Vector
Path:
/core/math.ws

VecRotByAngleXY

function VecRotByAngleXY(vec : Vector, angleDeg : float) : Vector
Parameters:
vec : Vector
angleDeg : float
Returns:
Vector
Path:
/core/math.ws

VecInterpolate

function VecInterpolate(v1, v2 : Vector, ratio : float) : Vector
Parameters:
v1
v2 : Vector
ratio : float
Returns:
Vector
Path:
/core/math.ws

VecToString

function VecToString(vec : Vector) : string
Parameters:
vec : Vector
Returns:
string
Path:
/core/math.ws

VecToStringPrec

function VecToStringPrec(vec : Vector, precision : int) : string
Parameters:
vec : Vector
precision : int
Returns:
string
Path:
/core/math.ws

RotX

import function RotX(rotation : EulerAngles) : Vector
Parameters:
rotation : EulerAngles
Returns:
Vector
Path:
/core/math.ws

RotY

import function RotY(rotation : EulerAngles) : Vector
Parameters:
rotation : EulerAngles
Returns:
Vector
Path:
/core/math.ws

RotZ

import function RotZ(rotation : EulerAngles) : Vector
Parameters:
rotation : EulerAngles
Returns:
Vector
Path:
/core/math.ws

RotForward

import function RotForward(rotation : EulerAngles) : Vector
Parameters:
rotation : EulerAngles
Returns:
Vector
Path:
/core/math.ws

RotRight

import function RotRight(rotation : EulerAngles) : Vector
Parameters:
rotation : EulerAngles
Returns:
Vector
Path:
/core/math.ws

RotUp

import function RotUp(rotation : EulerAngles) : Vector
Parameters:
rotation : EulerAngles
Returns:
Vector
Path:
/core/math.ws

RotToMatrix

import function RotToMatrix(rotation : EulerAngles) : Matrix
Parameters:
rotation : EulerAngles
Returns:
Matrix
Path:
/core/math.ws

RotAxes

import function RotAxes(rotation : EulerAngles, out foward, right, up : Vector)
Parameters:
rotation : EulerAngles
out foward
right
up : Vector
Path:
/core/math.ws

RotDot

import function RotDot(a, b : EulerAngles)
Parameters:
a
b : EulerAngles
Path:
/core/math.ws

RotRand

import function RotRand(min, max : float) : EulerAngles
Parameters:
min
max : float
Returns:
EulerAngles
Path:
/core/math.ws

GetOppositeRotation180

function GetOppositeRotation180(rot : EulerAngles) : EulerAngles
Parameters:
rot : EulerAngles
Returns:
EulerAngles
Path:
/core/math.ws

MatrixIdentity

import function MatrixIdentity() : Matrix
Returns:
Matrix
Path:
/core/math.ws

MatrixBuiltTranslation

import function MatrixBuiltTranslation(move : Vector) : Matrix
Parameters:
move : Vector
Returns:
Matrix
Path:
/core/math.ws

MatrixBuiltRotation

import function MatrixBuiltRotation(rot : EulerAngles) : Matrix
Parameters:
rot : EulerAngles
Returns:
Matrix
Path:
/core/math.ws

MatrixBuiltScale

import function MatrixBuiltScale(scale : Vector) : Matrix
Parameters:
scale : Vector
Returns:
Matrix
Path:
/core/math.ws

MatrixBuiltPreScale

import function MatrixBuiltPreScale(scale : Vector) : Matrix
Parameters:
scale : Vector
Returns:
Matrix
Path:
/core/math.ws

MatrixBuiltTRS

import function MatrixBuiltTRS(optional translation : Vector, optional rotation : EulerAngles, optional scale : Vector) : Matrix
Parameters:
optional translation : Vector
optional rotation : EulerAngles
optional scale : Vector
Returns:
Matrix
Path:
/core/math.ws

MatrixBuiltRTS

import function MatrixBuiltRTS(optional rotation : EulerAngles, optional translation : Vector, optional scale : Vector) : Matrix
Parameters:
optional rotation : EulerAngles
optional translation : Vector
optional scale : Vector
Returns:
Matrix
Path:
/core/math.ws

MatrixBuildFromDirectionVector

import function MatrixBuildFromDirectionVector(dirVec : Vector) : Matrix
Parameters:
dirVec : Vector
Returns:
Matrix
Path:
/core/math.ws

MatrixGetTranslation

import function MatrixGetTranslation(m : Matrix) : Vector
Parameters:
m : Matrix
Returns:
Vector
Path:
/core/math.ws

MatrixGetRotation

import function MatrixGetRotation(m : Matrix) : EulerAngles
Parameters:
m : Matrix
Returns:
EulerAngles
Path:
/core/math.ws

MatrixGetScale

import function MatrixGetScale(m : Matrix) : Vector
Parameters:
m : Matrix
Returns:
Vector
Path:
/core/math.ws

MatrixGetAxisX

import function MatrixGetAxisX(m : Matrix) : Vector
Parameters:
m : Matrix
Returns:
Vector
Path:
/core/math.ws

MatrixGetAxisY

import function MatrixGetAxisY(m : Matrix) : Vector
Parameters:
m : Matrix
Returns:
Vector
Path:
/core/math.ws

MatrixGetAxisZ

import function MatrixGetAxisZ(m : Matrix) : Vector
Parameters:
m : Matrix
Returns:
Vector
Path:
/core/math.ws

MatrixGetDirectionVector

import function MatrixGetDirectionVector(m : Matrix) : Vector
Parameters:
m : Matrix
Returns:
Vector
Path:
/core/math.ws

MatrixGetInverted

import function MatrixGetInverted(m : Matrix) : Matrix
Parameters:
m : Matrix
Returns:
Matrix
Path:
/core/math.ws

GetBoxSize

function GetBoxSize(box : Box) : Vector
Parameters:
box : Box
Returns:
Vector
Path:
/core/math.ws

GetBoxExtents

function GetBoxExtents(box : Box) : Vector
Parameters:
box : Box
Returns:
Vector
Path:
/core/math.ws

GetBoxRange

function GetBoxRange(box : Box) : float
Parameters:
box : Box
Returns:
float
Path:
/core/math.ws

SphereIntersectRay

import function SphereIntersectRay(sphere : Sphere, orign : Vector, direction : Vector, out enterPoint : Vector, out exitPoint : Vector) : int
Parameters:
sphere : Sphere
orign : Vector
direction : Vector
out enterPoint : Vector
out exitPoint : Vector
Returns:
int
Path:
/core/math.ws

SphereIntersectEdge

import function SphereIntersectEdge(sphere : Sphere, a : Vector, b : Vector, out intersectionPoint0 : Vector, out intersectionPoint1 : Vector) : int
Parameters:
sphere : Sphere
a : Vector
b : Vector
out intersectionPoint0 : Vector
out intersectionPoint1 : Vector
Returns:
int
Path:
/core/math.ws

Int8ToInt

import function Int8ToInt(i : Int8) : int
Parameters:
i : Int8
Returns:
int
Path:
/core/math.ws

IntToInt8

import function IntToInt8(i : int) : Int8
Parameters:
i : int
Returns:
Int8
Path:
/core/math.ws

IntToUint64

import function IntToUint64(i : int) : Uint64
Parameters:
i : int
Returns:
Uint64
Path:
/core/math.ws

Uint64ToInt

import function Uint64ToInt(i : Uint64) : int
Parameters:
i : Uint64
Returns:
int
Path:
/core/math.ws

t_Identity

import function t_Identity(a : EngineQsTransform)
Parameters:
a : EngineQsTransform
Path:
/core/mathAdv.ws

t_SetIdentity

import function t_SetIdentity() : EngineQsTransform
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_BuiltTrans

import function t_BuiltTrans(move : Vector) : EngineQsTransform
Parameters:
move : Vector
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_BuiltRotQuat

import function t_BuiltRotQuat(quat : Vector) : EngineQsTransform
Parameters:
quat : Vector
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_BuiltRotAngles

import function t_BuiltRotAngles(x : float, y : float, z : float) : EngineQsTransform
Parameters:
x : float
y : float
z : float
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_BuiltScale

import function t_BuiltScale(scale : Vector) : EngineQsTransform
Parameters:
scale : Vector
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_Trans

import function t_Trans(a : EngineQsTransform, move : Vector)
Parameters:
a : EngineQsTransform
move : Vector
Path:
/core/mathAdv.ws

t_RotQuat

import function t_RotQuat(a : EngineQsTransform, quat : Vector)
Parameters:
a : EngineQsTransform
quat : Vector
Path:
/core/mathAdv.ws

t_Scale

import function t_Scale(a : EngineQsTransform, scale : Vector)
Parameters:
a : EngineQsTransform
scale : Vector
Path:
/core/mathAdv.ws

t_SetTrans

import function t_SetTrans(a : EngineQsTransform, move : Vector) : EngineQsTransform
Parameters:
a : EngineQsTransform
move : Vector
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_SetRotQuat

import function t_SetRotQuat(a : EngineQsTransform, quat : Vector) : EngineQsTransform
Parameters:
a : EngineQsTransform
quat : Vector
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_SetScale

import function t_SetScale(a : EngineQsTransform, scale : Vector) : EngineQsTransform
Parameters:
a : EngineQsTransform
scale : Vector
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_GetTrans

import function t_GetTrans(a : EngineQsTransform) : Vector
Parameters:
a : EngineQsTransform
Returns:
Vector
Path:
/core/mathAdv.ws

t_GetRotQuat

import function t_GetRotQuat(a : EngineQsTransform) : Vector
Parameters:
a : EngineQsTransform
Returns:
Vector
Path:
/core/mathAdv.ws

t_GetScale

import function t_GetScale(a : EngineQsTransform) : Vector
Parameters:
a : EngineQsTransform
Returns:
Vector
Path:
/core/mathAdv.ws

t_SetMul

import function t_SetMul(a : EngineQsTransform, b : EngineQsTransform) : EngineQsTransform
Parameters:
a : EngineQsTransform
b : EngineQsTransform
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_SetMulMulInv

import function t_SetMulMulInv(a : EngineQsTransform, b : EngineQsTransform) : EngineQsTransform
Parameters:
a : EngineQsTransform
b : EngineQsTransform
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_SetMulInvMul

import function t_SetMulInvMul(a : EngineQsTransform, b : EngineQsTransform) : EngineQsTransform
Parameters:
a : EngineQsTransform
b : EngineQsTransform
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_SetInterpolate

import function t_SetInterpolate(a : EngineQsTransform, b : EngineQsTransform, w : float) : EngineQsTransform
Parameters:
a : EngineQsTransform
b : EngineQsTransform
w : float
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_IsEqual

import function t_IsEqual(a : EngineQsTransform, b : EngineQsTransform) : bool
Parameters:
a : EngineQsTransform
b : EngineQsTransform
Returns:
bool
Path:
/core/mathAdv.ws

t_Inv

import function t_Inv(a : EngineQsTransform)
Parameters:
a : EngineQsTransform
Path:
/core/mathAdv.ws

t_SetInv

import function t_SetInv(a : EngineQsTransform) : EngineQsTransform
Parameters:
a : EngineQsTransform
Returns:
EngineQsTransform
Path:
/core/mathAdv.ws

t_NormalizeQuat

import function t_NormalizeQuat(a : EngineQsTransform)
Parameters:
a : EngineQsTransform
Path:
/core/mathAdv.ws

t_BlendNormalize

import function t_BlendNormalize(a : EngineQsTransform, w : float)
Parameters:
a : EngineQsTransform
w : float
Path:
/core/mathAdv.ws

t_IsOk

import function t_IsOk(a : EngineQsTransform) : bool
Parameters:
a : EngineQsTransform
Returns:
bool
Path:
/core/mathAdv.ws

q_SetIdentity

import function q_SetIdentity() : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

q_Identity

import function q_Identity(a : Vector)
Parameters:
a : Vector
Path:
/core/mathAdv.ws

q_SetInv

import function q_SetInv(a : Vector) : Vector
Parameters:
a : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

q_Inv

import function q_Inv(a : Vector)
Parameters:
a : Vector
Path:
/core/mathAdv.ws

q_SetNormalize

import function q_SetNormalize(a : Vector) : Vector
Parameters:
a : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

q_Normalize

import function q_Normalize(a : Vector)
Parameters:
a : Vector
Path:
/core/mathAdv.ws

q_SetMul

import function q_SetMul(a : Vector, b : Vector) : Vector
Parameters:
a : Vector
b : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

q_SetMulMulInv

import function q_SetMulMulInv(a : Vector, b : Vector) : Vector
Parameters:
a : Vector
b : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

q_SetMulInvMul

import function q_SetMulInvMul(a : Vector, b : Vector) : Vector
Parameters:
a : Vector
b : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

q_SetShortestRotation

import function q_SetShortestRotation(from : Vector, to : Vector) : Vector
Parameters:
from : Vector
to : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

q_SetShortestRotationDamped

import function q_SetShortestRotationDamped(from : Vector, to : Vector, w : float) : Vector
Parameters:
from : Vector
to : Vector
w : float
Returns:
Vector
Path:
/core/mathAdv.ws

q_SetAxisAngle

import function q_SetAxisAngle(axis : Vector, angle : float) : Vector
Parameters:
axis : Vector
angle : float
Returns:
Vector
Path:
/core/mathAdv.ws

q_RemoveAxisComponent

import function q_RemoveAxisComponent(quat : Vector, axis : Vector)
Parameters:
quat : Vector
axis : Vector
Path:
/core/mathAdv.ws

q_DecomposeAxis

import function q_DecomposeAxis(quat : Vector, axis : Vector) : float
Parameters:
quat : Vector
axis : Vector
Returns:
float
Path:
/core/mathAdv.ws

q_SetSlerp

import function q_SetSlerp(a : Vector, b : Vector, w : float) : Vector
Parameters:
a : Vector
b : Vector
w : float
Returns:
Vector
Path:
/core/mathAdv.ws

q_GetAngle

import function q_GetAngle(a : Vector) : float
Parameters:
a : Vector
Returns:
float
Path:
/core/mathAdv.ws

q_GetAxis

import function q_GetAxis(a : Vector) : Vector
Parameters:
a : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

v_SetInterpolate

import function v_SetInterpolate(a : Vector, b : Vector, w : float) : Vector
Parameters:
a : Vector
b : Vector
w : float
Returns:
Vector
Path:
/core/mathAdv.ws

v_SetRotatedDir

import function v_SetRotatedDir(quat : Vector, dir : Vector) : Vector
Parameters:
quat : Vector
dir : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

v_SetTransformedPos

import function v_SetTransformedPos(trans : EngineQsTransform, vec : Vector) : Vector
Parameters:
trans : EngineQsTransform
vec : Vector
Returns:
Vector
Path:
/core/mathAdv.ws

v_ZeroElement

import function v_ZeroElement(a : Vector, i : int)
Parameters:
a : Vector
i : int
Path:
/core/mathAdv.ws

EPSILON

function EPSILON() : float
Returns:
float
Path:
/core/mathAdv.ws

GetRangePct_F

function GetRangePct_F(minVal : float, maxVal : float, value : float) : float
Parameters:
minVal : float
maxVal : float
value : float
Returns:
float
Path:
/core/mathAdv.ws

GetRangePct_V

function GetRangePct_V(range : Vector, value : float) : float
Parameters:
range : Vector
value : float
Returns:
float
Path:
/core/mathAdv.ws

GetRangeVal_F

function GetRangeVal_F(minVal : float, maxVal : float, pct : float) : float
Parameters:
minVal : float
maxVal : float
pct : float
Returns:
float
Path:
/core/mathAdv.ws

GetRangeVal_V

function GetRangeVal_V(range : Vector, pct : float) : float
Parameters:
range : Vector
pct : float
Returns:
float
Path:
/core/mathAdv.ws

GetMappedRangeValue

function GetMappedRangeValue(inRange : Vector, outRange : Vector, value : float) : float
Parameters:
inRange : Vector
outRange : Vector
value : float
Returns:
float
Path:
/core/mathAdv.ws

InterpTo_F

function InterpTo_F(current : float, desired : float, deltaTime : float, interpSpeed : float) : float
Parameters:
current : float
desired : float
deltaTime : float
interpSpeed : float
Returns:
float
Path:
/core/mathAdv.ws

InterpConstTo_F

function InterpConstTo_F(current : float, desired : float, deltaTime : float, interpSpeed : float) : float
Parameters:
current : float
desired : float
deltaTime : float
interpSpeed : float
Returns:
float
Path:
/core/mathAdv.ws

InterpEaseIn_F

function InterpEaseIn_F(a : float, b : float, alpha : float, exp : float) : float
Parameters:
a : float
b : float
alpha : float
exp : float
Returns:
float
Path:
/core/mathAdv.ws

InterpEaseOut_F

function InterpEaseOut_F(a : float, b : float, alpha : float, exp : float) : float
Parameters:
a : float
b : float
alpha : float
exp : float
Returns:
float
Path:
/core/mathAdv.ws

InterpEaseInOut_F

function InterpEaseInOut_F(a : float, b : float, alpha : float, exp : float) : float
Parameters:
a : float
b : float
alpha : float
exp : float
Returns:
float
Path:
/core/mathAdv.ws

CubicInterp_F

function CubicInterp_F(p0 : float, t0 : float, p1 : float, t1 : float, a : float) : float
Parameters:
p0 : float
t0 : float
p1 : float
t1 : float
a : float
Returns:
float
Path:
/core/mathAdv.ws

GetVectComponent

function GetVectComponent(v : Vector, inComp : int) : float
Parameters:
v : Vector
inComp : int
Returns:
float
Path:
/core/mathAdv.ws

LerpV

function LerpV(a : Vector, b : Vector, alpha : float) : Vector
Parameters:
a : Vector
b : Vector
alpha : float
Returns:
Vector
Path:
/core/mathAdv.ws

InterpTo_V

function InterpTo_V(current : Vector, desired : Vector, deltaTime : float, interpSpeed : float) : Vector
Parameters:
current : Vector
desired : Vector
deltaTime : float
interpSpeed : float
Returns:
Vector
Path:
/core/mathAdv.ws

CubicInterp_V

function CubicInterp_V(p0 : Vector, t0 : Vector, p1 : Vector, t1 : Vector, a : float) : Vector
Parameters:
p0 : Vector
t0 : Vector
p1 : Vector
t1 : Vector
a : float
Returns:
Vector
Path:
/core/mathAdv.ws

InterpEaseIn_V

function InterpEaseIn_V(a : Vector, b : Vector, alpha : float, exp : float) : Vector
Parameters:
a : Vector
b : Vector
alpha : float
exp : float
Returns:
Vector
Path:
/core/mathAdv.ws

InterpEaseOut_V

function InterpEaseOut_V(a : Vector, b : Vector, alpha : float, exp : float) : Vector
Parameters:
a : Vector
b : Vector
alpha : float
exp : float
Returns:
Vector
Path:
/core/mathAdv.ws

InterpEaseInOut_V

function InterpEaseInOut_V(a : Vector, b : Vector, alpha : float, exp : float) : Vector
Parameters:
a : Vector
b : Vector
alpha : float
exp : float
Returns:
Vector
Path:
/core/mathAdv.ws

VecReduceTowardsZero

function VecReduceTowardsZero(source : Vector, ammount : float) : Vector
Parameters:
source : Vector
ammount : float
Returns:
Vector
Path:
/core/mathAdv.ws

VecReduceNotExceedingV

function VecReduceNotExceedingV(_VectorV : Vector, _ReductionAmmountF : float, _MinLengthF : float) : Vector
Parameters:
_VectorV : Vector
_ReductionAmmountF : float
_MinLengthF : float
Returns:
Vector
Path:
/core/mathAdv.ws

VecAddNotExceedingV

function VecAddNotExceedingV(_VectorV : Vector, _AdditionV : Vector, _MaxLengthF : float) : Vector
Parameters:
_VectorV : Vector
_AdditionV : Vector
_MaxLengthF : float
Returns:
Vector
Path:
/core/mathAdv.ws

VecSetZeros

function VecSetZeros(out vector : Vector)
Parameters:
out vector : Vector
Path:
/core/mathAdv.ws

EulerSetZeros

function EulerSetZeros(out eulerAngles : EulerAngles)
Parameters:
out eulerAngles : EulerAngles
Path:
/core/mathAdv.ws

LogVector

function LogVector(vectorName : string, vector : Vector)
Parameters:
vectorName : string
vector : Vector
Path:
/core/mathAdv.ws

MapF

function MapF(val, minOrig, maxOrig, minDest, maxDest : float) : float
Parameters:
val
minOrig
maxOrig
minDest
maxDest : float
Returns:
float
Path:
/core/mathAdv.ws

BlendLinearF

function BlendLinearF(value, target, speed : float) : float
Parameters:
value
target
speed : float
Returns:
float
Path:
/core/mathAdv.ws

BlendF

function BlendF(origin, end, coef : float) : float
Parameters:
origin
end
coef : float
Returns:
float
Path:
/core/mathAdv.ws

SignF

function SignF(value : float) : float
Parameters:
value : float
Returns:
float
Path:
/core/mathAdv.ws

SignOrZeroF

function SignOrZeroF(value : float) : float
Parameters:
value : float
Returns:
float
Path:
/core/mathAdv.ws

Log

import function Log(text : string)
Parameters:
text : string
Path:
/core/misc.ws

LogChannel

import function LogChannel(channel : name, text : string)
Parameters:
channel : name
text : string
Path:
/core/misc.ws

Uint64ToString

import function Uint64ToString(i : Uint64) : string
Parameters:
i : Uint64
Returns:
string
Path:
/core/misc.ws

Trace

import function Trace()
Path:
/core/misc.ws

DebugBreak

import function DebugBreak()
Path:
/core/misc.ws

Sleep

import latent function Sleep(time : float)
Parameters:
time : float
Path:
/core/misc.ws

SleepOneFrame

import latent function SleepOneFrame()
Path:
/core/misc.ws

KillThread

import latent function KillThread()
Path:
/core/misc.ws

DumpClassHierarchy

import function DumpClassHierarchy(baseClass : name) : bool
Parameters:
baseClass : name
Returns:
bool
Path:
/core/misc.ws

EnumGetMax

import function EnumGetMax(type : name) : int
Parameters:
type : name
Returns:
int
Path:
/core/misc.ws

EnumGetMin

import function EnumGetMin(type : name) : int
Parameters:
type : name
Returns:
int
Path:
/core/misc.ws

IsNameValid

function IsNameValid(n : name) : bool
Parameters:
n : name
Returns:
bool
Path:
/core/misc.ws

LogAssert

function LogAssert(condition : bool, text : string)
Parameters:
condition : bool
text : string
Path:
/core/misc.ws

ProcessCompare

function ProcessCompare(comparator : ECompareOp, valA : float, valB : float) : bool
Parameters:
comparator : ECompareOp
valA : float
valB : float
Returns:
bool
Path:
/core/misc.ws

LogAchievements

function LogAchievements(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogAlchemy

function LogAlchemy(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogAttackEvents

function LogAttackEvents(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogAttackRangesDebug

function LogAttackRangesDebug(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogBgNPC

function LogBgNPC(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogBlockGameplayFunctionality

function LogBlockGameplayFunctionality(src, msg : string)
Parameters:
src
msg : string
Path:
/core/misc.ws

LogCharacterStats

function LogCharacterStats(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogCrafting

function LogCrafting(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogCritical

function LogCritical(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogCriticalPlayer

function LogCriticalPlayer(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogEffects

function LogEffects(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogFacts

function LogFacts(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogHaggle

function LogHaggle(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogInput

function LogInput(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogItems

function LogItems(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogLocalization

function LogLocalization(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogLockable

function LogLockable(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogOils

function LogOils(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogPerks

function LogPerks(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogPotions

function LogPotions(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogPS4Light

function LogPS4Light(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogQuest

function LogQuest(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogRandomLoot

function LogRandomLoot(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogReactionSystem

function LogReactionSystem(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogSigns

function LogSigns(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogSkillColors

function LogSkillColors(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogSkills

function LogSkills(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogSound

function LogSound(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogSpeed

function LogSpeed(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogStamina

function LogStamina(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogStates

function LogStates(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogStats

function LogStats(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogThrowable

function LogThrowable(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogTime

function LogTime(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogTutorial

function LogTutorial(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogUnitAtt

function LogUnitAtt(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogItemCollision

function LogItemCollision(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogSpecialHeavy

function LogSpecialHeavy(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogBoat

function LogBoat(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogBoatFatal

function LogBoatFatal(str : string)
Parameters:
str : string
Path:
/core/misc.ws

LogDMHits

function LogDMHits(str : string, optional action : W3DamageAction)
Parameters:
str : string
optional action : W3DamageAction
Path:
/core/misc.ws

LoadResource

import function LoadResource(resource : string, optional isDepotPath : bool) : CResource
Parameters:
resource : string
optional isDepotPath : bool
Returns:
CResource
Path:
/core/resource.ws

LoadResourceAsync

import latent function LoadResourceAsync(resource : string, optional isDepotPath : bool) : CResource
Parameters:
resource : string
optional isDepotPath : bool
Returns:
CResource
Path:
/core/resource.ws

StrLen

import function StrLen(str : string) : int
Parameters:
str : string
Returns:
int
Path:
/core/string.ws

StrCmp

import function StrCmp(str, with : string, optional length : int, optional noCase : bool) : int
Parameters:
str
with : string
optional length : int
optional noCase : bool
Returns:
int
Path:
/core/string.ws

StrFindFirst

import function StrFindFirst(str, match : string) : int
Parameters:
str
match : string
Returns:
int
Path:
/core/string.ws

StrFindLast

import function StrFindLast(str, match : string) : int
Parameters:
str
match : string
Returns:
int
Path:
/core/string.ws

StrSplitFirst

import function StrSplitFirst(str, divider : string, out left, right : string) : bool
Parameters:
str
divider : string
out left
right : string
Returns:
bool
Path:
/core/string.ws

StrSplitLast

import function StrSplitLast(str, divider : string, out left, right : string) : bool
Parameters:
str
divider : string
out left
right : string
Returns:
bool
Path:
/core/string.ws

StrReplace

import function StrReplace(str, match, with : string) : string
Parameters:
str
match
with : string
Returns:
string
Path:
/core/string.ws

StrReplaceAll

import function StrReplaceAll(str, match, with : string) : string
Parameters:
str
match
with : string
Returns:
string
Path:
/core/string.ws

StrMid

import function StrMid(str : string, first : int, optional length : int) : string
Parameters:
str : string
first : int
optional length : int
Returns:
string
Path:
/core/string.ws

StrLeft

import function StrLeft(str : string, length : int) : string
Parameters:
str : string
length : int
Returns:
string
Path:
/core/string.ws

StrRight

import function StrRight(str : string, length : int) : string
Parameters:
str : string
length : int
Returns:
string
Path:
/core/string.ws

StrBeforeFirst

import function StrBeforeFirst(str, match : string) : string
Parameters:
str
match : string
Returns:
string
Path:
/core/string.ws

StrBeforeLast

import function StrBeforeLast(str, match : string) : string
Parameters:
str
match : string
Returns:
string
Path:
/core/string.ws

StrAfterFirst

import function StrAfterFirst(str, match : string) : string
Parameters:
str
match : string
Returns:
string
Path:
/core/string.ws

StrAfterLast

import function StrAfterLast(str, match : string) : string
Parameters:
str
match : string
Returns:
string
Path:
/core/string.ws

StrBeginsWith

import function StrBeginsWith(str, match : string) : bool
Parameters:
str
match : string
Returns:
bool
Path:
/core/string.ws

StrEndsWith

import function StrEndsWith(str, match : string) : bool
Parameters:
str
match : string
Returns:
bool
Path:
/core/string.ws

StrUpper

import function StrUpper(str : string) : string
Parameters:
str : string
Returns:
string
Path:
/core/string.ws

StrLower

import function StrLower(str : string) : string
Parameters:
str : string
Returns:
string
Path:
/core/string.ws

StrChar

import function StrChar(i : int) : string
Parameters:
i : int
Returns:
string
Path:
/core/string.ws

NameToString

import function NameToString(n : name) : string
Parameters:
n : name
Returns:
string
Path:
/core/string.ws

FloatToString

import function FloatToString(value : float) : string
Parameters:
value : float
Returns:
string
Path:
/core/string.ws

FloatToStringPrec

import function FloatToStringPrec(value : float, precision : int) : string
Parameters:
value : float
precision : int
Returns:
string
Path:
/core/string.ws

IntToString

import function IntToString(value : int) : string
Parameters:
value : int
Returns:
string
Path:
/core/string.ws

StringToInt

import function StringToInt(value : string, optional defValue : int) : int
Parameters:
value : string
optional defValue : int
Returns:
int
Path:
/core/string.ws

StringToFloat

import function StringToFloat(value : string, optional defValue : float) : float
Parameters:
value : string
optional defValue : float
Returns:
float
Path:
/core/string.ws

StrUpperUTF

import function StrUpperUTF(str : string) : string
Parameters:
str : string
Returns:
string
Path:
/core/string.ws

StrLowerUTF

import function StrLowerUTF(str : string) : string
Parameters:
str : string
Returns:
string
Path:
/core/string.ws

NameToInt

function NameToInt(n : name) : int
Parameters:
n : name
Returns:
int
Path:
/core/string.ws

NameToFloat

function NameToFloat(n : name) : float
Parameters:
n : name
Returns:
float
Path:
/core/string.ws

NoTrailZeros

function NoTrailZeros(f : float) : string
Parameters:
f : float
Returns:
string
Path:
/core/string.ws

GetRandomName

function GetRandomName() : name
Returns:
name
Path:
/core/string.ws

SpaceFill

function SpaceFill(str : string, length : int, optional mode : ESpaceFillMode) : string
Parameters:
str : string
length : int
optional mode : ESpaceFillMode
Returns:
string
Path:
/core/string.ws

StrStartsWith

function StrStartsWith(str : string, subStr : string) : bool
Parameters:
str : string
subStr : string
Returns:
bool
Path:
/core/string.ws

StrContains

function StrContains(str : string, subStr : string) : bool
Parameters:
str : string
subStr : string
Returns:
bool
Path:
/core/string.ws

GetAnimNameFromEventAnimInfo

import function GetAnimNameFromEventAnimInfo(eventAnimInfo : SAnimationEventAnimInfo) : name
Parameters:
eventAnimInfo : SAnimationEventAnimInfo
Returns:
name
Path:
/engine/animEvents.ws

GetLocalAnimTimeFromEventAnimInfo

import function GetLocalAnimTimeFromEventAnimInfo(eventAnimInfo : SAnimationEventAnimInfo) : float
Parameters:
eventAnimInfo : SAnimationEventAnimInfo
Returns:
float
Path:
/engine/animEvents.ws

GetEventDurationFromEventAnimInfo

import function GetEventDurationFromEventAnimInfo(eventAnimInfo : SAnimationEventAnimInfo) : float
Parameters:
eventAnimInfo : SAnimationEventAnimInfo
Returns:
float
Path:
/engine/animEvents.ws

GetEventEndsAtTimeFromEventAnimInfo

import function GetEventEndsAtTimeFromEventAnimInfo(eventAnimInfo : SAnimationEventAnimInfo) : float
Parameters:
eventAnimInfo : SAnimationEventAnimInfo
Returns:
float
Path:
/engine/animEvents.ws

GCameraShakeLight

function GCameraShakeLight(strength : float, optional testDistance : bool, optional shakeEpicenter : Vector, optional maxDistance : float, optional looping : bool, optional animName : name, optional speed : float)
Parameters:
strength : float
optional testDistance : bool
optional shakeEpicenter : Vector
optional maxDistance : float
optional looping : bool
optional animName : name
optional speed : float
Path:
/engine/camera.ws

GCameraShake

function GCameraShake(strength : float, optional testDistance : bool, optional shakeEpicenter : Vector, optional maxDistance : float, optional looping : bool, optional animName : name, optional speed : float)
Parameters:
strength : float
optional testDistance : bool
optional shakeEpicenter : Vector
optional maxDistance : float
optional looping : bool
optional animName : name
optional speed : float
Path:
/engine/camera.ws

EntityHandleGet

import function EntityHandleGet(handle : EntityHandle) : CEntity
Parameters:
handle : EntityHandle
Returns:
CEntity
Path:
/engine/entity.ws

EntityHandleSet

import function EntityHandleSet(handle : EntityHandle, entity : CEntity)
Parameters:
handle : EntityHandle
entity : CEntity
Path:
/engine/entity.ws

PreloadEffectForEntityTemplate

import function PreloadEffectForEntityTemplate(entityTemplate : CEntityTemplate, effectName : name) : bool
Parameters:
entityTemplate : CEntityTemplate
effectName : name
Returns:
bool
Path:
/engine/entity.ws

PreloadEffectForAnimationForEntityTemplate

import function PreloadEffectForAnimationForEntityTemplate(entityTemplate : CEntityTemplate, animName : name) : bool
Parameters:
entityTemplate : CEntityTemplate
animName : name
Returns:
bool
Path:
/engine/entity.ws

ActivateEnvironmentDefinition

import function ActivateEnvironmentDefinition(environmentDefinition : CEnvironmentDefinition, priority : int, blendFactor : float, blendInTime : float) : int
Parameters:
environmentDefinition : CEnvironmentDefinition
priority : int
blendFactor : float
blendInTime : float
Returns:
int
Path:
/engine/environment.ws

DeactivateEnvironment

import function DeactivateEnvironment(environmentID : int, blendOutTime : float)
Parameters:
environmentID : int
blendOutTime : float
Path:
/engine/environment.ws

ActivateQuestEnvironmentDefinition

import function ActivateQuestEnvironmentDefinition(environmentDefinition : CEnvironmentDefinition, priority : int, blendFactor : float, blendTime : float)
Parameters:
environmentDefinition : CEnvironmentDefinition
priority : int
blendFactor : float
blendTime : float
Path:
/engine/environment.ws

GetRainStrength

import function GetRainStrength() : float
Returns:
float
Path:
/engine/environment.ws

GetSnowStrength

import function GetSnowStrength() : float
Returns:
float
Path:
/engine/environment.ws

IsSkyClear

import function IsSkyClear() : bool
Returns:
bool
Path:
/engine/environment.ws

AreaIsCold

function AreaIsCold() : bool
Returns:
bool
Path:
/engine/environment.ws

SetUnderWaterBrightness

import function SetUnderWaterBrightness(val : float)
Parameters:
val : float
Path:
/engine/environment.ws

GetWeatherConditionName

import function GetWeatherConditionName() : name
Returns:
name
Path:
/engine/environment.ws

RequestWeatherChangeTo

import function RequestWeatherChangeTo(weatherName : name, blendTime : float) : bool
Parameters:
weatherName : name
blendTime : float
Returns:
bool
Path:
/engine/environment.ws

RequestRandomWeatherChange

import function RequestRandomWeatherChange(blendTime : float) : bool
Parameters:
blendTime : float
Returns:
bool
Path:
/engine/environment.ws

ForceFakeEnvTime

import function ForceFakeEnvTime(hour : float)
Parameters:
hour : float
Path:
/engine/environment.ws

DisableFakeEnvTime

import function DisableFakeEnvTime()
Path:
/engine/environment.ws

EnableDrunkFx

import function EnableDrunkFx(optional fadeIn : float)
Parameters:
optional fadeIn : float
Path:
/engine/fx.ws

DisableDrunkFx

import function DisableDrunkFx(optional fadeout : float)
Parameters:
optional fadeout : float
Path:
/engine/fx.ws

ScaleDrunkFx

import function ScaleDrunkFx(scale : float)
Parameters:
scale : float
Path:
/engine/fx.ws

EnableCatViewFx

import function EnableCatViewFx(optional fadeIn : float)
Parameters:
optional fadeIn : float
Path:
/engine/fx.ws

DisableCatViewFx

import function DisableCatViewFx(optional fadeout : float)
Parameters:
optional fadeout : float
Path:
/engine/fx.ws

SetPositionCatViewFx

import function SetPositionCatViewFx(position : Vector, optional autoPositioning : bool)
Parameters:
position : Vector
optional autoPositioning : bool
Path:
/engine/fx.ws

SetTintColorsCatViewFx

import function SetTintColorsCatViewFx(tintNear : Vector, tintFar : Vector, optional desaturaion : float)
Parameters:
tintNear : Vector
tintFar : Vector
optional desaturaion : float
Path:
/engine/fx.ws

SetBrightnessCatViewFx

import function SetBrightnessCatViewFx(optional brightStrength : float)
Parameters:
optional brightStrength : float
Path:
/engine/fx.ws

SetViewRangeCatViewFx

import function SetViewRangeCatViewFx(optional viewRanger : float)
Parameters:
optional viewRanger : float
Path:
/engine/fx.ws

SetHightlightCatViewFx

import function SetHightlightCatViewFx(color : Vector, optional hightlightInterior : float, optional blurSize : float)
Parameters:
color : Vector
optional hightlightInterior : float
optional blurSize : float
Path:
/engine/fx.ws

SetFogDensityCatViewFx

import function SetFogDensityCatViewFx(density : float, optional startOffset : float)
Parameters:
density : float
optional startOffset : float
Path:
/engine/fx.ws

RadialBlurSetup

import function RadialBlurSetup(blurSourcePos : Vector, blurAmount, sineWaveAmount, sineWaveSpeed, sineWaveFreq : float)
Parameters:
blurSourcePos : Vector
blurAmount
sineWaveAmount
sineWaveSpeed
sineWaveFreq : float
Path:
/engine/game.ws

RadialBlurDisable

import function RadialBlurDisable()
Path:
/engine/game.ws

FullscreenBlurSetup

import function FullscreenBlurSetup(intensity : float)
Parameters:
intensity : float
Path:
/engine/game.ws

GetGameplayEffectsComponent

function GetGameplayEffectsComponent(entity : CEntity) : CGameplayEffectsComponent
Parameters:
entity : CEntity
Returns:
CGameplayEffectsComponent
Path:
/engine/gameplayEffectsComponent.ws

GameTimeCreate

import function GameTimeCreate(optional days, hours, minutes, seconds : int) : GameTime
Parameters:
optional days
hours
minutes
seconds : int
Returns:
GameTime
Path:
/engine/gameTime.ws

GameTimeSeconds

import function GameTimeSeconds(time : GameTime) : int
Parameters:
time : GameTime
Returns:
int
Path:
/engine/gameTime.ws

GameTimeMinutes

import function GameTimeMinutes(time : GameTime) : int
Parameters:
time : GameTime
Returns:
int
Path:
/engine/gameTime.ws

GameTimeHours

import function GameTimeHours(time : GameTime) : int
Parameters:
time : GameTime
Returns:
int
Path:
/engine/gameTime.ws

GameTimeDays

import function GameTimeDays(time : GameTime) : int
Parameters:
time : GameTime
Returns:
int
Path:
/engine/gameTime.ws

GameTimeToString

import function GameTimeToString(time : GameTime) : string
Parameters:
time : GameTime
Returns:
string
Path:
/engine/gameTime.ws

GameTimeToSeconds

import function GameTimeToSeconds(time : GameTime) : int
Parameters:
time : GameTime
Returns:
int
Path:
/engine/gameTime.ws

ScheduleTimeEvent

import function ScheduleTimeEvent(context : IScriptable, functionWithParams : string, date : GameTime, optional relative : bool, optional period : GameTime, optional limit : int)
Parameters:
context : IScriptable
functionWithParams : string
date : GameTime
optional relative : bool
optional period : GameTime
optional limit : int
Path:
/engine/gameTime.ws

Have24HoursPassed

function Have24HoursPassed(time1 : GameTime, time2 : GameTime) : bool
Parameters:
time1 : GameTime
time2 : GameTime
Returns:
bool
Path:
/engine/gameTime.ws

ConvertRealTimeSecondsToGameSeconds

function ConvertRealTimeSecondsToGameSeconds(s : float) : float
Parameters:
s : float
Returns:
float
Path:
/engine/gameTime.ws

ConvertGameSecondsToRealTimeSeconds

function ConvertGameSecondsToRealTimeSeconds(s : float) : float
Parameters:
s : float
Returns:
float
Path:
/engine/gameTime.ws

GameTimeCreateFromGameSeconds

function GameTimeCreateFromGameSeconds(seconds : int) : GameTime
Parameters:
seconds : int
Returns:
GameTime
Path:
/engine/gameTime.ws

GetDayPart

function GetDayPart(time : GameTime) : EDayPart
Parameters:
time : GameTime
Returns:
EDayPart
Path:
/engine/gameTime.ws

GetHourForDayPart

function GetHourForDayPart(dp : EDayPart) : int
Parameters:
dp : EDayPart
Returns:
int
Path:
/engine/gameTime.ws

GameTimeIntervalContainsTime

import function GameTimeIntervalContainsTime(time : GameTime, timeInterval : GameTimeInterval, optional ignoreDays : bool) : bool
Parameters:
time : GameTime
timeInterval : GameTimeInterval
optional ignoreDays : bool
Returns:
bool
Path:
/engine/gameTimeInterval.ws

InputKeyToString

function InputKeyToString(keyId : EInputKey) : string
Parameters:
keyId : EInputKey
Returns:
string
Path:
/engine/inputKeys.ws

FindClosestNode

import function FindClosestNode(position : Vector, nodes : array<CNode>) : CNode
Parameters:
position : Vector
nodes : array<CNode>
Returns:
CNode
Path:
/engine/node.ws

SortNodesByDistance

import function SortNodesByDistance(position : Vector, out nodes : array<CNode>)
Parameters:
position : Vector
out nodes : array<CNode>
Path:
/engine/node.ws

PersistentRefSetNode

import function PersistentRefSetNode(out outPersistentRef : PersistentRef, node : CNode)
Parameters:
out outPersistentRef : PersistentRef
node : CNode
Path:
/engine/persistentReference.ws

PersistentRefSetOrientation

import function PersistentRefSetOrientation(out outPersistentRef : PersistentRef, position : Vector, rotation : EulerAngles)
Parameters:
out outPersistentRef : PersistentRef
position : Vector
rotation : EulerAngles
Path:
/engine/persistentReference.ws

PersistentRefGetEntity

import function PersistentRefGetEntity(out persistentRef : PersistentRef) : CEntity
Parameters:
out persistentRef : PersistentRef
Returns:
CEntity
Path:
/engine/persistentReference.ws

PersistentRefGetWorldPosition

import function PersistentRefGetWorldPosition(out persistentRef : PersistentRef) : Vector
Parameters:
out persistentRef : PersistentRef
Returns:
Vector
Path:
/engine/persistentReference.ws

PersistentRefGetWorldRotation

import function PersistentRefGetWorldRotation(out persistentRef : PersistentRef) : EulerAngles
Parameters:
out persistentRef : PersistentRef
Returns:
EulerAngles
Path:
/engine/persistentReference.ws

PersistentRefGetWorldOrientation

import function PersistentRefGetWorldOrientation(out persistentRef : PersistentRef, out outPosition : Vector, out outRotation : EulerAngles)
Parameters:
out persistentRef : PersistentRef
out outPosition : Vector
out outRotation : EulerAngles
Path:
/engine/persistentReference.ws

PhysxDebugger

import function PhysxDebugger(host : string) : bool
Parameters:
host : string
Returns:
bool
Path:
/engine/physicsWorld.ws

SetPhysicalEventOnCollision

import function SetPhysicalEventOnCollision(triggerObject : CComponent, optional receiverObject : CObject, optional onEventName : name) : bool
Parameters:
triggerObject : CComponent
optional receiverObject : CObject
optional onEventName : name
Returns:
bool
Path:
/engine/physicsWorld.ws

SetPhysicalEventOnTriggerFocusFound

import function SetPhysicalEventOnTriggerFocusFound(triggerObject : CComponent, optional receiverObject : CObject, optional onEventName : name) : bool
Parameters:
triggerObject : CComponent
optional receiverObject : CObject
optional onEventName : name
Returns:
bool
Path:
/engine/physicsWorld.ws

SetPhysicalEventOnTriggerFocusLost

import function SetPhysicalEventOnTriggerFocusLost(triggerObject : CComponent, optional receiverObject : CObject, optional onEventName : name) : bool
Parameters:
triggerObject : CComponent
optional receiverObject : CObject
optional onEventName : name
Returns:
bool
Path:
/engine/physicsWorld.ws

GetMeshSoundTypeIdentification

import function GetMeshSoundTypeIdentification(component : CComponent) : name
Parameters:
component : CComponent
Returns:
name
Path:
/engine/sound.ws

GetMeshSoundSizeIdentification

import function GetMeshSoundSizeIdentification(component : CComponent) : name
Parameters:
component : CComponent
Returns:
name
Path:
/engine/sound.ws

CPPForceActorLOD

import function CPPForceActorLOD(enable : bool, optional LODIndex : int)
Parameters:
enable : bool
optional LODIndex : int
Path:
/game/actor.ws

IsRequiredAttitudeBetween

function IsRequiredAttitudeBetween(one, two : CEntity, hostile : bool, optional neutral : bool, optional friendly : bool) : bool
Parameters:
one
two : CEntity
hostile : bool
optional neutral : bool
optional friendly : bool
Returns:
bool
Path:
/game/actorsStorage.ws

GetAttitudeBetween

function GetAttitudeBetween(one, two : CEntity) : EAIAttitude
Parameters:
one
two : CEntity
Returns:
EAIAttitude
Path:
/game/actorsStorage.ws

GetActorsInRange

function GetActorsInRange(center : CNode, range : float, optional maxResults : int, optional tag : name, optional onlyAlive : bool) : array<CActor>
Parameters:
center : CNode
range : float
optional maxResults : int
optional tag : name
optional onlyAlive : bool
Returns:
array<CActor>
Path:
/game/actorsStorage.ws

GetNonFriendlyGameplayEntitiesInRange

function GetNonFriendlyGameplayEntitiesInRange(center : CNode, range : float, attitudeReferenceActor : CActor, optional maxResults : int, optional tag : name) : array<CGameplayEntity>
Parameters:
center : CNode
range : float
attitudeReferenceActor : CActor
optional maxResults : int
optional tag : name
Returns:
array<CGameplayEntity>
Path:
/game/actorsStorage.ws

FindGameplayEntitiesInRange

import function FindGameplayEntitiesInRange(out entities : array<CGameplayEntity>, center : CNode, range : float, maxResults : int, optional tag : name, optional queryFlags : int, optional target : CGameplayEntity, optional className : name)
Parameters:
out entities : array<CGameplayEntity>
center : CNode
range : float
maxResults : int
optional tag : name
optional queryFlags : int
optional target : CGameplayEntity
optional className : name
Path:
/game/actorsStorage.ws

FindGameplayEntitiesInSphere

import function FindGameplayEntitiesInSphere(out entities : array<CGameplayEntity>, point : Vector, range : float, maxResults : int, optional tag : name, optional queryFlags : int, optional target : CGameplayEntity, optional className : name)
Parameters:
out entities : array<CGameplayEntity>
point : Vector
range : float
maxResults : int
optional tag : name
optional queryFlags : int
optional target : CGameplayEntity
optional className : name
Path:
/game/actorsStorage.ws

FindGameplayEntitiesInCylinder

import function FindGameplayEntitiesInCylinder(out entities : array<CGameplayEntity>, point : Vector, range : float, height : float, maxResults : int, optional tag : name, optional queryFlags : int, optional target : CGameplayEntity, optional className : name)
Parameters:
out entities : array<CGameplayEntity>
point : Vector
range : float
height : float
maxResults : int
optional tag : name
optional queryFlags : int
optional target : CGameplayEntity
optional className : name
Path:
/game/actorsStorage.ws

FindGameplayEntitiesInCone

import function FindGameplayEntitiesInCone(out entities : array<CGameplayEntity>, point : Vector, coneDir : float, coneAngle : float, range : float, maxResults : int, optional tag : name, optional queryFlags : int, optional target : CGameplayEntity, optional className : name)
Parameters:
out entities : array<CGameplayEntity>
point : Vector
coneDir : float
coneAngle : float
range : float
maxResults : int
optional tag : name
optional queryFlags : int
optional target : CGameplayEntity
optional className : name
Path:
/game/actorsStorage.ws

FindGameplayEntitiesInBox

import function FindGameplayEntitiesInBox(out entities : array<CGameplayEntity>, point : Vector, boxLS : Box, maxResults : int, optional tag : name, optional queryFlags : int, optional target : CGameplayEntity, optional className : name)
Parameters:
out entities : array<CGameplayEntity>
point : Vector
boxLS : Box
maxResults : int
optional tag : name
optional queryFlags : int
optional target : CGameplayEntity
optional className : name
Path:
/game/actorsStorage.ws

FindGameplayEntitiesCloseToPoint

import function FindGameplayEntitiesCloseToPoint(out entities : array<CGameplayEntity>, point : Vector, range : float, maxResults : int, optional tag : name, optional queryFlags : int, optional target : CGameplayEntity, optional className : name)
Parameters:
out entities : array<CGameplayEntity>
point : Vector
range : float
maxResults : int
optional tag : name
optional queryFlags : int
optional target : CGameplayEntity
optional className : name
Path:
/game/actorsStorage.ws

FindActorsAtLine

import function FindActorsAtLine(startPos : Vector, endPos : Vector, radius : float, out result : array<SRaycastHitResult>, optional collisionGroupsNames : array<name>)
Parameters:
startPos : Vector
endPos : Vector
radius : float
out result : array<SRaycastHitResult>
optional collisionGroupsNames : array<name>
Path:
/game/actorsStorage.ws

StatNameToEnum

function StatNameToEnum(n : name) : EBaseCharacterStats
Parameters:
n : name
Returns:
EBaseCharacterStats
Path:
/game/characterStats.ws

StatEnumToName

function StatEnumToName(s : EBaseCharacterStats) : name
Parameters:
s : EBaseCharacterStats
Returns:
name
Path:
/game/characterStats.ws

PowerStatNameToEnum

function PowerStatNameToEnum(n : name) : ECharacterPowerStats
Parameters:
n : name
Returns:
ECharacterPowerStats
Path:
/game/characterStats.ws

PowerStatEnumToName

function PowerStatEnumToName(s : ECharacterPowerStats) : name
Parameters:
s : ECharacterPowerStats
Returns:
name
Path:
/game/characterStats.ws

RegenStatNameToEnum

function RegenStatNameToEnum(n : name) : ECharacterRegenStats
Parameters:
n : name
Returns:
ECharacterRegenStats
Path:
/game/characterStats.ws

RegenStatEnumToName

function RegenStatEnumToName(s : ECharacterRegenStats) : name
Parameters:
s : ECharacterRegenStats
Returns:
name
Path:
/game/characterStats.ws

GetStatForRegenStat

function GetStatForRegenStat(stat : ECharacterRegenStats) : EBaseCharacterStats
Parameters:
stat : ECharacterRegenStats
Returns:
EBaseCharacterStats
Path:
/game/characterStats.ws

GetRegenStatForStat

function GetRegenStatForStat(stat : EBaseCharacterStats) : ECharacterRegenStats
Parameters:
stat : EBaseCharacterStats
Returns:
ECharacterRegenStats
Path:
/game/characterStats.ws

ResistStatPointNameToEnum

function ResistStatPointNameToEnum(n : name) : ECharacterDefenseStats
Parameters:
n : name
Returns:
ECharacterDefenseStats
Path:
/game/characterStats.ws

ResistStatPercentNameToEnum

function ResistStatPercentNameToEnum(n : name) : ECharacterDefenseStats
Parameters:
n : name
Returns:
ECharacterDefenseStats
Path:
/game/characterStats.ws

ResistStatPointEnumToName

function ResistStatPointEnumToName(s : ECharacterDefenseStats) : name
Parameters:
s : ECharacterDefenseStats
Returns:
name
Path:
/game/characterStats.ws

ResistStatPercentEnumToName

function ResistStatPercentEnumToName(s : ECharacterDefenseStats) : name
Parameters:
s : ECharacterDefenseStats
Returns:
name
Path:
/game/characterStats.ws

ResistStatNameToEnum

function ResistStatNameToEnum(n : name, out isPointResistance : bool) : ECharacterDefenseStats
Parameters:
n : name
out isPointResistance : bool
Returns:
ECharacterDefenseStats
Path:
/game/characterStats.ws

ResistStatEnumToName

function ResistStatEnumToName(s : ECharacterDefenseStats, isPointResistance : bool) : name
Parameters:
s : ECharacterDefenseStats
isPointResistance : bool
Returns:
name
Path:
/game/characterStats.ws

GetStatValue

function GetStatValue(statName : name) : string
Parameters:
statName : name
Returns:
string
Path:
/game/characterStats.ws

GetGenericStatValue

function GetGenericStatValue(statName : name, out valueStr : string) : void
Parameters:
statName : name
out valueStr : string
Returns:
void
Path:
/game/characterStats.ws

IsNonPhysicalResistStat

function IsNonPhysicalResistStat(stat : ECharacterDefenseStats) : bool
Parameters:
stat : ECharacterDefenseStats
Returns:
bool
Path:
/game/characterStats.ws

IsPhysicalResistStat

function IsPhysicalResistStat(stat : ECharacterDefenseStats) : bool
Parameters:
stat : ECharacterDefenseStats
Returns:
bool
Path:
/game/characterStats.ws

AngleToDirection

function AngleToDirection(angle : float) : EDirection
Parameters:
angle : float
Returns:
EDirection
Path:
/game/direction.ws

VectorToDirection

function VectorToDirection(vec : Vector) : EDirection
Parameters:
vec : Vector
Returns:
EDirection
Path:
/game/direction.ws

GetCurMoonState

function GetCurMoonState() : EMoonState
Returns:
EMoonState
Path:
/game/environmentManager.ws

GetCurWeather

function GetCurWeather() : EWeatherEffect
Returns:
EWeatherEffect
Path:
/game/environmentManager.ws

FactsAdd

import function FactsAdd(ID : string, optional value : int, optional validFor : int)
Parameters:
ID : string
optional value : int
optional validFor : int
Path:
/game/facts.ws

FactsQuerySum

import function FactsQuerySum(ID : string) : int
Parameters:
ID : string
Returns:
int
Path:
/game/facts.ws

FactsQuerySumSince

import function FactsQuerySumSince(ID : string, sinceTime : EngineTime) : int
Parameters:
ID : string
sinceTime : EngineTime
Returns:
int
Path:
/game/facts.ws

FactsQueryLatestValue

import function FactsQueryLatestValue(ID : string) : int
Parameters:
ID : string
Returns:
int
Path:
/game/facts.ws

FactsDoesExist

import function FactsDoesExist(ID : string) : bool
Parameters:
ID : string
Returns:
bool
Path:
/game/facts.ws

FactsRemove

import function FactsRemove(ID : string) : bool
Parameters:
ID : string
Returns:
bool
Path:
/game/facts.ws

FactsSet

function FactsSet(ID : string, val : int, optional validFor : int)
Parameters:
ID : string
val : int
optional validFor : int
Path:
/game/facts.ws

FactsSubstract

function FactsSubstract(ID : string, optional val : int)
Parameters:
ID : string
optional val : int
Path:
/game/facts.ws

GameplayFactsAdd

function GameplayFactsAdd(factName : string, optional value : int, optional realtimeSecsValidFor : int)
Parameters:
factName : string
optional value : int
optional realtimeSecsValidFor : int
Path:
/game/facts.ws

GameplayFactsSet

function GameplayFactsSet(factName : string, value : int)
Parameters:
factName : string
value : int
Path:
/game/facts.ws

GameplayFactsQuerySum

function GameplayFactsQuerySum(factName : string) : int
Parameters:
factName : string
Returns:
int
Path:
/game/facts.ws

GameplayFactsRemove

function GameplayFactsRemove(factName : string)
Parameters:
factName : string
Path:
/game/facts.ws

TriggerPerformableEvent

function TriggerPerformableEvent(actionList : array<IPerformableAction>, parnt : CEntity)
Parameters:
actionList : array<IPerformableAction>
parnt : CEntity
Path:
/game/gameplayEntity.ws

TriggerPerformableEventArgNode

function TriggerPerformableEventArgNode(actionList : array<IPerformableAction>, parnt : CEntity, node : CNode)
Parameters:
actionList : array<IPerformableAction>
parnt : CEntity
node : CNode
Path:
/game/gameplayEntity.ws

Ep1_sword

function Ep1_sword()
Path:
/game/geralt_templates.ws

Ep1_signs

function Ep1_signs()
Path:
/game/geralt_templates.ws

Ep1_alchemy

function Ep1_alchemy()
Path:
/game/geralt_templates.ws

GetGlobalEventCategory

function GetGlobalEventCategory(scriptedCategory : EScriptedEventCategory) : EGlobalEventCategory
Parameters:
scriptedCategory : EScriptedEventCategory
Returns:
EGlobalEventCategory
Path:
/game/globalEventsScriptsDisptacher.ws

GetScriptedEventCategory

function GetScriptedEventCategory(globalCategory : EGlobalEventCategory) : EScriptedEventCategory
Parameters:
globalCategory : EGlobalEventCategory
Returns:
EScriptedEventCategory
Path:
/game/globalEventsScriptsDisptacher.ws

GetGlobalEventType

function GetGlobalEventType(scriptedType : EScriptedEventType) : EGlobalEventType
Parameters:
scriptedType : EScriptedEventType
Returns:
EGlobalEventType
Path:
/game/globalEventsScriptsDisptacher.ws

GetScriptedEventType

function GetScriptedEventType(globalType : EGlobalEventType) : EScriptedEventType
Parameters:
globalType : EGlobalEventType
Returns:
EScriptedEventType
Path:
/game/globalEventsScriptsDisptacher.ws

AddHitFacts

function AddHitFacts(victimTags : array<name>, attackerTags : array<name>, hitType : string, optional validForever : bool, optional prefix : string)
Parameters:
victimTags : array<name>
attackerTags : array<name>
hitType : string
optional validForever : bool
optional prefix : string
Path:
/game/hitLogging.ws

GetCurrentTextLocCode

function GetCurrentTextLocCode() : string
Returns:
string
Path:
/game/inGameConfigWrapper.ws

IsPressed

function IsPressed(action : SInputAction, optional justValue : bool) : bool
Parameters:
action : SInputAction
optional justValue : bool
Returns:
bool
Path:
/game/inputManager.ws

IsReleased

function IsReleased(action : SInputAction, optional justValue : bool) : bool
Parameters:
action : SInputAction
optional justValue : bool
Returns:
bool
Path:
/game/inputManager.ws

activateJournalBestiaryEntryWithAlias

function activateJournalBestiaryEntryWithAlias(entryAlias : string, journalManager : CWitcherJournalManager) : void
Parameters:
entryAlias : string
journalManager : CWitcherJournalManager
Returns:
void
Path:
/game/journal.ws

activateJournalGlossaryGroupWithAlias

function activateJournalGlossaryGroupWithAlias(entryAlias : string, journalManager : CWitcherJournalManager) : void
Parameters:
entryAlias : string
journalManager : CWitcherJournalManager
Returns:
void
Path:
/game/journal.ws

activateJournalStoryBookPageEntryWithAlias

function activateJournalStoryBookPageEntryWithAlias(entryAlias : string, journalManager : CWitcherJournalManager) : void
Parameters:
entryAlias : string
journalManager : CWitcherJournalManager
Returns:
void
Path:
/game/journal.ws

activateJournalCharacterEntryWithAlias

function activateJournalCharacterEntryWithAlias(entryAlias : string, journalManager : CWitcherJournalManager) : void
Parameters:
entryAlias : string
journalManager : CWitcherJournalManager
Returns:
void
Path:
/game/journal.ws

activateBaseBestiaryEntryWithAlias

function activateBaseBestiaryEntryWithAlias(entryAlias : string, journalManager : CWitcherJournalManager) : void
Parameters:
entryAlias : string
journalManager : CWitcherJournalManager
Returns:
void
Path:
/game/journal.ws

GetLocStringById

import function GetLocStringById(stringId : int) : string
Parameters:
stringId : int
Returns:
string
Path:
/game/localizedContent.ws

GetLocStringByKey

import function GetLocStringByKey(stringKey : string) : string
Parameters:
stringKey : string
Returns:
string
Path:
/game/localizedContent.ws

GetLocStringByKeyExt

import function GetLocStringByKeyExt(stringKey : string) : string
Parameters:
stringKey : string
Returns:
string
Path:
/game/localizedContent.ws

FixStringForFont

import function FixStringForFont(originalString : string) : string
Parameters:
originalString : string
Returns:
string
Path:
/game/localizedContent.ws

GetItemCategoryLocalisedString

function GetItemCategoryLocalisedString(cat : name) : string
Parameters:
cat : name
Returns:
string
Path:
/game/localizedContent.ws

GetAttributeNameLocStr

function GetAttributeNameLocStr(attName : name, isMult : bool) : string
Parameters:
attName : name
isMult : bool
Returns:
string
Path:
/game/localizedContent.ws

GetLocStringByKeyExtWithParams

function GetLocStringByKeyExtWithParams(stringKey : string, optional intParamsArray : array<int>, optional floatParamsArray : array<float>, optional stringParamsArray : array<string>, optional addNbspTag : bool) : string
Parameters:
stringKey : string
optional intParamsArray : array<int>
optional floatParamsArray : array<float>
optional stringParamsArray : array<string>
optional addNbspTag : bool
Returns:
string
Path:
/game/localizedContent.ws

GetLocStringByIdWithParams

function GetLocStringByIdWithParams(stringId : int, optional intParamsArray : array<int>, optional floatParamsArray : array<float>, optional stringParamsArray : array<string>) : string
Parameters:
stringId : int
optional intParamsArray : array<int>
optional floatParamsArray : array<float>
optional stringParamsArray : array<string>
Returns:
string
Path:
/game/localizedContent.ws

GetItemTooltipText

function GetItemTooltipText(item : SItemUniqueId, inv : CInventoryComponent) : string
Parameters:
item : SItemUniqueId
inv : CInventoryComponent
Returns:
string
Path:
/game/localizedContent.ws

GetBaseStatLocalizedName

function GetBaseStatLocalizedName(stat : EBaseCharacterStats) : string
Parameters:
stat : EBaseCharacterStats
Returns:
string
Path:
/game/localizedContent.ws

GetBaseStatLocalizedDesc

function GetBaseStatLocalizedDesc(stat : EBaseCharacterStats) : string
Parameters:
stat : EBaseCharacterStats
Returns:
string
Path:
/game/localizedContent.ws

GetRegenStatLocalizedName

function GetRegenStatLocalizedName(stat : ECharacterRegenStats) : string
Parameters:
stat : ECharacterRegenStats
Returns:
string
Path:
/game/localizedContent.ws

GetRegenStatLocalizedDesc

function GetRegenStatLocalizedDesc(stat : ECharacterRegenStats) : string
Parameters:
stat : ECharacterRegenStats
Returns:
string
Path:
/game/localizedContent.ws

GetPowerStatLocalizedName

function GetPowerStatLocalizedName(stat : ECharacterPowerStats) : string
Parameters:
stat : ECharacterPowerStats
Returns:
string
Path:
/game/localizedContent.ws

GetPowerStatLocalizedDesc

function GetPowerStatLocalizedDesc(stat : ECharacterPowerStats) : string
Parameters:
stat : ECharacterPowerStats
Returns:
string
Path:
/game/localizedContent.ws

GetResistStatLocalizedName

function GetResistStatLocalizedName(s : ECharacterDefenseStats, isPointResistance : bool) : string
Parameters:
s : ECharacterDefenseStats
isPointResistance : bool
Returns:
string
Path:
/game/localizedContent.ws

GetResistStatLocalizedDesc

function GetResistStatLocalizedDesc(s : ECharacterDefenseStats, isPointResistance : bool) : string
Parameters:
s : ECharacterDefenseStats
isPointResistance : bool
Returns:
string
Path:
/game/localizedContent.ws

HasLolcalizationTags

function HasLolcalizationTags(s : string) : bool
Parameters:
s : string
Returns:
bool
Path:
/game/localizedContent.ws

GetIconByPlatform

function GetIconByPlatform(tag : string) : string
Parameters:
tag : string
Returns:
string
Path:
/game/localizedContent.ws

ReplaceTagsToIcons

function ReplaceTagsToIcons(s : string) : string
Parameters:
s : string
Returns:
string
Path:
/game/localizedContent.ws

GetIconForKey

function GetIconForKey(key : EInputKey, optional isGuiKey : bool) : string
Parameters:
key : EInputKey
optional isGuiKey : bool
Returns:
string
Path:
/game/localizedContent.ws

GetHoldLabel

function GetHoldLabel() : string
Returns:
string
Path:
/game/localizedContent.ws

GetBracketSymbols

function GetBracketSymbols(out openingSymbol : string, out closingSymbol : string, optional isRoundBrackets : bool) : void
Parameters:
out openingSymbol : string
out closingSymbol : string
optional isRoundBrackets : bool
Returns:
void
Path:
/game/localizedContent.ws

GetHTMLForICO

function GetHTMLForICO(icon : string) : string
Parameters:
icon : string
Returns:
string
Path:
/game/localizedContent.ws

GetHTMLForMouseICO

function GetHTMLForMouseICO(icon : string) : string
Parameters:
icon : string
Returns:
string
Path:
/game/localizedContent.ws

GetHTMLForItemICO

function GetHTMLForItemICO(icon : string, optional vspace : float) : string
Parameters:
icon : string
optional vspace : float
Returns:
string
Path:
/game/localizedContent.ws

GetBookTexture

function GetBookTexture(tag : string) : string
Parameters:
tag : string
Returns:
string
Path:
/game/localizedContent.ws

GetIconForTag

function GetIconForTag(tag : string) : string
Parameters:
tag : string
Returns:
string
Path:
/game/localizedContent.ws

GetIconOrColorForTag2

function GetIconOrColorForTag2(tag : string) : string
Parameters:
tag : string
Returns:
string
Path:
/game/localizedContent.ws

GetIconOrColorForTag3

function GetIconOrColorForTag3(tag : string) : string
Parameters:
tag : string
Returns:
string
Path:
/game/localizedContent.ws

GetIconNameForKey

function GetIconNameForKey(key : EInputKey) : string
Parameters:
key : EInputKey
Returns:
string
Path:
/game/localizedContent.ws

GetPadFileName

function GetPadFileName(type : string) : string
Parameters:
type : string
Returns:
string
Path:
/game/localizedContent.ws

DEBUG_Test_GetIconForTag

function DEBUG_Test_GetIconForTag(out text : string, tag : string)
Parameters:
out text : string
tag : string
Path:
/game/localizedContent.ws

DEBUG_Test_GetIconNameForKey

function DEBUG_Test_GetIconNameForKey(out text : string, key : EInputKey)
Parameters:
out text : string
key : EInputKey
Path:
/game/localizedContent.ws

PROFILER_Init

import function PROFILER_Init(bufforSize : int)
Parameters:
bufforSize : int
Path:
/game/profiler.ws

PROFILER_InitEx

import function PROFILER_InitEx(bufforSize : int, bufforSignalsSize : int)
Parameters:
bufforSize : int
bufforSignalsSize : int
Path:
/game/profiler.ws

PROFILER_ScriptEnable

import function PROFILER_ScriptEnable()
Path:
/game/profiler.ws

PROFILER_ScriptDisable

import function PROFILER_ScriptDisable()
Path:
/game/profiler.ws

PROFILER_Start

import function PROFILER_Start()
Path:
/game/profiler.ws

PROFILER_Stop

import function PROFILER_Stop()
Path:
/game/profiler.ws

PROFILER_Store

import function PROFILER_Store(profileName : string)
Parameters:
profileName : string
Path:
/game/profiler.ws

PROFILER_StoreDef

import function PROFILER_StoreDef()
Path:
/game/profiler.ws

PROFILER_StoreInstrFuncList

import function PROFILER_StoreInstrFuncList()
Path:
/game/profiler.ws

PROFILER_StartCatchBreakpoint

import function PROFILER_StartCatchBreakpoint()
Path:
/game/profiler.ws

PROFILER_StopCatchBreakpoint

import function PROFILER_StopCatchBreakpoint()
Path:
/game/profiler.ws

PROFILER_SetTimeBreakpoint

import function PROFILER_SetTimeBreakpoint(instrFuncName : string, time : float, stopOnce : bool)
Parameters:
instrFuncName : string
time : float
stopOnce : bool
Path:
/game/profiler.ws

PROFILER_SetHitCountBreakpoint

import function PROFILER_SetHitCountBreakpoint(instrFuncName : string, counter : int)
Parameters:
instrFuncName : string
counter : int
Path:
/game/profiler.ws

PROFILER_DisableTimeBreakpoint

import function PROFILER_DisableTimeBreakpoint(instrFuncName : string)
Parameters:
instrFuncName : string
Path:
/game/profiler.ws

PROFILER_DisableHitCountBreakpoint

import function PROFILER_DisableHitCountBreakpoint(instrFuncName : string)
Parameters:
instrFuncName : string
Path:
/game/profiler.ws

hasSaveDataToLoad

function hasSaveDataToLoad() : bool
Returns:
bool
Path:
/game/r4Game.ws

addbooks_

function addbooks_()
Path:
/game/temp.ws

additemfood

function additemfood()
Path:
/game/temp.ws

additemalchemy

function additemalchemy()
Path:
/game/temp.ws

additemcrafting

function additemcrafting()
Path:
/game/temp.ws

additemleather

function additemleather()
Path:
/game/temp.ws

additemmetals

function additemmetals()
Path:
/game/temp.ws

additemrunesupgrades

function additemrunesupgrades()
Path:
/game/temp.ws

additemmonstrous

function additemmonstrous()
Path:
/game/temp.ws

additemsprecious

function additemsprecious()
Path:
/game/temp.ws

PrintInventory

function PrintInventory(optional onlyEquipped : bool)
Parameters:
optional onlyEquipped : bool
Path:
/game/temp.ws

PrintInventory2

function PrintInventory2()
Path:
/game/temp.ws

PrintInventory2Item

function PrintInventory2Item(index : int)
Parameters:
index : int
Path:
/game/temp.ws

PlayerDynamicGlobal

function PlayerDynamicGlobal()
Path:
/game/temp.ws

PlayerKinematicGlobal

function PlayerKinematicGlobal()
Path:
/game/temp.ws

Debug_stats

function Debug_stats(actor : CActor)
Parameters:
actor : CActor
Path:
/game/temp.ws

Debug_Attributes

function Debug_Attributes(n : CActor)
Parameters:
n : CActor
Path:
/game/temp.ws

AddAndEquipSkill

function AddAndEquipSkill(skill : ESkill) : bool
Parameters:
skill : ESkill
Returns:
bool
Path:
/game/temp.ws

temp_difflevel

function temp_difflevel(i : EDifficultyMode)
Parameters:
i : EDifficultyMode
Path:
/game/temp.ws

skilleq_internal

function skilleq_internal(skill : ESkill, optional id : int, optional level : int)
Parameters:
skill : ESkill
optional id : int
optional level : int
Path:
/game/temp.ws

printabs_f

function printabs_f(optional tag : name, optional fromItems : bool, optional attributes : bool, optional act : CActor)
Parameters:
optional tag : name
optional fromItems : bool
optional attributes : bool
optional act : CActor
Path:
/game/temp.ws

damageitem_g

function damageitem_g(slot : EEquipmentSlots, perc : float)
Parameters:
slot : EEquipmentSlots
perc : float
Path:
/game/temp.ws

rw_internal

function rw_internal(typ : string, optional removeAllExisting : bool, optional onSilverSword : bool) : SItemUniqueId
Parameters:
typ : string
optional removeAllExisting : bool
optional onSilverSword : bool
Returns:
SItemUniqueId
Path:
/game/temp.ws

spawnt_inquistion

function spawnt_inquistion(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_nilfgard

function spawnt_nilfgard(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_nml_t1

function spawnt_nml_t1(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_nml_t2

function spawnt_nml_t2(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_novigrad

function spawnt_novigrad(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_redania

function spawnt_redania(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_skellige_t1

function spawnt_skellige_t1(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_skellige_t2

function spawnt_skellige_t2(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_wild_hunt

function spawnt_wild_hunt(template_nbr : int, optional distance : float)
Parameters:
template_nbr : int
optional distance : float
Path:
/game/tmp_templates.ws

spawnt_internal

function spawnt_internal(nam : string, optional quantity : int, optional distance : float)
Parameters:
nam : string
optional quantity : int
optional distance : float
Path:
/game/tmp_templates.ws

AreaNameToType

function AreaNameToType(lName : string) : EAreaName
Parameters:
lName : string
Returns:
EAreaName
Path:
/game/types.ws

AreaTypeToName

function AreaTypeToName(type : EAreaName) : string
Parameters:
type : EAreaName
Returns:
string
Path:
/game/types.ws

ZoneNameToType

function ZoneNameToType(lName : name) : EZoneName
Parameters:
lName : name
Returns:
EZoneName
Path:
/game/types.ws

ZoneTypeToName

function ZoneTypeToName(type : EZoneName) : name
Parameters:
type : EZoneName
Returns:
name
Path:
/game/types.ws

MinDiffMode

function MinDiffMode(a, b : EDifficultyMode) : EDifficultyMode
Parameters:
a
b : EDifficultyMode
Returns:
EDifficultyMode
Path:
/game/types.ws

GetDifficultyTagForMode

function GetDifficultyTagForMode(d : EDifficultyMode) : name
Parameters:
d : EDifficultyMode
Returns:
name
Path:
/game/types.ws

ModifyHitSeverityReaction

function ModifyHitSeverityReaction(target : CActor, type : EHitReactionType) : EHitReactionType
Parameters:
target : CActor
type : EHitReactionType
Returns:
EHitReactionType
Path:
/game/types.ws

IsBasicAttack

function IsBasicAttack(attackName : name) : bool
Parameters:
attackName : name
Returns:
bool
Path:
/game/types.ws

MonsterCategoryIsMonster

function MonsterCategoryIsMonster(type : EMonsterCategory) : bool
Parameters:
type : EMonsterCategory
Returns:
bool
Path:
/game/types.ws

MonsterCategoryToAttackPowerBonus

function MonsterCategoryToAttackPowerBonus(type : EMonsterCategory) : name
Parameters:
type : EMonsterCategory
Returns:
name
Path:
/game/types.ws

MonsterCategoryToCriticalChanceBonus

function MonsterCategoryToCriticalChanceBonus(type : EMonsterCategory) : name
Parameters:
type : EMonsterCategory
Returns:
name
Path:
/game/types.ws

MonsterCategoryToCriticalDamageBonus

function MonsterCategoryToCriticalDamageBonus(type : EMonsterCategory) : name
Parameters:
type : EMonsterCategory
Returns:
name
Path:
/game/types.ws

MonsterCategoryToResistReduction

function MonsterCategoryToResistReduction(type : EMonsterCategory) : name
Parameters:
type : EMonsterCategory
Returns:
name
Path:
/game/types.ws

CalculateAttributeValue

function CalculateAttributeValue(att : SAbilityAttributeValue, optional disallowNegativeMult : bool) : float
Parameters:
att : SAbilityAttributeValue
optional disallowNegativeMult : bool
Returns:
float
Path:
/game/types.ws

GetAttributeRandomizedValue

function GetAttributeRandomizedValue(min, max : SAbilityAttributeValue) : SAbilityAttributeValue
Parameters:
min
max : SAbilityAttributeValue
Returns:
SAbilityAttributeValue
Path:
/game/types.ws

StaminaActionTypeToName

function StaminaActionTypeToName(action : EStaminaActionType) : name
Parameters:
action : EStaminaActionType
Returns:
name
Path:
/game/types.ws

StatisticEnumToName

function StatisticEnumToName(s : EStatistic) : name
Parameters:
s : EStatistic
Returns:
name
Path:
/game/types.ws

StatisticNameToEnum

function StatisticNameToEnum(f : name) : EStatistic
Parameters:
f : name
Returns:
EStatistic
Path:
/game/types.ws

GetBookReadFactName

function GetBookReadFactName(bookName : name) : string
Parameters:
bookName : name
Returns:
string
Path:
/game/types.ws

AchievementNameToEnum

function AchievementNameToEnum(n : name) : EAchievement
Parameters:
n : name
Returns:
EAchievement
Path:
/game/types.ws

AchievementEnumToName

function AchievementEnumToName(a : EAchievement) : name
Parameters:
a : EAchievement
Returns:
name
Path:
/game/types.ws

ResetAnimatedComponentSyncSettings

import function ResetAnimatedComponentSyncSettings(out settings : SAnimatedComponentSyncSettings)
Parameters:
out settings : SAnimatedComponentSyncSettings
Path:
/game/animations/animatedSlider.ws

ResetAnimatedSlideSettings

import function ResetAnimatedSlideSettings(out settings : SAnimatedSlideSettings)
Parameters:
out settings : SAnimatedSlideSettings
Path:
/game/animations/animatedSlider.ws

ResetActionMatchToSettings

import function ResetActionMatchToSettings(out settings : SActionMatchToSettings)
Parameters:
out settings : SActionMatchToSettings
Path:
/game/animations/animatedSlider.ws

SetActionMatchToTarget_StaticPoint

import function SetActionMatchToTarget_StaticPoint(out target : SActionMatchToTarget, point : Vector, yaw : float, position : bool, rotation : bool)
Parameters:
out target : SActionMatchToTarget
point : Vector
yaw : float
position : bool
rotation : bool
Path:
/game/animations/animatedSlider.ws

ResetAnimatedComponentSlotAnimationSettings

import function ResetAnimatedComponentSlotAnimationSettings(out settings : SAnimatedComponentSlotAnimationSettings)
Parameters:
out settings : SAnimatedComponentSlotAnimationSettings
Path:
/game/animations/animatedSlider.ws

DebugBehTreeStart

import function DebugBehTreeStart(optional actor : CActor)
Parameters:
optional actor : CActor
Path:
/game/behavior_tree/behTreeTask.ws

DebugBehTreeStopAll

import function DebugBehTreeStopAll()
Path:
/game/behavior_tree/behTreeTask.ws

GlobalRegisterReactionSceneGroups

function GlobalRegisterReactionSceneGroups()
Path:
/game/behavior_tree/reactionScenesGroups.ws

GlobalRegisterReactionSceneGroups_Prologue

function GlobalRegisterReactionSceneGroups_Prologue(reactionManager : CBehTreeReactionManager)
Parameters:
reactionManager : CBehTreeReactionManager
Path:
/game/behavior_tree/reactionScenesGroups.ws

GlobalRegisterReactionSceneGroups_Skellige

function GlobalRegisterReactionSceneGroups_Skellige(reactionManager : CBehTreeReactionManager)
Parameters:
reactionManager : CBehTreeReactionManager
Path:
/game/behavior_tree/reactionScenesGroups.ws

GlobalRegisterReactionSceneGroups_Nml

function GlobalRegisterReactionSceneGroups_Nml(reactionManager : CBehTreeReactionManager)
Parameters:
reactionManager : CBehTreeReactionManager
Path:
/game/behavior_tree/reactionScenesGroups.ws

GlobalRegisterReactionSceneGroups_Novigrad

function GlobalRegisterReactionSceneGroups_Novigrad(reactionManager : CBehTreeReactionManager)
Parameters:
reactionManager : CBehTreeReactionManager
Path:
/game/behavior_tree/reactionScenesGroups.ws

GetItem

function GetItem(inv : CInventoryComponent, category : name, out itemId : SItemUniqueId) : bool
Parameters:
inv : CInventoryComponent
category : name
out itemId : SItemUniqueId
Returns:
bool
Path:
/game/components/inventoryComponent.ws

PrintItem

function PrintItem(inv : CInventoryComponent, weaponItemId : SItemUniqueId)
Parameters:
inv : CInventoryComponent
weaponItemId : SItemUniqueId
Path:
/game/components/inventoryComponent.ws

PlayItemEquipSound

function PlayItemEquipSound(itemCategory : name) : void
Parameters:
itemCategory : name
Returns:
void
Path:
/game/components/inventoryComponent.ws

PlayItemUnequipSound

function PlayItemUnequipSound(itemCategory : name) : void
Parameters:
itemCategory : name
Returns:
void
Path:
/game/components/inventoryComponent.ws

PlayItemConsumeSound

function PlayItemConsumeSound(item : SItemUniqueId) : void
Parameters:
item : SItemUniqueId
Returns:
void
Path:
/game/components/inventoryComponent.ws

IsExplorationOneSided

function IsExplorationOneSided(exploration : SExplorationQueryToken) : bool
Parameters:
exploration : SExplorationQueryToken
Returns:
bool
Path:
/game/explorations/explorationAPI.ws

LogExploration

function LogExploration(_TextS : string)
Parameters:
_TextS : string
Path:
/game/explorations/exploration_movement_system/explorationStateManager.ws

LogExplorationError

function LogExplorationError(_TextS : string)
Parameters:
_TextS : string
Path:
/game/explorations/exploration_movement_system/explorationStateManager.ws

LogExplorationWarning

function LogExplorationWarning(_TextS : string)
Parameters:
_TextS : string
Path:
/game/explorations/exploration_movement_system/explorationStateManager.ws

LogExplorationToken

function LogExplorationToken(text : string)
Parameters:
text : string
Path:
/game/explorations/exploration_movement_system/explorationStateManager.ws

InitExplorationLogs

function InitExplorationLogs()
Path:
/game/explorations/exploration_movement_system/explorationStateManager.ws

LogExplorationClimb

function LogExplorationClimb(text : string)
Parameters:
text : string
Path:
/game/explorations/exploration_movement_system/exploration_substates/explorationStateClimb.ws

LogSlidingTerrain

function LogSlidingTerrain(text : string)
Parameters:
text : string
Path:
/game/explorations/exploration_movement_system/exploration_substates/explorationStateSlide.ws

LogCollisionTrajectory

function LogCollisionTrajectory(text : string)
Parameters:
text : string
Path:
/game/explorations/prediction/collisionTrajectory.ws

LinkStringToType

function LinkStringToType(str : string) : ESkillColor
Parameters:
str : string
Returns:
ESkillColor
Path:
/game/gameplay/ability/abilityManagerTypes.ws

SkillPathNameToType

function SkillPathNameToType(n : name) : ESkillPath
Parameters:
n : name
Returns:
ESkillPath
Path:
/game/gameplay/ability/abilityManagerTypes.ws

SkillPathTypeToName

function SkillPathTypeToName(s : ESkillPath) : name
Parameters:
s : ESkillPath
Returns:
name
Path:
/game/gameplay/ability/abilityManagerTypes.ws

SkillPathTypeToLocalisationKey

function SkillPathTypeToLocalisationKey(s : ESkillPath) : name
Parameters:
s : ESkillPath
Returns:
name
Path:
/game/gameplay/ability/abilityManagerTypes.ws

SkillSubPathToLocalisationKey

function SkillSubPathToLocalisationKey(s : ESkillSubPath) : string
Parameters:
s : ESkillSubPath
Returns:
string
Path:
/game/gameplay/ability/abilityManagerTypes.ws

SkillSubPathNameToType

function SkillSubPathNameToType(n : name) : ESkillSubPath
Parameters:
n : name
Returns:
ESkillSubPath
Path:
/game/gameplay/ability/abilityManagerTypes.ws

SkillSubPathTypeToName

function SkillSubPathTypeToName(s : ESkillSubPath) : name
Parameters:
s : ESkillSubPath
Returns:
name
Path:
/game/gameplay/ability/abilityManagerTypes.ws

IsSkillSign

function IsSkillSign(skill : ESkill) : bool
Parameters:
skill : ESkill
Returns:
bool
Path:
/game/gameplay/ability/abilityManagerTypes.ws

getAlchemyRecipeFromName

function getAlchemyRecipeFromName(recipeName : name) : SAlchemyRecipe
Parameters:
recipeName : name
Returns:
SAlchemyRecipe
Path:
/game/gameplay/alchemy/alchemyManager.ws

AlchemyCookedItemTypeStringToEnum

function AlchemyCookedItemTypeStringToEnum(nam : string) : EAlchemyCookedItemType
Parameters:
nam : string
Returns:
EAlchemyCookedItemType
Path:
/game/gameplay/alchemy/alchemyTypes.ws

AlchemyCookedItemTypeEnumToName

function AlchemyCookedItemTypeEnumToName(type : EAlchemyCookedItemType) : name
Parameters:
type : EAlchemyCookedItemType
Returns:
name
Path:
/game/gameplay/alchemy/alchemyTypes.ws

AlchemyCookedItemTypeToLocKey

function AlchemyCookedItemTypeToLocKey(type : EAlchemyCookedItemType) : string
Parameters:
type : EAlchemyCookedItemType
Returns:
string
Path:
/game/gameplay/alchemy/alchemyTypes.ws

AlchemyExceptionToString

function AlchemyExceptionToString(result : EAlchemyExceptions) : string
Parameters:
result : EAlchemyExceptions
Returns:
string
Path:
/game/gameplay/alchemy/alchemyTypes.ws

IsAlchemyRecipe

function IsAlchemyRecipe(recipeName : name) : bool
Parameters:
recipeName : name
Returns:
bool
Path:
/game/gameplay/alchemy/alchemyTypes.ws

ClearAPID

import function ClearAPID(out apID : SActionPointId)
Parameters:
out apID : SActionPointId
Path:
/game/gameplay/community/actionPointManager.ws

IsAPValid

import function IsAPValid(apID : SActionPointId) : bool
Parameters:
apID : SActionPointId
Returns:
bool
Path:
/game/gameplay/community/actionPointManager.ws

DumpCommunityAgentsCPP

import function DumpCommunityAgentsCPP()
Path:
/game/gameplay/community/communitySystem.ws

getCraftingSchematicFromName

function getCraftingSchematicFromName(schematicName : name) : SCraftingSchematic
Parameters:
schematicName : name
Returns:
SCraftingSchematic
Path:
/game/gameplay/crafting/craftingManager.ws

CraftingExceptionToString

function CraftingExceptionToString(result : ECraftingException) : string
Parameters:
result : ECraftingException
Returns:
string
Path:
/game/gameplay/crafting/craftingTypes.ws

ParseCraftsmanTypeStringToEnum

function ParseCraftsmanTypeStringToEnum(s : string) : ECraftsmanType
Parameters:
s : string
Returns:
ECraftsmanType
Path:
/game/gameplay/crafting/craftingTypes.ws

ParseCraftsmanLevelStringToEnum

function ParseCraftsmanLevelStringToEnum(s : string) : ECraftsmanLevel
Parameters:
s : string
Returns:
ECraftsmanLevel
Path:
/game/gameplay/crafting/craftingTypes.ws

CraftsmanTypeToLocalizationKey

function CraftsmanTypeToLocalizationKey(type : ECraftsmanType) : string
Parameters:
type : ECraftsmanType
Returns:
string
Path:
/game/gameplay/crafting/craftingTypes.ws

CraftsmanLevelToLocalizationKey

function CraftsmanLevelToLocalizationKey(type : ECraftsmanLevel) : string
Parameters:
type : ECraftsmanLevel
Returns:
string
Path:
/game/gameplay/crafting/craftingTypes.ws

IsCraftingSchematic

function IsCraftingSchematic(recipeName : name) : bool
Parameters:
recipeName : name
Returns:
bool
Path:
/game/gameplay/crafting/craftingTypes.ws

getEnchamtmentStatName

function getEnchamtmentStatName(enchantmentName : name) : name
Parameters:
enchantmentName : name
Returns:
name
Path:
/game/gameplay/crafting/craftingTypes.ws

GetAllRunewordSchematics

function GetAllRunewordSchematics() : array<CName>
Returns:
array<CName>
Path:
/game/gameplay/crafting/craftingTypes.ws

getEnchantmentSchematicFromName

function getEnchantmentSchematicFromName(schematicName : name) : SEnchantmentSchematic
Parameters:
schematicName : name
Returns:
SEnchantmentSchematic
Path:
/game/gameplay/crafting/enchantmentManager.ws

DamageHitsEssence

function DamageHitsEssence(damageName : name) : bool
Parameters:
damageName : name
Returns:
bool
Path:
/game/gameplay/damage/damageManagerTypes.ws

DamageHitsVitality

function DamageHitsVitality(damageName : name) : bool
Parameters:
damageName : name
Returns:
bool
Path:
/game/gameplay/damage/damageManagerTypes.ws

DamageHitsMorale

function DamageHitsMorale(damageName : name) : bool
Parameters:
damageName : name
Returns:
bool
Path:
/game/gameplay/damage/damageManagerTypes.ws

DamageHitsStamina

function DamageHitsStamina(damageName : name) : bool
Parameters:
damageName : name
Returns:
bool
Path:
/game/gameplay/damage/damageManagerTypes.ws

GetBasicAttackDamageAttributeName

function GetBasicAttackDamageAttributeName(attackType : name, damageName : name) : name
Parameters:
attackType : name
damageName : name
Returns:
name
Path:
/game/gameplay/damage/damageManagerTypes.ws

IsDamageTypeNameValid

function IsDamageTypeNameValid(damageName : name) : bool
Parameters:
damageName : name
Returns:
bool
Path:
/game/gameplay/damage/damageManagerTypes.ws

DamageTypeStringToName

function DamageTypeStringToName(damageStr : string) : name
Parameters:
damageStr : string
Returns:
name
Path:
/game/gameplay/damage/damageManagerTypes.ws

GetResistForDamage

function GetResistForDamage(damageName : name, isDoTDamage : bool) : ECharacterDefenseStats
Parameters:
damageName : name
isDoTDamage : bool
Returns:
ECharacterDefenseStats
Path:
/game/gameplay/damage/damageManagerTypes.ws

GetMinorShrineBuffs

function GetMinorShrineBuffs() : array<EEffectType>
Returns:
array<EEffectType>
Path:
/game/gameplay/effects/effectTypes.ws

ModifyHitSeverityBuff

function ModifyHitSeverityBuff(target : CActor, type : EEffectType) : EEffectType
Parameters:
target : CActor
type : EEffectType
Returns:
EEffectType
Path:
/game/gameplay/effects/effectTypes.ws

IsKnockdownEffectType

function IsKnockdownEffectType(type : EEffectType) : bool
Parameters:
type : EEffectType
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

IsCriticalEffectType

function IsCriticalEffectType(type : EEffectType) : bool
Parameters:
type : EEffectType
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

IsNegativeEffectType

function IsNegativeEffectType(type : EEffectType) : bool
Parameters:
type : EEffectType
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

GetBuffCriticalType

function GetBuffCriticalType(buff : CBaseGameplayEffect) : ECriticalStateType
Parameters:
buff : CBaseGameplayEffect
Returns:
ECriticalStateType
Path:
/game/gameplay/effects/effectTypes.ws

CriticalBuffIsDestroyedOnInterrupt

function CriticalBuffIsDestroyedOnInterrupt(buff : CBaseGameplayEffect) : bool
Parameters:
buff : CBaseGameplayEffect
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

CriticalBuffIsHitAllowed

function CriticalBuffIsHitAllowed(buff : CBaseGameplayEffect, hit : EHitReactionType) : bool
Parameters:
buff : CBaseGameplayEffect
hit : EHitReactionType
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

IsCriticalEffect

function IsCriticalEffect(e : CBaseGameplayEffect) : bool
Parameters:
e : CBaseGameplayEffect
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

IsDoTEffect

function IsDoTEffect(e : CBaseGameplayEffect) : bool
Parameters:
e : CBaseGameplayEffect
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

CriticalEffectCanPlayAnimation

function CriticalEffectCanPlayAnimation(buff : CBaseGameplayEffect) : bool
Parameters:
buff : CBaseGameplayEffect
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

CriticalBuffDisallowPlayAnimation

function CriticalBuffDisallowPlayAnimation(buff : CBaseGameplayEffect)
Parameters:
buff : CBaseGameplayEffect
Path:
/game/gameplay/effects/effectTypes.ws

CriticalBuffUsesFullBodyAnim

function CriticalBuffUsesFullBodyAnim(buff : CBaseGameplayEffect) : bool
Parameters:
buff : CBaseGameplayEffect
Returns:
bool
Path:
/game/gameplay/effects/effectTypes.ws

IsEffectNameValid

function IsEffectNameValid(effectName : name) : bool
Parameters:
effectName : name
Returns:
bool
Path:
/game/gameplay/effects/gameEffectManager.ws

EffectNameToType

function EffectNameToType(effectName : name, out type : EEffectType, out abilityName : name)
Parameters:
effectName : name
out type : EEffectType
out abilityName : name
Path:
/game/gameplay/effects/gameEffectManager.ws

HACK_NO_MEMORY_TO_COMPILE_EffectNameToType_Part1

function HACK_NO_MEMORY_TO_COMPILE_EffectNameToType_Part1(effectName : name, out type : EEffectType, out abilityName : name) : bool
Parameters:
effectName : name
out type : EEffectType
out abilityName : name
Returns:
bool
Path:
/game/gameplay/effects/gameEffectManager.ws

HACK_NO_MEMORY_TO_COMPILE_EffectNameToType_Part2

function HACK_NO_MEMORY_TO_COMPILE_EffectNameToType_Part2(effectName : name, out type : EEffectType, out abilityName : name)
Parameters:
effectName : name
out type : EEffectType
out abilityName : name
Path:
/game/gameplay/effects/gameEffectManager.ws

EffectTypeToName

function EffectTypeToName(effectType : EEffectType) : name
Parameters:
effectType : EEffectType
Returns:
name
Path:
/game/gameplay/effects/gameEffectManager.ws

IsBuffAutoBuff

function IsBuffAutoBuff(effectType : EEffectType) : bool
Parameters:
effectType : EEffectType
Returns:
bool
Path:
/game/gameplay/effects/gameEffectManager.ws

IsBuffShrine

function IsBuffShrine(effectType : EEffectType) : bool
Parameters:
effectType : EEffectType
Returns:
bool
Path:
/game/gameplay/effects/gameEffectManager.ws

ForceCleanupAllEncounters

function ForceCleanupAllEncounters()
Path:
/game/gameplay/encounter/encounter.ws

CheckNestDestructionAchievement

function CheckNestDestructionAchievement(optional debugLog : bool)
Parameters:
optional debugLog : bool
Path:
/game/gameplay/interactive/monsterNestEntity.ws

ProcessVelen

function ProcessVelen(out entityMapPins : array<SEntityMapPinInfo>)
Parameters:
out entityMapPins : array<SEntityMapPinInfo>
Path:
/game/gameplay/interactive/monsterNestEntity.ws

IsSlotHorseSlot

function IsSlotHorseSlot(slot : EEquipmentSlots) : bool
Parameters:
slot : EEquipmentSlots
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

SlotEnumToName

function SlotEnumToName(slot : EEquipmentSlots) : name
Parameters:
slot : EEquipmentSlots
Returns:
name
Path:
/game/gameplay/items/itemsTypes.ws

SlotNameToEnum

function SlotNameToEnum(slot : name) : EEquipmentSlots
Parameters:
slot : name
Returns:
EEquipmentSlots
Path:
/game/gameplay/items/itemsTypes.ws

GetLocNameFromEquipSlot

function GetLocNameFromEquipSlot(slotType : EEquipmentSlots) : name
Parameters:
slotType : EEquipmentSlots
Returns:
name
Path:
/game/gameplay/items/itemsTypes.ws

IsMultipleSlot

function IsMultipleSlot(slot : EEquipmentSlots) : bool
Parameters:
slot : EEquipmentSlots
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

GetInvalidUniqueId

function GetInvalidUniqueId() : SItemUniqueId
Returns:
SItemUniqueId
Path:
/game/gameplay/items/itemsTypes.ws

GetFilterTypeName

function GetFilterTypeName(filterType : EInventoryFilterType) : name
Parameters:
filterType : EInventoryFilterType
Returns:
name
Path:
/game/gameplay/items/itemsTypes.ws

GetFilterTypeByName

function GetFilterTypeByName(filterName : name) : EInventoryFilterType
Parameters:
filterName : name
Returns:
EInventoryFilterType
Path:
/game/gameplay/items/itemsTypes.ws

GetSlotForItem

function GetSlotForItem(category : name, tags : array<name>, isPlayer : bool) : EEquipmentSlots
Parameters:
category : name
tags : array<name>
isPlayer : bool
Returns:
EEquipmentSlots
Path:
/game/gameplay/items/itemsTypes.ws

GetSlotForItemByCategory

function GetSlotForItemByCategory(category : name) : EEquipmentSlots
Parameters:
category : name
Returns:
EEquipmentSlots
Path:
/game/gameplay/items/itemsTypes.ws

IsSlotSkillMutagen

function IsSlotSkillMutagen(slot : EEquipmentSlots) : bool
Parameters:
slot : EEquipmentSlots
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

IsSlotPotionMutagen

function IsSlotPotionMutagen(slot : EEquipmentSlots) : bool
Parameters:
slot : EEquipmentSlots
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

IsSlotQuickslot

function IsSlotQuickslot(slot : EEquipmentSlots) : bool
Parameters:
slot : EEquipmentSlots
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

IsSlotMutagen

function IsSlotMutagen(slot : EEquipmentSlots) : bool
Parameters:
slot : EEquipmentSlots
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

IsSlotPotionSlot

function IsSlotPotionSlot(slot : EEquipmentSlots) : bool
Parameters:
slot : EEquipmentSlots
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

IsSlotPetardslot

function IsSlotPetardslot(slot : EEquipmentSlots) : bool
Parameters:
slot : EEquipmentSlots
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

GetItemActionFriendlyName

function GetItemActionFriendlyName(itemAction : EInventoryActionType, optional isEquipped : bool) : string
Parameters:
itemAction : EInventoryActionType
optional isEquipped : bool
Returns:
string
Path:
/game/gameplay/items/itemsTypes.ws

IsBookTextureTag

function IsBookTextureTag(tag : string) : bool
Parameters:
tag : string
Returns:
bool
Path:
/game/gameplay/items/itemsTypes.ws

GetSwitchByTag

function GetSwitchByTag(tag : name) : W3Switch
Parameters:
tag : name
Returns:
W3Switch
Path:
/game/gameplay/mechanisms/switch/switch.ws

GetPlayerReputationManager

function GetPlayerReputationManager() : W3Reputation
Returns:
W3Reputation
Path:
/game/gameplay/reputation/reputation.ws

Boids_IsLocationInSwarmLair

import function Boids_IsLocationInSwarmLair(location : Vector) : bool
Parameters:
location : Vector
Returns:
bool
Path:
/game/gameplay/swarms/boids.ws

Boids_CastFireInCone

import function Boids_CastFireInCone(location : Vector, coneDir : float, coneAngle : float, range : float)
Parameters:
location : Vector
coneDir : float
coneAngle : float
range : float
Path:
/game/gameplay/swarms/boids.ws

FlyingGroupId_Compare

import function FlyingGroupId_Compare(groupIdA : CFlyingGroupId, groupIdB : CFlyingGroupId) : bool
Parameters:
groupIdA : CFlyingGroupId
groupIdB : CFlyingGroupId
Returns:
bool
Path:
/game/gameplay/swarms/flyingCrittersLairEntity.ws

FlyingGroupId_IsValid

import function FlyingGroupId_IsValid(groupId : CFlyingGroupId) : bool
Parameters:
groupId : CFlyingGroupId
Returns:
bool
Path:
/game/gameplay/swarms/flyingCrittersLairEntity.ws

FlyingSwarm_RequestGroupStateChange

function FlyingSwarm_RequestGroupStateChange(lairTag : name, groupState : name, affectAllGroups : bool)
Parameters:
lairTag : name
groupState : name
affectAllGroups : bool
Path:
/game/gameplay/swarms/swarm_function.ws

FlyingSwarm_RequestCreateGroup

function FlyingSwarm_RequestCreateGroup(lairTag : name, boidCount : int, spawnPOI : name)
Parameters:
lairTag : name
boidCount : int
spawnPOI : name
Path:
/game/gameplay/swarms/swarm_function.ws

FlyingSwarm_RequestAllGroupsInstantDespawn

function FlyingSwarm_RequestAllGroupsInstantDespawn(lairTag : name)
Parameters:
lairTag : name
Path:
/game/gameplay/swarms/swarm_function.ws

Swarm_DisablePOIs

function Swarm_DisablePOIs(poiTag : name, disable : bool)
Parameters:
poiTag : name
disable : bool
Path:
/game/gameplay/swarms/swarm_function.ws

Swarm_DisableLair

function Swarm_DisableLair(lairTag : name, disable : bool)
Parameters:
lairTag : name
disable : bool
Path:
/game/gameplay/swarms/swarm_function.ws

TutorialLevelUp

reward function TutorialLevelUp()
Path:
/game/gameplay/tutorial/tutorialTypes.ws

NameToFlashUInt

import function NameToFlashUInt(value : name) : int
Parameters:
value : name
Returns:
int
Path:
/game/gui/flashScriptImports.ws

ItemToFlashUInt

import function ItemToFlashUInt(value : SItemUniqueId) : int
Parameters:
value : SItemUniqueId
Returns:
int
Path:
/game/gui/flashScriptImports.ws

GetObjectFromArrayWithLabel

function GetObjectFromArrayWithLabel(csArray : CScriptedFlashArray, variableName : string, labelName : string, out matchingObject : CScriptedFlashObject) : bool
Parameters:
csArray : CScriptedFlashArray
variableName : string
labelName : string
out matchingObject : CScriptedFlashObject
Returns:
bool
Path:
/game/gui/flashScriptImports.ws

FlashArgBool

import function FlashArgBool(value : bool) : SFlashArg
Parameters:
value : bool
Returns:
SFlashArg
Path:
/game/gui/flashScriptImports.ws

FlashArgInt

import function FlashArgInt(value : int) : SFlashArg
Parameters:
value : int
Returns:
SFlashArg
Path:
/game/gui/flashScriptImports.ws

FlashArgUInt

import function FlashArgUInt(value : int) : SFlashArg
Parameters:
value : int
Returns:
SFlashArg
Path:
/game/gui/flashScriptImports.ws

FlashArgNumber

import function FlashArgNumber(value : float) : SFlashArg
Parameters:
value : float
Returns:
SFlashArg
Path:
/game/gui/flashScriptImports.ws

FlashArgString

import function FlashArgString(value : string) : SFlashArg
Parameters:
value : string
Returns:
SFlashArg
Path:
/game/gui/flashScriptImports.ws

ExtractStringFromCSV

function ExtractStringFromCSV(str : string) : string
Parameters:
str : string
Returns:
string
Path:
/game/gui/r4guimanager.ws

GetBaseScreenPosition

function GetBaseScreenPosition(out screenPos : Vector, entity : CEntity, optional comp : CInteractionComponent, optional extraZ : float, optional noOppositeCamera : bool, optional normalized : bool) : bool
Parameters:
out screenPos : Vector
entity : CEntity
optional comp : CInteractionComponent
optional extraZ : float
optional noOppositeCamera : bool
optional normalized : bool
Returns:
bool
Path:
/game/gui/hud/hud.ws

GetOppositeCameraScreenPos

function GetOppositeCameraScreenPos(worldPos : Vector, out x : float, out y : float)
Parameters:
worldPos : Vector
out x : float
out y : float
Path:
/game/gui/hud/hud.ws

IsPointOnScreen

function IsPointOnScreen(screenPos : Vector) : bool
Parameters:
screenPos : Vector
Returns:
bool
Path:
/game/gui/hud/hud.ws

IngameMenu_GetOptionTypeFromString

function IngameMenu_GetOptionTypeFromString(optionType : string) : InGameMenuActionType
Parameters:
optionType : string
Returns:
InGameMenuActionType
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_FillOptionsSubMenuData

function IngameMenu_FillOptionsSubMenuData(flashStorageUtility : CScriptedFlashValueStorage, isMainMenu : bool) : CScriptedFlashArray
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
isMainMenu : bool
Returns:
CScriptedFlashArray
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_FillCreditsSubGroup

function IngameMenu_FillCreditsSubGroup(flashStorageUtility : CScriptedFlashValueStorage, rootFlashArray : CScriptedFlashArray) : void
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
rootFlashArray : CScriptedFlashArray
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_FillArrayFromConfigGroup

function IngameMenu_FillArrayFromConfigGroup(flashStorageUtility : CScriptedFlashValueStorage, groupID : int, rootFlashArray : CScriptedFlashArray) : void
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
groupID : int
rootFlashArray : CScriptedFlashArray
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_FetchAndGenerateGroupMenuObject

function IngameMenu_FetchAndGenerateGroupMenuObject(flashStorageUtility : CScriptedFlashValueStorage, displayNamePrefix : string, groupDisplayName : string, rootFlashArray : CScriptedFlashArray, out optionParentArray : CScriptedFlashArray) : CScriptedFlashObject
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
displayNamePrefix : string
groupDisplayName : string
rootFlashArray : CScriptedFlashArray
out optionParentArray : CScriptedFlashArray
Returns:
CScriptedFlashObject
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_FillSubMenuOptionsList

function IngameMenu_FillSubMenuOptionsList(flashStorageUtility : CScriptedFlashValueStorage, groupID : int, groupName : name, groupRootObject : CScriptedFlashObject) : bool
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
groupID : int
groupName : name
groupRootObject : CScriptedFlashObject
Returns:
bool
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_AddDifficultyOption

function IngameMenu_AddDifficultyOption(flashStorageUtility : CScriptedFlashValueStorage, listToAddToo : CScriptedFlashArray) : void
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
listToAddToo : CScriptedFlashArray
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_AddGwentDifficultyOption

function IngameMenu_AddGwentDifficultyOption(flashStorageUtility : CScriptedFlashValueStorage, listToAddToo : CScriptedFlashArray) : void
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
listToAddToo : CScriptedFlashArray
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_ChangePresetValue

function IngameMenu_ChangePresetValue(groupId : name, targetPresetIndex : int, parentMenu : CR4IngameMenu) : void
Parameters:
groupId : name
targetPresetIndex : int
parentMenu : CR4IngameMenu
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_GatherOptionUpdatedValues

function IngameMenu_GatherOptionUpdatedValues(groupId : name, parentObject : CScriptedFlashObject, flashStorageUtility : CScriptedFlashValueStorage) : void
Parameters:
groupId : name
parentObject : CScriptedFlashObject
flashStorageUtility : CScriptedFlashValueStorage
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_GatherKeybindData

function IngameMenu_GatherKeybindData(parentArray : CScriptedFlashArray, flashStorageUtility : CScriptedFlashValueStorage) : void
Parameters:
parentArray : CScriptedFlashArray
flashStorageUtility : CScriptedFlashValueStorage
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_GetLocalizedKeybindName

function IngameMenu_GetLocalizedKeybindName(keybindName : name) : string
Parameters:
keybindName : name
Returns:
string
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_GetPCInputGroupIndex

function IngameMenu_GetPCInputGroupIndex() : int
Returns:
int
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_GetKeybindTagWithKeybindKey

function IngameMenu_GetKeybindTagWithKeybindKey(newKeybindValue : EInputKey) : name
Parameters:
newKeybindValue : EInputKey
Returns:
name
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

inGameMenu_LocalizeKeyString

function inGameMenu_LocalizeKeyString(key : string) : string
Parameters:
key : string
Returns:
string
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

inGameMenu_TryLocalize

function inGameMenu_TryLocalize(key : string) : string
Parameters:
key : string
Returns:
string
Path:
/game/gui/main_menu/ingamemenu/igmOptions.ws

IngameMenu_UpdateDLCScriptTags

function IngameMenu_UpdateDLCScriptTags()
Path:
/game/gui/main_menu/ingamemenu/igmUtilities.ws

IngameMenu_PopulateSaveDataForSlotType

function IngameMenu_PopulateSaveDataForSlotType(flashStorageUtility : CScriptedFlashValueStorage, saveType : int, parentObject : CScriptedFlashArray, allowEmptySlot : bool) : void
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
saveType : int
parentObject : CScriptedFlashArray
allowEmptySlot : bool
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmUtilities.ws

IngameMenu_PopulateImportSaveData

function IngameMenu_PopulateImportSaveData(flashStorageUtility : CScriptedFlashValueStorage, parentObject : CScriptedFlashArray) : void
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
parentObject : CScriptedFlashArray
Returns:
void
Path:
/game/gui/main_menu/ingamemenu/igmUtilities.ws

InGameMenu_CreateControllerData

function InGameMenu_CreateControllerData(flashStorageUtility : CScriptedFlashValueStorage) : CScriptedFlashArray
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
Returns:
CScriptedFlashArray
Path:
/game/gui/main_menu/ingamemenu/igmUtilities.ws

InGameMenu_CreateControllerDataCiri

function InGameMenu_CreateControllerDataCiri(flashStorageUtility : CScriptedFlashValueStorage) : CScriptedFlashArray
Parameters:
flashStorageUtility : CScriptedFlashValueStorage
Returns:
CScriptedFlashArray
Path:
/game/gui/main_menu/ingamemenu/igmUtilities.ws

AddCharacterHeader

function AddCharacterHeader(locKey : string, toArray : CScriptedFlashArray, flashMaster : CScriptedFlashValueStorage) : void
Parameters:
locKey : string
toArray : CScriptedFlashArray
flashMaster : CScriptedFlashValueStorage
Returns:
void
Path:
/game/gui/popups/CharacterStatsPopup.ws

AddCharacterStat

function AddCharacterStat(tag : string, varKey : name, locKey : string, iconTag : string, toArray : CScriptedFlashArray, flashMaster : CScriptedFlashValueStorage) : void
Parameters:
tag : string
varKey : name
locKey : string
iconTag : string
toArray : CScriptedFlashArray
flashMaster : CScriptedFlashValueStorage
Returns:
void
Path:
/game/gui/popups/CharacterStatsPopup.ws

AddCharacterStatSigns

function AddCharacterStatSigns(tag : string, varKey : name, locKey : string, iconTag : string, toArray : CScriptedFlashArray, flashMaster : CScriptedFlashValueStorage) : void
Parameters:
tag : string
varKey : name
locKey : string
iconTag : string
toArray : CScriptedFlashArray
flashMaster : CScriptedFlashValueStorage
Returns:
void
Path:
/game/gui/popups/CharacterStatsPopup.ws

AddCharacterStatF

function AddCharacterStatF(tag : string, varKey : name, locKey : string, iconTag : string, toArray : CScriptedFlashArray, flashMaster : CScriptedFlashValueStorage) : void
Parameters:
tag : string
varKey : name
locKey : string
iconTag : string
toArray : CScriptedFlashArray
flashMaster : CScriptedFlashValueStorage
Returns:
void
Path:
/game/gui/popups/CharacterStatsPopup.ws

AddCharacterStatU

function AddCharacterStatU(tag : string, varKey : name, locKey : string, iconTag : string, toArray : CScriptedFlashArray, flashMaster : CScriptedFlashValueStorage) : void
Parameters:
tag : string
varKey : name
locKey : string
iconTag : string
toArray : CScriptedFlashArray
flashMaster : CScriptedFlashValueStorage
Returns:
void
Path:
/game/gui/popups/CharacterStatsPopup.ws

AddCharacterStatU2

function AddCharacterStatU2(tag : string, varKey : name, locKey : string, iconTag : string, toArray : CScriptedFlashArray, flashMaster : CScriptedFlashValueStorage) : void
Parameters:
tag : string
varKey : name
locKey : string
iconTag : string
toArray : CScriptedFlashArray
flashMaster : CScriptedFlashValueStorage
Returns:
void
Path:
/game/gui/popups/CharacterStatsPopup.ws

GetItemRarityDescriptionFromInt

function GetItemRarityDescriptionFromInt(quality : int) : string
Parameters:
quality : int
Returns:
string
Path:
/game/gui/_old/components/guiPlayerInventoryComponent.ws

CalculateStatsComparance

function CalculateStatsComparance(itemStats : array<SAttributeTooltip>, compareItemStats : array<SAttributeTooltip>, rootGFxObject : CScriptedFlashObject, out compResult : CScriptedFlashArray, optional ignorePrimStat : bool, optional dontCompare : bool, optional extendedData : bool)
Parameters:
itemStats : array<SAttributeTooltip>
compareItemStats : array<SAttributeTooltip>
rootGFxObject : CScriptedFlashObject
out compResult : CScriptedFlashArray
optional ignorePrimStat : bool
optional dontCompare : bool
optional extendedData : bool
Path:
/game/gui/_old/components/guiTooltipComponent.ws

GetItemAttributeComparison

function GetItemAttributeComparison(attrName : string, attrValue : float, equipedItemStats : array<SAttributeTooltip>) : string
Parameters:
attrName : string
attrValue : float
equipedItemStats : array<SAttributeTooltip>
Returns:
string
Path:
/game/gui/_old/components/guiTooltipComponent.ws

GetStatDiff

function GetStatDiff(a : float, b : float) : string
Parameters:
a : float
b : float
Returns:
string
Path:
/game/gui/_old/components/guiTooltipComponent.ws

CalculateCriticalStateTypePriority

function CalculateCriticalStateTypePriority(type : ECriticalStateType) : int
Parameters:
type : ECriticalStateType
Returns:
int
Path:
/game/npc/npcTypes.ws

BehGraphIntToName

function BehGraphIntToName(graphEnum : int) : name
Parameters:
graphEnum : int
Returns:
name
Path:
/game/npc/npcTypes.ws

BehGraphEnumToName

function BehGraphEnumToName(graphEnum : EBehaviorGraph) : name
Parameters:
graphEnum : EBehaviorGraph
Returns:
name
Path:
/game/npc/npcTypes.ws

StaminaBoyInternal

function StaminaBoyInternal(on : bool)
Parameters:
on : bool
Path:
/game/player/playerCheats.ws

StaminaPonyInternal

function StaminaPonyInternal(on : bool)
Parameters:
on : bool
Path:
/game/player/playerCheats.ws

SkillNameToEnum

function SkillNameToEnum(n : name) : ESkill
Parameters:
n : name
Returns:
ESkill
Path:
/game/player/playerTypes.ws

SignEnumToSkillEnum

function SignEnumToSkillEnum(s : ESignType) : ESkill
Parameters:
s : ESignType
Returns:
ESkill
Path:
/game/player/playerTypes.ws

SkillEnumToName

function SkillEnumToName(s : ESkill) : name
Parameters:
s : ESkill
Returns:
name
Path:
/game/player/playerTypes.ws

SignNameToEnum

function SignNameToEnum(signName : name) : ESignType
Parameters:
signName : name
Returns:
ESignType
Path:
/game/player/playerTypes.ws

SignStringToEnum

function SignStringToEnum(signString : string) : ESignType
Parameters:
signString : string
Returns:
ESignType
Path:
/game/player/playerTypes.ws

SignEnumToString

function SignEnumToString(signType : ESignType) : string
Parameters:
signType : ESignType
Returns:
string
Path:
/game/player/playerTypes.ws

IsBufferActionAttackAction

function IsBufferActionAttackAction(a : EBufferActionType) : bool
Parameters:
a : EBufferActionType
Returns:
bool
Path:
/game/player/playerTypes.ws

IsActionCombat

function IsActionCombat(action : EInputActionBlock) : bool
Parameters:
action : EInputActionBlock
Returns:
bool
Path:
/game/player/playerTypes.ws

GetWitcherPlayer

function GetWitcherPlayer() : W3PlayerWitcher
Returns:
W3PlayerWitcher
Path:
/game/player/playerWitcher.ws

LogSkating

function LogSkating(str : string)
Parameters:
str : string
Path:
/game/player/states/skating.ws

OpenContainerQuest

latent function OpenContainerQuest(npcTag : CName, optional tagsFilter : array<name>)
Parameters:
npcTag : CName
optional tagsFilter : array<name>
Path:
/game/quests/quest_function.ws

QuestHelper_BlockGameplayFunctionality

latent function QuestHelper_BlockGameplayFunctionality(act : EInputActionBlock, sourceName : name, lock : bool)
Parameters:
act : EInputActionBlock
sourceName : name
lock : bool
Path:
/game/quests/quest_function.ws

OutOfMemoryHack_Level0Items

function OutOfMemoryHack_Level0Items(out items : array<SGwentIngDef>)
Parameters:
out items : array<SGwentIngDef>
Path:
/game/quests/quest_function.ws

OutOfMemoryHack_Level10Items

function OutOfMemoryHack_Level10Items(out items : array<SGwentIngDef>)
Parameters:
out items : array<SGwentIngDef>
Path:
/game/quests/quest_function.ws

AddRandomCraftingComponentsGwintQuest

function AddRandomCraftingComponentsGwintQuest(merchantTag : name)
Parameters:
merchantTag : name
Path:
/game/quests/quest_function.ws

ConvertLanguageNameToEnum

function ConvertLanguageNameToEnum(languageName : string) : ECheckedLanguage
Parameters:
languageName : string
Returns:
ECheckedLanguage
Path:
/game/quests/conditions/chosenLanguageCondition.ws

TutorialScript2

function TutorialScript2(scriptName : name, tutorialMessageName : name)
Parameters:
scriptName : name
tutorialMessageName : name
Path:
/game/quests/functions/tutorial.ws

TutorialScript3

function TutorialScript3(scriptName : name, tutorialMessageName : name)
Parameters:
scriptName : name
tutorialMessageName : name
Path:
/game/quests/functions/tutorial.ws

TutorialMessagesEnable

function TutorialMessagesEnable(optional enable : bool)
Parameters:
optional enable : bool
Path:
/game/quests/functions/tutorial.ws

ShouldProcessTutorial

function ShouldProcessTutorial(scriptName : name) : bool
Parameters:
scriptName : name
Returns:
bool
Path:
/game/quests/functions/tutorial.ws

ShouldProcessInteractionTutorials

function ShouldProcessInteractionTutorials() : bool
Returns:
bool
Path:
/game/quests/functions/tutorial.ws

GetCiriPlayer

function GetCiriPlayer() : W3ReplacerCiri
Returns:
W3ReplacerCiri
Path:
/game/replacers/ciri.ws

GetReplacerPlayer

function GetReplacerPlayer() : W3Replacer
Returns:
W3Replacer
Path:
/game/replacers/replacer.ws

GetDialogActionIcons

function GetDialogActionIcons(flag : int) : array<EDialogActionIcon>
Parameters:
flag : int
Returns:
array<EDialogActionIcon>
Path:
/game/scenes/choiceActions.ws

DoStorySceneGameplayAction

function DoStorySceneGameplayAction(out callbackInfo : SStorySceneGameplayActionCallbackInfo)
Parameters:
out callbackInfo : SStorySceneGameplayActionCallbackInfo
Path:
/game/scenes/scenePlayer.ws

OpenInventoryForScene

latent function OpenInventoryForScene(containerNPC : CGameplayEntity, filterTags : array<name>)
Parameters:
containerNPC : CGameplayEntity
filterTags : array<name>
Path:
/game/scenes/scene_functions.ws

OpenGUIPanelForScene

latent function OpenGUIPanelForScene(menu : name, backgroundMenu : name, shopOwner : CGameplayEntity, optional menuInitData : W3MenuInitData)
Parameters:
menu : name
backgroundMenu : name
shopOwner : CGameplayEntity
optional menuInitData : W3MenuInitData
Path:
/game/scenes/scene_functions.ws

DampAngleFloatSpring

function DampAngleFloatSpring(out current : float, out velocity : float, dest : float, smoothTime : float, dt : float)
Parameters:
out current : float
out velocity : float
dest : float
smoothTime : float
dt : float
Path:
/game/utils/dampers/angleSpringDamp.ws

DampVectorConst

function DampVectorConst(out currValue, destValue : Vector, deltaValue, dt : float)
Parameters:
out currValue
destValue : Vector
deltaValue
dt : float
Path:
/game/utils/dampers/constDamper.ws

DampFloatSpring

function DampFloatSpring(out current : float, out velocity : float, dest : float, smoothTime : float, dt : float)
Parameters:
out current : float
out velocity : float
dest : float
smoothTime : float
dt : float
Path:
/game/utils/dampers/springDamp.ws

DampVectorSpring

function DampVectorSpring(out current : Vector, out velocity : Vector, dest : Vector, smoothTime : float, dt : float)
Parameters:
out current : Vector
out velocity : Vector
dest : Vector
smoothTime : float
dt : float
Path:
/game/utils/dampers/springDamp.ws

EulerMult

function EulerMult(angle : EulerAngles, value : float) : EulerAngles
Parameters:
angle : EulerAngles
value : float
Returns:
EulerAngles
Path:
/game/utils/dampers/springDamp.ws

EulerNeg

function EulerNeg(angle1 : EulerAngles, angle2 : EulerAngles) : EulerAngles
Parameters:
angle1 : EulerAngles
angle2 : EulerAngles
Returns:
EulerAngles
Path:
/game/utils/dampers/springDamp.ws

EulerAdd

function EulerAdd(angle1 : EulerAngles, angle2 : EulerAngles) : EulerAngles
Parameters:
angle1 : EulerAngles
angle2 : EulerAngles
Returns:
EulerAngles
Path:
/game/utils/dampers/springDamp.ws
Community content is available under CC BY-SA 3.0 unless otherwise noted.
More Fandoms

Fan Feed

More Witcher Wiki