Stratos: Punto de Encuentro de Desarrolladores

¡Bienvenido a Stratos!

Acceder

Foros





El cambio de perfiles no funciona bien con el avatarRenderer

Iniciado por Hans, 13 de Octubre de 2011, 06:40:08 PM

« anterior - próximo »

Hans

Si inicio sesión con un perfil aparece bien su avatar asociado. Cierro sesión y aparece uno random. Si vuelvo a cargar el mismo perfil vuelve a salir el mismo avatar. El problema es simple, si cargo otro perfil en vez de salir el avatar asociado a este nuevo perfil me sale el del anterior. El índice de mando es el mismo, obviamente, y pasa por LoadAvatar, así que sólo me queda que la lista de SignedGamers no se vacíe o algo así.

¿Alguna ocurrencia?


using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System.Collections.ObjectModel;
using AvatarPunch;
using EasyStorage;


public class cAvatarRenderer
{
    cBase dBase;

    public PlayerIndex PlayerIndex = PlayerIndex.One;
    public PlayerIndex playerIndexAnterior = PlayerIndex.One;

    AvatarRenderer avatarRenderer = null;
    AvatarDescription avatarDescription = null;

    enum cEstadoCargaAvatar { noCargado, comoUser, comoRandom };
    cEstadoCargaAvatar estadoCargaAvatar = cEstadoCargaAvatar.noCargado;

    float lightRotation = 90;
    Vector3 defaultAmbientColor = new Vector3(0.4f, 0.4f, 0.4f);
    Vector3 defaultLightColor = new Vector3(0.55f, 0.55f, 0.55f);

    bool necesitaComprobacionDeQueNoEsMismoPlayerQueElPrimero = false;

