unity3d
Communication avec le serveur

Obtenir

Get obtient des données du serveur Web. et new WWW("https://urlexample.com"); avec une url mais sans second paramètre fait un Get .

c'est à dire

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour 
{
    public string url = "http://google.com";
    
    IEnumerator Start() 
    {
        WWW www = new WWW(url); // One get.
        yield return www;
        Debug.Log(www.text); // The data of the url.
    }
}

Simple Post (Post Fields)

Chaque instance de WWW avec un deuxième paramètre est une publication .

Voici un exemple pour poster un identifiant et un mot de passe sur le serveur.

void Login(string id, string pwd)
{
    WWWForm dataParameters = new WWWForm();    // Create a new form.
    dataParameters.AddField("username", id); 
    dataParameters.AddField("password", pwd);   // Add fields.
    WWW www = new WWW(url+"/account/login",dataParameters);
    StartCoroutine("PostdataEnumerator", www);
}

IEnumerator PostdataEnumerator(WWW www)
{
    yield return www;
    if (!string.IsNullOrEmpty(www.error))
    {
        Debug.Log(www.error);
    }
    else
    {
        Debug.Log("Data Submitted");
    }
}

Poster (Télécharger un fichier)

Télécharger un fichier sur le serveur est également un message. Vous pouvez facilement télécharger un fichier via WWW , comme ci-dessous:

Télécharger un fichier zip sur le serveur

string mainUrl = "http://server/upload/";
string saveLocation;

void Start() 
{
    saveLocation = "ftp:///home/xxx/x.zip"; // The file path.
    StartCoroutine(PrepareFile());
}

// Prepare The File.
IEnumerator PrepareFile() 
{
    Debug.Log("saveLoacation = " + saveLocation);
     
    // Read the zip file.
    WWW loadTheZip = new WWW(saveLocation);

    yield return loadTheZip;

    PrepareStepTwo(loadTheZip);
}

void PrepareStepTwo(WWW post) 
{
    StartCoroutine(UploadTheZip(post));
}

// Upload.
IEnumerator UploadTheZip(WWW post) 
{
    // Create a form.
    WWWForm form = new WWWForm();
 
    // Add the file.
    form.AddBinaryData("myTestFile.zip",post.bytes,"myFile.zip","application/zip");
 
    // Send POST request.
    string url = mainUrl;
    WWW POSTZIP = new WWW(url,form);
 
    Debug.Log("Sending zip...");
    yield return POSTZIP;
    Debug.Log("Zip sent!");
}

Dans cet exemple, la coroutine est utilisée pour préparer et télécharger le fichier. Si vous souhaitez en savoir plus sur les coroutines de Unity, visitez le site de Coroutines .

Envoi d'une requête au serveur

Il y a plusieurs façons de communiquer avec les serveurs en utilisant Unity en tant que client (certaines méthodologies sont meilleures que d'autres selon votre objectif). Tout d'abord, il faut déterminer si le serveur doit pouvoir envoyer efficacement des opérations vers et depuis le serveur. Pour cet exemple, nous allons envoyer quelques données à notre serveur pour être validées.

Très probablement, le programmeur aura configuré une sorte de gestionnaire sur son serveur pour recevoir les événements et répondre au client en conséquence - toutefois, cela est hors de la portée de cet exemple.

C #:

using System.Net;
using System.Text;

public class TestCommunicationWithServer
{
    public string SendDataToServer(string url, string username, string password)
    {
        WebClient client = new WebClient();

        // This specialized key-value pair will store the form data we're sending to the server
        var loginData = new System.Collections.Specialized.NameValueCollection();
        loginData.Add("Username", username);
        loginData.Add("Password", password);

        // Upload client data and receive a response
        byte[] opBytes = client.UploadValues(ServerIpAddress, "POST", loginData);
    
        // Encode the response bytes into a proper string
        string opResponse = Encoding.UTF8.GetString(opBytes);

        return opResponse;
    }

La première chose à faire est de lancer des instructions qui nous permettent d’utiliser les classes WebClient et NameValueCollection.

Pour cet exemple, la fonction SendDataToServer prend en 3 paramètres de chaîne (facultatifs):

1. Url du serveur avec lequel nous communiquons
2. Première donnée
3. Deuxième donnée que nous envoyons au serveur

Le nom d'utilisateur et le mot de passe sont les données facultatives que j'envoie au serveur. Pour cet exemple, nous l'utilisons pour une validation ultérieure à partir d'une base de données ou de tout autre stockage externe.

Maintenant que nous avons configuré notre structure, nous allons instancier un nouveau WebClient pour envoyer nos données. Maintenant, nous devons charger nos données dans notre NameValueCollection et télécharger les données sur le serveur.

La fonction UploadValues ​​prend également 3 paramètres nécessaires:

1. Adresse IP du serveur
2. Méthode HTTP
3. Les données que vous envoyez (le nom d'utilisateur et le mot de passe dans notre cas)

Cette fonction renvoie un tableau d'octets de la réponse du serveur. Nous devons encoder le tableau d'octets renvoyés en une chaîne appropriée pour pouvoir manipuler et disséquer la réponse.

On pourrait faire quelque chose comme ça:

if(opResponse.Equals(ReturnMessage.Success))
{
    Debug.Log("Unity client has successfully sent and validated data on server.");
}

Maintenant, vous pourriez encore être confus, donc je suppose que je vais donner une brève explication sur la façon de gérer un serveur de réponse face.

Pour cet exemple, je vais utiliser PHP pour gérer la réponse du client. Je recommande d'utiliser PHP comme langage de script principal car il est très polyvalent, facile à utiliser et surtout rapide. Il existe certainement d'autres moyens de gérer une réponse sur un serveur, mais à mon avis, PHP est de loin l'implémentation la plus simple et la plus simple dans Unity.

PHP:

// Check to see if the unity client send the form data
if(!isset($_REQUEST['Username']) || !isset($_REQUEST['Password']))
{
    echo "Empty";
}
else
{ 
    // Unity sent us the data - its here so do whatever you want 
  
    echo "Success";
   
}

C'est donc la partie la plus importante - l'écho. Lorsque notre client télécharge les données sur le serveur, le client enregistre la réponse (ou la ressource) dans ce tableau d'octets. Une fois que le client a la réponse, vous savez que les données ont été validées et que vous pouvez passer au client une fois que cet événement est arrivé. Vous devez également réfléchir au type de données que vous envoyez (dans une certaine mesure) et à la manière de minimiser le montant réellement envoyé.

Il ne s’agit donc que d’une seule façon d’envoyer / recevoir des données de la part d’Unity. Selon votre projet, il existe d’autres moyens plus efficaces pour vous.