public override void SendCommand(CharacterCommands command)
	{
		switch(command)
		{
		case CharacterCommands.Crouch:
			UpdateState(HumanBodyStates.CrouchWalk);
			break;
		case CharacterCommands.ThrowGrenade:
			UpdateState(HumanBodyStates.StandIdle);
			break;
		case CharacterCommands.Throw:
			UpdateState(HumanBodyStates.StandIdle);
			break;
		case CharacterCommands.LeftAttack:
			UpdateState(HumanBodyStates.StandIdle);
			break;
		case CharacterCommands.RightAttack:
			UpdateState(HumanBodyStates.StandIdle);
			break;
		case CharacterCommands.Block:
			UpdateState(HumanBodyStates.StandIdle);
			break;
		case CharacterCommands.Idle:
			UpdateState(HumanBodyStates.StandIdle);
			break;
		}
	}
示例#2
0
        public async Task ConfirmCharDel(SocketReaction reaction, IUserMessage msg)
        {
            if (reaction.Emote.ToString() == ok)
            {
                string id = reaction.UserId + "\\" + data;
                Player p  = Player.Load(id, Player.IgnoreException.All);
                await p.DeleteFileMongo();

                if (p.Area != null && p.Area.name != "Moceoy's Basement")
                {
                    NPCSystems.NPC revival = NPCSystems.NPC.GenerateNPC(p.level, "Choichoith");
                    if (revival != null)
                    {
                        revival.inventory.inv.AddRange(p.inventory.inv);
                        NPCSystems.PopulationHandler.Add(p.Area, revival);
                    }
                }
                await TryMSGDel(msg);

                await CharacterCommands.ListCharacters(reaction.User.Value, reaction.Channel);
            }
            else if (reaction.Emote.ToString() == cancel)
            {
                await TryMSGDel(msg);
            }
        }
示例#3
0
    public override void SendCommand(CharacterCommands command)
    {
        switch (command)
        {
        case CharacterCommands.GoToPosition:
            if (this.ParentCharacter.CurrentStance == HumanStances.Sprint)
            {
                UpdateState(HumanBodyStates.WalkForward);
            }
            else
            {
                UpdateState(HumanBodyStates.CrouchWalk);
            }
            break;

        case CharacterCommands.StopCrouch:
            UpdateState(HumanBodyStates.StandIdle);
            break;

        case CharacterCommands.ThrowGrenade:
            //_aimFreelookAngle = 0;
            //_noAimFreelookAngle = 0;
            break;
        }
    }
示例#4
0
 void EatState()
 {
     if (chara.FoodList.Count != 0)
     {
         CharacterCommands.Eat(chara, chara.FoodList[0]);
     }
 }
示例#5
0
    // Update is called once per frame
    void Update()
    {
        StateSetter();
        switch (charaState)
        {
        case States.Moving:
            if (enemy && Vector2.Distance(transform.position, enemy.transform.position) <= chara.Vision && !enemy.IsDead)
            {
                CharacterCommands.SetPath(chara, enemy.transform.position);
            }
            else if (target)
            {
                CharacterCommands.SetPath(chara, target.position);
            }
            break;

        case States.Attacking:
            AttackState();
            break;

        case States.Eating:
            EatState();
            break;

        case States.Seeking:
            SeekState();
            break;

        default:
            break;
        }
    }
示例#6
0
        public async Task ConfirmSkills(SocketReaction reaction, IUserMessage msg)
        {
            if (reaction.Emote.ToString() == ok)
            {
                player.health  = player.Health();
                player.stamina = player.Stamina();
                player.SaveFileMongo();
                await TryMSGDel(msg);

                await CharacterCommands.ChooseRace(player, reaction.Channel);
            }
            else if (reaction.Emote.ToString() == cancel)
            {
                int[] rolls = Utils.JSON <int[]>(data.Split(';')[0]);
                player.stats.endurance    = 0;
                player.stats.intelligence = 0;
                player.stats.strength     = 0;
                player.stats.charisma     = 0;
                player.stats.dexterity    = 0;
                player.stats.perception   = 0;
                player.SaveFileMongo();
                await TryMSGDel(msg);

                await CharacterCommands.SetSkills(player, reaction.Channel, 0, rolls, new bool[6]);
            }
        }
 public override void SendCommand(CharacterCommands command)
 {
     if (command == CharacterCommands.AnimationActionDone)
     {
         UpdateState(MutantBodyStates.Idle);
     }
 }
    public override void SendCommand(CharacterCommands command)
    {
        switch (command)
        {
        case CharacterCommands.Crouch:
            UpdateState(HumanBodyStates.CrouchWalk);
            break;

        case CharacterCommands.ThrowGrenade:
            UpdateState(HumanBodyStates.StandIdle);
            break;

        case CharacterCommands.Throw:
            UpdateState(HumanBodyStates.StandIdle);
            break;

        case CharacterCommands.LeftAttack:
            UpdateState(HumanBodyStates.StandIdle);
            break;

        case CharacterCommands.RightAttack:
            UpdateState(HumanBodyStates.StandIdle);
            break;

        case CharacterCommands.Block:
            UpdateState(HumanBodyStates.StandIdle);
            break;

        case CharacterCommands.Idle:
            UpdateState(HumanBodyStates.StandIdle);
            break;
        }
    }
示例#9
0
 public void command(CharacterCommands command, params object[] args)
 {
     switch(command)
     {
         case CharacterCommands.SetEntityQuery:
             eq = (IEntityQuery)args[0];
             return;
         case CharacterCommands.Face:
             System.Console.WriteLine("face");
             state = 0;
             d = (Directions)args[0];
             return;
         case CharacterCommands.Walk:
             System.Console.WriteLine("walk");
             state = 1;
             if(d == (Directions)args[0]) step = step==0?1:0;
             else step = 0;
             d = (Directions)args[0];
             counter = 0;
             break;
         case CharacterCommands.Stop:
             System.Console.WriteLine("stop");
             state = 0;
             return;
         case CharacterCommands.Step:
             System.Console.WriteLine("step");
             state = 2;
             if(d == (Directions)args[0]) step = (step+1)&1;
             else step = 0;
             d = (Directions)args[0];
             counter = 0;
             return;
     }
 }
