MonoGame.Samples/RolePlayingGame/RolePlayingGameData/Characters/Character.cs

//-----------------------------------------------------------------------------
// Character.cs
//
// Microsoft XNA Community Game Platform
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------

using System;
using System.Diagnostics;
using System.IO;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace RolePlaying.Data
{
    /// <summary>
    /// A character in the game world.
    /// </summary>
#if !XBOX
    [DebuggerDisplay("Name = {name}")]
#endif
    public abstract partial class Character : WorldObject
    {
        /// <summary>
        /// The state of this character.
        /// </summary>
        private CharacterState state = CharacterState.Idle;

        /// <summary>
        /// The state of this character.
        /// </summary>
        [ContentSerializerIgnore]
        public CharacterState State
        {
            get { return state; }
            set { state = value; }
        }


        /// <summary>
        /// Returns true if the character is dead or dying.
        /// </summary>
        public bool IsDeadOrDying
        {
            get
            {
                return ((State == CharacterState.Dying) ||
                    (State == CharacterState.Dead));
            }
        }






        /// <summary>
        /// The position of this object on the map.
        /// </summary>
        private Point mapPosition;

        /// <summary>
        /// The position of this object on the map.
        /// </summary>
        [ContentSerializerIgnore]
        public Point MapPosition
        {
            get { return mapPosition; }
            set { mapPosition = value; }
        }


        /// <summary>
        /// The orientation of this object on the map.
        /// </summary>
        private Direction direction;

        /// <summary>
        /// The orientation of this object on the map.
        /// </summary>
        [ContentSerializerIgnore]
        public Direction Direction
        {
            get { return direction; }
            set { direction = value; }
        }






        /// <summary>
        /// The animating sprite for the map view of this character.
        /// </summary>
        private AnimatingSprite mapSprite;

        /// <summary>
        /// The animating sprite for the map view of this character.
        /// </summary>
        [ContentSerializer(Optional = true)]
        public AnimatingSprite MapSprite
        {
            get { return mapSprite; }
            set { mapSprite = value; }
        }


        /// <summary>
        /// The animating sprite for the map view of this character as it walks.
        /// </summary>
        /// <remarks>
        /// If this object is null, then the animations are taken from MapSprite.
        /// </remarks>
        private AnimatingSprite walkingSprite;

        /// <summary>
        /// The animating sprite for the map view of this character as it walks.
        /// </summary>
        /// <remarks>
        /// If this object is null, then the animations are taken from MapSprite.
        /// </remarks>
        [ContentSerializer(Optional = true)]
        public AnimatingSprite WalkingSprite
        {
            get { return walkingSprite; }
            set { walkingSprite = value; }
        }


        /// <summary>
        /// Reset the animations for this character.
        /// </summary>
        public virtual void ResetAnimation(bool isWalking)
        {
            state = isWalking ? CharacterState.Walking : CharacterState.Idle;
            if (mapSprite != null)
            {
                if (isWalking && mapSprite["Walk" + Direction.ToString()] != null)
                {
                    mapSprite.PlayAnimation("Walk", Direction);
                }
                else
                {
                    mapSprite.PlayAnimation("Idle", Direction);
                }
            }
            if (walkingSprite != null)
            {
                if (isWalking && walkingSprite["Walk" + Direction.ToString()] != null)
                {
                    walkingSprite.PlayAnimation("Walk", Direction);
                }
                else
                {
                    walkingSprite.PlayAnimation("Idle", Direction);
                }
            }
        }


        /// <summary>
        /// The small blob shadow that is rendered under the characters.
        /// </summary>
        private Texture2D shadowTexture;

        /// <summary>
        /// The small blob shadow that is rendered under the characters.
        /// </summary>
        [ContentSerializerIgnore]
        public Texture2D ShadowTexture
        {
            get { return shadowTexture; }
            set { shadowTexture = value; }
        }







        /// <summary>
        /// The default idle-animation interval for the animating map sprite.
        /// </summary>
        private int mapIdleAnimationInterval = 200;

        /// <summary>
        /// The default idle-animation interval for the animating map sprite.
        /// </summary>
        [ContentSerializer(Optional = true)]
        public int MapIdleAnimationInterval
        {
            get { return mapIdleAnimationInterval; }
            set { mapIdleAnimationInterval = value; }
        }


        /// <summary>
        /// Add the standard character idle animations to this character.
        /// </summary>
        internal void AddStandardCharacterIdleAnimations()
        {
            if (mapSprite != null)
            {
                mapSprite.AddAnimation(new Animation("IdleSouth", 1, 6,
                    MapIdleAnimationInterval, true));
                mapSprite.AddAnimation(new Animation("IdleSouthwest", 7, 12,
                    MapIdleAnimationInterval, true));
                mapSprite.AddAnimation(new Animation("IdleWest", 13, 18,
                    MapIdleAnimationInterval, true));
                mapSprite.AddAnimation(new Animation("IdleNorthwest", 19, 24,
                    MapIdleAnimationInterval, true));
                mapSprite.AddAnimation(new Animation("IdleNorth", 25, 30,
                    MapIdleAnimationInterval, true));
                mapSprite.AddAnimation(new Animation("IdleNortheast", 31, 36,
                    MapIdleAnimationInterval, true));
                mapSprite.AddAnimation(new Animation("IdleEast", 37, 42,
                    MapIdleAnimationInterval, true));
                mapSprite.AddAnimation(new Animation("IdleSoutheast", 43, 48,
                    MapIdleAnimationInterval, true));
            }
        }


        /// <summary>
        /// The default walk-animation interval for the animating map sprite.
        /// </summary>
        private int mapWalkingAnimationInterval = 80;

        /// <summary>
        /// The default walk-animation interval for the animating map sprite.
        /// </summary>
        [ContentSerializer(Optional = true)]
        public int MapWalkingAnimationInterval
        {
            get { return mapWalkingAnimationInterval; }
            set { mapWalkingAnimationInterval = value; }
        }


        /// <summary>
        /// Add the standard character walk animations to this character.
        /// </summary>
        internal void AddStandardCharacterWalkingAnimations()
        {
            AnimatingSprite sprite = (walkingSprite == null ? mapSprite : walkingSprite);
            if (sprite != null)
            {
                sprite.AddAnimation(new Animation("WalkSouth", 1, 6,
                    MapWalkingAnimationInterval, true));
                sprite.AddAnimation(new Animation("WalkSouthwest", 7, 12,
                    MapWalkingAnimationInterval, true));
                sprite.AddAnimation(new Animation("WalkWest", 13, 18,
                    MapWalkingAnimationInterval, true));
                sprite.AddAnimation(new Animation("WalkNorthwest", 19, 24,
                    MapWalkingAnimationInterval, true));
                sprite.AddAnimation(new Animation("WalkNorth", 25, 30,
                    MapWalkingAnimationInterval, true));
                sprite.AddAnimation(new Animation("WalkNortheast", 31, 36,
                    MapWalkingAnimationInterval, true));
                sprite.AddAnimation(new Animation("WalkEast", 37, 42,
                    MapWalkingAnimationInterval, true));
                sprite.AddAnimation(new Animation("WalkSoutheast", 43, 48,
                    MapWalkingAnimationInterval, true));
            }
        }

        /// <summary>
        /// Reads a Character object from the content pipeline.
        /// </summary>
        public class CharacterReader : ContentTypeReader<Character>
        {
            /// <summary>
            /// Reads a Character object from the content pipeline.
            /// </summary>
            protected override Character Read(ContentReader input,
                Character existingInstance)
            {
                Character character = existingInstance;
                if (character == null)
                {
                    throw new ArgumentNullException("existingInstance");
                }

                input.ReadRawObject<WorldObject>(character as WorldObject);

                character.MapIdleAnimationInterval = input.ReadInt32();
                character.MapSprite = input.ReadObject<AnimatingSprite>();
                if (character.MapSprite != null)
                {
                    character.MapSprite.SourceOffset =
                        new Vector2(
                        character.MapSprite.SourceOffset.X - 32,
                        character.MapSprite.SourceOffset.Y - 32);
                }
                character.AddStandardCharacterIdleAnimations();

                character.MapWalkingAnimationInterval = input.ReadInt32();
                character.WalkingSprite = input.ReadObject<AnimatingSprite>();
                if (character.WalkingSprite != null)
                {
                    character.WalkingSprite.SourceOffset =
                        new Vector2(
                        character.WalkingSprite.SourceOffset.X - 32,
                        character.WalkingSprite.SourceOffset.Y - 32);
                }
                character.AddStandardCharacterWalkingAnimations();

                character.ResetAnimation(false);

                character.shadowTexture = input.ContentManager.Load<Texture2D>(Path.Combine("Textures", "Characters", "CharacterShadow"));

                return character;
            }
        }
    }
}