Example #1
0
        protected override void PaintContent(Graphics graphics)
        {
            ICharacterState player1 = selectMenuPlayer1.CurrentCharacter;
            ICharacterState player2 = selectMenuPlayer2.CurrentCharacter;

            DrawBackground(graphics, background);
            DrawImage(graphics, udcLabel, 0, 0, cellX * 5, cellY * 5);
            graphics.DrawString("Выберите персонажей", mainFont, ColorConstants.CharacterSelectLabels, cellX * 7, cellY * 2);
            for (int i = 0; i < selectMenuPlayer1.Characters.Count; i++)
            {
                DrawImage(graphics, selectMenuPlayer1.Characters[i].Icon, cellX * i * 2 + cellX, cellY * 4, cellX * 2, cellX * 2);
            }

            if (!selectMenuPlayer1.Selected)
            {
                DrawImage(graphics, selectFirstImage, cellX * selectMenuPlayer1.Selection * 2 + cellX, cellY * 4, cellX * 2,
                          cellX * 2);
            }

            DrawImage(graphics, player1.Image, cellX * 1, cellY * 10, cellY * 10, cellY * 10);
            graphics.DrawString(selectMenuPlayer1.Characters[selectMenuPlayer1.Selection].PlayerName, mainFont, selectMenuPlayer1.Selected? ColorConstants.Selected : ColorConstants.NonSelected, cellX, cellY * 8);

            if (!selectMenuPlayer2.Selected)
            {
                DrawImage(graphics, selectSecondImage, cellX * selectMenuPlayer2.Selection * 2 + cellX, cellY * 4, cellX * 2, cellX * 2);
            }
            graphics.DrawString(selectMenuPlayer2.Characters[selectMenuPlayer2.Selection].PlayerName, mainFont, selectMenuPlayer2.Selected ? ColorConstants.Selected : ColorConstants.NonSelected, cellX * 15, cellY * 8);
            DrawImage(graphics, player2.Image, cellX * 13, cellY * 10, cellY * 10, cellY * 10);
        }
 private void JumpInput()
 {
     if (Input.GetButtonDown("Jump"))
     {
         state = state.Jump(playerSettings.jumpForce);
     }
 }
        private void UpdateStateResponseToInput(IUserCmd cmd, ICharacterState stateManager,
                                                IAdaptiveContainer <IFsmInputCommand> commandsContainer, PlayerEntity playerEntity)
        {
            try
            {
                SingletonManager.Get <DurationHelp>().ProfileStart(CustomProfilerStep.StateUpdateResponseToInput);
                _fsmOutputs.ResetOutput();
                // 更新状态机
                stateManager.Update(commandsContainer, cmd.FrameInterval, _fsmOutputs.AddOutput,
                                    FsmUpdateType.ResponseToInput, playerEntity.fsmInputRelateInterface.Relate.GetFsmInputLimits());
                // 更新手臂动画
                playerEntity.characterBoneInterface.CharacterBone.SetWeaponPitch(_fsmOutputs.AddOutput,
                                                                                 playerEntity.characterBone.WeaponPitch);
                // 更新一、三人称Animator
                _fsmOutputs.SetOutput(playerEntity);

                if (!SharedConfig.IsServer &&
                    playerEntity.thirdPersonAnimator.UnityAnimator.cullingMode != AnimatorCullingMode.AlwaysAnimate)
                {
                    _logger.WarnFormat("wrong culling mode: {0}",
                                       playerEntity.thirdPersonAnimator.UnityAnimator.cullingMode);
                }
            }
            finally
            {
                SingletonManager.Get <DurationHelp>().ProfileEnd(CustomProfilerStep.StateUpdateResponseToInput);
            }
        }
        private void UpdateStateResponseToAnimation(ICharacterState stateManager,
                                                    IAdaptiveContainer <IFsmInputCommand> commandsContainer,
                                                    AnimatorClipManager animatorClipManager, PlayerEntity playerEntity)
        {
            try
            {
                SingletonManager.Get <DurationHelp>().ProfileStart(CustomProfilerStep.StateUpdateResponseToAnimation);

                _fsmOutputs.ResetOutput();
                // 更新状态机
                stateManager.Update(commandsContainer, 0, _fsmOutputs.AddOutput, FsmUpdateType.ResponseToAnimation,
                                    playerEntity.fsmInputRelateInterface.Relate.GetFsmInputLimits());
                // 更新Clip速率
                animatorClipManager.Update(_fsmOutputs.AddOutput,
                                           playerEntity.thirdPersonAnimator.UnityAnimator,
                                           playerEntity.firstPersonAnimator.UnityAnimator,
                                           playerEntity.WeaponController().HeldWeaponAgent.ConfigId);

                // 更新Animator的Param
                _fsmOutputs.SetOutput(playerEntity);
            }
            finally
            {
                SingletonManager.Get <DurationHelp>().ProfileEnd(CustomProfilerStep.StateUpdateResponseToAnimation);
            }
        }
        private void SprintDisableTest(ICharacterState state, IAdaptiveContainer <IFsmInputCommand> commands)
        {
            int slowDown     = NoLimit;
            int prevSlowDown = state.GetSteepSlowDown();

            if (IsLimitRun(state.GetSteepAngle(), prevSlowDown))
            {
                for (int i = 0; i < commands.Length; ++i)
                {
                    var v = commands[i];
                    if (v.Type == FsmInput.Sprint || v.Type == FsmInput.Run)
                    {
                        v.Type = FsmInput.Walk;
                        _logger.DebugFormat("sprint to Walk due to move in water or is steep slope!, angle:{0}", state.GetSteepAngle());
                        slowDown = LimitRun;
                    }
                }
            }
            else if (state.IsMoveInWater() || IsLimitSprint(state.GetSteepAngle(), prevSlowDown))
            {
                for (int i = 0; i < commands.Length; ++i)
                {
                    var v = commands[i];
                    if (v.Type == FsmInput.Sprint)
                    {
                        v.Type = FsmInput.Run;
                        _logger.DebugFormat("sprint to run due to move in water or is steep slope!, angle:{0}", state.GetSteepAngle());
                        slowDown = LimitSprint;
                    }
                }
            }
            state.SetSteepSlowDown(slowDown);
        }
 private void ShootInput()
 {
     if (Input.GetButtonDown("Fire1"))
     {
         state = state.Shoot(bulletPool, transform.position);
     }
 }
        public static ThirdPersonAction GetAction(ICharacterState state)
        {
            ThirdPersonAction ret;
            var stateActionInConfig = state.GetActionState();

            switch (stateActionInConfig)
            {
            case ActionInConfig.SwitchWeapon:
                ret = ThirdPersonAction.SwitchWeapon;
                break;

            case ActionInConfig.PickUp:
                ret = ThirdPersonAction.PickUp;
                break;

            case ActionInConfig.Reload:
                ret = ThirdPersonAction.Reload;
                break;

            case ActionInConfig.SpecialReload:
                ret = ThirdPersonAction.SpecialReload;
                break;

            default:
                ret = ThirdPersonAction.EndOfTheWorld;
                break;
            }

            return(ret);
        }
