package.fish.blocks_and_bullets

Score affected by kills, deaths and objectives.

Increment a stat. Also sends the increment to sbox stat service API.

Set a stat. Also sends the increment to sbox stat service API.

Get the value of a stat.

Get the total stat HashCode.

Create a bot client

Taken from https://steamladder.com/ladder/steam_age/

Clears the scene of all non-essential components and objects.

Which maps have been voted for.

Maps available to vote for.

The number of votes a map has. A table of every map ID and their votes. If you've voted for a map.

Allows maps to override suggested player counts for a specific mode.
Uses the default, map-specific ideal player count otherwise.

All valid maps except templates. If the map is valid and contains the string within its file name or display name.

The method to call when setting the map through voting or commands.
Searches each map definition for the specified string.

A (sub)string to find the map by its file name.

Allows the host or a developer to set the map.

A table of gear indexed by string ID.

Set the current state, only host can do this.

Set the current state using a TypeDescription(which hopefully works).

TypeLibary info. Attempt to load Setup state upon type creation failure?

Called when starting a new lobby from the menu.

Set the state from a flag.

Set the gamemode to a random one from the specified map's supported modes.

A collection of clients that are guaranteed to have a valid connection.
This is ideal for UI and gamemode logic.
This does not include Bots, use for that.

Returns including all bots

Are we without a pawn or not in free mode as a spectator?

Are we a valid spectator in free mode?

Useful when calling .
does not allow awaiting the end of a frame.

An impassable wall that can be shot through.

Sets the bounds of the border given a BBox and normalizes it.

Should the decal fade after a period?

The length of time before automatically fading the decal.

How long it takes for the decal to fade.

Should the GameObject be destroyed upon fully fading?

Is it actively fading?

Additional damage dealt upon direct impact.

Scale of force added by damage to the attacker.

Scale of vertical force from explosive jumping.

Dampens downward force by this amount if falling.

Scale of force added by damage to enemy players.

Scale of vertical force added to enemies.

Restores less than full health.

Restores full amount of default health.

Gives a grenade.

Gives rockets.

Boomstick ammo.

Increases movement and attack speed.

Increases damage.

Highlights players through walls.

How to represent the model in the editor.

Spawns an object under certain conditions, such as pre-round and for certain gamemodes.

How to represent the object only while in the editor.

The prefab to spawn upon the condition(s).

If the prefab contains a component with it will set its team.

Remove the previous object when a new one spawns?

Remove the object at a specific stage?

When to remove the object.

When to spawn the object.

Restrict spawning to certain gamemodes?

Which gamemodes are allowed to spawn the object.

Should the spawned object be networked?

How to network the spawned object.

Network ownership transfer flag of the spawned object.

Who it goes to when the spawned object's owner disconnects.

If the object is meant for the current gamemode.

Creates lines depending on speed.

When lines start being created and when they are destroyed.

How often lines are created depending on speed.

The lifetime of lines depending on speed.

How long lines are depending on speed.

Should the force be applied immediately? If not, then over time.

Amount of instantaneous force applied.

Upward speed is set to at least this length before the boost. (-1 disables this)

Vertical velocity must be at least this amount before applying velocity.

The maximum amount of health

Allows footsteps to be softer the slower you move.

Modify the wish velocity before it's fed to the controller

Modify the velocity and position after it went through the controller and before it gets applied

True when the controller is currently climbing blocks as if they were a ramp

The maximum amount of health

The amount of health, is clamped to 0 and .

Current health fraction of the max health 0 to 1

When the unit's health is under 40% of the max health

View ray of this unit

null if this Unit is not a player

Is this unit a player

Currently alive?

Attempt to damage this unit

The final applied damage

Is this unit able to receive damage and additional modifiers before passing it off

Can this unit attack the victim

Process/modify the damage and relay the result to the attacking player.
You should always be calling this when a unit is damaged.

A player has damaged this unit. Send this to the attacker only.
Don't modify damage here! This is mainly to show hitmarkers etc.

Process health regeneration that happens after a delay from when you're last shot.

Get the hitbox of that limb

Get the world position of the limb

Get the world bounds of the limb

Delay between being hurt and when health restoration begins.

Frequency of health restoration after the delay.

The amount of health restored per interval.

The most amount of health that you can be healed to by default.

Time (unix) when the ban will expire

Ban a player from the lobby / local machine

Unban a player from the lobby / local machine

Components with this interface will not be destroyed when switching maps.

If the component should not be destroyed. If the GameObject should not be destroyed.

Destroys non-essential components on the object, and the object itself if it has no essential components.
This should be called on the main thread at the end of the frame to prevent potential errors.

If object was destroyed.

Check if we need to autofill the match with bots

Automatically add bots to the match until we reach the ideal amount of players

Add a bot to this match and automatically assign it to the team with the least players

Remove a bot from this match, picks one from the team with the most players

Get the bot's current objective

Get the map's bounds slightly shrunk

Get a random standable position inside of that bbox, return null if not found

Whether or not an event is objective related.

Something state-related happened.

Whether or not the specified event is objective related. A short description of an objective.

When this timer ends the next stage will begin.

The text that appears under the voting screen header.
This is synced in case the host changes.

Called for the host when entering this state.

Called for the host when leaving this state.

Called when the state is set to .

Called when the timer runs out post-round to either start a new round or start voting.

