package.wurstsoftware.koth

Handles the main game loop, using components that listen to state change events to handle game logic.

Gets all game modes referenced by a scene.

Gets the given component from within the game mode's object hierarchy, or null if not found / enabled.

A list of game utilities that'll help us achieve common goals with less code... I guess?

All players in the game (includes disconnected players before expiration).

Get all players on a team.

Every currently in the world.

Every currently in the world, on the given team.

Get all spawn point transforms for the given team.

Pick a random spawn point for the given team.

Helper list of the two teams.

Get a player from a component that belongs to a player or their descendants.

Returns the invoking client to the main menu

Log all known player states to the console.

Plop this on something you're using for. We could codegen this attribute on components that use it to save this hassle.

Looks for a bunch of score attributes from components on a , and returns a formatted, sorted list of values.

Handles all the player score values.

Open the dropdown.

A relatively simple color slider panel. thank you Alex for your instagib code from 2021

The player's inventory

The player

0 to 100

The player

The player's inventory

The player

Are we off screen?

Is this marker entirely behind the screen?

The equipment's slot

The player's equipment.

Handles certain events and plays radio sounds.

Play a sound at the start of this state.

Play a radio message at the start of this state.

When the round starts.

When the team has won.

When the team has lost.

When the bomb has been planted.

When the bomb has been defused.

When someone has thrown a grenade.

When someone dies, and there's 2 people left.

When someone dies, and there's 1 person left.

When a teammate dies.

Called on the host to broadcast radio sounds to people

Locally controlled, spam control.

How frequently can we spam the radio?

Send a radio sound to all players on the specified team

Called on the host to clean up objects that shouldn't persist between rounds.

Dispatches a when entering this state.

Transition to the given state when one team's score reaches the given value.

Transition when either team reaches this score.

Transition to this state when reaches the target score.

Keep players frozen while this state is active.

How many players can we display on the round display until we substitute them for a general head-count?

Show a warning message when entering this state, then throw everyone back to the menu when this state ends.

Respawn players after a delay.

If set to 0, the player ragdoll will only remove after round changes.

Use spawns that include at least one of these tags.

Avoid spawning within this radius of an enemy player.

Assume an enemy player is out of line-of-sight if at least this far away.

Respawn all players at the start of this state.

If true, reset alive players as if they'd died.

Give each player a component.

Per-player win tracker for retakes.

How many rounds has this player been on the winning team.

Give points to all players on the winning team.

Which team won?

Increment a team's score when entering this state.

Event dispatched on the host when should be reset.

Event dispatched on the host when should be incremented.

Keep track of how many rounds have been played.

Current round number, starting at 1.

Resets when this state is entered.

Increments when this state is entered.

Transition to a given state after a given number of rounds. Requires a .

Lets us change the scoring format per-gamemode.

The scoring format. https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings

Dispatched on the host when a player starts being spawn protected.

Dispatched on the host when a player stops being spawn protected.

Makes respawned players invulnerable for a given duration, or until they move / shoot.

Show a warning message when entering this state, then throw everyone back to the menu when this state ends.

Shows a countdown based on the duration of the current state.

Shows a toast in the middle of the screen for the duration of this state.

Display a special icon in the game status display.

Path to the icon image to show.

Swap teams when entering this state.

Don't auto-balance.

Pick random players to move.

Prefer to move players with the lowest scores.

Prefer to move players with the lowest scores from just the last round.

Split players into two balanced teams. If is true, new players will be assigned as soon as they join. Otherwise, teams will only be assigned when this game state is entered.

Target number of Ts per CT.

What sort of auto-balancing should we apply when entering this state.

Transition to another state if one team is eliminated.

Transition to this state when all players are eliminated.

Transition to this state when all players are eliminated simultaneously.

Keeps track of a score for each team.

You can define a scoring format for the scores, say you want to format in currency.

Transitions to specified states if one team's score is higher than the other's.

Minimum difference between scores to trigger a transition.

Use team-specific spawn points.

Use spawns that include at least one of these tags.

Skip to the next state if enough players are connected.

Only start the game if there are at least this many players.

Immediately start the game if this number of players are connected.

One in a scene, used by to dictate rules around who can broadcast their voices to who.

Should we exclude this potential listener from hearing our voice?

The model renderer.

The player state ID

This pawn's PlayerState

The position this player last spawned at.

The rotation this player last spawned at.

The tags of the last spawn point of this pawn.

What team does this pawn belong to?

Are we possessing this pawn right now? (Clientside)

Is this pawn locally controlled by us?

What's our name?

What's the pawn's eye angles?

The pawn's camera. Has to have one.

Who's the owner?

Possess the pawn.

De possesses the pawn.

Have the player look at this point in the world

We can force the model to walk or run, or let it decide based on the speed.

Called to wear an outfit based off a team.

Produces footstep sounds for the player.

