unity3d
Comunicación con el servidor

Obtener

Obtener es obtener datos del servidor web. y new WWW("https://urlexample.com"); con un url pero sin un segundo parámetro está haciendo un Get .

es decir

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 simple (Campos Post)

Cada instancia de WWW con un segundo parámetro es una publicación .

Aquí hay un ejemplo para publicar el ID de usuario y la contraseña en el servidor.

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

Publicar (subir un archivo)

Subir un archivo al servidor es también una publicación. Puede cargar fácilmente un archivo a través de WWW , como el siguiente:

Subir un archivo zip al servidor

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

En este ejemplo, usa la rutina para preparar y cargar el archivo. Si quieres saber más acerca de Unity coroutines, visita Coroutines .

Enviando una solicitud al servidor.

Hay muchas formas de comunicarse con los servidores utilizando Unity como cliente (algunas metodologías son mejores que otras según su propósito). Primero, uno debe determinar la necesidad del servidor para poder enviar operaciones de manera efectiva hacia y desde el servidor. Para este ejemplo, enviaremos algunos datos a nuestro servidor para validarlos.

Lo más probable es que el programador haya configurado algún tipo de controlador en su servidor para recibir eventos y responder al cliente en consecuencia, sin embargo, eso está fuera del alcance de este ejemplo.

DO#:

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

Lo primero que hay que hacer es tirar sus declaraciones de uso que nos permiten usar las clases WebClient y NameValueCollection.

Para este ejemplo, la función SendDataToServer toma 3 parámetros de cadena (opcionales):

1. Url del servidor con el que nos estamos comunicando.
2. Primer dato
3. Segunda pieza de datos que estamos enviando al servidor.

El nombre de usuario y la contraseña son los datos opcionales que estoy enviando al servidor. Para este ejemplo, lo estamos utilizando para validarlo luego desde una base de datos o cualquier otro almacenamiento externo.

Ahora que hemos configurado nuestra estructura, crearemos una instancia de un nuevo WebClient que se utilizará para enviar nuestros datos. Ahora necesitamos cargar nuestros datos en nuestra colección NameValue y cargar los datos en el servidor.

La función UploadValues ​​toma en 3 parámetros necesarios también:

1. Dirección IP del servidor
2. Método HTTP
3. Datos que está enviando (el nombre de usuario y la contraseña en nuestro caso)

Esta función devuelve una matriz de bytes de la respuesta del servidor. Necesitamos codificar la matriz de bytes devuelta en una cadena adecuada para poder manipular y diseccionar la respuesta.

Uno podría hacer algo como esto:

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

Ahora es posible que todavía esté confundido, así que supongo que le daré una breve explicación de cómo manejar un servidor de respuesta.

Para este ejemplo usaré PHP para manejar la respuesta del cliente. Recomiendo usar PHP como su lenguaje de scripts de back-end porque es súper versátil, fácil de usar y, sobre todo, rápido. Definitivamente hay otras formas de manejar una respuesta en un servidor, pero en mi opinión, PHP es, con mucho, la implementación más sencilla y sencilla en 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";
   
}

Así que esta es la parte más importante - el 'eco'. Cuando nuestro cliente carga los datos al servidor, el cliente guarda la respuesta (o recurso) en esa matriz de bytes. Una vez que el cliente tiene la respuesta, usted sabe que los datos se han validado y puede continuar en el cliente una vez que ese evento haya ocurrido. También debe pensar qué tipo de datos está enviando (hasta cierto punto) y cómo minimizar la cantidad que está enviando.

Así que esta es solo una forma de enviar / recibir datos de Unity: hay otras formas que pueden ser más efectivas para usted dependiendo de su proyecto.