CharacterActions.cs

using System;
using System.Linq;
using AutomaticTypeMapper;
using EOLib.Domain.Extensions;
using EOLib.Domain.NPC;
using EOLib.Domain.Spells;
using EOLib.IO.Repositories;
using EOLib.Net;
using EOLib.Net.Communication;

namespace EOLib.Domain.Character
{
    [AutoMappedType]
    public class CharacterActions : ICharacterActions
    {
        private readonly IPacketSendService _packetSendService;
        private readonly ICharacterRepository _characterRepository;
        private readonly IESFFileProvider _spellFileProvider;
        private readonly IGameStartTimeProvider _gameStartTimeProvider;

        public CharacterActions(IPacketSendService packetSendService,
                                ICharacterRepository characterRepository,
                                IESFFileProvider spellFileProvider,
                                IGameStartTimeProvider gameStartTimeProvider)
        {
            _packetSendService = packetSendService;
            _characterRepository = characterRepository;
            _spellFileProvider = spellFileProvider;
            _gameStartTimeProvider = gameStartTimeProvider;
        }

        public void Face(EODirection direction)
        {
            var packet = new PacketBuilder(PacketFamily.Face, PacketAction.Player)
                .AddChar((int)direction)
                .Build();

            _packetSendService.SendPacket(packet);
        }

        public void Walk()
        {
            var admin = _characterRepository.MainCharacter.NoWall &&
                        _characterRepository.MainCharacter.AdminLevel != AdminLevel.Player;
            var renderProperties = _characterRepository.MainCharacter.RenderProperties;

            var packet = new PacketBuilder(PacketFamily.Walk, admin ? PacketAction.Admin : PacketAction.Player)
                .AddChar((int)renderProperties.Direction)
                .AddThree(_gameStartTimeProvider.TimeStamp)
                .AddChar(renderProperties.GetDestinationX())
                .AddChar(renderProperties.GetDestinationY())
                .Build();

            _packetSendService.SendPacket(packet);
        }

        public void Attack()
        {
            var c = _characterRepository.MainCharacter;
            var sp = Math.Max(0, c.Stats[CharacterStat.SP] - 1);
            _characterRepository.MainCharacter = c.WithStats(c.Stats.WithNewStat(CharacterStat.SP, sp));

            var packet = new PacketBuilder(PacketFamily.Attack, PacketAction.Use)
                .AddChar((int) _characterRepository.MainCharacter.RenderProperties.Direction)
                .AddThree(_gameStartTimeProvider.TimeStamp)
                .Build();

            _packetSendService.SendPacket(packet);
        }

        public void ToggleSit()
        {
            var renderProperties = _characterRepository.MainCharacter.RenderProperties;
            var sitAction = renderProperties.SitState == SitState.Standing
                ? SitAction.Sit
                : SitAction.Stand;

            var packetFamily = renderProperties.SitState == SitState.Chair
                ? PacketFamily.Chair
                : PacketFamily.Sit;

            var packet = new PacketBuilder(packetFamily, PacketAction.Request)
                .AddChar((int)sitAction)
                .Build();

            _packetSendService.SendPacket(packet);
        }

        public void SitInChair()
        {
            var rp = _characterRepository.MainCharacter.RenderProperties;
            var action = rp.SitState == SitState.Chair ? SitAction.Stand : SitAction.Sit;
            var packet = new PacketBuilder(PacketFamily.Chair, PacketAction.Request)
                .AddChar((int)action)
                .AddChar(rp.GetDestinationX())
                .AddChar(rp.GetDestinationY())
                .Build();

            _packetSendService.SendPacket(packet);
        }

        public void PrepareCastSpell(int spellId)
        {
            var packet = new PacketBuilder(PacketFamily.Spell, PacketAction.Request)
                .AddShort(spellId)
                .AddThree(_gameStartTimeProvider.TimeStamp)
                .Build();

            _packetSendService.SendPacket(packet);
        }

        public void CastSpell(int spellId, ISpellTargetable target)
        {
            var data = _spellFileProvider.ESFFile.Single(x => x.ID == spellId);

            var c = _characterRepository.MainCharacter;
            var sp = Math.Max(0, c.Stats[CharacterStat.SP] - data.SP);
            _characterRepository.MainCharacter = c.WithStats(c.Stats.WithNewStat(CharacterStat.SP, sp));

            var action = data.Target == IO.SpellTarget.Self
                ? PacketAction.TargetSelf
                : data.Target == IO.SpellTarget.Normal
                    ? PacketAction.TargetOther
                    : data.Target == IO.SpellTarget.Group
                        ? PacketAction.TargetGroup
                        : throw new InvalidOperationException("Spell ID has unknown spell target");

            IPacketBuilder builder = new PacketBuilder(PacketFamily.Spell, action);

            if (data.Target == IO.SpellTarget.Group)
            {
                builder = builder
                    .AddShort(spellId)
                    .AddThree(_gameStartTimeProvider.TimeStamp);
            }
            else
            {
                var spellTargetType = target is NPC.NPC
                    ? SpellTargetType.NPC
                    : target is Character
                        ? SpellTargetType.Player
                        : throw new InvalidOperationException("Invalid spell target specified, must be player or character");
                builder = builder.AddChar((int)spellTargetType);

                if (data.Target == IO.SpellTarget.Normal)
                {
                    builder = builder
                        .AddChar(1) // unknown
                        .AddShort(1) // unknown
                        .AddShort(spellId)
                        .AddShort(target.Index)
                        .AddThree(_gameStartTimeProvider.TimeStamp);
                }
                else
                {
                    builder = builder
                        .AddShort(spellId)
                        .AddInt(_gameStartTimeProvider.TimeStamp);
                }
            }

            _packetSendService.SendPacket(builder.Build());
        }

        public void Emote(Emote whichEmote)
        {
            var packet = new PacketBuilder(PacketFamily.Emote, PacketAction.Report)
                .AddChar((int)whichEmote)
                .Build();

            _packetSendService.SendPacket(packet);
        }
    }

    public interface ICharacterActions
    {
        void Face(EODirection direction);

        void Walk();

        void Attack();

        void ToggleSit();

        void SitInChair();

        void PrepareCastSpell(int spellId);

        void CastSpell(int spellId, ISpellTargetable target);

        void Emote(Emote whichEmote);
    }
}