The Game class (Game.cs) is a MonoBehavior that defines the main loop of the game.
All gamecode is run from Game.Update method (with a few exceptions).
The game class is one of first classes to be instantiated and is always present no matter what state the game is in.
The Game class instantiates various systems like Audio and Input and has other app level utility functionality.
The Game class instantiates various systems like Audio, Input as well as containing other app level utility functionality.
Gameloops implements various mode the game can be in.
They handle initialization and shutdown of required systems and updates systems in correct order.
Gameloops implements various modes the game can be in.
They handle initialization and shutdown of required systems along with updating systems in the correct order.
ServerGameLoop (ServerGameLoop.cs) handles connection to a list of clients and update all server systems.
ServerGameLoop (ServerGameLoop.cs) handles connection to a list of clients and updates all the server systems.
PreviewGameLoop (PreviewGameLoop.cs) is mutations of Server and Client game loops slapped together.
It uses a mix of server and client systems and is used as a way to preview game without building bundles and starting up server and client.
This is the gameloop that is used when user presses play in editor with a game scene loaded.
PreviewGameLoop (PreviewGameLoop.cs) is a mutation of Server and Client game loops slapped together.
It uses a mix of server and client systems as a way to preview the game without building bundles or starting up the server and client.
This becomes the gameloop when a user presses play in the editor with a game scene loaded.
Modules contains components and the systems that update them and one or more module class that what is instantiated from the gameloop.
Modules can have specific server, client or preview implementations.
Modules are found in Assets/Scripts/Game/Modules
Modules contain components, along with the systems that update these components. The modules may also contain one or more additional specific classes that are instantiated by the gameloop.
Modules can have a specific server, client or preview implementations.
Modules location: Assets/Scripts/Game/Modules
To replicate a gameobject it needs to be a prefab and have the ReplicatedEntity component attached.
This will ensure prefab is registered in ReplicatedEntityRegistry (when build tool "Update Registry" is run).
Server and client have different ReplicatedEntityRegistry allowing for different prefabs to be spawned on server and client each representing the same entity (but they both need same set of serializable components)
Components that has data that should be replicated needs to implement the INetworkSerializable interface and be attacheds to same gameobject as ReplicatedEntity component.
To replicate a gameobject, it must be a prefab with the ReplicatedEntity component attached.
This will ensure the prefab is registered within ReplicatedEntityRegistry (any time build tool runs: "Update Registry").
Server and client have different ReplicatedEntityRegistry allowing for different prefabs to be spawned on the server and client. Each representing the same entity while simultaneously utilizing the same set of serializable components.
Components that have data to be replicated must implement the INetworkSerializable interface and be attached to the same gameobject as ReplicatedEntity component.
To replicate an ECS entity you need to create a scriptable object deriving from ReplicatedEntityFactory.
This class is also registered in ReplicatedEntityRegistry and has abstracts methods that needs to be implemented to create entity and create classes that serializes/deserializes component
To replicate an ECS entity you create a ScriptableObject deriving from ReplicatedEntityFactory.
This class is also registered in ReplicatedEntityRegistry. It contains abstract methods that must be implemented in order to create entities and classes with the serialize or deserialize component.
Player module handles server broadcasting of player information, sampling of user commands on client and local handling of controlled characters.
Player module handles server broadcasting of player information. The sampling of user commands on the client and local handling of controlled characters.
Player entity contains data that server sends to all clients (e.g. playername and what character the player is controlling) and data that is sent only the client the player represents (e.g. what UI elements to open)
Player entities contain data that the server sends to all connected clients (e.g. playername and what character the player is controlling). This data that is sent only to the client that the player represents (e.g. what UI elements to open)
Each client also have a *LocalPlayer* instantiated that has local presentation components (e.g camera control and UI).
Components specific to the type of entity being controlled can be added to LocalPlayer for custom handling.
Each client acontains a *LocalPlayer* instantiation that has local presentation components (e.g camera control and UI).
Components specific to the type of entity that is being controlled can be added to the LocalPlayer for custom handling.
Character module handles character abilities, animation and UI.
A character is define by prefab with either Character or Character1P MonoBehavior attached.
Character is used on server and on client for 3P characters whereas Character1P is used for 1P view of character.
Characters are setup using the *CharacterTypeDefinition*scriptable object.
It has references to Server and Client versions of the 3P character prefab, and reference to the 1P prefab character that is instantiated in 1P view.
The Character module is responsible for character abilities, animation and UI.
A character is defined by a prefab with either Character or Character1P MonoBehavior attached.
Character is used on the server and on the client for 3P characters. Whereas, Character1P is used for first person camera view.
Characters are setup using the *CharacterTypeDefinition*ScriptableObject.
This ScriptableObject has references to the Server and Client versions of the 3P character prefab, and reference to the 1P prefab character that is instantiated in first person camera view.
All character behaviour is handled by *Abilities* (in Character/Behaviours/Abilities).
What abilities are active is controlled by the *AbilityController*.
In current implementation characters always have the movement ability active and allow for only one other ability to be active (e.g. sprint, melee, shoot)
All character behaviour is handled by *Abilities* (Located: Character/Behaviours/Abilities).
Abilities are actives and controlled by the *AbilityController*.
In the current implementation characters always have the movement ability active. Characters are allowed only one other ability to be active at a time (e.g. sprint, melee, shoot)
HeroTypeAsset (HeroTypeAsset.cs) is used to setup a game hero. (note: in comments and naming the word character is often used for hero)
HeroTypeAsset (HeroTypeAsset.cs) is used to setup the games hero. (note: in comments and naming the word character is often used for hero)
Items are replicated but currently only client versions of prefabs have any logic or presentation.
When items are updated they read state of relevant abilities and uses that to trigger effects.
Items are replicated but currently only the client versions of the prefab have any logic or visuals.
When items are updated they read the state of the relevant abilities and use those to trigger the associated effects.
Effect module is responsible for showing short clientside effects (gfx and sound).
Effects are "fire and forget" and cannot be canceled.
Currently supports two kinds of effects: *SpatialEffect* and *HitscanEffect*.
Effects are created in a static pools at startup and reused.
Each effect is setup using a scriptable object (e.g. SpatialEffectTypeDefinition) that defines what prefab should be used for the effect and how large effect pool should be.
Effect are requested by gamecode by creating entities with request component (e.g SpatialEffectRequest) that are then picked up by effect systems and effct is triggered.
Effect module controls clientside effects (gfx and sound).
Effects are "fire and forget" this cannot be cancelled.
This module currently supports two kinds of effects: *SpatialEffect* and *HitscanEffect*.
Effects are created within static pools at startup.
Each effect is setup using a ScriptableObject (e.g. SpatialEffectTypeDefinition) that defines what prefab should be used for the effect as well as how large the effect pool should be.
Effects are requested by gamecode, it creates entities with the requested component (e.g SpatialEffectRequest). These are then added to the effect systems at which time the effect is then triggered.
Grenade module handles creation and updating of grenades. Grenades is updated on server and interpolated on client.
Grenade module handles the creation and updating of grenades. Grenades are updated on the server and interpolated to the client.
HitCollision module handles hit collision of all objects that can receive damage in the game.
Server stores position and rotation of moving colliders so they can be "rolled back" to a given tick before collision tests are performed.
HitCollision module handles hit collision of all objects that are capable of receiving damage within the game.
The server stores position and rotation of moving colliders so that they can be "rolled back". This allows rollingback the collider to any given tick before collision tests have been performed.
HitCollision for characters can be setup in a seperate prefab so it can be shared betweem server and client prefab
HitCollision for characters can be setup in a seperate prefab so that it can be shared between the server and client prefabs.
*RaySphereQueryReciever* can be used to queue collision queries that first does a raytest against environment and then sphere cast against hit collision.
*RaySphereQueryReciever* can be used to queue collision queries. It first processes a raytest against the environment and then sphere casts against the hit collision.
When hit collision is hit the *HitCollisionOwner* component can be used to add damage events.
These events are not used by the HitCollision module, but it is up to some other system (e.g. Character or DestructableProp) to read and clear list and apply damage to whatever health presentation they have.
When hit collision is hit the *HitCollisionOwner* component is used for adding damage events.
These events are not used by the HitCollision module. Instead it is used by other systems (e.g. Character or DestructableProp) to read and clear the list and apply damage to whatever health value they have.
Module also contains*SplashDamageSystem* that is an fire and forget way of giving splash damage to an area
This module also contains a*SplashDamageSystem* that is a fire and forget way of giving splash damage to an area.
Handles simulation of projectiles and visualization of projectiles on clients.
Server creates *Projectiles* that are replicated to clients.
When client receives projectile it creates a corresponding *ClientProjectile*that contains visualization of projectile.
Projectiles can also predicatively be created on client.
When a projectile is received from server that matches a predicted, the predicted is deleted and the associated clientprojectile is linked to the projectile from the server.
This module processes simulation of projectiles and their associated visuals to the client.
The server creates *Projectiles* and these are what is replicated to client side.
When a client receives a projectile it creates a corresponding *ClientProjectile*with visuals of the projectile.
Projectiles can also predicatively be created on the client.
When a projectile is received from the server which matches a predicted, the predicted is deleted while the associated clientprojectile is linked to the projectile from the server.
Handles updating state of all active ragdolls. Simulation done by Unity physics system.
Updates the state of all active ragdolls. Simulation processed by Unity physics system.
Handles a replicated player controllable camera. This has been used to test controlling non-character units and is currently in a pretty hacky state.
Controls a replicated player camera, that can be controlled by the spectator. This can be used to test control of non-character units and is currently in a pretty hacky state.
## If you are interested in contributing, here are some ground rules:
As the projects matures this will change, but currently it is like this:
* We are not ready to take new features or bigger changes so don't make big PRs yet. Bring up your thoughts in the forum.
* We are happy to get fixes to bugs and improvements to the out-of-box experience of the project.
## All contributions are subject to the [Unity Contribution Agreement(UCA)](https://unity3d.com/legal/licenses/Unity_Contribution_Agreement)
By making a pull request, you are confirming agreement to the terms and conditions of the UCA, including that your Contributions are your original creation and that you have complete right and authority to make your Contributions.
## Once you have a change ready following these ground rules. Simply make a pull request
Cuts the current selection in the scene Hierarchy. The cut objects are marked by a little round icon to the right in the scene Hierarchy
> Hotkey: Ctrl+Shift+X\
> Menu: FPS Sample > Hotkeys > Cut GameObjects
__Paste GameObjects [Hotkey]__\
Paste in previous cut selections in the scene Hierarchy
> Hotkey: Ctrl+Shift+V\
> Menu: FPS Sample > Hotkeys > Paste GameObjects
__Deselect All [Hotkey]__\
Clears the current selection in the scene Hierarchy and Project
> Hotkey: Alt+D\
> Menu: FPS Sample > Hotkeys > Deselect all
__Position under mouse [Hotkey]__\
Positions current selection under the mouse cursor in the scene view on first found collider. Very handy for worldbuilding
> Hotkey: Ctrl+Shift+Q\
> Menu: FPS Sample > Hotkeys > Position under mouse
__Align and position under mouse [Hotkey]__\
Positions and aligns rotation of current selection under the mouse cursor in
the scene view on first found collider
> Hotkey: Ctrl+Shift+Z\
> Menu: FPS Sample > Hotkeys > Align and position under mouse
__Selection History [Dockable window]__\
A dockable window that captures selection history. The checkbox next to history items is
used to 'pin' the item so it doesn't get pushed out by later selected items.
Items in the history window can be dragged onto component fields.
This is useful for setting up assets with many cross references such as materials and complicated prefabs
> Menu: FPS Sample > Windows > Selection History
__Toggle Gizmos [Hotkey toggle]__\
Toggles the visibility of gizmos in the scene view
> Hotkey: Ctrl+G\
> Menu: FPS Sample > Hotkeys > Toggle Gizmos
__LodSelector [Hotkey toggle]__\
A toggle to prevent selection in the scene view of gameobjects that are
referenced in a LOD Component. This helps you avoid mistakes where you select a LOD gameobject
and e.g. move that instead of the prefab it belongs to.
> Hotkey: Alt+L\
> Menu: FPS Sample > Hotkeys > LodSelector
__Replace scene selection by this prefab [Hotkey]__\
Enables you to easily replace scene Hierarchy selection with another resource from Project. Simply make a selection in the
scene Hierarchy and Ctrl+RMB in Project on what resource you want to replace your selection with and press "Replace scene selection by this prefab"
> Hotkey: Ctrl+RMB
__Take screenshot [Utility]__\
Takes a screenshot using active game view and prompts user where to save screenshot. This script saves out the screenshot in whatever
resolution is chosen in game view regardless of monitor resolution and because of this it can be used to capture high resolution screenshots better than a regular PrintScreen
> Menu: FPS Sample > Take Screenshot
__Fix sceneview fov [Utility]__\
When zooming in the scene view by using the mousewheel the camera clipping
planes are scaled. This script prevents that. Instead the mousewheel will
The _Material Property Override Component_ allows the user to override material properties based on shader keywords. This is handy as it enables you to tweak ie. the color of a material
or the strength of a normalmap without having to create a new material.
The _Material Property Override Asset_ allows you to push the properties you want to override to a Material Property Override Component from an asset rather than typing it in manually per instance.
This way you can easily push changes to many different materials making it easy to manage ie. color schemes. In the FPS Sample we used Material Property Override Assets
to manage the colors of the pipes, the industrial tanks, the factory exterior detail props and more. By using Material
Property Override Assets we could push the same color values to many different materials making it easy to manage color schemes and keep the number of material resources at a minimum.
__Rope line [Component]__\
These components help setting up ropes using a line renderer. The Rope Line Component keeps track of anchor gameobjects and
draws lines using a line renderer between the ancors. Children of the gameobject that has a Rope Anchor Component will automatically be assigned
to the anchor list if Simulate is ticked. When Simulate is ticked the anchor list is updated and the ropes are simulated. When you
are satisfied with the ropes untick Simulate and the ropes are then saved.
The Rope Anchor Component defines the length and number of segments for that section of the rope.
## Lighting
__LPPV Tool [Component]__\
This component helps set up and manage light probe proxy volumes. It is a component that references
a given light probe proxy volume and basically checks if it's meshrenderer children are set up to use the same light probe proxy volume
as it refers to. If this is not the case you can set this up by pressing "Assign". This speeds up bulk setup of light probe proxy volumes
__Clear all reflectionprobes to black [Utility]__\
Clears all reflectionprobes to black. This is required to get correct bakes when baking reflectionprobes
> Menu: FPS Sample > Lighting > Reflection Probes > Clear To Black
__Light probe placement [Component]__\
This is a component that can be used for easier placement of lightprobes.
To use this component add it to the gameobject you have your Light Probe Group component.
Enable the script by pressing the toggle key labelled "Place [L key]" and press "Edit Light Probes" in the Light Probe Group Component.
Now a lightprobe will be added whenever you press L. The placement of the probe is pushed in the normal direction of the collision you click on and the height can be altered in the Light Probe Placement component.
It is important that the gameobject on which the component is placed is situated at 0, 0, 0 in worldspace as the probe placement otherwise will be incorrect.
__Light Probe Generator [Asset postprocessor]__\
This is an asset post processor that looks for meshes with the prefix "LPG_" and when found it assigns a Light Probe Group to the object and generates a lightprobe per vertice.
## Other
__Lookup asset guid [Utility]__\
Looks up the GUID for an asset OR looks up the asset for a particular GUID.
> Hotkey: Ctrl+Alt+L\
> Menu: FPS Sample > Hotkeys > Lookup asset guid
## Animation
__Update Avatar Masks [Utility]__\
Updates all Avatar Masks copies in Clips to their latest source
Peter Andreasen
6 年前
