unity3d
Comunicazione con il server

Ottenere

Ottenere sta ottenendo dati dal server web. e new WWW("https://urlexample.com"); con un URL ma senza un secondo parametro sta facendo un Get .

vale a 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.
    }
}

Post semplice (campi postali)

Ogni istanza di WWW con un secondo parametro è un post .

Ecco un esempio per inviare ID utente e password al server.

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");
    }
}

Posta (Carica un file)

Carica un file sul server è anche un post. Puoi facilmente caricare un file tramite WWW , come il seguente:

Carica un file zip sul server

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!");
}

In questo esempio, usa la coroutine per preparare e caricare il file, se vuoi saperne di più sulle coroutine Unity, visita Coroutines .

Invio di una richiesta al server

Esistono molti modi per comunicare con i server utilizzando Unity come client (alcune metodologie sono migliori di altre a seconda del tuo scopo). Innanzitutto, è necessario determinare la necessità del server di essere in grado di inviare in modo efficace le operazioni da e verso il server. Per questo esempio, invieremo alcune parti di dati al nostro server per essere convalidate.

Molto probabilmente, il programmatore avrà impostato una sorta di gestore sul proprio server per ricevere gli eventi e rispondere di conseguenza al client, tuttavia ciò non rientra nell'ambito di questo esempio.

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 prima cosa da fare è lanciare le loro istruzioni using che ci permettono di usare le classi WebClient e NameValueCollection.

Per questo esempio la funzione SendDataToServer accetta 3 parametri di stringa (facoltativi):

1. URL del server con cui comunichiamo
2. Primo pezzo di dati
3. Secondo pezzo di dati che stiamo inviando al server

Il nome utente e la password sono i dati opzionali che invio al server. Per questo esempio lo stiamo usando per essere poi ulteriormente convalidato da un database o da qualsiasi altra memoria esterna.

Ora che abbiamo impostato la nostra struttura, istanziamo un nuovo WebClient da utilizzare per inviare effettivamente i nostri dati. Ora dobbiamo caricare i nostri dati nel nostro NameValueCollection e caricare i dati sul server.

La funzione UploadValues ​​accetta anche 3 parametri necessari:

1. Indirizzo IP del server
2. Metodo HTTP
3. Dati che stai inviando (nome utente e password nel nostro caso)

Questa funzione restituisce una matrice di byte della risposta dal server. Abbiamo bisogno di codificare il byte array restituito in una stringa corretta per poter essere in grado di manipolare e sezionare la risposta.

Si potrebbe fare qualcosa del genere:

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

Ora potresti ancora essere confuso, quindi suppongo che darò una breve spiegazione su come gestire un lato server di risposta.

Per questo esempio userò PHP per gestire la risposta dal client. Ti consiglio di utilizzare PHP come linguaggio di scripting back-end perché è super versatile, facile da usare e soprattutto veloce. Ci sono sicuramente altri modi per gestire una risposta su un server, ma a mio parere il PHP è di gran lunga la più semplice e semplice implementazione in 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";
   
}

Quindi questa è la parte più importante - l '"eco". Quando il nostro client carica i dati sul server, il client salva la risposta (o la risorsa) in quell'array di byte. Una volta che il cliente ha risposto, sai che i dati sono stati convalidati e puoi andare avanti nel client una volta che l'evento è successo. Devi anche pensare a quale tipo di dati stai inviando (in una certa misura) e come minimizzare l'importo che stai effettivamente inviando.

Quindi questo è solo un modo per inviare / ricevere dati da Unity - ci sono altri modi che potrebbero essere più efficaci per te in base al tuo progetto.