    public bool EsRandom = true;


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// Constructor
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public cAvatarRenderer(cBase dBase, bool necesitaComprobacionDeQueNoEsMismoPlayerQueElPrimero)
    {
        this.dBase = dBase;
        this.necesitaComprobacionDeQueNoEsMismoPlayerQueElPrimero = necesitaComprobacionDeQueNoEsMismoPlayerQueElPrimero;
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// Renderer
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public AvatarRenderer Renderer
    {
        get { return avatarRenderer; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// Description
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public AvatarDescription Description
    {
        get { return avatarDescription; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// World
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Matrix World
    {
        get { return avatarRenderer.World; }
        set { avatarRenderer.World = value; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// Projection
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Matrix Projection
    {
        get { return avatarRenderer.Projection; }
        set { avatarRenderer.Projection = value; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// View
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Matrix View
    {
        get { return avatarRenderer.View; }
        set { avatarRenderer.View = value; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// AmbientLightColor
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Vector3 AmbientLightColor
    {
        get { return avatarRenderer.AmbientLightColor; }
        set { avatarRenderer.AmbientLightColor = value; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// AmbientLightColor
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Vector3 LightColor
    {
        get { return avatarRenderer.LightColor; }
        set { avatarRenderer.LightColor = value; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// AmbientLightColor
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Vector3 LightDirection
    {
        get { return avatarRenderer.LightDirection; }
        set { avatarRenderer.LightDirection = value; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// LightRotation
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public float LightRotation
    {
        get { return lightRotation; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// DefaultAmbientColor
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Vector3 DefaultAmbientColor
    {
        get { return defaultAmbientColor; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// DefaultLightColor
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Vector3 DefaultLightColor
    {
        get { return defaultLightColor; }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// Ready
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public bool Ready
    {
        get { return ((avatarRenderer != null) && (avatarRenderer.State == AvatarRendererState.Ready)); }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// LoadAvatar
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if XBOX
    void LoadAvatar(Gamer gamer)
    {
        UnloadAvatar();

        AvatarDescription.BeginGetFromGamer(gamer, LoadAvatarDescription, null);
    }
#endif
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// LoadAvatarDescription
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if XBOX
    void LoadAvatarDescription(IAsyncResult result)
    {
        // Get the AvatarDescription for the gamer
        avatarDescription = AvatarDescription.EndGetFromGamer(result);

        // Load the avatarRenderer if description is valid
        if (avatarDescription.IsValid)
        {
            avatarRenderer = new AvatarRenderer(avatarDescription);
            EsRandom = false;
        }
        // Load random for an invalid description
        else
        {
            LoadRandomAvatar();
        }
    }
#endif
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// LoadRandomAvatar
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if XBOX
    void LoadRandomAvatar()
    {
        UnloadAvatar();

        avatarDescription = AvatarDescription.CreateRandom();
        avatarRenderer = new AvatarRenderer(avatarDescription);
        EsRandom = true;
    }
#endif
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// Unloads the current avatar
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if XBOX
    void UnloadAvatar()
    {
        // Dispose the current Avatar
        if (avatarRenderer != null)
        {
            avatarRenderer.Dispose();
            avatarRenderer = null;
        }
    }
#endif
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// UpdateCargaAvatar
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if XBOX
    public void UpdateCargaAvatar()
    {
        if (dBase.StartApretado)
        {
            bool playerValido = false;
            int indicePlayer = -1;

            for (int i = 0; i < Gamer.SignedInGamers.Count; i++)
            {
                if (Gamer.SignedInGamers[i].PlayerIndex == PlayerIndex)
                {
                    playerValido = true;
                    indicePlayer = i;
                }
            }

            if (necesitaComprobacionDeQueNoEsMismoPlayerQueElPrimero)
            {
                if (dBase.TipoPartida == AvatarPunch.AvatarPunch.cTipoPartida.TwoPlayers)
                {
                    if (dBase.RecalcularAvatarSegundoJugador)
                    {
                        dBase.RecalcularAvatarSegundoJugador = false;

                        if (playerValido)
                        {
                            LoadAvatar(Gamer.SignedInGamers[indicePlayer]);
                            estadoCargaAvatar = cEstadoCargaAvatar.comoUser;
                        }
                        else
                        {
                            LoadRandomAvatar();
                            estadoCargaAvatar = cEstadoCargaAvatar.comoRandom;
                        }
                    }

                    if (dBase.AvatarRendererPrimerJugador.Description == dBase.AvatarRendererSegundoJugador.Description)
                    {
                        LoadRandomAvatar();
                        playerValido = false;
                    }
                }
                else
                {
                    if (dBase.AvatarRendererPrimerJugador.Description == dBase.AvatarRendererSegundoJugador.Description)
                    {
                        LoadRandomAvatar();
                        playerValido = false;
                    }
                }
            }
            else TenerEnCuentaEstado(playerValido, indicePlayer);
        }
    }
#endif
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// TenerEnCuentaEstado
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void TenerEnCuentaEstado(bool playerValido, int indicePlayer)
    {
        switch (estadoCargaAvatar)
        {
            case cEstadoCargaAvatar.noCargado:
                if (avatarDescription == null)
                {
                    if (playerValido)
                    {
                        LoadAvatar(Gamer.SignedInGamers[indicePlayer]);
                        estadoCargaAvatar = cEstadoCargaAvatar.comoUser;
                    }
                    else
                    {
                        LoadRandomAvatar();
                        estadoCargaAvatar = cEstadoCargaAvatar.comoRandom;
                    }
                }
                break;

            case cEstadoCargaAvatar.comoRandom:
                if (playerValido)
                {
                    LoadAvatar(Gamer.SignedInGamers[indicePlayer]);
                    estadoCargaAvatar = cEstadoCargaAvatar.comoUser;
                }
                break;

            case cEstadoCargaAvatar.comoUser:
                if (!playerValido)
                {
                    LoadRandomAvatar();
                    estadoCargaAvatar = cEstadoCargaAvatar.comoRandom;
                }
                break;
        }
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// ForceRandom
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public void ForceRandom()
    {
        LoadRandomAvatar();
        estadoCargaAvatar = cEstadoCargaAvatar.comoRandom;
    }
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>
    /// Draw
    /// </summary>
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public void Draw(IList<Matrix> bones, AvatarExpression expression)
    {
        avatarRenderer.Draw(bones, expression);
    }
}

WaaghMan

Es un bug del Framework reportado y reconocido. A mí también me ha pasado y no hay nada que se pueda hacer para evitarlo (con reiniciar el juego se arregla).
Milkstone Studios - Autores de Avatar Ninja!, Little Racers, MotorHEAT y Wool en Xbox Live Indie Games

Hans

¿En serio? Joder, todo el día perdido haciendo pruebas como un idiota T_T Y lo peor es que no he subido el juego por eso. En fin, mañana lo subo con todos los cambios T_T

Muchas gracias :P

Por cierto, tb he detectado otro que puede ser un bug. Si cargas y descargas el avatar de un jugador muchas veces al final deja de cargar. Parece ser hacia la quinta vez, más o menos. Lo he arreglado simplemente guardando el avatar y sólo recalculándolo si la descripción ha cambiado. Pero vaya tela de fallos más rebuscados. Estaba convencido de que era cosa mía todo.

WaaghMan

Del segundo problema no tengo constancia. En nuestros juegos creo y destruyo el AvatarRenderer constantemente (no sé si te refieres a eso, la descripción sí que la conservo) y sin problemas.
Milkstone Studios - Autores de Avatar Ninja!, Little Racers, MotorHEAT y Wool en Xbox Live Indie Games






Stratos es un servicio gratuito, cuyos costes se cubren en parte con la publicidad.
Por favor, desactiva el bloqueador de anuncios en esta web para ayudar a que siga adelante.
Muchísimas gracias.