LogoLogo
⚠️ Outdated documentationGo to LatestHomeAPI
SDK 1.1
SDK 1.1
  • Welcome
  • Overview
    • What is coherence?
    • How does coherence work?
    • Rooms and Worlds
    • Features and Roadmap
    • Release Notes
    • Known issues and Troubleshooting
  • Learn
    • Beginner's guide to networking
    • Package samples
    • First Steps tutorial
      • 1. Basic syncing
        • 1.2. Animation parameters
        • 1.3. Sending commands
      • 2. Physics / Authority transfer
      • 3. Areas of interest
      • 4. Parenting entities
      • 5. Complex hierarchies
      • 6. Persistence
    • Campfire project
      • Game mechanics
      • Leveraging object pooling
      • Remote interactions: Chairs
      • Remote interactions: Trees
      • A unique object with complex state
      • Custom instantiation and destruction
      • Running a server-side NPC
      • Playing audio and particles
      • A simple text chat
    • How to network [genre]…
      • Racing
      • Turn-based
      • First-Person Shooter
      • MMO
      • Fighting
    • Video tutorials
  • Get started
    • Installation
    • Scene Setup
      • Sample UIs
    • Prefab setup: CoherenceSync
    • Testing locally
      • Tips and recommendations
    • coherence Cloud
      • Create a free account
      • Deploy a Replication Server
      • Share builds
  • coherence SDK for Unity
    • Components
      • CoherenceSync
      • CoherenceBridge
      • CoherenceLiveQuery
      • CoherenceTagQuery
      • Order of execution
    • Asset Management
      • Using CoherenceSyncConfig to instantiate GameObjects locally
      • CoherenceSyncConfigRegistry Save Modes
    • Networking State Changes
      • Supported types
      • Messaging with Commands
      • Syncing child GameObjects
      • Parenting network entities
        • Direct child CoherenceSyncs
        • Deeply-nested CoherenceSyncs
        • Nesting Prefabs at Edit time
      • Animation
      • CoherenceSync references
      • [Sync] and [Command] Attributes
      • [OnValueSynced] Attribute
      • Creating your own syncable member
      • Custom Component Actions
    • Baking (Code generation)
    • Scene Management
    • Authority
      • Authority transfer
      • Server-authoritative setup
    • Lifetime
      • Persistence
      • Example – a global counter
    • Optimization
      • Simulation Frequency
      • Areas of Interest
      • Level of Detail (LOD)
    • Profiling
    • Interpolation
    • Rigid Bodies
    • Settings
    • Simulation Frame
    • Replication Server
    • Simulators
      • Scripting: Client vs Simulator
      • Local Development
      • World Simulators
      • Room Simulators
      • Simulator Slugs
      • Multi-Room Simulators
      • Build and Publish
      • Command-line arguments
      • Load Balancing
    • Client-Hosting
    • Client Connections
    • Rollback Networking Support
    • World Origin Shifting
    • Offline gameplay
    • CLI
    • Upgrade Guide
      • Upgrade 1.0 -> 1.1
      • Upgrade 0.10 -> 1.0
      • Upgrade 0.9 -> 0.10
  • Hosting
  • coherence Cloud
    • Developer Portal
    • Dashboard
    • Worlds
    • Rooms
    • Lobbies
    • Game Services
      • Account
      • Key-Value Store
    • Using coherence Cloud in Unity
      • Worlds
      • Rooms
      • Lobbies
      • Game Services
        • Authentication Service (Player Accounts)
        • Key-value store
  • Schema explained
    • Overview
    • Specification
    • Field settings
    • Archetypes
  • coherence Scripting API
  • Additional resources
    • Community
    • Pricing
    • Quick Samples
    • Continuous Integration
    • Unreal Engine Support
    • WebGL Support
    • Peer-to-Peer Support (P2P)
    • Glossary
  • Credit cost & pricing
Powered by GitBook
On this page
  • In this scene
  • How it's set up

Was this helpful?

Export as PDF
  1. Learn
  2. First Steps tutorial
  3. 1. Basic syncing

1.3. Sending commands

Last updated 1 year ago

Was this helpful?

Using the same scene as in the , we now take a look at another way to make Clients communicate: Network Commands. Network Commands are commonly referred to as "RPCs" (Remote Procedure Calls) in other networking frameworks. You can think of them as sending messages to objects, instead of syncing the value of a variable.

|

  • WASD or Left stick: Move character

  • Hold Shift or Shoulder button left: Run

  • Spacebar or Joypad button down: Jump

  • Q or D-pad up: Wave

In this scene

Building on top of previous examples, let's now focus on two key player actions. Press Space to jump, or Q to greet other players. For both of these actions to play their animation, we need to send a command over the network to invoke Animator.SetTrigger() on the other Client.

How it's set up

Like before, select the player Prefab located in the /Prefabs/Characters folder, and browse its Hierarchy until you find the child GameObject called Workman.

Open the coherence Configure window on the third tab, Methods:

You can see how the method Animator.SetTrigger(string) has been marked as a Network Command. With this done, it is now possible to invoke it over the network using code.

You can find the code doing so in the Wave class (located in /Scripts/Player/Wave.cs):

sync.SendCommand<Animator>(nameof(Animator.SetTrigger), MessageTarget.Other, "Wave");

Analysing this line of code, we can recognize 5 key parts:

  • First, notice how the command is invoked on a specific CoherenceSync (that sync property).

  • We want to invoke this command on a component that is an Animator.

  • We invoke a method called "Animator.SetTrigger".

  • With MessageTarget.Other, we are asking to send this message only to network entities other than the one that has the CoherenceSync we chose to use.

  • We pass the string "Wave" as the first parameter of the method to invoke.

Because we don't invoke this on the one with authority, you will notice that just before invoking the Network Command, we also call SetTrigger locally in the usual way:

animator.SetTrigger("Wave");

An alternative to this would have been to call CoherenceSync.SendCommand() with MessageTarget.All.

In this example we used Network Commands to trigger a transition in an animation state machine, but they can be used to call any instantaneous behavior that has to be replicated over the network. As an example of this, it is also used in the lesson to change a number in a UI element across all Clients.

Persistence
previous lesson
Network Commands
Animation
Two connected players waving at each other.