Example #8
0
 public SwordmanAttack1(IMainCharacter mainCharacter)
 {
     step               = 1f;
     results            = new Collider[5];
     this.mainCharacter = mainCharacter;
     caromState         = new SwordmanAttack2(mainCharacter);
 } // end SwordmanAttack1
        //public ArmorUnit characterArmors;

        public MyCharacter(string n, int hp, int dmg, int lvl, int tp, int arm)
        {
            name            = n;
            healthPoints    = hp;
            damage          = dmg;
            level           = lvl;
            type            = tp;
            coordinateX     = 0;
            coordinateY     = 0;
            characterState  = new NormalState(this);
            blindedState    = new BlindedState(this);
            normalState     = new NormalState(this);
            knockedoutState = new KnockedOutState(this);
            freezedState    = new FreezedState(this);
            gold            = 0;

            //characterArmors = new ArmorUnit("Shirts And pants", arm);



            //var json = JsonConvert.SerializeObject(this);
            //json = json.Remove(2, 41); //remove spellAction from string
            //var response = HttpClientToAPI.Instance().Post("players", json);
            //Player pl = JsonConvert.DeserializeObject<Player>(response);
            //id = pl.Id;
            //HttpClientToAPI.Instance().Post("coordinates", "{\"PlayerId\":" + id + ", \"CoordinateX\":0, \"CoordinateY\":0}");
        }
Example #10
0
 public void ChangeState(ICharacterState newState)
 {
     // Leave like this for now
     if (CheckForValidStateChange(newState))
     {
         currentState = newState;
     }
 }
