Client-server architecture in Unity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Unity client-server message exchange?

Consider a simple Unity client-server setup where the server sends a message to the client, and the client logs it. What will be printed in the Unity console?

Unity

using UnityEngine;

public class Server : MonoBehaviour {
    public delegate void MessageHandler(string message);
    public static event MessageHandler OnMessageSent;

    void Start() {
        SendMessageToClient("Hello from Server");
    }

    void SendMessageToClient(string msg) {
        OnMessageSent?.Invoke(msg);
    }
}

public class Client : MonoBehaviour {
    void OnEnable() {
        Server.OnMessageSent += ReceiveMessage;
    }

    void OnDisable() {
        Server.OnMessageSent -= ReceiveMessage;
    }

    void ReceiveMessage(string msg) {
        Debug.Log("Client received: " + msg);
    }
}

A Client received: Hello from Server

B Server received: Hello from Server

C No output because events are not subscribed

D NullReferenceException at runtime

💡 Hint

Think about which class subscribes to the event and what message is passed.

The Server class sends a message via an event. The Client subscribes to this event and logs the received message. So the output is the client logging the server's message.

🧠 Conceptual

intermediate

Which statement best describes client-server roles in Unity networking?

In a Unity multiplayer game using client-server architecture, which statement is true about the roles of client and server?

A Clients and server have identical responsibilities

B Clients manage game state and server only relays messages

C The server manages game state and clients send input commands

D Server only displays graphics, clients handle logic

💡 Hint

Think about who has authority over the game world.

The server is authoritative and manages the game state. Clients send their input to the server, which processes and updates the state.

🔧 Debug

advanced

Why does this Unity client never receive server messages?

Given the following Unity code, why does the client never log the server's message?

Unity

public class Server : MonoBehaviour {
    public delegate void MessageHandler(string message);
    public static event MessageHandler OnMessageSent;

    void Start() {
        SendMessageToClient("Hello Client");
    }

    void SendMessageToClient(string msg) {
        OnMessageSent?.Invoke(msg);
    }
}

public class Client : MonoBehaviour {
    void Start() {
        Server.OnMessageSent += ReceiveMessage;
    }

    void ReceiveMessage(string msg) {
        Debug.Log("Received: " + msg);
    }
}

A Event delegate is not static, so client can't subscribe

B Client subscribes too late; event fired before subscription

C Client unsubscribes immediately after subscribing

D Server never invokes the event

💡 Hint

Check the order of event subscription and invocation.

The Server fires the event in Start(), but the Client subscribes in its Start(), which may run after the Server's Start(). So the event is fired before the client subscribes.

📝 Syntax

advanced

Which option correctly declares a Unity event for client-server messaging?

Which of the following is the correct syntax to declare a static event in Unity C# for sending string messages from server to clients?

A public event static Action<string> OnMessageSent;

B public static delegate event Action<string> OnMessageSent;

C static public event void OnMessageSent(string message);

D public static event Action<string> OnMessageSent;

💡 Hint

Remember the order: access modifier, static, event, delegate type, name.

Option D correctly declares a static event using the Action delegate with a string parameter.

🚀 Application

expert

How many clients receive this server broadcast in Unity?

In a Unity server script, the server broadcasts a message to all connected clients using a static event. If 3 clients are connected and subscribed to the event, how many clients will receive the message?

Unity

using System;
using UnityEngine;

public class Server : MonoBehaviour {
    public static event Action<string> OnBroadcast;

    public void Broadcast(string msg) {
        OnBroadcast?.Invoke(msg);
    }
}

public class Client : MonoBehaviour {
    void OnEnable() {
        Server.OnBroadcast += Receive;
    }

    void OnDisable() {
        Server.OnBroadcast -= Receive;
    }

    void Receive(string msg) {
        Debug.Log("Client received: " + msg);
    }
}

A 3

B Depends on network latency

C 0

D 1

💡 Hint

Think about how events work with multiple subscribers.

Each subscribed client receives the event invocation, so all 3 clients get the message.

Practice

1. In Unity's client-server architecture, what is the main role of the client?

easy

A. Send requests to the server and receive responses

B. Store all game data permanently

C. Control the server hardware

D. Manage other clients directly

Solution

1. Step 1: Understand client role in client-server

   The client initiates communication by sending requests to the server.

2. Step 2: Understand server response

   The server processes requests and sends back responses to the client.

3. Final Answer:

   Send requests to the server and receive responses -> Option A

4. Quick Check:

   Client = Request sender [OK]

Hint: Clients always ask; servers always answer [OK]

Common Mistakes:

• Thinking client stores all data permanently
• Confusing client with server hardware control
• Assuming clients manage other clients

2. Which of the following is the correct way to create a TcpClient in Unity C#?

easy

A. TcpClient client = TcpClient("127.0.0.1", 8080);

B. TcpClient client = new TcpClient.connectTo("127.0.0.1", 8080);

C. TcpClient client = new TcpClient.connect("127.0.0.1", 8080);