Grants a unique Id to each player, generated on host and synced. When a player disconnects that Id is returned to the pool and can be issued to new players. Issues an Id globally and per-team.

Unique Id of this player in the game. New players will occupy vacant ids.

Unique Id of this player within their team. New players will occupy vacant ids.

What equipment do we have right now?

A that will hold all of our equipment.

Can we unequip the current weapon so we have no equipment out?

Does this player have a defuse kit?

Gets the player's current weapon.

Try to drop the given held equipment item.

Item to drop. If we can't drop, remove it from the inventory anyway.

Removes the given weapon (by its resource data) and destroys it.

Clears the player's loadout equipment.

A component that handles the state of the player's marker on the minimap and the HUD.

The player.

An accessor to see if the player is alive or not.

Defines a custom marker panel type to instantiate. Might remove this later.

Where is the marker?

What type of icon are we using on the minimap?

Is this a directional icon?

What direction should we be facing? Surely this could be a float?

Defines a custom css style for this minimap icon.

The minimap element's position in the world.

Is this player an enemy of the viewer?

Did we spot this player recently?

Should we render this element at all?

A component that has a team on it.

Accessor to get the team of someone/something.

Are we friendly with this other team?

Are these two GameObjects friends with eachother?

Are these two s friends with each other?

A reference to the camera component we're going to be doing stuff with.

The default player camera prefab.

Constructs a ray using the camera's GameObject

Updates the camera's position, from player code

When jumping into walls, should we bounce off or just stop dead?

Add acceleration to the current velocity. No need to scale by time delta - it will be done inside.

Apply an amount of friction to the current velocity. No need to scale by time delta - it will be done inside.

Trace the controller's current position to the specified delta

Disconnect from ground and punch our velocity. This is useful if you want the player to jump or something.

Move a character, with this velocity

Move from our current position to this target position, but using tracing an sliding. This is good for different control modes like ladders and stuff.

What are we called?

What's currently mounted?

Development: should bots follow the player's input?

What effect should we spawn when a player gets headshot?

What effect should we spawn when a player gets headshot while wearing a helmet?

What effect should we spawn when we hit a player?

What sound should we play when a player gets headshot?

What sound should we play when we hit a player?

Is the player holding use?

How far can we use stuff?

Which object did the player last press use on?

What Weapon are we using?

How inaccurate are things like gunshots?

Which s is the player currently standing in.

Update which s the player is standing in.

The position of the ping marker (on the minimap AND the screen)

Should we override the icon on the minimap and screen?

What should the colour be?

Called when we start pinging something

Called when this ping gets cancelled by another

Should this show?

A simple component that handles pinging for the player.

The player

How far can we ping?

How long do we exist for?

Store a reference to the last ping this player placed.

Sends a ping to people on the server, can only be called by the owner of this player. This gets networked to people on the same team.

Can we ping?

Trace for the ping

Behavior that makes a ping follow a player until they're no longer visible.

Unique ID of this Bot

Is this a bot?

How long has it been since this player has d/c'd

How long does it take to clean up a player once they disconnect?

Are we ready to respawn?

Called when changes across the network.

Our networked list of voting options.

Our networked list of votes.

How long until we decide who won?

How long until we move server?

Which option is the winner?

An instance of the map vote overlay UI

The screen panel which draws our UI

Converts a list of networked options to readable ones

Converts a list of normal options to networked ones

What's our current winning option? TODO: provide sorted options instead so other systems can take winner, or take a draw

Start a vote. This'll make a component on the server and

TODO: remove me

RPCs a vote, targeted to the host, so it's not exposed to any public API.

Sends a vote to the host.

A networked vote.

The player's SteamId

Which option are we voting for? (Mapped to the list)

A voting option that has real data.

What mode are we playing?

What map?

Converts this to a networkable

A networkable variant of , since it only passes through strings.

The full resource path of the map.

The full resource path of the gamemode.

Convert this to a readable

Raw access to the marker object's

Where is this marker?

Are we overriding the type here?

What icon does this marker have?

What styles should we apply to the marker?

What text should we show?

How far can we see this marker?

How big's the marker?

Should we show a chevron when we're off-screen?

Should we even show this marker?

Input hint?

Should we dim the marker when looking at it?

This purely exists as a wrappe for a real lobby, so we can display fake lobbies in the UI.

A reference to our internal lobby type.

Creates a GameObject that plays a sound.

Creates a which will deferred delete the .

A component that registers itself as a global.

It's nice to be able to access a global anywhere.

Fetch a global.

A maintained list of all the globals.

The gameobject we're hosting all the globals on.

Creates a global since it doesn't exist in the scene.

Tries to grab a global, if it exists. If it doesn't, we'll make one.

Some network utils, mainly RPC filters.

Makes a RPC filter based on your team.

Makes a RPC filter to a specific team.

A simple component that plays a sound.

How long until we destroy the GameObject.

Should we follow the current GameObject?

Should the GameObject be destroyed when the sound has finished?