示例#10
0
	public override void SendCommand (CharacterCommands command)
	{
		if(command == CharacterCommands.AnimationActionDone)
		{
			UpdateState(MutantBodyStates.Idle);
		}

	}
示例#11
0
	public override void SendCommand(CharacterCommands command)
	{
		switch(command)
		{
		case CharacterCommands.Idle:
			UpdateState(MutantBodyStates.Idle);
			break;
		}
	}
示例#12
0
 public override void SendCommand(CharacterCommands command)
 {
     switch (command)
     {
     case CharacterCommands.GoToPosition:
         UpdateState(MutantBodyStates.Move);
         break;
     }
 }
 public override void SendCommand(CharacterCommands command)
 {
     switch (command)
     {
     case CharacterCommands.Idle:
         UpdateState(MutantBodyStates.Idle);
         break;
     }
 }
示例#14
0
	public override void SendCommand (CharacterCommands command)
	{
		switch(command)
		{
		case CharacterCommands.GoToPosition:
			UpdateState(MutantBodyStates.Move);
			break;
		}

	}
示例#15
0
 void AttackState()
 {
     if (!enemy.IsDead)
     {
         CharacterCommands.Attack(chara, enemy);
     }
     else
     {
         enemy = null;
     }
 }
 public override void SendCommand(CharacterCommands command)
 {
     if (command == CharacterCommands.AnimationActionDone)
     {
         UpdateState(HumanBodyStates.StandIdle);
         if (ParentCharacter.MyAI.BlackBoard.AnimationAction == AnimationActions.ChairSit)
         {
             ParentCharacter.MyAnimator.SetBool("IsChairSitting", false);
         }
     }
 }
示例#17
0
 void SeekState()
 {
     CharacterCommands.GetVision(chara, detectable);
     if (chara.FoundItems.Count > 0)
     {
         foreach (Transform item in chara.FoundItems)
         {
             if (item.tag == "Weapon" && item.GetComponent <Weapon>().Damage > chara.Weapon.Damage)
             {
                 target = item;
                 break;
             }
             else if (item.tag == "Treasure")
             {
                 target = item;
                 break;
             }
         }
         if (!target && !chara.FullFoodBag)
         {
             List <Transform> foundFood = new List <Transform>();
             foreach (Transform item in chara.FoundItems)
             {
                 if (item.tag == "Food")
                 {
                     foundFood.Add(item);
                 }
             }
             target = GetClosest(foundFood);
         }
         if (!enemy)
         {
             List <Transform> enemyList = new List <Transform>();
             foreach (Transform _enemy in chara.FoundItems)
             {
                 if (_enemy.tag == "Player" && _enemy.GetComponent <CharacterBehaviours>() != chara)
                 {
                     enemyList.Add(_enemy);
                     print(_enemy.name);
                 }
             }
             if (enemyList.Count > 1)
             {
                 GameObject closestEnemy = GetClosest(enemyList).gameObject;
                 enemy = closestEnemy.GetComponent <CharacterBehaviours>();
             }
             else if (enemyList.Count != 0)
             {
                 enemy = enemyList[0].GetComponent <CharacterBehaviours>();
             }
         }
     }
 }
示例#18
0
        public async Task SetSkill(SocketReaction reaction, IUserMessage msg)
        {
            int result = GetLetter(reaction.Emote.ToString()) + 1;

            string[] arrays = data.Split(';');
            bool[]   rused  = Utils.JSON <bool[]>(arrays[1]);
            if (!rused[result - 1])
            {
                await CharacterCommands.SetSkills(player, reaction.Channel, result,
                                                  Utils.JSON <int[]>(arrays[0]), rused, true);
            }
        }
示例#19
0
    Text playerNameText; //Nome do seu personagem

    private void Start()
    {
        if (Weapon == null)
        {
            Weapon = Instantiate(Resources.Load <Weapon>("Prefabs/DemFists"), transform.position, Quaternion.identity);
            CharacterCommands.CatchWeapon(this, Weapon.gameObject);
        }
        if (GetComponentInChildren <Canvas>())
        {
            playerNameText      = GetComponentInChildren <Text>(); //PlayerNameText é um componente do canvas filho do prefab. Deve ser referenciado dessa maneira para que o nome do seu personagem apareça na tela do jogo
            playerNameText.text = PlayerName;
        }
    }
示例#20
0
        public async Task ChooseRace(SocketReaction reaction, IUserMessage msg)
        {
            bool selected = true;

            switch (reaction.Emote.ToString())
            {
            case "🇭":
            {
                player.race = ReferenceData.HumanoidRaces.Human;
                player.perks.Add(PerkLoad.Load("Human Adaptation"));
            }
            break;

            case "🇹":
            {
                player.race = ReferenceData.HumanoidRaces.Tsiun;
                player.perks.Add(PerkLoad.Load("Tsiun Trickery"));
            }
            break;

            case "🇺":
            {
                player.race = ReferenceData.HumanoidRaces.Uskavian;
                player.perks.Add(PerkLoad.Load("Uskavian Learning"));
            }
            break;

            case "🇲":
            {
                player.race = ReferenceData.HumanoidRaces.Miganan;
                player.perks.Add(PerkLoad.Load("Migana Skin"));
            }
            break;

            case "🇮":
            {
                player.race = ReferenceData.HumanoidRaces.Ireskian;
                player.perks.Add(PerkLoad.Load("Ireskian Talent"));
            }
            break;

            default: selected = false; break;
            }
            if (selected)
            {
                player.SaveFileMongo();
                await TryMSGDel(msg);

                await CharacterCommands.StarterAbilities(player, reaction.Channel, 0);
            }
        }
示例#21
0
	public override void SendCommand (CharacterCommands command)
	{
		switch(command)
		{
		case CharacterCommands.GoToPosition:
			UpdateState(HumanBodyStates.WalkForward);
			break;
		case CharacterCommands.Crouch:
			UpdateState(HumanBodyStates.CrouchIdle);
			break;
		case CharacterCommands.ThrowGrenade:
			//_aimFreelookAngle = 0;
			//_noAimFreelookAngle = 0;
			break;
		}

	}
示例#22
0
    public override void SendCommand(CharacterCommands command)
    {
        switch (command)
        {
        case CharacterCommands.GoToPosition:
            UpdateState(HumanBodyStates.WalkForward);
            break;

        case CharacterCommands.Crouch:
            UpdateState(HumanBodyStates.CrouchIdle);
            break;

        case CharacterCommands.ThrowGrenade:
            //_aimFreelookAngle = 0;
            //_noAimFreelookAngle = 0;
            break;
        }
    }