Example #11
0
 public SwordmanAttack2(IMainCharacter mainCharacter)
 {
     step               = 1f;
     halfExtents        = new Vector3(0.3f, 0.5f, 0.6f);
     results            = new Collider[5];
     this.mainCharacter = mainCharacter;
     caromState         = new SwordmanAttack3(mainCharacter);
 } // end SwordmanAttack1
    void Start()
    {
        navAgent     = GetComponent <NavMeshAgent>();
        currentState = combatState;


        StartCoroutine(EnemyCheck());
    }
 private void CrouchInput()
 {
     if (Input.GetKeyDown(KeyCode.S))
     {
         float inputX = Input.GetAxisRaw("Horizontal");
         state = state.Crouch(inputX);
     }
 }
 public static void CharacterUnmount(this ICharacterState State, Action holsterStart, Action holsterEnd,
                                     float unarmParam)
 {
     _loggerAdapter.Info("[Tmp]Interrupt");
     State.InterruptAction();
     State.ForceFinishGrenadeThrow();
     State.Holster(holsterStart, holsterEnd, unarmParam);
 }
Example #15
0
 public void ChangeState(ICharacterState nextState)
 {
     if (currentState != null)
     {
         this.currentState.Exit();
     }
     this.currentState = nextState;
     this.currentState.Enter(this);
 }
Example #16
0
        public void Start()
        {
            Debug.Assert(behaviour != null);

            character = GetComponent <Character> ();
            Debug.Assert(character != null);

            currentState = new IdleState(behaviour, character);
        }
Example #17
0
    private void Start()
    {
        flyBoy = GetComponent <CharacterController>();

        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible   = (false);
        CursorLockedVar  = (true);

        state = Grounded;
    }
Example #18
0
 private void TransitionCharacterState(ICharacterState state)
 {
     if (characterState != null)
     {
         characterState.Exit();
     }
     characterState = state;
     characterState.Enter(selected);
     //SetCombatMenu();
 }
        public static ThirdPersonPosture GetPosture(ICharacterState state)
        {
            ThirdPersonPosture ret;
            var stateInConfig = state.GetCurrentPostureState();

            switch (stateInConfig)
            {
            case PostureInConfig.Stand:
                ret = ThirdPersonPosture.Stand;
                break;

            case PostureInConfig.Crouch:
                ret = ThirdPersonPosture.Crouch;
                break;

            case PostureInConfig.Prone:
                ret = ThirdPersonPosture.Prone;
                break;

            case PostureInConfig.ProneTransit:
                ret = ThirdPersonPosture.ProneTransit;
                break;

            case PostureInConfig.ProneToStand:
                ret = ThirdPersonPosture.ProneToStand;
                break;

            case PostureInConfig.ProneToCrouch:
                ret = ThirdPersonPosture.ProneToCrouch;
                break;

            case PostureInConfig.Swim:
                ret = ThirdPersonPosture.Swim;
                break;

            case PostureInConfig.Dive:
                ret = ThirdPersonPosture.Dive;
                break;

            case PostureInConfig.Dying:
                ret = ThirdPersonPosture.Dying;
                break;

            case PostureInConfig.Climb:
                ret = ThirdPersonPosture.Climb;
                break;

            default:
                ret = ThirdPersonPosture.EndOfTheWorld;
                break;
            }

            return(ret);
        }
    public void ChangeState(ICharacterState newState)
    {
        if (currentState != null)
        {
            currentState.Exit();
        }

        currentState = newState;

        currentState.Enter(this);
    }
 // Token: 0x0600204B RID: 8267 RVA: 0x0009A550 File Offset: 0x00098750
 public void Shoot(ICharacterState state)
 {
     if (state != null && this._nextShootTime < Time.time && this._currentSlot != null && (!(this._currentSlot.Logic is ProjectileWeapon) || this._currentSlot.View.ItemClass == UberstrikeItemClass.WeaponSplattergun))
     {
         this._nextShootTime = Time.time + WeaponConfigurationHelper.GetRateOfFire(this._currentSlot.View);
         this.BeginShooting();
         CmunePairList <BaseGameProp, ShotPoint> cmunePairList;
         this._currentSlot.Logic.Shoot(new Ray(this.ShootingPoint(state) + GameState.Current.Player.EyePosition, this.ShootingDirection(state)), out cmunePairList);
         this.EndShooting();
     }
 }