A utility component that lets you have tags update based on conditions, similarly to how we have Panel.BindClass

A cache of binds.

Do we have a bind already?

Bind a tag to a specific condition. Must not exist.

A simple component that destroys its GameObject.

How long until we destroy the GameObject.

The real time until we destroy the GameObject.

For properties that contain an , wrap the getter to return null if the stored value isn't valid.

An ammo container. It holds ammo for a weapon.

How much ammo are we holding?

Do we have any ammo?

Is this container full?

A weapon component. This can be anything that controls a weapon. Aiming, recoil, sway, shooting..

The weapon.

The player.

Show this property in the equipment resource editor.

Accessor for the aim ray.

How long since we shot?

Fetches the desired model renderer that we'll focus effects on like trail effects, muzzle flashes, etc.

Store a reference to the blood impact sound so we don't have to grab it every time.

Play any particle effects such as muzzle flashes.

Shoot the gun!

Are we nearby a position? Used for FX

Makes some tracers using legacy particle effects.

Runs a trace with all the data we have supplied it, and returns the result

A weapon component that reacts to input actions.

What input action are we going to listen for?

Should we perform the action when ALL input actions match, or any?

ActionGraphs action so you can do stuff with visual scripting.

Called when the input method succeeds.

When the button is up

When the button is down

Where is the marker?

What text?

An equipment component.

A reference to the equipment's .

A tag binder for this equipment.

Shorthand to bind a tag.

A reference to the equipment's model renderer.

The default holdtype for this equipment.

What sound should we play when taking this gun out?

How slower do we walk with this equipment out?

What prefab should we spawn as the mounted version of this piece of equipment?

Should we enable the crosshair?

Cached version of the owner once we fetch it.

Who owns this gun?

The Guid of the owner's

Is this equipment currently deployed by the player?

Updates the render mode, if we're locally controlling a player, we want to hide the world model.

Deploy this equipment.

Holster this equipment.

Allow equipment to override holdtypes at any notice.

Interface for components on weapons that persist when dropped.

Interface for components on weapons that persist when dropped. Default implementation will create a copy of this component on the dropped weapon, then copy it back on pickup.

Should we be using loop points?

Which point index is our loop point start?

Are we looping right now?

Tries to get a point, and will wrap around if the index falls over.

A weapon's viewmodel. It's responsibility is to listen to events from a weapon. It should only exist on the client for the currently possessed pawn.

A reference to the we want to listen to.

A reference to the viewmodel's arms.

Is this a throwable?

Looks up the tree to find the player controller.

Should we play deploy effects?

Animation curve to use, X is the time between 0-1 and Y is how much the door is open to its target angle from 0-1.

Sound to play when a door is opened.

Sound to play when a door is fully opened.

Sound to play when a door is closed.

Sound to play when a door has finished closing.

Optional pivot point, origin will be used if not specified.

How far should the door rotate.

How long in seconds should it take to open this door.

Open away from the person who uses this door.

Tracks whether something has been seen by the enemy team.

The team this belongs to. Any players that aren't of this team will be able to spot this.

As the position doesn't move, it'll always be spotted after it's seen once.

Controlls the spotting behaviour of a player.

This is spawned clientside when a ping happens.

Who's the owner?

Are we pinging a world object that might move?

Triggers the ping to tear off in X seconds.

Called on the host when a new player joins, before NetworkSpawn is called.

Called on the host when a player (re)spawns.

Called on the host when a player is assigned to a team.

Called on the host when all scores should be reset.

Called on the host when both teams swap.

Dispatches a when this state is entered.

Destroy this object when a is dispatched.

Gets the angle (in degrees) between two Vector2s

What slot is this equipment for?

Non-pistol guns.

Pistols.

Knives etc.

Grenades etc.

C4 etc.

A resource definition for a piece of equipment. This could be a weapon, or a deployable, or a gadget, or a grenade.. Anything really.

If set, only this team can buy the equipment.

If false, only can pick up this equipment.

If true, owner will drop this equipment if they disconnect.

The equipment's icon

Is this equipment shown in the buy menu

How much is this equipment to buy in the buy menu?

How much money do you get per kill with this equipment?

The prefab to create and attach to the player when spawning it in.

The prefab to create when making a viewmodel for this equipment.

A team spawn point.

What team is this for?

A region of the map with some specific gameplay purpose. The extents of the zone are defined by s attached to this object.

Optional name to show in the HUD.

Returns all zones that contain the given position.

Checks the current button and updates the glyph.

The right side of the slider.

The left side of the slider.

If set to 1, value will be rounded to 1's If set to 10, value will be rounded to 10's If set to 0.1, value will be rounded to 0.1's

Show the range values above the slider

When changing the value show the tooltip

How to display numbers in this control

Convert a screen position to a value. The value is clamped, but not snapped.

If we move the mouse while we're being pressed then set the value

On mouse press jump to that position