示例#23
0
 // Update is called once per frame
 void Update()
 {
     if (chara.IsDead)
     {
         return;
     }
     if (!target)
     {
         CharacterCommands.GetVision(chara, players);
     }
     else
     {
         if (Vector2.Distance(transform.position, target.transform.position) <= chara.Weapon.Range)
         {
             CharacterCommands.Attack(chara, target);
         }
     }
 }
示例#24
0
 private void OnTriggerEnter2D(Collider2D col)
 {
     if (col.transform == target)
     {
         if (col.tag == "Food")
         {
             CharacterCommands.CatchFood(chara, col.gameObject);
         }
         if (col.tag == "Weapon")
         {
             CharacterCommands.CatchWeapon(chara, col.gameObject);
         }
         if (col.tag == "Treasure")
         {
             CharacterCommands.CatchTreasure(chara, col.gameObject);
         }
         target = null;
     }
 }
示例#25
0
        public async Task StarterAbilities(SocketReaction reaction, IUserMessage msg)
        {
            string[] split = data.Split('/');
            int      p     = int.Parse(split[0]);
            int      x     = int.Parse(split[1]);
            int      z     = int.Parse(split[2]);
            int      index = GetNum(reaction.Emote.ToString());

            if (index > -1)
            {
                Ability a = Ability.Load(LoadAbility.Starters[p, index]);
                if (player.abilities.Count < 3)
                {
                    player.abilities.Add(a);
                }
                if (x > -1)
                {
                    string prefix = CommandHandler.GetPrefix(reaction.Channel);
                    player.level = 0;
                    await EditMessage("Character creation completed");

                    await GameCommands.StatsDisplay(player, reaction.Channel);

                    await reaction.Channel.SendMessageAsync("Welcome to Neitsillia, Traveler. To guide you, you've been given the \"Tutorial\" Quest line."
                                                            + Environment.NewLine + "Use the `Quest` command to view your quest list and inspect the quest using the assigned emote. Follow the Tutorial quest to learn to play.");
                }
                else
                {
                    await CharacterCommands.StarterAbilities(player, reaction.Channel, p);
                }
                player.SaveFileMongo();
            }
            else if (reaction.Emote.ToString() == next)
            {
                await CharacterCommands.StarterAbilities(player, reaction.Channel, p + 1, x, z);
            }
            else if (reaction.Emote.ToString() == prev)
            {
                await CharacterCommands.StarterAbilities(player, reaction.Channel, p - 1, x, z);
            }
        }
    public override void SendCommand(CharacterCommands command)
    {
        switch (command)
        {
        case CharacterCommands.StopCrouch:
            Debug.Log("Stop Crouch during sneak forward");
            UpdateState(HumanBodyStates.StandIdle);
            break;

        case CharacterCommands.Idle:
            UpdateState(HumanBodyStates.CrouchIdle);
            break;

        case CharacterCommands.ThrowGrenade:
            UpdateState(HumanBodyStates.CrouchIdle);
            break;

        case CharacterCommands.Throw:
            UpdateState(HumanBodyStates.CrouchIdle);
            break;
        }
    }
示例#27
0
        public void Command(CharacterCommands command, params object[] args)
        {
            customAnimation = null;
            switch(command)
            {
                case CharacterCommands.Step:
                    state = 1;
                    d = (Directions)args[0];
                    walkAnims[(int)d].reset();
                    return;
                case CharacterCommands.Face:
                    //if(state == 1 && d == (Directions)args[0]) { }
                    //else
                    //state = 0;
                    if(d != (Directions)args[0])
                        state = 0;
                    d = (Directions)args[0];
                    return;
                case CharacterCommands.Stop:
                    state = 0;

                    return;
                case CharacterCommands.Walk:
                    if(d == (Directions)args[0] && state == 1) { }
                    else {
                        state = 1;
                        walkAnims[(int)(Directions)args[0]].reset();
                        d = (Directions)args[0];
                    }
                    return;
                case CharacterCommands.Animate:
                    state = 3;
                    customAnimation = new StandardChrAnimationController((string)args[0]);
                    customAnimation.reset();
                    return;
                default: return;
            }
        }
示例#28
0
	public override void SendCommand (CharacterCommands command)
	{
		switch(command)
		{
		case CharacterCommands.GoToPosition:
			if(this.ParentCharacter.CurrentStance == HumanStances.Sprint)
			{
				UpdateState(HumanBodyStates.WalkForward);
			}
			else
			{
				UpdateState(HumanBodyStates.CrouchWalk);
			}
			break;
		case CharacterCommands.StopCrouch:
			UpdateState(HumanBodyStates.StandIdle);
			break;
		case CharacterCommands.ThrowGrenade:
			//_aimFreelookAngle = 0;
			//_noAimFreelookAngle = 0;
			break;
		}
	}
示例#29
0
        public async Task AutoNewCharacter(SocketReaction reaction, IUserMessage msg)
        {
            switch (reaction.Emote.ToString())
            {
            case ok:
                await CharacterCommands.AutoCharacter(player, reaction.Channel, false);

                break;

            case next:
                await CharacterCommands.SetSkills(player, reaction.Channel, 0, null, new[] { false, false, false, false, false, false });

                break;

            case info:
                EmbedBuilder em = DUtils.BuildEmbed("Character Creation",
                                                    $"{EUI.ok} - Randomize {Environment.NewLine} {EUI.next} - Manual (Advanced)", null, default,
                                                    DUtils.NewField("Use the reactions to make your choice", "Making a character can be complicated for new users, use this to skip this step and start playing."
                                                                    + Environment.NewLine + "You can always make another new character once you are more comfortable with the system."));
                await EditMessage(null, em.Build(), removeReactions : false);

                break;
            }
        }
