/// <summary>
/// Sauvegarde les données d'un type d'anim à l'ouverture de l'Animation Manager
/// </summary>
/// <param name="pType">Type d'animation</param>
public void SaveAnim(Enums.AnimationType type)
{
SAVEANIM = new GameCoreAnimationSave();
switch (type)
{
case Enums.AnimationType.CharacterFace:
foreach (VO_Animation anims in Game.CharFacesAnimations)
{
SAVEANIM.CharFaces.Add(anims.Clone());
}
break;
case Enums.AnimationType.IconAnimation:
foreach (VO_Animation anims in Game.IconsAnimations)
{
SAVEANIM.Icons.Add(anims.Clone());
}
break;
case Enums.AnimationType.Menu:
foreach (VO_Animation anims in Game.MenusAnimations)
{
SAVEANIM.Menus.Add(anims.Clone());
}
break;
case Enums.AnimationType.ObjectAnimation:
foreach (VO_Animation anims in Game.ObjectAnimations)
{
SAVEANIM.ObjectAnimations.Add(anims.Clone());
}
break;
}
}
/// <summary>
/// Restaure la base de données d'animations
/// </summary>
/// <param name="pType">Type d'animations à sauver</param>
public void RestaureAnim(Enums.AnimationType type)
{
RunServiceTask(delegate
{
_Business.RestaureAnim(type);
}, Errors.ERROR_ANIMATION_STR_DBRESTORE, type.ToString());
}
/// <summary>
/// Create de l'animation
/// </summary>
/// <param name="item">Item</param>
/// <param name="IdCharacter">Id du character</param>
/// <param name="type">Type d'anim</param>
/// <param name="x">Position X</param>
/// <param name="y">Position Y</param>
private void CreateAnimation(Guid itemId, Guid IdCharacter, Enums.AnimationType type, int x, int y, ViewerEnums.ImageResourceType resourceType)
{
ReadyToExecScript = true;
VO_Animation anim = null;
switch (type)
{
case Enums.AnimationType.CharacterAnimation:
anim = GameCore.Instance.GetCharAnimationById(IdCharacter, itemId);
break;
case Enums.AnimationType.CharacterFace:
anim = GameCore.Instance.GetCharFaceById(itemId);
break;
case Enums.AnimationType.IconAnimation:
anim = GameCore.Instance.GetIconById(itemId);
break;
case Enums.AnimationType.Menu:
anim = GameCore.Instance.GetMenuById(itemId);
break;
case Enums.AnimationType.ObjectAnimation:
anim = GameCore.Instance.GetAnimationById(itemId);
break;
}
CreateAnimation(itemId, IdCharacter, type, x, y, resourceType, anim.Row);
}
/// <summary>
/// Sauvegarde la base de données d'animations
/// </summary>
/// <param name="pType">Type d'animations à sauver</param>
public void SaveAnim(Enums.AnimationType type, Guid charId)
{
RunServiceTask(delegate
{
_Business.SaveAnim(type, charId);
}, Errors.ERROR_ANIMATION_STR_DBSAVE, type.ToString(), charId.ToString());
}
/// <summary>
/// Recharge les données à envoyer à l'Animation manager quand celle ci n'existe pas encore
/// </summary>
/// <param name="pAnimationType">Type d'animation</param>
public void ResetAnimationManager(Enums.AnimationType animationType)
{
AnimationManager.ParentCharacter = this.ParentCharacter;
AnimationManager.CurrentAnimation = null;
AnimationManager.OriginPoint = this.OriginPoint;
AnimationId = new Guid();
AnimationManager.AnimationType = animationType;
}
/// <summary>
/// Reason
/// </summary>
/// <param name="type">Animation type</param>
public static string GetReason(this Enums.AnimationType type)
{
if (type == Enums.AnimationType.Synchronous)
{
return("Animation");
}
return("AsynchronousAnimation");
}
/// <summary>
/// Recharge les données à envoyer à l'Animation manager
/// </summary>
/// <param name="pAnimationType">Type d'animation</param>
/// <param name="pSelectedAnimation">Id de l'animation sélectionnée</param>
public void ResetAnimationManager(Enums.AnimationType animationType, Guid selectedAnimation)
{
AnimationManager.ParentCharacter = this.ParentCharacter;
AnimationManager.AnimationType = animationType;
AnimationManager.OriginPoint = this.OriginPoint;
AnimationManager.CurrentAnimation = new VO_Animation(selectedAnimation, animationType);
AnimationId = selectedAnimation;
}
/// <summary>
/// Charge le VO_Animation en fonction du type
/// </summary>
/// <param name="pType">Type d'animation</param>
/// <param name="pId">Id de l'animation</param>
/// <returns>Animation</returns>
public VO_Animation LoadVOObject(Enums.AnimationType type, Guid id)
{
VO_Animation animation = null;
RunServiceTask(delegate
{
animation = _Business.LoadVOObject(type, id);
}, Errors.ERROR_ANIMATION_STR_LOAD, type.ToString(), id.ToString());
return(animation);
}
/// <summary>
/// Starts animation
/// </summary>
/// <param name="collection">Collection of components</param>
/// <param name="reasons">Reasons</param>
/// <param name="animationType">Type of animation</param>
/// <param name="pause">Pause</param>
/// <param name="timeScale">Time scale</param>
/// <param name="realTime">The "real time" sign</param>
/// <param name="absoluteTime">The "absolute time" sign</param>
/// <returns>Animation asynchronous calculation</returns>
public static object StartAnimation(IComponentCollection collection, string[] reasons,
Enums.AnimationType animationType,
TimeSpan pause, double timeScale, bool realTime, bool absoluteTime)
{
if (driver == null)
{
return(null);
}
return(driver.StartAnimation(collection, reasons,
animationType, pause, timeScale, realTime, absoluteTime));
}
/// <summary>
/// Charge la liste en fonction du type d'animation choisie
/// </summary>
/// <param name="pType">Type d'animation</param>
/// <returns>Liste de VO_Base</returns>
public List <VO_Base> ProvisionList(Enums.AnimationType type)
{
List <VO_Base> list = null;
RunServiceTask(delegate
{
list = _Business.ProvisionList(type);
}, Errors.ERROR_STR_LIST_PROVISION, type.ToString());
return(list);
}
/// <summary>
/// Crée une animation
/// </summary>
/// <param name="pType">Type d'animation</param>
/// <returns>VO_Animation</returns>
public VO_Animation CreateAnimation(Enums.AnimationType type)
{
VO_Animation animation = null;
RunServiceTask(delegate
{
animation = _Business.CreateAnimation(type);
}, Errors.ERROR_ANIMATION_STR_CREATE, type.ToString());
return(animation);
}
/// <summary>
/// Sauvegarde les données d'un type d'anim à l'ouverture de l'Animation Manager
/// </summary>
/// <param name="pType">Type d'animation</param>
public void SaveAnim(Enums.AnimationType type, Guid characterId)
{
SAVEANIM = new GameCoreAnimationSave();
VO_Character character = GetCharacterById(characterId);
SAVEANIM.CharacterId = characterId;
SAVEANIM.CharAnimations = new List <VO_Animation>();
foreach (VO_Animation anims in character.Animations)
{
SAVEANIM.CharAnimations.Add(anims.Clone());
}
}
/// <summary>
/// Restaure les données d'un type d'anim à la fermeture de l'Animation Manager
/// </summary>
/// <param name="pType">Type d'animation</param>
public void RestoreAnim(Enums.AnimationType pType)
{
switch (pType)
{
case Enums.AnimationType.CharacterAnimation:
VO_Character character = GetCharacterById(SAVEANIM.CharacterId);
character.Animations = new List <VO_Animation>();
foreach (VO_Animation anim in SAVEANIM.CharAnimations)
{
character.Animations.Add(anim.Clone());
}
break;
case Enums.AnimationType.CharacterFace:
Game.CharFacesAnimations = new List <VO_Animation>();
foreach (VO_Animation anim in SAVEANIM.CharFaces)
{
Game.CharFacesAnimations.Add(anim.Clone());
}
break;
case Enums.AnimationType.IconAnimation:
Game.IconsAnimations = new List <VO_Animation>();
foreach (VO_Animation anim in SAVEANIM.Icons)
{
Game.IconsAnimations.Add(anim.Clone());
}
break;
case Enums.AnimationType.Menu:
Game.MenusAnimations = new List <VO_Animation>();
foreach (VO_Animation anim in SAVEANIM.Menus)
{
Game.MenusAnimations.Add(anim.Clone());
}
break;
case Enums.AnimationType.ObjectAnimation:
Game.ObjectAnimations = new List <VO_Animation>();
foreach (VO_Animation anim in SAVEANIM.ObjectAnimations)
{
Game.ObjectAnimations.Add(anim.Clone());
}
break;
}
}
/// <summary>
/// Charge le VO_Animation en fonction du type
/// </summary>
/// <param name="pType">Type d'animation</param>
/// <param name="pId">Id de l'animation</param>
/// <returns>Animation</returns>
public VO_Animation LoadVOObject(Enums.AnimationType type, Guid id)
{
switch (type)
{
case Enums.AnimationType.CharacterFace:
return(GameCore.Instance.GetCharFaceById(id));
case Enums.AnimationType.IconAnimation:
return(GameCore.Instance.GetIconById(id));
case Enums.AnimationType.Menu:
return(GameCore.Instance.GetMenuById(id));
case Enums.AnimationType.ObjectAnimation:
return(GameCore.Instance.GetAnimationById(id));
}
throw new Exception();
}
/// <summary>
/// Charge la liste en fonction du type d'animation choisie
/// </summary>
/// <param name="pType">Type d'animation</param>
/// <returns>Liste de VO_Base</returns>
public List <VO_Base> ProvisionList(Enums.AnimationType type)
{
switch (type)
{
case Enums.AnimationType.CharacterFace:
return(GameCore.Instance.GetCharFaces());
case Enums.AnimationType.IconAnimation:
return(GameCore.Instance.GetIcons());
case Enums.AnimationType.Menu:
return(GameCore.Instance.GetMenus());
case Enums.AnimationType.ObjectAnimation:
return(GameCore.Instance.GetAnimations());
}
throw new Exception();
}
/// <summary>
/// Crée une animation
/// </summary>
/// <param name="pType">Type d'animation</param>
/// <returns>VO_Animation</returns>
public VO_Animation CreateAnimation(Enums.AnimationType type)
{
switch (type)
{
case Enums.AnimationType.CharacterFace:
return(ObjectsFactory.CreateCharFace());
case Enums.AnimationType.IconAnimation:
return(ObjectsFactory.CreateIconAnimation());
case Enums.AnimationType.Menu:
return(ObjectsFactory.CreateMenuAnimation());
case Enums.AnimationType.ObjectAnimation:
return(ObjectsFactory.CreateAnimation());
}
throw new Exception();
}
/// <summary>
/// Constructeur principal
/// </summary>
/// <param name="pAnimationType">Type d'animation</param>
public AnimationManager(Enums.AnimationType pAnimationType)
{
//Configuration par défaut
InitializeComponent();
//Initialisation de la couche Service
_Service = new AnimationService();
//AnimationType
AnimationType = pAnimationType;
//Frequency
ddpFrequency.Minimum = GlobalConstants.ANIMATION_MIN_FREQUENCY;
ddpFrequency.Maximum = GlobalConstants.ANIMATION_MAX_FREQUENCY;
ddpFrequency.Value = GlobalConstants.ANIMATION_NORMAL_FREQUENCY;
//Timer
_FrequencyTimer = new Timer();
_FrequencyTimer.Tick += new EventHandler(CallBack_Frequency);
}
/// <summary>
/// Récupérer une URI d'un dossier en fonction de la ressource demandée
/// </summary>
/// <param name="pPath">Type d'animation</param>
/// <returns>Chemin URI</returns>
public static string GetProjectPath(Enums.AnimationType path)
{
switch (path)
{
case Enums.AnimationType.CharacterAnimation:
return(GameCore.Instance.Game.Project.RootPath + GlobalConstants.PROJECT_DIR_RESOURCES + "\\" + GlobalConstants.PROJECT_DIR_ANIMATIONS + "\\" + GlobalConstants.PROJECT_DIR_CHARACTERANIMATIONS + "\\");
case Enums.AnimationType.CharacterFace:
return(GameCore.Instance.Game.Project.RootPath + GlobalConstants.PROJECT_DIR_RESOURCES + "\\" + GlobalConstants.PROJECT_DIR_ANIMATIONS + "\\" + GlobalConstants.PROJECT_DIR_CHARACTERFACES + "\\");
case Enums.AnimationType.IconAnimation:
return(GameCore.Instance.Game.Project.RootPath + GlobalConstants.PROJECT_DIR_RESOURCES + "\\" + GlobalConstants.PROJECT_DIR_ANIMATIONS + "\\" + GlobalConstants.PROJECT_DIR_ICONS + "\\");
case Enums.AnimationType.Menu:
return(GameCore.Instance.Game.Project.RootPath + GlobalConstants.PROJECT_DIR_RESOURCES + "\\" + GlobalConstants.PROJECT_DIR_ANIMATIONS + "\\" + GlobalConstants.PROJECT_DIR_MENUS + "\\");
case Enums.AnimationType.ObjectAnimation:
return(GameCore.Instance.Game.Project.RootPath + GlobalConstants.PROJECT_DIR_RESOURCES + "\\" + GlobalConstants.PROJECT_DIR_ANIMATIONS + "\\" + GlobalConstants.PROJECT_DIR_OBJECTANIMATIONS + "\\");
}
return(string.Empty);
}
public VO_Animation(Guid pID, Enums.AnimationType pType)
{
Id = pID;
AnimationType = pType;
}
/// <summary>
/// Constructeur
/// </summary>
/// <param name="item">Item</param>
/// <param name="IdCharacter">Id du character</param>
/// <param name="type">Type d'anim</param>
/// <param name="x">Position X</param>
/// <param name="y">Position Y</param>
public VO_AnimatedSprite(Guid itemId, Guid IdCharacter, Enums.AnimationType type, int x, int y, ViewerEnums.ImageResourceType resourceType, int rowOverload)
{
CreateAnimation(itemId, IdCharacter, type, x, y, resourceType, rowOverload);
}
/// <summary>
/// Sauvegarde la base de données d'animations
/// </summary>
/// <param name="pType">Type d'animations à sauver</param>
public void SaveAnim(Enums.AnimationType type, Guid charId)
{
GameCore.Instance.SaveAnim(type, charId);
}
/// <summary>
/// Sauvegarde la base de données d'animations
/// </summary>
/// <param name="pType">Type d'animations à sauver</param>
public void SaveAnim(Enums.AnimationType type)
{
GameCore.Instance.SaveAnim(type);
}
/// <summary>
/// Charge l'animation manager avec plusieurs paramètres
/// </summary>
/// <param name="pAnimationType">Type d'animation</param>
/// <param name="pSelectedAnimation">Animation actuellement sélectionnée</param>
/// <param name="pSelectedRow">Colonne actuellement utilisée</param>
public void LoadAnimationManager(Enums.AnimationType animationType, Guid selectedAnimation)
{
FormsManager.Instance.AnimationManagerContainer.ResetAnimationManager(animationType, selectedAnimation);
FormsManager.Instance.AnimationManagerContainer.ShowDialog();
}
/// <summary>
/// Restaure la base de données d'animations
/// </summary>
/// <param name="pType">Type d'animations à sauver</param>
public void RestaureAnim(Enums.AnimationType type)
{
GameCore.Instance.RestoreAnim(type);
}
/// <summary>
/// Constructeur
/// </summary>
/// <param name="item">Item</param>
/// <param name="type">Type d'anim</param>
/// <param name="x">Position X</param>
/// <param name="y">Position Y</param>
public VO_AnimatedSprite(Guid itemId, Enums.AnimationType type, int x, int y)
{
CreateAnimation(itemId, new Guid(), type, x, y, ViewerEnums.ImageResourceType.Screen);
}
/// <summary>
/// Constructeur
/// </summary>
/// <param name="item">Item</param>
/// <param name="IdCharacter">Id du character</param>
/// <param name="type">Type d'anim</param>
/// <param name="x">Position X</param>
/// <param name="y">Position Y</param>
public VO_AnimatedSprite(Guid itemId, Guid IdCharacter, Enums.AnimationType type, int x, int y)
{
CreateAnimation(itemId, IdCharacter, type, x, y, ViewerEnums.ImageResourceType.Screen);
}
/// <summary>
/// Create de l'animation
/// </summary>
/// <param name="item">Item</param>
/// <param name="IdCharacter">Id du character</param>
/// <param name="type">Type d'anim</param>
/// <param name="x">Position X</param>
/// <param name="y">Position Y</param>
private void CreateAnimation(Guid itemId, Guid IdCharacter, Enums.AnimationType type, int x, int y, ViewerEnums.ImageResourceType resourceType, int rowOverload)
{
//Récupérer l'animation
VO_Animation anim = null;
switch (type)
{
case Enums.AnimationType.CharacterAnimation:
anim = GameCore.Instance.GetCharAnimationById(IdCharacter, itemId);
break;
case Enums.AnimationType.CharacterFace:
anim = GameCore.Instance.GetCharFaceById(itemId);
break;
case Enums.AnimationType.IconAnimation:
anim = GameCore.Instance.GetIconById(itemId);
break;
case Enums.AnimationType.Menu:
anim = GameCore.Instance.GetMenuById(itemId);
break;
case Enums.AnimationType.ObjectAnimation:
anim = GameCore.Instance.GetAnimationById(itemId);
break;
}
if (!string.IsNullOrEmpty(anim.ResourcePath))
{
Texture2D resource = null;
////TODO: Vérifier l'existence de la ressource, sinon mettre une image par défaut DANS L'IMAGE MANAGER !!!!!
//String LocalPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\Resources\\";
//if (File.Exists(PathTools.GetProjectPath(type) + anim.ResourcePath) == false)
//{
// anim.ResourcePath = LocalPath + "Default.jpg";
//}
switch (resourceType)
{
case ViewerEnums.ImageResourceType.Screen:
resource = ImageManager.CurrentStage.GetScreenImage(PathTools.GetProjectPath(type) + anim.ResourcePath);
break;
case ViewerEnums.ImageResourceType.Permanent:
resource = ImageManager.GetPermanentImage(PathTools.GetProjectPath(type) + anim.ResourcePath);
break;
}
if (resource != null)
{
Frequency = (int)((double)(10000 / anim.Frequency) * 0.06);
Width = (uint)anim.SpriteWidth;
Height = (uint)anim.SpriteHeight;
int nbrSprites = (int)resource.Width / anim.SpriteWidth;
_Sprites = new VO_Sprite[nbrSprites];
_posX = x;
_posY = y;
AnimationId = anim.Id;
_CharacterId = IdCharacter;
_AnimationType = type;
_ResourceType = resourceType;
//Création des sprites
for (int i = 0; i < nbrSprites; i++)
{
Guid id = Guid.NewGuid();
int posX = i * (int)Width;
int posY = rowOverload * (int)Height;
switch (resourceType)
{
case ViewerEnums.ImageResourceType.Screen:
SpriteManager.CreateScreenSprite(id, PathTools.GetProjectPath(type) + anim.ResourcePath, new Vector2(x, y), new Rectangle(posX, rowOverload * (int)Height, (int)Width, (int)Height), null);
_Sprites[i] = SpriteManager.GetScreenSprite(id);
break;
case ViewerEnums.ImageResourceType.Permanent:
SpriteManager.CreatePermanentSprite(id, PathTools.GetProjectPath(type) + anim.ResourcePath, new Vector2(x, y), new Rectangle(posX, rowOverload * (int)Height, (int)Width, (int)Height), null);
_Sprites[i] = SpriteManager.GetPermanentSprite(id);
break;
}
_Sprites[i].Id = id;
}
_CurrentSprite = 0;
CurrentExecutingPage = -1;
}
}
else
{
_Sprites = new VO_Sprite[1];
_Sprites[0] = null;
}
}
/// <summary>
/// Charge l'animation manager avec plusieurs paramètres
/// </summary>
/// <param name="pAnimationType">Type d'animation</param>
/// <param name="pSelectedAnimation">Animation actuellement sélectionnée</param>
/// <param name="pSelectedRow">Colonne actuellement utilisée</param>
public void LoadAnimationManager(Enums.AnimationType pAnimationType, Guid pSelectedAnimation, int pSelectedRow)
{
FormsManager.instance.AnimationManagerContainer.ResetAnimationManager(pAnimationType, pSelectedAnimation, pSelectedRow);
FormsManager.Instance.AnimationManagerContainer.ShowDialog();
}
/// <summary>
/// Charge l'animation manager avec plusieurs paramètres
/// </summary>
/// <param name="pAnimationType">Type d'animation</param>
public void LoadAnimationManager(Enums.AnimationType pAnimationType)
{
FormsManager.instance.AnimationManagerContainer.ResetAnimationManager(pAnimationType);
FormsManager.Instance.AnimationManagerContainer.ShowDialog();
}
