|
KeyPoint Class Reference: by BlackSway
Last Updated
6 July, 2002
|
| |
| Introduction |
|
This is a descriptive list of the KeyPoint actor class within the
unreal script class structure. It is intended as a reference for
level editors and is not intended for programmers or mod developers.
However they may find it of some use, you never know.
The KeyPoint classes are used to mark specific places in a level
and provide further actions or properties to that place.
Some of these classes are of no use to level editors at all, and
will be covered very lightly. For some others, only the parent classes
will be dealt with and these features should apply to all their
children classes.
|
| |
| Quick Guide to acronymns and icons |
|
UT: Unreal Tournament only
AmbientSound | BlockAll
| BlockMonster | BlockPlayer
| DynamicAmbientSound | EarthQuake
| CH_Earthquake | InterpolationPoint
| LocationID | MakeNaliFriendly
| ObjectPath | PathPoint
| RockSlide | SpectatorCam
| QuakeCam | ThingFactory
| CreatureFactory | ThrowStuff
| TriggeredAmbientSound
GuardPoint | HoldSpot
OEMEnd
|
| |
AmbientSound:  |
| Sits their and emits a sound. No different
from placing any other actor in a level and setting its ambient sound |
| [^TOP] |
| |
| BlockAll: |
|
Simply put, this actor blocks all actors
(in much the same way as a wall does, but it cannot be seem when
playing.) Used by Epic stop bots try to get to unreachable places,
(e.g. through floor grates etc.)
These three keypoints use the following
properties to affect different types of objects.
bCollideActors:
Blocks projectiles
etc.
bBlockActors:
Blocks monsters
bBlockPlayers:
Blocks players
and bots
|
| [^TOP] |
| |
| BlockMonster: |
| BlockMonsters prevents monsters from
passing, but allows players and projectiles to cross. |
| [^TOP] |
| |
| BlockPlayer: |
| BlockPlayers prevents players from passing,
but allows monsters and projectiles to cross. |
| [^TOP] |
| |
| DynamicAmbientSound:
|
|
Randomlly plays one of a number of
different sounds. You can specify a probability the likelyhood of
a sound playing next 'round'.
Every n seconds, where n
is a random time between minReCheckTime and maxReCheckTime it will
check the playProbability, and if true then it will play one of
however many sounds you have specified.
|
|
bInitiallyOn:
Will play a
random sound on startup if true
Sounds[16]:
The sounds
to play
playProbability:
The probability
of playing a sound each 'round' (between 0 and 1, default is 0.6)
minReCheckTime:
The minimum
time between 'rounds'
maxReCheckTime:
The maximum
time between 'rounds'
bDontRepeat:
Never play
a sound twice in a row.
|
| [^TOP] |
| |
| EarthQuake: |
|
This will shake and throw players on
a level. This makes their HUD shake and can optionally move tha
player about as well.
|
|
magnitude:
The amount
to shake the player by, default is 2000
duration:
duration for
earthquake, default is 5 seconds
radius:
radius for
those players to be affected by the earthquake
bThrowPlayer:
Does the earthquake
move the player as well (throws them from side to side etc.)
|
| [^TOP] |
| |
| CH_Earthquake: UT: |
| Much the same as EarthQuake, but uses
a more efficient algorithm for checking to see if players are affects,
and will also throw pushable objects (barrels etc) around if bThrowStuff
is set to true. This is the only parameter that is different from
the above EarthQuake. |
| [^TOP] |
| |
GuardPoint:  |
| This is created when a monster is set
to guard a particular object. You set 'Orders' to "Guarding" and set
the 'OrderTag' to the tag of the object to be guarded. You shouldn't
place this in your levels. |
| [^TOP] |
| |
| HoldSpot: UT: |
| This is created when you issue the 'Hold'
command to bots in Unreal Tournament. You shouldn't got placing this
in your levels. |
| [^TOP] |
| |
| InterpolationPoint:
|
|
Ooh, complicated. Put basically they
are used for creating a path for a kind of movie fly-by effect.
They are used in the start-game castle fly-by at the start of Unreal
and the start-game intro in Unreal Tournament. But enough about
that, lets get down and dirty…
First thing to do is create a SpecialEvent
with initial state "PlayerPath". Set its Event to "Int1" for example.
Next create a number of InterpolationPoint's with tags of "Int1"
and set their Position values from 0 to the whatever. Set one of
the InterpolationPoint's bEndPath to true (presumably the last one!).
Then when the SpecialEvent is triggered the player should get a
fly-by rush. I really must test this!
Half the other properties aren't used
anywhere, so I don't know why they are there. Who knows.
|
| [^TOP] |
| |
| LocationID: |
|
Marks and names an area in a Zone.
These can be used when you want area descriptions to appear (say
in team matches in the chat screen) bu don't want to split you level
up into little zones.
Simply place the LocationID in your
level, set its Radius and the LocationName.
|
| [^TOP] |
| |
| MakeNaliFriendly:
|
|
Should really be in the 'Triggers'
section, but hey, who am I to complain.
When triggered makes all Nali in the
level friendly to the player (even if you've blown their friends
to little bits of Nali Chunks!)
|
| [^TOP] |
| |
| ObjectPath: |
|
Allows you to move an actor. Set the
tag of the actor to be moved to the same as the PathActorTag property.
Then place a number of PathPoints with the same tag as the ObjectPath
actor. These define the path to be taken by the actor object. Then
when the ObjectPath is triggered the object is moved to the first
PathPoint and then allong the path (using lots of complicated curving
algorithms that I couldn't be arsed to work out).
N.B Important! You need to
set Advanced->bStatic to false else the ObjectPath will not work!
|
|
PathActorTag:
Tag of the
actor to be moved
bAlterPitch:
Does the pitch
of the actor change as it moves along
bAlterYaw:
Does the yaw
of the actor change as it moves along
bAlterRoll:
Does the roll
of the actor change as it moves along. Use all three for a kind
of airplane effect
RAdjust:
Adjust the
rotation of the actor as it moves along.
|
| [^TOP] |
| |
OEMEnd:  |
| Err, presumably used at the end of Unreal
somewhere. Don't have Unreal on this computer so I can't tell you. |
| [^TOP] |
| |
| PathPoint: |
|
See above ObjectPath for more details.
|
|
sequence_Number:
To order the path
points
curveSpeed:
how fast the
object must move at this point (affects shape of path, not really
speed)
speedU:
speed factor,
a value of 1 will travel through the segment in 1 second, 0 stop,
2 in 1/2 second, etc..
|
| [^TOP] |
| |
| RockSlide: |
|
This would appear to create a rock
slide, hey, what will these epic guys think of next…
It spawns rocks within the CubeDimensions
of the RockSlides location you specify. It will continue till TimeLength
is reached or forever if TimeLimit is false.
As noted in the code, the rocks aren't
currently doing a lot, so let them fall a distance to do more damage.
|
|
CubeDimensions:
vector of the dimensions
of the space to create the rocks in.
TimeLimit:
if false will
continue for ever.
TimeLength:
the amount
of time till no more rocks are created from when it is triggered.
MinBetweenTime:
Minimum time
between rocks
MaxBetweenTime:
Maximum time
between rocks
MinScaleFactor:
Minimum scale
factor of the rocks (1 is normal etc)
MaxScaleFactor:
Maximum scale
factor of the rocks
InitialDirection:
The initial
rotation of the rock
minInitialSpeed:
the minimum
initial speed
maxInitialSpeed:
the maximum
initial speed
|
| [^TOP] |
| |
| SpectatorCam: UT: |
|
Simply put, this is a camera position which is placed in the game.
It is used if someone starts the game as a spectator, and also for
those end of game sequences in the Assault maps.
|
|
|
|
bSkipView:
If being used by player as a spectator, then
should they skip this camera.
FadeOutTime:
The time to fade when used as a end game camera.
|
| [^TOP] |
| |
| QuakeCam: UT: |
|
Identical to the SpectatorCam, except is also shakes the view of
the player
|
|
|
|
magnitude:
The magnitude of the shakes, defaults to 2000.
|
| [^TOP] |
| |
| ThingFactory: |
| Simply put the thing factory creates things. You place a ThingFactory
somewhere on your map, and a number of SpawnPoints (See NavigationPoint
Ref). Set up the factory with a prototype and the maxitems and
capacity for the factory. When the ThingFactory is triggered it should
start spawning things at the various SpawnPoints. |
|
prototype:
The class of the thing to spawn.
maxitems:
The maximum number of current objects allowed
in existence at once.
capacity:
The total number of objects this factory will
spawn in its lifetime.
interval:
interval in seconds between spawning, altered
by timeDistribution below
itemtag:
A tag to apply to any spawned objects, defaults
to 'MadeInUSA', those crazie Epic guys!
bFalling:
Whether the object created is initially set
into a falling physical state.
timeDistribution:
One of: Constant, time between each creation
is the same; Uniform, time between spawnings is between 0 and 2*interval;
Gaussian, some kind of ultra random range between 0 and 2* interval.
bOnlyPlayerTouched:
If triggered by touch (determined largely by
where you put the damn thing) only trigger from the player, not
monsters.
bConvert:
If true, then only spawn at a spawnpoint which
the player cannot see, if players can see them all then no object
is spawned.
bStoppable:
Stops spawning if the thing factory is untouched
(i.e. the player walks away)
|
| [^TOP] |
| |
| CreatureFactory: |
|
The same as ThingFactory above, but allows you to assign orders
to creatures that are spawned.
See Unreal
AI reference for patrol points and guard points for the purpose
of Orders etc.
|
|
Orders:
See above reference, but you may wish to for
example set the Orders property to Ambush, set the OrderTag to the
value of a AmbushPoint and then the creature will move to this AmbushPoint
upon creation.
OrderTag:
Used in conjunction with the Orders value above.
AlarmTag:
The tag of the AlarmPoint the creature should
attempt to reach when they see the player.
AddedCoopCapacity:
If the game type is CoopGame then add the capacity
of the creature factory is increased by this amount.
|
| [^TOP] |
| |
| ThrowStuff: |
| This will throw all pushable objects in a given or random direction. |
|
throwVect:
The velocity vector to throw the objects, or
used as the basis for the random direction if bRandomize is true.
bRandomize:
If true then the above throwVect is randomized.
The vertical direction is always maintained (i.e. if throwVect is
in a upwardly direction then so will the new random vector)
interval:
Time between throws.
Numthrows:
The number of throws. Defaults to 1.
|
| [^TOP] |
| |
| TriggeredAmbientSound:
|
|
While on this will replay a sound using the values set below.
This has 2 states, either TriggerToggled or OnWhileTriggered.
If TriggerToggled then each time it is triggered it is turned either
on or off.
If OnWhileTriggered then it will be on while triggered and off
while not triggered.
|
|
bInitiallyOn:
If true then the sound is played as soon as
the level starts.
AmbSound:
The sound to play.
rePlayTime:
The minimum time between replays of the sound.
rePlayVariance:
A random variation of this size to when the
sound replays.
bPlayOnceOnly:
Should the sound be only played once. Doesn't
could the first play if bInitiallyOn is true.
|
| [^TOP] |
| |
| WayBeacon |
|
OK, these don't seem to be used much as far as I can tell. If anyone
knows then please let me know.
There are references in 2 functions in PlayerPawn.uc and also in
Bots.uc
I think they are used for debugging, to check where bots are heading
(it is spawned as a little unreal lamp).
|
| [^TOP] |
| |