示例#30
0
	public override void SendCommand (CharacterCommands command)
	{
		if(command == CharacterCommands.PlayAnimationAction)
		{
			CurrentAnimState = new MutantAnimStateAction(this);
			IsBodyLocked = true;
		}

		if(command == CharacterCommands.AnimationActionDone)
		{
			Debug.Log("Action Done");
			IsBodyLocked = false;
		}





		if(!IsBodyLocked && !IsMoveLocked)
		{
			CurrentAnimState.SendCommand(command);
		}

		if(IsBodyLocked)
		{
			return;
		}

		/*
		if(command == CharacterCommands.IdleAction)
		{
			if(UnityEngine.Random.value > 0.5f)
			{
				this.MyAnimator.SetTrigger("Agonize");
			}
			else
			{
				this.MyAnimator.SetTrigger("Convulse");
			}
		}
		*/

		if(command == CharacterCommands.RunningAttack)
		{
			this.MyAnimator.SetTrigger("RunningAttack");
			MyReference.FixedMeleeRight.GetComponent<MeleeWeapon>().SwingStart();
			ActionState = HumanActionStates.Melee;
		}

		if(command == CharacterCommands.LeftAttack)
		{
			this.MyAnimator.SetTrigger("LeftAttack");
			MyReference.FixedMeleeLeft.GetComponent<MeleeWeapon>().SwingStart();
			ActionState = HumanActionStates.Melee;
		}

		if(command == CharacterCommands.RightAttack)
		{
			this.MyAnimator.SetTrigger("RightAttack");
			MyReference.FixedMeleeRight.GetComponent<MeleeWeapon>().SwingStart();
			ActionState = HumanActionStates.Melee;
		}

		if(command == CharacterCommands.QuickAttack)
		{
			this.MyAnimator.SetTrigger("QuickAttack");
			MyReference.FixedMeleeRight.GetComponent<MeleeWeapon>().SwingStart();
			ActionState = HumanActionStates.Melee;
		}


	}
示例#31
0
 public bool supportsCommand(CharacterCommands command)
 {
     return true;
 }
示例#32
0
	public override void SendCommand (CharacterCommands command)
	{


	}
示例#33
0
    public override void SendCommand(CharacterCommands command)
    {
        if (command == CharacterCommands.PlayAnimationAction)
        {
            CurrentAnimState = new MutantAnimStateAction(this);
            IsBodyLocked     = true;
        }

        if (command == CharacterCommands.AnimationActionDone)
        {
            //Debug.Log("Action Done");
            IsBodyLocked = false;
        }



        if (!IsBodyLocked && !IsMoveLocked)
        {
            CurrentAnimState.SendCommand(command);
        }

        if (IsBodyLocked)
        {
            return;
        }

        /*
         * if(command == CharacterCommands.IdleAction)
         * {
         *      if(UnityEngine.Random.value > 0.5f)
         *      {
         *              this.MyAnimator.SetTrigger("Agonize");
         *      }
         *      else
         *      {
         *              this.MyAnimator.SetTrigger("Convulse");
         *      }
         * }
         */

        if (command == CharacterCommands.RunningAttack)
        {
            this.MyAnimator.SetTrigger("RunningAttack");
            _meleeSide  = 1;
            ActionState = HumanActionStates.Melee;
        }

        if (command == CharacterCommands.LeftAttack)
        {
            this.MyAnimator.SetTrigger("LeftAttack");
            _meleeSide  = 0;
            ActionState = HumanActionStates.Melee;
        }

        if (command == CharacterCommands.RightAttack)
        {
            this.MyAnimator.SetTrigger("RightAttack");
            _meleeSide  = 1;
            ActionState = HumanActionStates.Melee;
        }

        if (command == CharacterCommands.QuickAttack)
        {
            this.MyAnimator.SetTrigger("QuickAttack");
            _meleeSide  = 1;
            ActionState = HumanActionStates.Melee;
        }

        if (command == CharacterCommands.Bite)
        {
            if (ActionState != HumanActionStates.None || MyAI.BlackBoard.TargetEnemy == null)
            {
                return;
            }



            //Debug.Log("Start biting");
            Vector3 lineOfSight = MyAI.BlackBoard.TargetEnemy.transform.position - transform.position;


            //stop movement
            SendCommand(CharacterCommands.Idle);
            IsBodyLocked       = true;
            MyNavAgent.enabled = false;

            //place my position right behind target
            transform.position = MyAI.BlackBoard.TargetEnemy.transform.position - lineOfSight.normalized * 1f;

            //align my facing direction to enemy's
            lineOfSight = new Vector3(lineOfSight.x, 0, lineOfSight.z);
            Quaternion rotation = Quaternion.LookRotation(lineOfSight);
            transform.rotation = rotation;

            MyAnimator.SetTrigger("Bite");
            _strangleTarget = MyAI.BlackBoard.TargetEnemy;


            ActionState = HumanActionStates.Strangle;
        }
    }
        internal static async Task <bool> SpecialExceptions(NeitsilliaError error, IMessageChannel chan, Player player)
        {
            switch (error.ErrorType)
            {
            case NeitsilliaErrorType.ReplyError:
                await chan.SendMessageAsync(error.ExtraMessage);

                return(true);

            case NeitsilliaErrorType.ReplyUI:
            {
                await chan.SendMessageAsync(error.ExtraMessage);

                switch (error.uitype)
                {
                case MsgType.CardGame:
                {
                    Type type = Neitsillia.Gambling.Games.GamblingGame.GetGameType(player.ui.data);
                    Neitsillia.Gambling.Games.IGamblingGame game = Neitsillia.Gambling.Games.GamblingGame.CreateInstance(type, player);
                    var embed = ((Neitsillia.Gambling.Games.GamblingGame)game).GetEmbed(player).Build();
                    await player.NewUI(null, embed, await player.DMChannel(), player.ui.type, player.ui.data);
                }
                break;
                }
                return(true);
            }

            case NeitsilliaErrorType.CharacterIsNotSetUp:
                if (player != null)
                {
                    if (player.ui.type == MsgType.AutoNewCharacter)
                    {
                        await CharacterCommands.AutoCharacter(player, chan, true);
                    }
                    else if (player.ui.type == MsgType.SetSkill ||
                             player.ui.type == MsgType.ConfirmSkills)
                    {
                        string[] arrays = player.ui.data.Split(';');
                        await CharacterCommands.SetSkills(player, chan, 0, Utils.JSON <int[]>(arrays[0]), Utils.JSON <bool[]>(arrays[1]));
                    }
                    else if (!await CharacterCommands.Set_Race(chan, player))
                    {
                        await CharacterCommands.StarterAbilities(player, chan, 1);
                    }
                    return(true);
                }
                return(false);

            case NeitsilliaErrorType.CharacterAdventuring:
                if (player != null)
                {
                    await Areas.AdventureStat(player, chan);

                    return(true);
                }
                return(false);

            case NeitsilliaErrorType.CharacterIsResting:
                if (player != null)
                {
                    await Areas.RestStat(player, chan);

                    return(true);
                }
                return(false);

            default: return(false);
            }
        }
