示例#1
0
        void Move_Tick()
        {
            moveTimer += Time.deltaTime;
            if (moveTimer > moveTime)
            {
                moveTimer = 0f;
                float randnum = Nez.Random.nextFloat();
                if (randnum < moveRate)
                {
                    currentState = BigSlimeSimpleStates.Move;
                }
                else if (randnum >= moveRate && randnum < reProduce)
                {
                    currentState = BigSlimeSimpleStates.Reproducetion;
                }
                else
                {
                    currentState = BigSlimeSimpleStates.Dush;
                }
            }
            direction = bigSlime.target.position - bigSlime.position;
            direction.Normalize();
            var movement = direction * bigSlime.moveSpeed * Time.deltaTime * 0.5f;
            FSCollisionResult fSCollisionResult;

            FixtureExt.collidesWithAnyFixtures(bigSlime.collider.GetFixture(), ref movement, out fSCollisionResult);
            bigSlime.position += movement;
        }
        void Move_Tick()
        {
            moveTimer += Time.deltaTime;
            if (moveTimer > moveTime)
            {
                moveTimer = 0f;
                var rand = Nez.Random.nextFloat();
                if (rand > 0.5)
                {
                    currentState = ArcherStates.SuperAttack;
                }
                else
                {
                    currentState = ArcherStates.Attack;
                }
            }

            var direction = archer.target.position - archer.position;

            direction.Normalize();
            var rigidBody = archer.rigidBody;
            var movement  = direction * archer.moveSpeed * Time.deltaTime;
            FSCollisionResult fSCollisionResult;

            FixtureExt.collidesWithAnyFixtures(rigidBody.body.fixtureList[0], ref movement, out fSCollisionResult);
            colliderWithHole(rigidBody.body.fixtureList[0], ref movement, out fSCollisionResult);
            rigidBody.entity.position += movement;
        }
示例#3
0
        public TaskStatus patrol()
        {
            if (!startPatrol)
            {
                patrolDirection = new Vector2(Nez.Random.minusOneToOne(), Nez.Random.minusOneToOne());
                patrolDirection.Normalize();
                changeAnimeion(SlimeAnimation.Move);
                startPatrol = true;
            }
            patrolTimer += Time.deltaTime;
            if (patrolTimer >= patrolTime)
            {
                startPatrol = false;
                patrolTimer = 0f;
                return(TaskStatus.Success);
            }

            moveDir = Vector2.Zero;
            moveDir = patrolDirection;
            var movement = moveDir * actorProperty.totalMoveSpeed * Time.deltaTime;
            FSCollisionResult fSCollisionResult;

            FixtureExt.collidesWithAnyFixtures(collider.GetFixture(), ref movement, out fSCollisionResult);
            rigidBody.entity.position += movement;

            return(TaskStatus.Running);
        }
示例#4
0
        void Dush_Tick()
        {
            dushTimer += Time.deltaTime;
            if (dushTimer > dushTime)
            {
                dushTimer    = 0f;
                currentState = BigSlimeSimpleStates.Idle;
            }
            var movement = direction * bigSlime.moveSpeed * Time.deltaTime * 2f;
            FSCollisionResult fSCollisionResult;

            FixtureExt.collidesWithAnyFixtures(bigSlime.collider.GetFixture(), ref movement, out fSCollisionResult);
            bigSlime.position += movement;
        }
示例#5
0
        public override void update(float deltaTime)
        {
            var moveDir = Vector2.Zero;

            if (_context.upButton.isDown)
            {
                moveDir += new Vector2(0, -1);
            }
            if (_context.downButton.isDown)
            {
                moveDir += new Vector2(0, 1);
            }

            if (_context.rightButton.isDown)
            {
                moveDir += new Vector2(1, 0);
            }
            if (_context.leftButton.isDown)
            {
                moveDir += new Vector2(-1, 0);
            }

            if (moveDir.Length() > 1)
            {
                moveDir.Normalize();
            }

            if (moveDir != Vector2.Zero)
            {
                var rigidBody = _context.getComponent <FSRigidBody>();
                var movement  = moveDir * _context.moveSpeed * 0.2f * deltaTime;
                FSCollisionResult fSCollisionResult;
                FixtureExt.collidesWithAnyFixtures(rigidBody.body.fixtureList[0], ref movement, out fSCollisionResult);
                rigidBody.entity.position += movement;
            }

            if (_context.attackButton.isDown)
            {
                attacking = true;
            }
            else
            {
                attacking = false;
            }
            if (attacking)
            {
                _context.weapon.update();
            }
        }