Set the active state to and carry over round info.

Extend the time remaining.

Called while the current stage is .

A list of components

If the modifier could be added.

Gets an active list of modifiers.

Spawn borders during prep and remove them after?
Custom border filters can override this setting.

The only capture points that should be enabled.

If the voxel at this position can be damaged.

Enables the capture points meant for this mode, disables all others.

The team/player score threshold for victory(unless it's zero or less).

Allows scoring and displaying of score.

The score a player gets for doing something.

The score value for an event of this mode.

If disabled: no team scoring, logic or selection.

If disabled: you cannot select a team.

If enabled: consolidates teams into one list while voting and in scoreboard.

Pre-summed team count cache.

Set the cache of team counts.

If the team is a valid choice.

The player is requesting a team.

Set the team directly without checks.
Can be used to perform effects upon switching.

If the local connection is the one hosting.

Called for the host when a client has connected.

Called for the host when a client has disconnected.

Called on the server when the player presses "GO" in the loadout screen.

Respawn players if they're trying to do so.

Respawn a player with loadout according to mode.

Called clientside to update other players.

Whether to allow grenade throwing and drawing them on the HUD. How many attacks per second this weapon is capable of, or null for default. The overall spread value of the player. Null for default max health, or an override. The speed the player should be moving at.

Prevents spawning unless you have a valid team.

Whether or not the player can spawn after choosing their loadout. If the player can automatically respawn.

Called clientside when the player spawns to set their position, before their loadout is given.

If the unit is allowed to attack with a specific gear.

Called by the local client when spawning their loadout.
See to override loadouts.

The player object calling this. Passed to bypass Sync'd var lag. The loadout sent from the host.

Called by the local player to process loadout.

Some modes may want to block loadouts in some cases.

If the client should be able to select a loadout

Allows altering or denying damage being dealt to a player.

Called clientside when a Player is receiving damage.

Called clientside when a Player has been damaged.

Called when a player is trying to attack someone.

If the damage is allowed.

Should be called after killing/hurting a player to determine if it was friendly fire.

Places an array of blocks of a color.

Damages a voxel from worldspace coordinates.

Damages a voxel from voxelspace coordinates.

Damage blocks in given radius.

Create an explosion at worldspace coordinates.

Create an explosion at voxelspace coordinates.

The of the currently loaded map, if any.
This used to be Sync( SyncFlags.FromHost )'d but it had a habit of being null for no good reason.

If false: hides this from menus and voting.

This map probably won't be nominated outside of this player range.

Allows overriding ideal player counts for modes on this map.

The default position of the spectator/voting camera.

The preview image. Resolution: 600x300px

A hack for wheatley so that indirect skybox lighting setting will stick.

Get voxels along 2 points.

Start point. End point. Max number of blocks to step. If true, only axis‑aligned steps are allowed. An IEnumerable of all voxels visited.

Gets the chunk position from a global voxel position.

Converts a world position to VoxelWorld position.

Converts VoxelWorld position to a world position.

Return the voxel's center top

Converts global VoxelWorld coordinates to local, also outs the chunk.

Converts local coordinates of a chunk to global coordinates in a VoxelWorld.

Gets chunk and voxel by offset relative to a chunk, or Chunks[0, 0, 0]

Sets voxel by offset, relative to the chunk parameter or Chunks[0, 0, 0]. Make sure to not track the change if it's something you're doing thousands of times.

Find spawn space from x and y coordinates, bottom to up.

Which chunks will get regenerated next NavGrid refresh

When the next NavGrid refresh will happen

Check if there's only air above

Traces a path from start to end and returns the last voxel that didn't hit.
Returns start if it instantly collided, Returns end if it didn't hit anything.

Traces a trajectory from start to end and returns the last voxel that didn't hit.
Returns start if it instantly collided

If there's a wall in the way, find the cell on the other side of it

The final desired position null if none found or there's no wall

Was this map loaded from a snapshot instead of the MapDefinition?

Toggles box gizmos on chunks with voxels in them.

Gets rid of all existing voxel maps.

Generates a collection of chunks.

Build a chunk.

Force this gamemode to be loaded OnStart.

The PrefabFile of the map to spawn. If the game scene should be (re)loaded.

Applies immediate force to child physics objects and fades models over time.

How long it takes for the gibs to begin fading.

How long it takes for gibs to fade after the delay.

The origin of force applied to gibs when spawned. Null values default to this object's position.

Gets or sets a lobby setting.

Sets the starting map. Supports exact ID and partial name matching. Will fail if it finds no/multiple results.

Finds a map prefab from its exact file name first, exact display name second.
If that fails it will search through all file and display names and return the results.

This will find a map to launch to. Particularly useful for dedicated servers.
By default it will choose randomly among the selected modes.
The "map" convar(settable at launch) can override this to a specific map.

The name to display in the server listing and ingame UI.

The "Message of The Day". In other words: text to greet users with.

For dedicated servers: when the server should next restart.

If the server should restart when the match ends or there are zero players.

Allows launching the server with autofill enabled/disabled. Example: +autofill false

If the lobby is configured to nominate this flag. If this nomination has an allowed mode.

This is the method you should call from menus to toggle if a gamemode is in rotation.

Sets the modes allowed to be nominated. Filters out invalid flags.

Allows launching the server into specific modes. Example: +modes "gib ffa"

Gets a random number of nominated maps with a limit as configured by lobby settings.
Double-checks that the nominations have a valid map and supported mode.

Add this to a static property on a to display it in a menu.
If added to a component with a it will associate it with its gamemode flag.

The internal id for commands/menus.

Lower values are first.

Gets all lobby setting information. Registers them if they haven't been already.

Get all settings for a particular gamemode flag.

The objective is in an exact location

The objective is an area

Exact position objective

Area position objective

Return the objective's position
The exact position if it's
A random position inside an area if it's

Checks for walkable bounds around the objective for anyone to patrol in its vicinity

Can this type of point(as configured) be connected to other points?

Resizes this voxel-sized child object to the dimensions of the voxel bounds.
The model should be the size of a voxel and its origin at its bottom center.

The map marker to tint according to the team.

The gamemode this capture point belongs to.
Gets disabled if it's not for this mode.

The team this capture point spawns as belonging to.

Should this point lock when captured by an enemy?

A point is added every (this) seconds.
I recommend you set it to the number of hills.
The current score limit is .

Points to lock/unlock when this one is captured.

Require these points to be captured before unlocking.

What to call this point in the feed/log. Examples: "Point A", "Middle Point"

How much progress is made per second with one person. (0 = none, 1 = instant)

How much progress is made with the most people. (0 = none, 1 = instant)

Capturing is fastest with this many team members.

The delay before/between giving a player score while capturing.

How many seconds it takes for progress to start reversing.

How quickly the point's progress resets if not fully capped. (1 = instant)

The sound to continuously play and adjust while capturing a point.

The starting to ending pitch of the looping sound when capturing a point.

The sound to play when a point is fully captured.

If there is more than one team touching this point.

The team that initially owns this point. They can't win by capturing this.

The team that is actively making progress towards capturing this point.

When a player will next receive score from capture progress.

Prevents the capture meter from rewinding if it's been this long since.

A fraction(0-1) of how much progress has been made towards a capture.

The amount of players on the same team actively capturing this point with no contest.

Prevents this point from being captured.

Allows a to capture a point.
This is ran frequently so don't let it get too expensive.

By default: if the player is valid, alive and has a team.

Received pickup request from a client.

When you kill an enemy.

When you get a headshot kill.

When you explode someone for all their health.

When you kill a flag carrier.

When you bring your flag back somehow.

When a kill is related to defending the point.

Awarded in intervals during capture.

Capture the Flag. Teams capture each other's flags.
Remember to setup the flag spawns.

Free for All. Players fight against eachother.

Team Deathmatch. Teams fight against each other.

Infection. Survivors fight against zombies.

Ludicrous Gibs. Mostly dudes railing each other.

Search 'n Destroy. Counter-strike, basically.

Fort Wars. Build yours, siege theirs.

King of The Hill. Fight for the point.

Snowball Fight. Gay tossers.

One in The Chamber. There's a chamber that holds one.

Gun Game. The game with the guns..

Tower of Babel. One flag that two teams try to capture.

Wave Survival. Defend yourself from waves of enemies.

Tug of War. Take enemy points while defending your own.

Assault. Overtake enemy capture points.

Only the gamemodes that are ready enough to play.

The default rotation of gamemodes for non-dedicated lobbies.
May contain modes that aren't ready to be played, but will be.

All gamemodes which may or may not be playable.

If the flag is registered and not hidden.

Tries to get an attribute's info. Registers all attributes if they haven't been yet.

The gamemode flag. The state's info: StateAttribute and TypeDescription.

Tries to get an attribute's ID. Registers all attributes if they haven't been yet.

The state object. The state's ID, or null. The gamemode flag. The state's ID, or null. The ID of the state. The name of the state. The ID of the state. The shortened name of the state. The ID of the state. The state's flag. The gamemode flag. The state's flag.

Add this to a State component to register it in menus and commands.

The internal id for commands/menus.

How to display it next to map name

Gamemode flag associated with this mode.

Recommended minimum players.

Recommended maximum players. ( 0 = no limit )

The image path(*.png) to display in the mode selection menu.

Lower values are first.

Hides it from menus.

Waiting period for players to spawn.

Pre-round. Scoring/damage is prevented.

When the round is actively being played.

The countdown before voting or a new round.

Lazy way of telling if something is a flag/spawner.

The time it takes after the round starts for zombies to get restless.

The delay before getting restless again after the difficulty is reset.

Zombies get powered up if they haven't killed someone after this time.

The last survivor gets bonuses.

Fraction(0-1) of pitch lerp.

Decrements the difficulty level, displaying a notice in chat.

Zombie health regenerated depending on difficulty. Zombie speed multiplier depending on difficulty.

A list of all remaining survivors.

A list of all undead.

Maximum distance to trace when trying to engage the hook.

Seconds of meter required before initiating another hook.

Minimum amount of slack allowed.

How quickly the hook is reeled in.

How quickly the hook is slacked.

Amount of inward force to apply when not intentionally slacking(per second).

Pull/elasticity cannot add speed after this threshold.

Scale of horizontal force to apply from swinging.

Gravity is reduced by this fraction of it.

Custom player damage falloff curve.

How much velocity is redirected by air strafing.

How much acceleration is gained by air strafing.

The amount you can move in the air, clamped by top/current speed.

Bunnyhopping and glows.

A team's flag capture point that does not spawn a flag itself.

The team this flag capture point belongs to.

Creates and stores a copy of state information relevant to the voting screen.

Make a hard copy of a NetDictionary without whitelist issues.

Was this player the best of their team?

Loads the currently specified, previously specified, or a random votable map.

Reset nominations when restarting a vote.

This enemy can be selected within these rounds.

The director's enemy spawning plan for a wave factors this cost when selecting which enemies to spawn.

If the ID is not null/whitespace, round range is configured and cost is greater than zero.

Provides data on an NPC including its which is used to spawn it.
The lets you collect all prefabs with this component.
Put this on the root of the object.. or else.

Enemies can be spawned during a wave within this range(horizontally).
A trace is made from the sky to the bottom to place the enemy.

Is this a spawn range for a boss-like monsta?

Positions an enemy at a location using its , destroying it upon failure.

Something players are meant to protect.

Resizes this voxel-sized child object to the dimensions of the voxel bounds.
The model should be the size of a voxel and its origin at its bottom center.

The 6 plane colliders to align with the voxel bounds.

A wave-based survival gamemode.

The director will not spawn more enemies at this active count.

Spawn enemies and end the round when done.

Add/apply the item to the player here.

Allows you to limit how much of something you can buy.

If true: players can buy stuff and respawn.

The current round number.
Rounds are comprised of a series of waves.

Only respawn players between waves.

The final round number.

Overrides timer logic whenever in for this mode.

The level of each weapon's upgrades per player.

The method to call for safely getting networked weapon data from this gamemode.

Networkable respresentation and handler of upgrade levels for whatever.

Information about an upgrade including its max level.

The object players are meant to protect. (only one is supported at a time)

Add this to a component for it to support team colors/ownership.

The display name. Can you select this team? Can this team choose a loadout?

Sometimes team colors don't look right on capture points for example.
This allows you to make them pop out more/less to solve that.

Get a random spawning position from this team

Combines all spawn bounds into a single one that encompasses them all

If the item is in the player's backpack (note not equipped!).

Added to the current time to affect current angle.

Used to set the spin offset when dropping a weapon.

The yaw this object should have at this point in time.

Create the relevant object and components for the dropped state.
This can be ran even if we're not dropped as they won't be enabled.

The loadout selection category.

The intended inventory slot.

Whether or not to play the thirdperson blocking animation(if supported for the hold type).

Allows this equipment to multiply player move speed.

Avoids checking for inputs and instead tried to attack

Attempts to reload

Allows you to modify/respond to damage while this gear is active.

The slot when picking a loadout.

No category. Can't be picked up or dropped normally.

Rifles mainly.

Shotgun and pistol(s).

The shovel.

The slot where building blocks typically go.

Grenades, mines, etc.

Power weapons.

Something.

Something else.

Something else entirely.

Is the weapon being forced to reload before firing again?

If true: weapon cannot fire and requires an animation queue.

Does this weapon drop when switched away from?

Does this weapon require pumping to attack? Also allows immediately interrupt reloading.

Should the weapon be forced to play a reload animation to fire again?

Should reloading not actually provide additional ammo?

Are you required to aim before shooting?

Velocity impulse added per shot in the opposite direction.

Should the crosshair be hidden while sighted?

Should pips be used? If not, simply show ammo count and max ammo.

What text should be displayed as the ammo type?

Should this weapon display image pips on the ammo counter?

On the HUD, how many bullets should count as one?

On the HUD, how wide should the ammo pips be?

The amount of damage this weapon deals.

The minimum and maximum ranges used to reduce damage over range.

The maximum range that the bullet trace will reach.

The multiplier of damage done to blocks/voxels.

Max ammunition this weapon can have.

The number of shots this weapon fires per attack.

Times this weapon can be fired per second.

What context should the input be called in?

The movement speed scale while sighting.

The base spread while sighted.

The base spread while not sighted.

How much dynamic spread is added from attacking while sighted.

How much dynamic spread is added while attacking from the hip.

The limit of dynamically added spread.

How quickly dynamic spread is reset.

How much spread is added from jumping.

The base spread plus current dynamic spread value.

Base spread from if you're sighted or not.

The current value of dynamically added spread.

The starting value of when we last had spread.

Used to determine how long will remain.

The projectile prefab to spawn when attacking with this weapon.
A null value means bullets are fired instead.

The length of velocity to set on the projectile prefab when first spawned.

The distance to initially project the prefab when spawned.

Lower the Z by this amount when spawning.

Is this weapon able to attack yet

Shoot this weapon

Fire a single projectile

A ray randomly along on the outside of a cone.

All valid block colors.

Automatically attack players in front while dashing?

The maximum amount of time you can dash.

Dash time gained by charging(per second).

Multiplier of dashing speed after dash has stopped.

Minimum amount of charge required to

Prevents both charging up and dashing.

Immediately stop what the sword is doing. Should not affect cooldowns.

Spawns a weapon and respawns it when it's destroyed.

The weapon prefab to assign to a new DroppedWeapon upon creation.

The name to display in the scene editor.

The minimum delay between respawns.

Weapon spawns with this ammo initially.

The amount of force to apply each zap.

Maximum distance to trace the lightning.

Damage dealt each interval.

Trace every frame but delay next damage by this(in seconds).

The color of the lightning beam.

The width of the lightning beam.

The delay between constantly recharging(after the firing cooldown).

The delay after firing that recharging begins.

If there's a loop sound playing it'll end it and play the wind down sound.

Whether the minigun is revving up or not.

How revved up the minigun is.

The spin speed to add when revving up(per second).

The spin speed to subtract when not revving(per second).

The limit of how fast the barrel can spin.

The minimum spin speed required before allowing an attack.

Minimum upwards velocity upon boost.

The scale of horizontal speed upon boosting.

Both the max charge amount and time it takes to fully charge.

How much each shot reduces the amount of charge.

Delay between firing shots during a charged burst attack.

Get the launch direction for the grenade to land

You always have two trajectories, pick the one that will reach the target or gets the closest

Trace a parabola

The hit position or where it's near the target

Attempts to , will instantly exit if no available grenades or valid trajectories or not within range

The position to throw the grenade, set null for it to follow the

Throw a grenade at the target

The position to throw the grenade, set null for it to follow the

Where the gamemode is currently telling the bot to go

is not null

The bot is close to the objective or has no objective to reach

Returns the gamemode dictated objective position, null if none found

Calculate and navigate to the current gamemode objective

Which gamemodes this bot can be spawned in

From 0 to 1, how strong this bot is

Selects the best equipped weapon based on the distance provided

Create and spawn a new bot in this game

Automatically aim towards the target

Which limb to aim at the target

Custom to tweak yourself

Aiming is like a spring that attaches the cursor to the target
The strenght dictates how fast the cursor moves
If you have high strenght but low you'll overshoot most of the times

Aiming is like a spring that attaches the cursor to the target
The damping dictates how easy the cursor stays on target
If you have low damping but high you'll overshoot most of the times

How far ahead it predicts the target's movement to shoot at the correct position rather than lagging behind

How small the target hitbox's bounds before we try attacking when intersected

How steady the aim is, the lower means more noise gets applied

How much the aiming matches the perfect aim, 0 = No interpolation, 1 = Full interpolation

Force the NPC to aim a certain direction, null if not

Where the NPC is trying to aim towards

Is the target under the npc's crosshair

Is the target within grenade distance

How fast the NPC reacts to events like being damaged

Called when the NPC gets damaged and provides the

When damaged, the receives the damaged message and can use to see who dealt the damage

Called when the NPC gets killed and provides the

When damaged, the receives the killed message and can use to see who killed it

Called when the NPC finds a and provides the of the target

When a target is found, the receives the found_target message

Called when the NPC loses the and provides the of the lost target

When the target is lost, the receives the lost_target message

The state machine that is able to receive messages

The last dealt to this NPC

The this NPC is currently targetting

Is the target almost dead

Are we almost dead

Send a message to this NPC's state machine

Called when the target has changed

Time passed since the target was last changed

Find and lose a automatically

How far they can see in front of them to find targets

How far they can follow target before losing sight

How often it looks for a target and if they lost the current one (Seconds)

How much around them they can see

How many seconds pass before the target is forgotten about

Aspect ratio for the detection height. 1 is vision as tall as it's wide, 0.5 is roughly a 16:9 monitor aspect ratio

The target is not in our target of sight anymore

Time passed since we had a line of sight with the target

Where the target was last spotted at

Handles finding a target within vision distance and angle
Also handles losing the target when they're further than the detection distance

Returns true if this npc has line of sight with the target

Returns true if the target is within the NPC's

Manually handle movement outside of this component, such as player bots. The component will still calculate the WishDirection

How fast the NPC moves when running, usually when they're running towards a target

How fast the NPC moves when running, usually when in idle

Build a custom to use for this NPC's navigation

Switch to run speed instead of walk speed

Which speed the NPC should be moving at

The path our NPC is currently following

How many seconds before it checks if the path is being followed or the target position changed

Provides the cancellation token source used while generating

The latest node that has been crossed in

The next node that needs to be crossed in

The final node in

Does the NPC have a path and has it arrived its destination

A 3D line from to

How far the NPC is from

The direction to follow if you want to reach

is valid and we're currently following the path towards them

Have we succesfully reached our destination yet

Force the NPC to stop but don't cancel the path

Check if there's voxels blocking the path

Rotates the towards the path the NPC is traversing

Rotates the towards the

When was the last time this NPC moved? Usually a sign that something went wrong with pathfinding

Cancel the current navigation and stop the npc

Navigate towards the and update the target position over time

How far away from the target it will stay Should it predict where the target will end up based on their velocity

Move from point to point inside an area and look around

Just move away from that position

Navigate towards the and update the target position over time

True if it found a cover

Walk in an orbit around a point

Turn another way if the line of sight is broken Move away from the point if it gets closer

around the

Turn another way if the line of sight is broken Move away from the point if it gets closer

Is there uninterrupted line of sight between the start and end

Where the attacks come from and where to calculate look angle

How far this NPC can attack for

The damage dealt

How many seconds before this npc can attack again

How big the trace radius is for the default attack

If this is defined will call this instead of the default

The current target is valid, alive, and active

Return the while taking into account the NPC's width and the base voxel unit

The current target is valid and within striking distance

The distance between this and the target which would guarantee is within striking range

The closest position between the target which ensures

Find the voxel this npc is on

to the

Get a random position around the NPC

Find the nearest cover

Where the danger is coming from Minimum voxels of vertical cover to be safe Minimum voxels of horizontal cover to be safe Maximum distance to look for

Blocks 'n Bullets pawn.

Manage whether or not certain components should be enabled.
This is largely a patch for issues with null ownership at .

The amount of grenades this player has.

The time this player has been cooking a grenade.

The current gear being held.

Give a GameObject as gear to a player.

Drop the gear and remove the slot it was in.

If it was held and thus removed.

The amount of health this player has, is clamped to 0 and .

Prevents auto-respawn spam on the host side.

Is this player currently alive?

Respawn this player, reset health and transforms.

Force the player to die.

All of the gear this player is holding.

A list of the player's gear.

A table of gear in each slot.

Allows footsteps to be softer the slower you move.

True when the controller is currently climbing blocks as if they were a ramp

View ray of this player.

Makes absolutely sure that this Player pawn is fully up to date.

If the Client has a valid and fully network synchronized Player pawn defined.

Prevents rendering if dead and gibbed.

The "source".

The "now".

A loadout that the host thinks the player should have.
Solves issues with RPCs being faster than Sync'd vars such as .

The team that the server knows we have, but we might now know yet.

A list of gear to give the player.

If true: player will deploy their configured loadout.

Trigger custom logic using string tags.

Gives player their preferred loadout.

Allows default/team-specific gear.

Gives custom gear.

A gear slot-aligned container/manager.
Gear can be fit automatically into its intended slot, or any slot manually.

The next/previous gear.

Purge our inventory of any invalid values.

Reset inventory, destroying all gear in the process.

The first instance of a gear of this type, or null.

Get the slot the gear is currently in.
Might not be the same as its intended slot.

Try to give the player a gear from its prefab dictionary ID.

Equip a gear. Slot is automatically set to the gear's default slot if not defined.

The thing. If null: Deploy the gear once equipped? If false: destroys the equipment. If there was something in the slot(now destroyed).

Is this spectator following a valid target?

Sensitivity of the mouse wheel when used to change the distance.
Can be negative to invert the mouse wheel direction, or zero to disable the mouse wheel altogether.

How quickly scrolling is smoothed towards its intended distance.
If zero or less: disable smoothing altogether.

Tags of objects that will obstruct the camera view.

If we should do firstperson rendering stuff.

How quickly to transition between modes.

The smoothness of mode transition speed. Slows it down effectively.

The local position and rotation relative to the pawn's origin.

The previous relative position and rotation to transition from.

The previous world position to transition from(optional).

Begins a transition given the current position of this view.

Instantly ends the transition. Might cause visible snapping if done midway!

Sets the transform safely using with transition support.

Strings for . Makes it easy to add new extensions to existing properties.

Given a string (steam id or username) returns a connection

Connection or null

Unassigned/misc.

Fell into nothing.

Fell from a height.

Hit by physics.

Your fat ass.

The Lightning Gun.

Teleport kill.

Inflicted by suicide commands/options.

The unit dealing the damage

The unit receiving the damage

Internal ID. Used by the killfeed for non-gear object kills.

Sets the attacker.

Sets the victim.

Sets the gear.

Sets the source.

Sets the damage amount.

Sets the damage type.

Sets the hitbox limb.

Sets the force vector.

Sets the hit position.

Sets the local hit position.

Sets the local hit direction.

Move a rotation towards a goal by a fixed distance

Clears all tags and then adds the provided strings to the set.

Rounds the Vector3.

Move a vector3 towards a goal by a fixed distance

Project a vector along a plane (normal) and scale it back to its original length

Apply an amount of friction to the current velocity.

A sign of that's never zero(will be 1 instead).

A number that's at least zero. A number that's at most zero. A number that's at least this far away from zero.

A that is always between 0 and 1.

Inspector-friendly data for the method.

The transform's world position. The transform's world rotation. The transform's world scale.

The center of the object, such as its mass center or hull center.
Can be used to avoid calculating its bounds every time(expensive!).

Safely sets the position.

If the position wasn't a NaN or infinity.

Safely sets the rotation.

If the rotation wasn't a NaN or infinity.

Safely sets the scale.

If the scale wasn't a NaN or infinity.

A position and a rotation, but not scale.
Makes it very easy to animate programmatically(mainly tweening).

The transform to offset from. The resulting transform of this offset from the specified transform.

Lerps a transform to an offset's position/rotation while preserving its original scale.
This is typically best used on local transforms.

Sets a transform to an offset's position/rotation while preserving its original scale.
This is typically best used on local transforms.

Directly sets the object's local transform to the specified offset.

Sets an object's offset from the specified transform.

Directly sets the local transform to the specified offset.

Sets an object's offset from the specified transform.

Sets an object's offset relative to another object.

Safely reference a prefab without breaking the entire project if it's missing.

If the prefab was valid and spawned a valid game object. If the prefab was valid and spawned a valid game object at the specified transform. If the prefab was valid and spawned a valid game object at the specified position.

Find all prefabs that contain a component. This is probably slow so avoid using it too much.

Tries to find a PrefabDefinition by Prefab path.

Convenience methods for randomization.
Less typing means cleaner code. 🎲

True or false. Integer between 0 and . Integer between and . Float between 0 and . Float between and . A random value from an enumeration. Up to the specified number of unique names.

The folks.

Min and max floats without a fixed value setting.

Min and max integers without the fixed value setting.

Manually update this by calling Move() or let it always be simulated

Width of our trace

Height of our trace

Which tags it should ignore

Max amount of trace calls whenever the simulation doesn't reach its target (Slide and collide bounces)

How fast you accelerate while on the ground (Units per second)

How fast you decelerate while on the ground (Units per second)

How fast you accelerate while in the air (Units per second)

How fast you decelerate while in the air (Units per second)

Do we ignore the friction of the surface you're standing on or not?

Is this MoveHelper meant for horizontal grounder movement? (false = For flying or noclip)

Do we ignore Z when it's near 0 (So that gravity affects you when not moving)

Stick the MoveHelper to the ground (IsOnGround will default to false if disabled)

How steep terrain can be for you to stand on without slipping

How far from the ground the MoveHelper is going to stick (Useful for going down stairs!)

Enable steps climbing (+1 Trace call)

How high steps can be for you to climb on

How deep it checks for steps (Minimum depth)

Instead of colliding with these tags the MoveHelper will be pushed away (Make sure the tags are in IgnoreTags as well!)

Which tags will push this MoveHelper away and with how much force (Make sure they are also included in IgnoreTags!) (+1 Trace call)

Apply gravity to this MoveHelper when not on the ground

Use the scene's gravity or our own

Units per second squared (Default is -850f)

Check if the MoveHelper is stuck and try to get it to unstuck (+Trace calls if stuck)

How many trace calls it will attempt to get the MoveHelper unstuck

The simulated target velocity for our MoveHelper (Units per second, we apply Time.Delta inside)

The resulting velocity after the simulation is done (Units per second)

Is the MoveHelper currently touching the ground

The current ground angle you're standing on (Always 0f if IsOnGround false)

The current surface you're standing on

The gameobject you're currently standing on

Is the MoveHelper currently pushing against a wall

The current wall normal you're pushing against (Always Vector3.Zero if IsPushingAgainstWall false)

The gameobject you're currently pushing on

Is the MoveHelper standing on a terrain too steep to stand on (Always false if IsOnGround false)

The MoveHelper is stuck and we can't get it out

To avoid getting stuck due to imprecision we shrink the bounds before checking and compensate for it later

The bounds of this MoveHelper generated from the TraceWidth and TraceHeight

If another MoveHelper moved at the same time and they're stuck, let this one know that the other already unstuck for us

Detach the MoveHelper from the ground and launch it somewhere (Units per second)

Apply the WishVelocity, update the Velocity and the Position of the GameObject by simulating the MoveHelper

Just calculate but don't update position If pushing against a wall, scale the velocity based on the wall's angle

Apply the WishVelocity, update the Velocity and the Position of the GameObject by simulating the MoveHelper

The time step Just calculate but don't update position If pushing against a wall, scale the velocity based on the wall's angle

Sometimes we have to update only the position but not the velocity (Like when climbing steps or getting unstuck) so we can't have Position rely only on Velocity

Debug don't use

Methods for getting static property values.

The value of the static property on if it exists, or null. The value of the static property on of type if it exists, or null. The value of the static property on of type if it exists, or a default.

Are we a fishie!?

If you're a developer. If a specific user is a developer. If you have access to admin commands. If a specific user has admin access.

Get the distance between this Vector3B and another

Shows you the voxel position of the GameObject.

The distance this fog reaches.

The color of this fog.

Approximate distance between line points. Used to determine point count.

Spawns during prep and disappears when the round starts.

Always there. Will be considered the "main" border by AI.

Spawns various kinds of borders from the configured bounds.

Prevents this border from being considered the "main" border meant to surround the map(used by AI).

Forces the spawned border's tags to be these.

If enabled: will ignore gamemode settings about borders and activates only for the set modes.

Which gamemodes does this border activate upon?

The main bounds covering the map.

Fix up the position to be at the mins and bounds to be positive.

Resets scale and rotation to default. Puts the origin of the object at Mins.

Stretch the bounds to the bottom and top of the voxel world.

Stretch the bounds to the sides of the voxel world.

An automatically properly sized bounding box.

An automatically properly sized bounding box in world units

A cached value. Calculates it if not yet cached.

Use this component to process a volume of voxels and apply changes to them...

Process a singular voxel with out processors settings..

Run the voxel processor.

Add a vertex.

Add an index. This is relative to the top of the vertex buffer. So 0 is Vertex.Count., 1 is Vertex.Count -1

Add an index. This is relative to the top of the vertex buffer. So 0 is Vertex.Count.

Add a triangle to the vertex buffer. Will include indices if they're enabled.

Add a quad to the vertex buffer. Will include indices if they're enabled.

Add a cube to the vertex buffer. Will include indices if they're enabled.

Begin building map data from a file.

Override the format of this builder.

Build voxel data from the map data asynchronously.

Specify exactly what the default view is?

Minimum players required to prefer this map.

Most players that can comfortably play here.

Create a break piece from a Dictionary of voxels.

Overlay color of this water.

Peak color of this water.

We store information about A* nodes and some utility methods inside of this class.

Get all neighbouring voxels, even ones we can jump on or land down

Get the distance between the node's voxel's position

Get the horizontal distance between the node's voxel's position

This struct defines the path full A* path.

Return the total length of the path

Simplify the path by iterating over line of sights between the given segment size, joining them if valid

Make the path 'wavy' by shifting nodes around

Minimum nodes in between waves, at least 3 or else you won't get good side movement Maximum nodes in between waves Minimum node shifting distance Maximum node shifting distance

All connections to other

The voxel data for this cell

The amount of free space above this cell

Must crouch to traverse this cell because there's not enough (Only 2)

There's at least one missing neighbour because of a wall

There's at least one missing neighbour because of a drop

Hash code for this cell, precomputed from the for faster lookup

Sets up connections for neighbouring cells, Walk, Jump, and Drop Down

Convert an EdgeDirection to its corresponding 2D offset (Z = 0) using the reverse lookup.

Does this cell has a non-walkable edge in the given cardinal direction?

Does this cell has a non-walkable edge in the given vectorial direction?

Get the edge direction from a given Vector3 direction

Find the nearest 2D free edge direction to the given vector. Returns None if the best dot‐product is negative.

Find the nearest 2D solid edge direction to the given vector. Returns None if the best dot‐product is negative.

Connect two cells together

If true set the connection on the other NavCell to this as well

Disconnect these two cells

If true disconnect on the other NavCell from this as well

all

Has the grid been generated?

Add a to the grid

The new NavCell, null if we weren't able to add it

Gets the at the given global coordinates

null if not found

Gets the at the given local coordinates in the given chunk
Can overflow and it will find in the nearby chunk

The local position, can overflow and it will find in the nearby chunk null if not found

Is there a line of sight between the two cells?

Find the nearest walkable voxel, EXPENSIVE!

Builder for an A* path. Usage:
await BuildPath( Vector3Int startPos, Vector3Int targetPos )
.WithMaxLength( 4096f )
.WithMaxDuration( 1f )
.Simplify( 2 )
.WithCancellationToken( cancellationToken )
.Run();

Start building an A* pathfinder.

Sets the maximum distance to look for before stopping.
Won't return any path if is set to false.
[8192f units by default]
Set to null for no max.

Sets the radius to look for the nearest walkable nodes at the start and target positions.
If no walkable nodes are found within the radius, no path will be returned.
[512f units by default]
It gets expensive past the default, I don't suggest increasing it.

Sets the maximum duration in seconds allowed for the path search.
If the search takes longer, it will cancel and return the final path if is true
[0.5f seconds by default]
Set to null for no max.

Return the unfinished path if it isn't able to reach the target.
[true by default]

Before pathfinding it checks for line of sight between the start and the target.
If line of sight is found, it returns a straight path from start to target.
[true by default]

Include the ability to dig through blocks to reach the destination
Use to change how expensive digging is
[false by default]

Extra applied to each digging voxel in the path
0f = No difference between walking and digging
1f = Digging is 100% more expensive compared to walking
5f = Digging is 500% more expensive compared to walking
[5f by default]

Include the ability to crouch spaces to reach the destination
Use to change how expensive crouching is
[true by default]

Extra applied to nodes where crouching is required
0f = No difference between walking and crouching
1f = Crouching is 100% more expensive compared to walking
2f = Crouching is 200% more expensive compared to walking
[2f by default]

Include the ability to jump to reach the destination
Use to change how expensive jumping is
[true by default]

Extra applied to nodes with connection jump
0f = No difference between walking and jumping
1f = Jumping is 100% more expensive compared to walking
[1f by default]

Include the ability to drop down to reach the destination
Use to change how expensive dropping is
[true by default]

Extra applied to nodes with connection drop
0f = No difference between walking and dropping
1f = Dropping is 100% more expensive compared to walking
[0f by default]

Include the ability to build up and horizontally to reach the destination
Use to change how expensive building is
[false by default]

Extra applied to nodes with connection build over each voxel
0f = No difference between walking and building
1f = Building is 100% more expensive compared to walking
[1f by default]

Reverse the nodes after the path has been generated.
[false by default]

Reduce the amount of nodes by checking which ones have direct line of sight and removing them.
The more iterations, the less final nodes unless they no longer can get culled. Set to null for no simplification.
Disables if turned on
[null by default]

Jumble the path to make it less direct and more "wavy".
Set to null for no jumbling
Doesn't work if is true and succesful
Disables if turned on
[null by default]

Add a to cancel the path generation.
When cancelled no path will be returned even if is true.
[ by default]

Runs the A* pathfinder.

Builds AO values for a voxel based on the parameters.

Did the local player cause this?

Was a map selected by voting?

Display a notification on the gamebar, this is not broadcasted.

If this time elapses without a video playing then try to load .

Shows smaller maps first. Should always return a non-null enumerable.

Log damage to the killfeed locally.

If this component is valid and loaded in an editor scene(not in game/play mode). If this component is valid and loaded in a play mode scene(not scene/prefab editor).

Approaches 1 but never reaches it as the inputNumber increases

Round to nearest int

Round a vector3 to the nearest Vector3Int

Is the provided point inside of the cone

Is the provided bbox hit by the cone

Make the integer loop within 0 and the module number given

Finds the nearest cardinal direction (Vector3.Right Vector3.Forward etc...)

A directional direction

Find the second nearest cardinal direction compared to the one provided

Calculate the direction a projectile needs to be thrown at to reach the end position

The initial position The target position The initial speed in units/second The constant force being applied in units/second There will always be two trajectories intersecting, a higher and lower one How long the projectile takes to reach the position, 0 if it can't reach