示例#35
0
	public abstract void SendCommand(CharacterCommands command);
示例#36
0
 public abstract void SendCommand(CharacterCommands command);
示例#37
0
 public abstract bool supportsCommand(CharacterCommands cc);
 public override void SendCommand(CharacterCommands command)
 {
 }
示例#39
0
 public override bool supportsCommand(CharacterCommands cc)
 {
     return true;
 }
示例#40
0
 public abstract void command(CharacterCommands cc, params object[] args);
示例#41
0
 public override void command(CharacterCommands cc, params object[] args)
 {
 }
示例#42
0
 public override void command(CharacterCommands cc, params object[] args)
 {
     switch(cc) {
         case CharacterCommands.Face:
             Directions d = (Directions)args[0];
             switch(d) {
                     //there are cleverer ways to do this
                     //like take the difference one way and if its greater than pi, invert delta
                 case Directions.e:
                     target = east;
                     if(angle > east && angle < west) delta = -1;
                     else delta = 1;
                     break;
                 case Directions.n:
                     target = north;
                     if(angle > south) delta = 1;
                     else delta = -1;
                     break;
                 case Directions.s:
                     target = south;
                     if(angle < south) delta = 1;
                     else delta = -1;
                     break;
                 case Directions.w:
                     target = west;
                     if(angle < west && angle > east) delta = 1;
                     else delta = -1;
                     break;
             }
             break;
     }
 }
示例#43
0
 public override void command(CharacterCommands cc, params object[] args)
 {
     switch(cc)
     {
         case CharacterCommands.Face:
             facing = (Directions)args[0];
             break;
     }
 }
示例#44
0
 void MoveState(Transform _target)
 {
     CharacterCommands.SetPath(chara, _target.position);
 }
示例#45
0
 public void Command(CharacterCommands command, params object[] args)
 {
     customAnimation = null;
     switch(command) {
         case CharacterCommands.Step:
             state = 1;
             d = (Directions)args[0];
             walkAnims[(int)d].controller.reset();
             return;
         case CharacterCommands.Face:
             //if(state == 1 && d == (Directions)args[0]) { }
             //else
             //state = 0;
             //if(d != (Directions)args[0])
             state = 0;
             if(d != (Directions)args[0]) {
                 d = (Directions)args[0];
                 if(GetCurrentAnimRecord() != null)
                     GetCurrentAnimRecord().controller.reset();
             }
             return;
         case CharacterCommands.Stop: {
                 state = 0;
                 AnimRecord ar = GetCurrentAnimRecord();
                 if(ar != null)
                     ar.controller.reset();
             }
             return;
         case CharacterCommands.Walk:
             if(d == (Directions)args[0] && state == 1) { } else {
                 state = 1;
                 walkAnims[(int)(Directions)args[0]].controller.reset();
                 d = (Directions)args[0];
             }
             return;
         case CharacterCommands.Animate:
             if(animations.TryGetValue((string)args[0], out customAnimation)) {
                 customAnimation.controller.reset();
                 state = 3;
             } else state = 0;
             return;
         default: return;
     }
 }
示例#46
0
 public bool SupportsCommand(CharacterCommands command)
 {
     if(command == CharacterCommands.Step) return false;
     return true;
 }