示例#6
0
        public TaskStatus chase()
        {
            if (target == null)
            {
                return(TaskStatus.Failure);
            }

            moveDir = Vector2.Zero;
            if ((int)target.position.X > (int)position.X)
            {
                moveDir += new Vector2(1, 0);
            }
            else if ((int)target.position.X < (int)position.X)
            {
                moveDir += new Vector2(-1, 0);
            }
            if ((int)target.position.Y > (int)position.Y)
            {
                moveDir += new Vector2(0, 1);
            }
            else if ((int)target.position.Y < (int)position.Y)
            {
                moveDir += new Vector2(0, -1);
            }

            var movement = moveDir * actorProperty.totalMoveSpeed * Time.deltaTime;
            FSCollisionResult fSCollisionResult;

            FixtureExt.collidesWithAnyFixtures(collider.GetFixture(), ref movement, out fSCollisionResult);
            rigidBody.entity.position += movement;

            chaseTimer += Time.deltaTime;
            if (chaseTimer >= chaseTime)
            {
                chaseTimer = 0f;
                return(TaskStatus.Success);
            }

            return(TaskStatus.Running);
        }
示例#7
0
        public TaskStatus back()
        {
            if (!isBackToInitPosition)
            {
                moveDir = Vector2.Zero;
                if ((int)initPosition.X > (int)position.X)
                {
                    moveDir += new Vector2(1, 0);
                }
                else if ((int)initPosition.X < (int)position.X)
                {
                    moveDir += new Vector2(-1, 0);
                }
                if ((int)initPosition.Y > (int)position.Y)
                {
                    moveDir += new Vector2(0, 1);
                }
                else if ((int)initPosition.Y < (int)position.Y)
                {
                    moveDir += new Vector2(0, -1);
                }

                var movement = moveDir * actorProperty.totalMoveSpeed * Time.deltaTime;
                FSCollisionResult fSCollisionResult;
                FixtureExt.collidesWithAnyFixtures(rigidBody.body.fixtureList[0], ref movement, out fSCollisionResult);
                rigidBody.entity.position += movement;

                return(TaskStatus.Running);
            }
            else
            {
                isLostTarget = false;
            }

            return(TaskStatus.Success);
        }
示例#8
0
        public override void update(float deltaTime)
        {
            moveDir = Vector2.Zero;

            if (_context.upButton.isDown)
            {
                moveDir += new Vector2(0, -1);
                if (!direLocker)
                {
                    direLocker = true;
                    _context.currentDirection = Direction.Up;
                }
            }
            else if (_context.upButton.isReleased)
            {
                if (direLocker && _context.currentDirection == Direction.Up)
                {
                    direLocker = false;
                }
            }

            if (_context.downButton.isDown)
            {
                moveDir += new Vector2(0, 1);

                if (!direLocker)
                {
                    direLocker = true;
                    _context.currentDirection = Direction.Down;
                }
            }
            else if (_context.downButton.isReleased)
            {
                if (direLocker && _context.currentDirection == Direction.Down)
                {
                    direLocker = false;
                }
            }

            if (_context.rightButton.isDown)
            {
                moveDir += new Vector2(1, 0);
                if (!direLocker)
                {
                    direLocker = true;
                    _context.currentDirection = Direction.Right;
                }
            }
            else if (_context.rightButton.isReleased)
            {
                if (direLocker && _context.currentDirection == Direction.Right)
                {
                    direLocker = false;
                }
            }

            if (_context.leftButton.isDown)
            {
                moveDir += new Vector2(-1, 0);
                if (!direLocker)
                {
                    direLocker = true;
                    _context.currentDirection = Direction.Left;
                }
            }
            else if (_context.leftButton.isReleased)
            {
                if (direLocker && _context.currentDirection == Direction.Left)
                {
                    direLocker = false;
                }
            }
            if (moveDir.Length() > 1)
            {
                moveDir.Normalize();
            }


            if (moveDir != Vector2.Zero)
            {
                var rigidBody = _context.getComponent <FSRigidBody>();
                var movement  = moveDir * _context.moveSpeed * deltaTime;
                FSCollisionResult fSCollisionResult;
                FixtureExt.collidesWithAnyFixtures(rigidBody.body.fixtureList[0], ref movement, out fSCollisionResult);
                rigidBody.entity.position += movement;

                if (_context.preDirection != _context.currentDirection)
                {
                    begin();
                }
            }
            else
            {
                _machine.changeState <IdleState>();
            }
        }