Example #22
0
 // Token: 0x0600185D RID: 6237 RVA: 0x000828E4 File Offset: 0x00080AE4
 public void Initialize(ICharacterState state, global::Avatar avatar)
 {
     this.State = state;
     this.State.OnDeltaUpdate += this.OnDeltaUpdate;
     this._transform.position  = this.State.Position;
     if (!this.State.Player.IsAlive)
     {
         Debug.Log("Initialize as dead player at " + this.State.Position);
     }
     base.gameObject.name = string.Format("Player{0}_{1}", this.State.Player.Cmid, this.State.Player.PlayerName);
     this.SetAvatar(avatar);
     this.WeaponSimulator.UpdateWeapons((int)this.State.Player.CurrentWeaponSlot, this.State.Player.Weapons);
 }
Example #23
0
 public void Enter(Character selected = null, Map map = null)
 {
     EventManager.Instance.Raise(new CombatMenuEvent());
     if (this.selected == null)
     {
         this.selected = selected;
         this.selected.ToggleHighlight(true);
         ICharacterState state = (selected.Moved || selected.Acted) ? new ActionState() : new MoveState() as ICharacterState;
         TransitionCharacterState(state);
     }
     EventManager.Instance.AddListener <CharacterStateTransitionEvent>(OnCharStateTransition);
     EventManager.Instance.Raise(new ColliderToggleEvent(false));
 }
Example #24
0
            } // end Update

            public void PerformTransition(ICharacterState state)
            {
                if (null != currentState)
                {
                    currentState.DoBeforeLeaving();
                }
                // end if
                currentState = state;
                if (null != currentState)
                {
                    currentState.DoBeforeEntering();
                }
            } // end PerformTransition
Example #25
0
    void StateDataBaseInitialize()
    {
        stateDataBase = new ICharacterState[5];

        stateDataBase[(int)CHARACTER_STATE.Idle]         = GetComponent <FunKiBaseState>();
        stateDataBase[(int)CHARACTER_STATE.Jump]         = GetComponent <FunKiBaseJumpState>();;
        stateDataBase[(int)CHARACTER_STATE.ObstacleJump] = GetComponent <FunKiBaseObstacleState>();
        stateDataBase[(int)CHARACTER_STATE.Falling]      = GetComponent <FunKiFallingState>();
        stateDataBase[(int)CHARACTER_STATE.Rigidity]     = GetComponent <FunKiRigidityState>();

        state = stateDataBase[(int)CHARACTER_STATE.Idle];

        Debug.Log("캐릭터의 현재 상태 : " + state.ToString());
    }
Example #26
0
    // Use this for initialization
    void Start()
    {
        rb   = GetComponent <Rigidbody>();
        anim = GetComponentInChildren <Animator>();
        //particles = GetComponentInChildren<ParticleSystem>();

        normalState  = new NormalState(this);
        currentState = normalState;

        pushableLayer = LayerMask.GetMask("Pushable");
        groundLayer   = LayerMask.GetMask("Ground");

        appliedForces = new Vector3(0f, 0f, 0f);
    }
Example #27
0
 /// <summary>
 /// 初始化
 /// </summary>
 private void Initialize()
 {
     character = this;
     states    = new ICharacterState[] {
         new CharacterState_Idle(character),
         new CharacterState_Walking(character),
         new CharacterState_Empty(character),
         new CharacterState_Holding(character)
     };
     currentState = states[0];
     animator     = character.GetComponent <Animator>();
     Debug.Log(animator);
     action = new Action(character);
 }
Example #28
0
    public bool CheckForValidStateChange(ICharacterState newState)
    {
        if (currentState == null)
        {
            return(true);
        }

        if (currentState.Id == newState.Id)
        {
            return(false);
        }

        return(true);
    }
 public virtual void ChangeState(string StateName)
 {
     if (stateDictionary.ContainsKey(StateName))
     {
         cState           = StateName;
         stateCurrentTime = 1;
         currentState.OnInterrupted();
         currentState = stateDictionary[StateName];
         currentState.OnStart();
     }
     else
     {
         Debug.Log("State " + StateName + " doesn't exist.");
     }
 }