示例#47
0
	public override void SendCommand(CharacterCommands command)
	{
		if(!IsBodyLocked && !IsMoveLocked)
		{
			CurrentAnimState.SendCommand(command);
		}


		//following commands are not given by AI or user. All commands that will unlock the body go here
		if(command == CharacterCommands.StopAim)
		{
			if(ActionState == HumanActionStates.None)
			{
				MyAI.WeaponSystem.StopFiringRangedWeapon();
				UpperBodyState = HumanUpperBodyStates.Idle;
				MyAimIK.solver.SmoothDisable(6);
				MyHeadIK.SmoothEnable();
				MyAnimator.SetBool("IsAiming", false);
				MyReference.Flashlight.transform.localEulerAngles = new Vector3(27, 0, 0);

				if(GetCurrentAnimWeapon() == WeaponAnimType.Pistol || GetCurrentAnimWeapon() == WeaponAnimType.Grenade)
				{
					MyLeftHandIK.InstantDisable();
				}
			}
			else
			{
				UpperBodyState = HumanUpperBodyStates.Idle;
			}

			_isHipAiming = false;
			//Debug.LogError("stopping aim " + ActionState + " " + this.name);
		}

		if(command == CharacterCommands.Cancel)
		{
			if(ActionState == HumanActionStates.Strangle)
			{
				ActionState = HumanActionStates.None;
				MyAnimator.SetTrigger("Cancel");

				Vector3 lineOfSight = _strangleTarget.transform.position - transform.position;
				transform.position = _strangleTarget.transform.position - lineOfSight.normalized;

				if(_strangleTarget.IsAlive)
				{
					_strangleTarget.IsBodyLocked = false;
					_strangleTarget.MyAnimator.SetTrigger("Cancel");
					_strangleTarget = null;
				}

				IsBodyLocked = false;
				MyNavAgent.enabled = true;

			}
		}

		if(command == CharacterCommands.RightAttack)
		{
			ActionState = HumanActionStates.Melee;
			_meleeStrikeStage = 0;

			MyAnimator.SetTrigger("RightAttack");
			IsMoveLocked = true;
			MyHeadIK.SmoothDisable(9);

			Debug.Log("starting right attack");
		}

		if(command == CharacterCommands.LeftAttack)
		{
			ActionState = HumanActionStates.Melee;
			_meleeStrikeStage = 0;

			Vector3 lookDir = LookTarget.position - transform.position;
			lookDir = new Vector3(lookDir.x, 0, lookDir.z);

			Vector3 destDir = MyNavAgent.velocity.normalized; 
			destDir = new Vector3(destDir.x, 0, destDir.z);
			float lookDestAngle = Vector3.Angle(lookDir, destDir);

			if(MyNavAgent.velocity.magnitude > 0f && lookDestAngle < 70)
			{
				MyAnimator.SetTrigger("ComboAttack");
			}
			else
			{
				MyAnimator.SetTrigger("LeftAttack");
				IsMoveLocked = true;
			}
			MyHeadIK.SmoothDisable(9);

			Debug.Log("starting left attack");
		}

		if(command == CharacterCommands.Block)
		{
			ActionState = HumanActionStates.Block;
			this.MyLeftHandIK.Target = MyReference.CurrentWeapon.GetComponent<Weapon>().ForeGrip;
			this.MyLeftHandIK.SmoothEnable(20);
			_meleeStrikeStage = 0;
			MyAnimator.SetTrigger("Block");
			IsMoveLocked = true;

		}





		if(IsBodyLocked)
		{
			return;
		}

		//following commands are given by AI or user, and can be locked


		if(command == CharacterCommands.Crouch)
		{
			CapsuleCollider collider = GetComponent<CapsuleCollider>();
			collider.height = 1f;
			collider.center = new Vector3(0, 0.5f, 0);

		}

		if(command == CharacterCommands.StopCrouch)
		{
			CapsuleCollider collider = GetComponent<CapsuleCollider>();
			collider.height = 1.7f;
			collider.center = new Vector3(0, 1, 0);
		}

	
		if((command == CharacterCommands.Aim || command == CharacterCommands.HipAim) && CurrentStance != HumanStances.Sprint)
		{
			if(MyAI.ControlType != AIControlType.Player)
				Debug.Log("action state " + ActionState + " weapon type " + GetCurrentAnimWeapon() + " upper body state " + UpperBodyState);

			if((ActionState == HumanActionStates.None || ActionState == HumanActionStates.Twitch) && GetCurrentAnimWeapon() != WeaponAnimType.Unarmed && !MyAnimator.GetBool("IsAiming"))
			{
				if(MyAI.ControlType != AIControlType.Player)
					Debug.Log(command);

				if(GetCurrentAnimWeapon() == WeaponAnimType.Grenade || GetCurrentAnimWeapon() == WeaponAnimType.Tool)
				{
					MyLeftHandIK.SmoothDisable(6);
					UpperBodyState = HumanUpperBodyStates.HalfAim;
				}
				else
				{
					
					UpperBodyState = HumanUpperBodyStates.Aim;
					if(GetCurrentAnimWeapon() == WeaponAnimType.Pistol)
					{
						MyLeftHandIK.InstantDisable();
					}
					MyLeftHandIK.SmoothEnable(6);
					MyAimIK.solver.InstantDisable();
					MyAimIK.solver.CurvedEnable(6f);
					//if(GetCurrentAnimWeapon() != WeaponAnimType.Melee)
					{
						MyHeadIK.InstantDisable();
					}
					MyAnimator.SetBool("IsAiming", true);
					if(MyAI.ControlType != AIControlType.Player)
						Debug.LogError("Animation parameter IsAiming has been set");
					MyReference.Flashlight.transform.localEulerAngles = new Vector3(0, 0, 0);
				}
					
				/*
				//draw a new grenade if there isn't one
				if(GetCurrentAnimWeapon() == WeaponAnimType.Grenade)
				{
					if(_thrownObjectInHand == null)
					{
						DrawNextGrenade();
					}
				}
				*/

			}
			else if(ActionState == HumanActionStates.SwitchWeapon)
			{
				
				if(UpperBodyState == HumanUpperBodyStates.Aim && !MyAnimator.GetBool("IsAiming"))
				{
					
					MyLeftHandIK.InstantDisable();
					MyLeftHandIK.SmoothEnable(6);
					MyAimIK.solver.InstantDisable();
					MyAimIK.solver.SmoothEnable(6f);
					MyHeadIK.InstantDisable();
					MyAnimator.SetBool("IsAiming", true);
					if(MyAI.ControlType != AIControlType.Player)
						Debug.LogError("Animation parameter IsAiming has been set");
					MyReference.Flashlight.transform.localEulerAngles = new Vector3(0, 0, 0);
				}
				else
				{
					UpperBodyState = HumanUpperBodyStates.Aim;
				}

			}
			else if(GetCurrentAnimWeapon() == WeaponAnimType.Unarmed)
			{
				SendCommand(MyAI.WeaponSystem.GetBestWeaponChoice());

			}


			if(command == CharacterCommands.HipAim)
			{
				_isHipAiming = true;
			}
			else if(command == CharacterCommands.Aim)
			{
				_isHipAiming = false;
			}
		}



		if(command == CharacterCommands.Sprint)
		{

			/*
			if(CurrentStance == HumanStances.Crouch || CurrentStance == HumanStances.CrouchRun)
			{
				CurrentStance = HumanStances.CrouchRun;
			}
			else*/
			{
				CurrentStance = HumanStances.Sprint;
				MyAimIK.solver.SmoothDisable();
				MyHeadIK.InstantDisable();
			}
		}

		if(command == CharacterCommands.StopSprint)
		{
			if(UpperBodyState == HumanUpperBodyStates.Aim)
			{
				MyAimIK.solver.SmoothEnable();
			}

			if(CurrentStance == HumanStances.CrouchRun || CurrentStance == HumanStances.Crouch)
			{
				CurrentStance = HumanStances.Crouch;
			}
			else
			{
				CurrentStance = HumanStances.Run;
			}
			MyHeadIK.SmoothEnable();
		}

		if(command == CharacterCommands.SwitchWeapon2)
		{
			if((ActionState == HumanActionStates.None || ActionState == HumanActionStates.Twitch) && MyAI.WeaponSystem.PrimaryWeapon != null)
			{
				CsDebug.Inst.CharLog(this, "Start switching weapon2");
				MyLeftHandIK.SmoothDisable(15);
				MyAimIK.solver.SmoothDisable(9);

				//SwitchWeapon(Inventory.RifleSlot);
				_weaponToSwitch = Inventory.RifleSlot;
				if(MyAI.WeaponSystem.PrimaryWeapon.IsRanged)
				{
					MyAnimator.SetInteger("WeaponType", 2);
				}
				else
				{
					MyAnimator.SetInteger("WeaponType", 3);
				}

				ActionState = HumanActionStates.SwitchWeapon;
			}
		}

		if(command == CharacterCommands.SwitchWeapon1)
		{
			if((ActionState == HumanActionStates.None || ActionState == HumanActionStates.Twitch) && MyAI.WeaponSystem.SideArm != null)
			{
				if(UpperBodyState == HumanUpperBodyStates.Aim)
				{
					//MyLeftHandIK.SmoothEnable();
				}
				else
				{
					
				}
				MyLeftHandIK.SmoothDisable(15);
				MyAimIK.solver.SmoothDisable(9);
				MyAnimator.SetInteger("WeaponType", 1);
				//SwitchWeapon(Inventory.SideArmSlot);
				_weaponToSwitch = Inventory.SideArmSlot;

				ActionState = HumanActionStates.SwitchWeapon;
			}
		}

		if(command == CharacterCommands.SwitchThrown)
		{
			if(ActionState == HumanActionStates.None)
			{

				MyLeftHandIK.SmoothDisable(6);
				MyAimIK.solver.SmoothDisable(9);
				MyAnimator.SetInteger("WeaponType", -1);
				//SwitchWeapon(Inventory.ThrowSlot);
				_weaponToSwitch = Inventory.ThrowSlot;

				ActionState = HumanActionStates.SwitchWeapon;
			}
		}

		if(command == CharacterCommands.SwitchTool)
		{
			if(ActionState == HumanActionStates.None)
			{
				GameObject.Destroy(this.MyReference.CurrentWeapon);
				if(_thrownObjectInHand != null)
				{
					GameObject.Destroy(_thrownObjectInHand.gameObject);
				}

				MyLeftHandIK.SmoothDisable(6);
				MyAimIK.solver.SmoothDisable(9);
				MyAnimator.SetInteger("WeaponType", -2);
				//SwitchWeapon("ThrowingRock");

				ActionState = HumanActionStates.SwitchWeapon;
			}
		}

		if(command == CharacterCommands.Unarm)
		{
			if(ActionState == HumanActionStates.None)
			{
				MyLeftHandIK.SmoothDisable();
				UpperBodyState = HumanUpperBodyStates.Idle;
				MyAimIK.solver.SmoothDisable();
				MyHeadIK.SmoothEnable();
				MyAnimator.SetBool("IsAiming", false);
				MyAnimator.SetInteger("WeaponType", 0);
				//SwitchWeapon(null);
				_weaponToSwitch = null;

				ActionState = HumanActionStates.SwitchWeapon;
			}
		}

		if(command == CharacterCommands.PullTrigger)
		{
			if(ActionState != HumanActionStates.None || UpperBodyState != HumanUpperBodyStates.Aim)
			{
				return;
			}

			if(GetCurrentAnimWeapon() == WeaponAnimType.Longgun || GetCurrentAnimWeapon() == WeaponAnimType.Pistol)
			{
				//
				this.MyReference.CurrentWeapon.GetComponent<Gun>().TriggerPull();


			}
		}

		if(command == CharacterCommands.ReleaseTrigger)
		{
			if(ActionState != HumanActionStates.None || UpperBodyState != HumanUpperBodyStates.Aim)
			{
				return;
			}

			if(GetCurrentAnimWeapon() == WeaponAnimType.Longgun || GetCurrentAnimWeapon() == WeaponAnimType.Pistol)
			{
				//
				this.MyReference.CurrentWeapon.GetComponent<Gun>().TriggerRelease();


			}
		}


		if(command == CharacterCommands.Reload)
		{
			if(ActionState == HumanActionStates.None && this.MyReference.CurrentWeapon != null)
			{
				GunMagazine magazine = this.MyReference.CurrentWeapon.GetComponent<GunMagazine>();
				if(magazine != null && magazine.AmmoLeft < magazine.MaxCapacity)
				{
					GridItemData ammo = this.Inventory.FindItemInBackpack(magazine.LoadedAmmoID);
					if(ammo != null)
					{
						if(GetCurrentAnimWeapon() == WeaponAnimType.Longgun || GetCurrentAnimWeapon() == WeaponAnimType.Pistol)
						{
							MyAimIK.solver.SmoothDisable(12);
							MyAnimator.SetInteger("ReloadType", (int)magazine.ReloadType);
							MyAnimator.SetTrigger("Reload");
							
							MyLeftHandIK.SmoothDisable();

						}

						MyHeadIK.SmoothDisable();
							
						ActionState = HumanActionStates.Reload;
					}
				}

			}
		}



		if(command == CharacterCommands.CancelReload)
		{
			if(ActionState == HumanActionStates.Reload && this.MyReference.CurrentWeapon != null)
			{
				
				Debug.Log("cancel reload");
				ActionState = HumanActionStates.None;

				if(UpperBodyState == HumanUpperBodyStates.Aim)
				{
					MyAimIK.solver.SmoothEnable();
					MyAnimator.SetTrigger("CancelReload");
				}
				else
				{
					MyAnimator.SetTrigger("CancelReload");
				}

				if(MyAnimator.GetInteger("WeaponType") == (int)WeaponAnimType.Longgun)
				{
					MyLeftHandIK.SmoothEnable();
				}
				else
				{
					Debug.Log("done reloading pistol " + UpperBodyState);
					if(UpperBodyState == HumanUpperBodyStates.Aim)
					{
						MyLeftHandIK.SmoothEnable();
					}
					else
					{
						//MyLeftHandIK.SmoothDisable();
						SendCommand(CharacterCommands.StopAim);
					}
				}

				MyHeadIK.SmoothEnable();

			}
		}



		if(command == CharacterCommands.Throw || command == CharacterCommands.LowThrow)
		{
			if(ActionState != HumanActionStates.None)
			{
				return;
			}

			if(_thrownObjectInHand == null)
			{
				DrawNextGrenade();
			}


			MyAimIK.solver.SmoothDisable(15);
			if(command == CharacterCommands.LowThrow)
			{
				MyAnimator.SetTrigger("LowThrow");
				_isLowThrow = true;
			}
			else
			{
				MyAnimator.SetTrigger("Throw");
				_isLowThrow = false;
			}

			_throwTarget = this.AimPoint;
			Quaternion rotation = Quaternion.LookRotation(this.AimPoint - transform.position);
			transform.rotation = rotation;
			IsBodyLocked = true;
			Debug.Log("Throw triggered");
		}

		if(command == CharacterCommands.ThrowGrenade)
		{
			if(ActionState != HumanActionStates.None)
			{
				return;
			}

			if(UpperBodyState != HumanUpperBodyStates.Aim)
			{
				//MyAimIK.solver.transform = this.MyReference.TorsoWeaponMount.transform;
			}

			SendCommand(CharacterCommands.CancelReload);

			if(this.MyReference.CurrentWeapon != null && MyAnimator.GetInteger("WeaponType") == (int)WeaponAnimType.Longgun)
			{
				MyLeftHandIK.SmoothEnable();
			}

			//MyHeadIK.SmoothDisable(1);

			//move weapon to torso mount so that right hand is free
			if(this.MyReference.CurrentWeapon != null)
			{
				this.MyReference.CurrentWeapon.transform.parent = this.MyReference.TorsoWeaponMount.transform;
			}
			MyAnimator.SetTrigger("ThrowGrenade");

			_throwTarget = this.AimPoint;

			_throwDir = this.AimPoint - transform.position;
			IsBodyLocked = true;
			Quaternion rotation = Quaternion.LookRotation(new Vector3(_throwDir.x, 0, _throwDir.z));
			transform.rotation = rotation;

			ActionState = HumanActionStates.Throw;

			_thrownObjectInHand = ((GameObject)GameObject.Instantiate(Resources.Load("PipeGrenade"))).GetComponent<ThrownObject>();
			Explosive explosive = _thrownObjectInHand.GetComponent<Explosive>();
			if(explosive != null)
			{
				explosive.Attacker = this;
			}

			_thrownObjectInHand.GetComponent<Rigidbody>().isKinematic = true;

			_thrownObjectInHand.transform.parent = this.MyReference.RightHandWeaponMount.transform;
			_thrownObjectInHand.transform.localPosition = _thrownObjectInHand.InHandPosition;
			_thrownObjectInHand.transform.localEulerAngles = _thrownObjectInHand.InHandRotation;
		}

		if(command == CharacterCommands.UseTool)
		{
			if(ActionState != HumanActionStates.None || MyAI.BlackBoard.TargetEnemy == null)
			{
				return;
			}

			//check if the target enemy is close enough and angle between character and enemy is less than 45
			if(Vector3.Distance(MyAI.BlackBoard.TargetEnemy.transform.position, transform.position) > 2 || 
				Vector3.Angle(MyAI.BlackBoard.TargetEnemy.transform.forward, transform.forward) > 45)
			{
				return;
			}

			Vector3 lineOfSight = MyAI.BlackBoard.TargetEnemy.transform.position - transform.position;
			//check if angle between character facing and target line of sight is less than 45
			if(Vector3.Angle(lineOfSight, transform.forward) > 45)
			{
				return;
			}

			//stop movement
			SendCommand(CharacterCommands.Idle);
			IsBodyLocked = true;
			MyNavAgent.enabled = false;

			//place player right behind target
			transform.position = MyAI.BlackBoard.TargetEnemy.transform.position - lineOfSight.normalized * 0.25f;

			//align player facing direction to enemy's
			lineOfSight = new Vector3(lineOfSight.x, 0, lineOfSight.z);
			Quaternion rotation = Quaternion.LookRotation(lineOfSight);
			transform.rotation = rotation;

			MyAnimator.SetTrigger("Strangle");
			_strangleTarget = MyAI.BlackBoard.TargetEnemy;

			SendCommand(CharacterCommands.StopAim);
			ActionState = HumanActionStates.Strangle;
		}

		if(command == CharacterCommands.Pickup)
		{
			if(ActionState != HumanActionStates.None || MyAI.BlackBoard.PickupTarget == null)
			{
				return;
			}

			//move weapon to torso mount so that right hand is free
			if(this.MyReference.CurrentWeapon != null && MyAnimator.GetInteger("WeaponType") == (int)WeaponAnimType.Longgun)
			{
				this.MyReference.CurrentWeapon.transform.parent = this.MyReference.TorsoWeaponMount.transform;
			}
			MyAnimator.SetTrigger("TakeObject");


		}

		if(command == CharacterCommands.Loot)
		{
			if(ActionState != HumanActionStates.None)
			{
				return;
			}
			GameObject useTarget = MyAI.BlackBoard.UseTarget;
			Character target = MyAI.BlackBoard.InteractTarget;

			if(target != null && target.MyStatus.Health <= 0)
			{
				if(this.MyAI.ControlType == AIControlType.Player)
				{
					UIEventHandler.Instance.TriggerLootBody();

				}
			}
			else if(useTarget != null)
			{
				//open chest
				Chest chest = useTarget.GetComponent<Chest>();
				if(chest != null)
				{
					
					//open UI 
					UIEventHandler.Instance.TriggerLootChest();
				}
			}

		}

		if(command == CharacterCommands.Talk)
		{
			if(ActionState != HumanActionStates.None)
			{
				return;
			}
			Debug.Log("opening dialog");
			Character target = MyAI.BlackBoard.InteractTarget;

			if(target != null && target.MyStatus.Health > 0)
			{
				if(this.MyAI.ControlType == AIControlType.Player)
				{
					UIEventHandler.Instance.TriggerDialogue();

				}
			}

		}

		if(command == CharacterCommands.SetAlert)
		{
			float ambient = RenderSettings.ambientIntensity;

			if(MyAI.BlackBoard.GuardLevel == 1)
			{
				//weapon holstered; only turn on flash light (if has one) when completely dark
				if(MyReference.CurrentWeapon != null)
				{
					SendCommand(CharacterCommands.Unarm);
				}
				if(MyReference.Flashlight != null)
				{
					if(ambient <= 0.3f)
					{
						MyReference.Flashlight.Toggle(true);
					}
					else
					{
						MyReference.Flashlight.Toggle(false);
					}
				}
			}
			else if(MyAI.BlackBoard.GuardLevel >= 2)
			{
				if(MyReference.CurrentWeapon == null)
				{
					SendCommand(MyAI.WeaponSystem.GetBestWeaponChoice());
				}

				if(MyReference.Flashlight != null)
				{
					if(ambient <= 0.5f)
					{
						MyReference.Flashlight.Toggle(true);
					}
					else
					{
						MyReference.Flashlight.Toggle(false);
					}
				}
			}

		}



	}