El cambio de perfiles no funciona bien con el avatarRenderer

[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?

Código [Seleccionar] Expand

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).

[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.