D. TcpClient client = new TcpClient("127.0.0.1", 8080);

Solution

1. Step 1: Recall TcpClient constructor syntax

   In C#, creating a new TcpClient requires the 'new' keyword and constructor with IP and port.

2. Step 2: Check each option's syntax

   Only TcpClient client = new TcpClient("127.0.0.1", 8080); uses 'new TcpClient("127.0.0.1", 8080);' correctly.

3. Final Answer:

   TcpClient client = new TcpClient("127.0.0.1", 8080); -> Option D

4. Quick Check:

   Use 'new' keyword with constructor [OK]

Hint: Always use 'new' to create objects in C# [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using incorrect method names like connect or connectTo
• Wrong constructor call syntax

3. What will the following Unity C# code output if the server sends back the string "Hello Client"?

using System;
using System.Net.Sockets;
using System.Text;

TcpClient client = new TcpClient("127.0.0.1", 9000);
NetworkStream stream = client.GetStream();
byte[] data = new byte[256];
int bytes = stream.Read(data, 0, data.Length);
string response = Encoding.ASCII.GetString(data, 0, bytes);
Console.WriteLine(response);

medium

A. System.Byte[]

B. Hello Client

C. null

D. Exception thrown

Solution

1. Step 1: Understand data reading from NetworkStream

   The code reads bytes from the stream into a byte array and counts bytes read.

2. Step 2: Convert bytes to string

   It converts the bytes read to a string using ASCII encoding, which matches the server's sent string.

3. Final Answer:

   Hello Client -> Option B

4. Quick Check:

   Read bytes + decode = server message [OK]

Hint: Decode bytes read from stream to get server message [OK]

Common Mistakes:

• Printing byte array directly instead of decoding
• Ignoring number of bytes read
• Assuming null if no data

4. Identify the error in this Unity C# client code snippet:

TcpClient client = new TcpClient();
client.Connect("192.168.1.10", 7000);
NetworkStream stream = client.GetStream();
byte[] message = Encoding.ASCII.GetBytes("Ping");
stream.Write(message, 0, message.Length);
stream.Close();
client.Close();

medium

A. Missing try-catch block for network exceptions

B. Calling stream.Close() before client.Close() causes error

C. TcpClient must be created with IP and port in constructor

D. No error; code is correct

Solution

1. Step 1: Review TcpClient creation and connection

   Creating TcpClient with default constructor and then calling Connect is valid.

2. Step 2: Check for error handling

   Network operations can fail; missing try-catch means exceptions are unhandled.

3. Final Answer:

   Missing try-catch block for network exceptions -> Option A

4. Quick Check:

   Always handle network exceptions [OK]

Hint: Always wrap network calls in try-catch [OK]

Common Mistakes:

• Assuming stream.Close() before client.Close() is wrong
• Thinking TcpClient must have IP in constructor
• Ignoring exception handling

5. You want to build a Unity client that connects to a server and sends a player's score only if it is above 1000. Which code snippet correctly implements this logic using TcpClient and NetworkStream?

hard

A. if(score > 1000) {
TcpClient client = new TcpClient("server.com");
NetworkStream stream = client.GetStream();
byte[] data = Encoding.ASCII.GetBytes(score.ToString());
stream.Write(data, 0, data.Length);
stream.Close();
client.Close();
}

B. TcpClient client = new TcpClient("server.com", 5000);
NetworkStream stream = client.GetStream();
if(score > 1000) {
byte[] data = Encoding.ASCII.GetBytes(score.ToString());
stream.Write(data, 0, data.Length);
}
stream.Close();
client.Close();

C. TcpClient client = new TcpClient();
if(score > 1000) {
client.Connect("server.com", 5000);
NetworkStream stream = client.GetStream();
byte[] data = Encoding.ASCII.GetBytes(score.ToString());
stream.Write(data, 0, data.Length);
stream.Close();
client.Close();
}

D. if(score > 1000) {
TcpClient client = new TcpClient();
client.Connect("server.com", 5000);
NetworkStream stream = client.GetStream();
byte[] data = Encoding.ASCII.GetBytes(score);
stream.Write(data, 0, data.Length);
stream.Close();
client.Close();
}

Solution

1. Step 1: Check conditional connection and sending

   TcpClient client = new TcpClient(); if(score > 1000) { client.Connect("server.com", 5000); NetworkStream stream = client.GetStream(); byte[] data = Encoding.ASCII.GetBytes(score.ToString()); stream.Write(data, 0, data.Length); stream.Close(); client.Close(); } creates TcpClient without parameters, connects only if score > 1000, then sends data.

2. Step 2: Verify data conversion and method calls

   Converts score to string before encoding to bytes, uses correct Connect() and stream methods.

3. Final Answer:

   new TcpClient(); client.Connect() inside if(score > 1000) -> Option C

4. Quick Check:

   Connect and send inside if condition [OK]

Hint: Connect and send only inside the if block [OK]

Common Mistakes:

• Sending data without converting score to string
• Connecting outside the if condition
• Using score directly as bytes without encoding