//-------------------------------------------------------------------------------------[]
        private void EventPreProcess(
            ICombatUpdatePack pack,
            ICombatEvent combatEvent)
        {
            switch (combatEvent.Type)
            {
            case CombatEventType.EndCombat:
                _matchId       = combatEvent.Combat.Value;
                _queueFighters = new QueueFighters[0];
                break;

            case CombatEventType.StartRound: {
                var newFighters = GetNewQueryFighters(pack,
                                                      combatEvent.Fighters);
                _queueFighters =
                    _queueFighters.Union(
                        newFighters.Where(
                            queueFighter => !_queueFighters.ExistsByProperty(f => f.FighterId,
                                                                             queueFighter.
                                                                             FighterId))).
                    ToArray();
            }
            break;

            case CombatEventType.Death:
                RemoveDeadGolemFromQueue(combatEvent.ActiveFighter);
                break;
            }

            Requirements.WriteToLogBeforeProcess(combatEvent, pack.OldModel);
        }
예제 #2
0
    private void ProcessAttackEvent(ICombatEvent combatEvent, ICombatPerson senderPerson,
                                    HashSet <CombatPersonModel> deadPersonModels)
    {
        if (!(combatEvent is AttackCombatEvent attackEvent))
        {
            return;
        }

        var senderModel = FindCombatPersonModel(senderPerson);
        var targetModel = FindCombatPersonModel(attackEvent.Target);

        CreateWeaponTracer(senderModel.transform.position, targetModel.transform.position);
        CreateShootFlash(senderModel.transform.position);
        ShakeCamera(.5f, .05f);

        var damageIndicator = Instantiate(DamageIndicatorPrefab, Parent);

        damageIndicator.transform.position = targetModel.transform.position + Vector3.up * 1.5f;
        damageIndicator.Canvas.worldCamera = Camera.main;

        switch (attackEvent.Result)
        {
        case AttackSuccessResult attackEventResult:
        {
            damageIndicator.SetDamage(attackEventResult.Damage);

            if (attackEventResult.TargetIsDead)
            {
                deadPersonModels.Add(targetModel);
            }

            break;
        }

        case AttackMissResult _:
        {
            damageIndicator.SetMiss();
            break;
        }
        }
    }
예제 #3
0
        public IPacket ReadPacket(IMinecraftDataReader reader)
        {
            Event = reader.ReadVarInt();

            switch (Event)
            {
            case 0:
                CombatEvent = new CombatEventEnterCombat().FromReader(reader);
                break;

            case 1:
                CombatEvent = new CombatEventEndCombat().FromReader(reader);
                break;

            case 2:
                CombatEvent = new CombatEventEntityDead().FromReader(reader);
                break;
            }


            return(this);
        }
        public IPacket ReadPacket(IMinecraftDataReader reader)
        {
            Event = reader.ReadVarInt();

            switch (Event)
            {
                case 0:
                    CombatEvent = new CombatEventEnterCombat().FromReader(reader);
                    break;

                case 1:
                    CombatEvent = new CombatEventEndCombat().FromReader(reader);
                    break;

                case 2:
                    CombatEvent = new CombatEventEntityDead().FromReader(reader);
                    break;
            }


            return this;
        }
        //-------------------------------------------------------------------------------------[]
        private void EventPostProcess(
            ICombatUpdatePack pack,
            ICombatEvent combatEvent)
        {
            Requirements.WriteToLogAfterProcess(combatEvent, pack.OldModel);
            switch (combatEvent.Type)
            {
            case CombatEventType.GolemsAnimationEnded:
                Requirements.SendGolemsAnimationEnded();
                break;

            case CombatEventType.StartCombat:
                _startCombatTime = DateTime.Now;
                break;

            case CombatEventType.EndCombat:
                _endCombatTime = DateTime.Now;
                if (OnEndCombat != null)
                {
                    OnEndCombat();
                }
                break;
            }
        }