Example #30
0
        protected override void PaintContent(Graphics graphics)
        {
            ICharacterState player = descriptionMenu.CurrentCharacter;

            DrawBackground(graphics, background);
            DrawImage(graphics, player.Image, cellX * -1, cellY * 2, cellX * 15, cellX * 15);
            graphics.DrawString(player.PlayerName, titleFont, ColorConstants.NormalColorBrush,
                                new RectangleF(cellX * 12, cellY * 2, Width - cellX * 12, cellY * 6), stringFormatCenter);
            graphics.DrawString(player.CharacterDescription, descriptionFont, ColorConstants.NormalColorBrush,
                                new RectangleF(cellX * 12, cellY * 8, Width - cellX * 12, Height - cellY * 8), stringFormatCenter);
            graphics.DrawString(player.StatsDescription, regularFont, ColorConstants.NormalColorBrush,
                                new RectangleF(cellX * 12, cellY * 19, Width - cellX * 12, Height - cellY * 19), stringFormatNormal);
            graphics.DrawString(player.AbilitiesDescription, regularFont, ColorConstants.NormalColorBrush,
                                new RectangleF(cellX * 2, cellY * 30, Width - cellX * 2, Height - cellY * 30), stringFormatNormal);
        }
Example #31
0
    //*********************************
    // VVVVV MONOBEHAVIOUR EVENTS VVVVV
    //*********************************
    void Start()
    {
        rigidbody = GetComponent<Rigidbody2D>();
        animator = GetComponent<Animator>();

        upAttackTrigger = Animator.StringToHash("UpAttack");
        sideUpAttackTrigger = Animator.StringToHash("SideUpAttack");
        sideAttackTrigger = Animator.StringToHash("SideAttack");
        sideDownAttackTrigger = Animator.StringToHash("SideDownAttack");
        downAttackTrigger = Animator.StringToHash("DownAttack");
        airJumpTrigger = Animator.StringToHash("AirJump");
        groundedHash = Animator.StringToHash("Grounded");
        walkingHash = Animator.StringToHash("Walking");
        stunnedHash = Animator.StringToHash("Stunned");

        startXScale = transform.localScale.x;

        attacks = new Dictionary<Direction, Attack>();
        attacks.Add(Direction.Up, upAttack);
        attacks.Add(Direction.RightUp, sideUpAttack);
        attacks.Add(Direction.Right, sideAttack);
        attacks.Add(Direction.RightDown, sideDownAttack);
        attacks.Add(Direction.Down, downAttack);
        attacks.Add(Direction.LeftDown, sideDownAttack);
        attacks.Add(Direction.Left, sideAttack);
        attacks.Add(Direction.LeftUp, sideUpAttack);

        currentState = new Idle();
        currentState.OnEnter(this);
        inputComponent = GetComponent(typeof(IGetInput)) as IGetInput;
        instructions = new CharacterInstructions();
        instructionsBuffer = new LinkedList<CharacterInstructions>();

        for(int i = 0; i < inputBufferLength; i++)
        {
            instructionsBuffer.AddFirst(new CharacterInstructions());
        }

        grounded = false;
        stunned = false;
        rigidbody.gravityScale = gravityScale;
    }
Example #32
0
    void Update()
    {
        //flip the character's x-scale to face left or right
        transform.localScale = new Vector3(facingRight ? startXScale : -startXScale, transform.localScale.y, transform.localScale.z);

        //fetch this frame's input from the input component
        //instructions.Clear();
        //inputComponent.GetInput(ref instructions);

        CharacterInstructions thisFrameInstructions = instructionsBuffer.Last.Value;
        instructionsBuffer.RemoveLast();
        thisFrameInstructions.Clear();
        inputComponent.GetInput(ref thisFrameInstructions);
        instructionsBuffer.AddFirst(thisFrameInstructions);
        bool actionFound = false;

        foreach(CharacterInstructions i in instructionsBuffer)
        {
            if (i.actedOn)
            {
                break;
            }
            else
            {
                if (i.actionInstructions != CharacterInstructions.ActionInstructions.none)
                {
                    instructions = i;
                    actionFound = true;
                    break;
                }
            }
        }

        if (!actionFound)
        {
            instructions = instructionsBuffer.First.Value;
        }

        //send this frame's input to the current state object
        //if this frame's input doesn't cause the character to change state, HandleInput returns null
        ICharacterState nextState = currentState.HandleInput(instructions);

        //if nextState is not null, we are switching states this frame. Call OnExit on the old state and OnEnter on the new state
        if (nextState != null)
        {
            currentState.OnExit();
            currentState = nextState;
            currentState.OnEnter(this);
        }

        //now that we know for certain what state we're in this frame, call this state's Update function
        currentState.Update();

        if (Mathf.Abs(rigidbody.velocity.x) > 0.1f)
        {
            animator.SetBool(walkingHash, true);
        }
        else
        {
            animator.SetBool(walkingHash, false);
        }
    }