Exemple #1
0
 public void MoveRight()
 {
     if (!CollisionChecker.IsCollision(boardGrid, grid, 1, 0))
     {
         grid.MoveRight();
     }
 }
Exemple #2
0
        public override void Update()
        {
            base.Update();

            BaseUnit[] baseUnits = new BaseUnit[Units.Count];
            Units.CopyTo(baseUnits);

            IEnumerable <CollisionPair> collidedUnits = CollisionChecker.GetAllCollisions(baseUnits);

            foreach (CollisionPair tuple in collidedUnits)
            {
                if (_lastCollided.All(prevoiseTuple => !prevoiseTuple.Equals(tuple)))
                {
                    tuple.Collided();
                }
            }

            bool ballOutside = _player.Ball.Position.Y > PlayingSize.Height;

            if (ballOutside && !testPhysic())
            {
                Failed = true;
            }

            //has no blocks
            if (baseUnits.All(unit => unit.UnitType != UnitType.Block))
            {
                Success = true;
            }
        }
Exemple #3
0
    public override IAbilityObject Execute(DashObject t)
    {
        CollisionChecker cc = t.transform.gameObject.GetComponent <CollisionChecker>() as CollisionChecker;

        if (!isDashing && unlocked && (Utils.GetUnixTime() - coolDownTime) > cooldown)
        {
            float dash = cc.GetDistanceUntilCollision(t.direction, dashDistance);
            //float dash = (t.direction == Direction.RIGHT) ? temp_dist : temp_dist * -1;

            currentPosition = t.transform.localPosition;
            Vector3 position = t.transform.localPosition;
            position.x   += dash;
            finalPosition = position;

            counter  = 5;
            interval = dash / counter;

            isDashing = true;

            timer          = new System.Timers.Timer();
            timer.Interval = 10;
            timer.Elapsed += UpdateDash;
            timer.Enabled  = true;
        }

        return(t);
    }
Exemple #4
0
        [Test] // Testing too much speed collision with platform results in death.
        public void CollisionWithPlatformDeathTest()
        {
            _testCollisionObstacle = new EntityContainer();
            _testCollisionPlatform = new EntityContainer();
            _testSpecifiedPlatform = new List <Dictionary <char, List <Entity> > >();
            _testPassengerList     = new List <Passenger>();

            var stationaryShape = new StationaryShape(new Vec2F(0.0f, 0.0f), new Vec2F(1.0f, 0.5f));
            var image           = new Image(Path.Combine("Assets", "Images", "Taxi_Thrust_None.png"));

            _testPlayer = new Player();
            _testPlayer.SetPosition(0.5f, 0.6f);
            _testPlayer.GetsShape().Direction.Y = -0.005f;

            _testCollisionPlatform.AddStationaryEntity(stationaryShape, image);

            CollisionChecker collisionTest = new CollisionChecker(_testCollisionObstacle, _testCollisionPlatform,
                                                                  _testPlayer, _testPassengerList, _testSpecifiedPlatform);

            while (!collisionTest.GetGameOverChecker())
            {
                _testPlayer.PlayerMove();
                collisionTest.CheckCollsion();
            }
            Assert.AreEqual(collisionTest.GetGameOverChecker(), true);
        }
Exemple #5
0
        public override bool CanMove(Vector2 direction, Room room)
        {
            var collisionChecker = new CollisionChecker();

            direction.Normalize();
            var movedEnemy = new Enemy(_x + _speed * direction.X, _y + _speed * direction.Y,
                                       _width, _height, _speed, _attackSpeed, _leftTexture, _rightTexture, _shotChar, _hp, _damage,
                                       _shotSpeed, _shotRange, _name);

            if (collisionChecker.IsCollided(movedEnemy, room))
            {
                return(false);
            }

            foreach (var t in room.Enemies)
            {
                if (collisionChecker.IsCollided(movedEnemy, t) && t != this)
                {
                    return(false);
                }
            }

            if (collisionChecker.IsCollided(room.Players[0], movedEnemy))
            {
                return(false);
            }



            return(base.CanMove(direction, room));
        }
Exemple #6
0
 public void Start()
 {
     this.warpSound = GetComponent <AudioSource>();
     this.gameObject.AddComponent <CollisionChecker>();
     this.collision           = this.gameObject.GetComponent <CollisionChecker>();
     this.collision.targetTag = "Player";
 }
Exemple #7
0
        public override void Collided(BaseUnit baseUnit)
        {
            if (baseUnit.UnitType != UnitType.Wall)
            {
                return;
            }

            ESide side = CollisionChecker.GetCollisionSide(this, _lastPosition, baseUnit);

            switch (side)
            {
            case ESide.Left:
                Position = new Point(baseUnit.Position.X - Width, Position.Y);
                break;

            case ESide.Right:
                Position = new Point(baseUnit.Position.X + baseUnit.Width, Position.Y);
                break;
            }

            if (baseUnit.UnitType == UnitType.Bonus)
            {
                //Width = Width * 2;
            }
        }
Exemple #8
0
 /// <summary>
 /// 刷新缓存数据,重置世界
 /// </summary>
 ///
 public void Reset()
 {
     if (isClose)
     {
         return;
     }
     if (objects != null)
     {
         lock (objects)
         {
             if (objects != null)
             {
                 objects.Clear();
                 objects = null;
             }
             if (collisionChecker != null)
             {
                 collisionChecker.Clear();
                 collisionChecker = null;
             }
             this.collisionChecker = new CollisionManager();
             this.objects          = new ActorTreeSet();
         }
     }
 }
Exemple #9
0
        public void NextMove(RobotVacuum vacuum)
        {
            _checker = RobotVacuum.Vacuum.Checker;

            /*
             * if (_checker.CollisionOccured(vacuum) && !_checker.NorthSouthWallCollision && !_checker.SideWallCollision)
             * {
             * }
             *
             * else if (_checker.CollisionOccured(vacuum) && _checker.NorthSouthWallCollision && _checker.SideWallCollision && vacuum.X >= 820)
             * {
             * }
             *
             * else if (_checker.CollisionOccured(vacuum) && _checker.NorthSouthWallCollision)
             * {
             * }
             *
             * else if (_checker.CollisionOccured(vacuum) && _checker.SideWallCollision)
             * {
             * }
             *
             * else
             * {
             * }
             */

            MoveForward(vacuum);


            AddPoints(vacuum);
        }
Exemple #10
0
        public override void Collided(BaseUnit baseUnit)
        {
            double angle       = CollisionChecker.GetAngle(_angle, _lastPosition, this, baseUnit);
            double randomAngle = new Random().NextDouble() / 10;
            int    sign        = new Random().Next() % 2 == 0 ? -1 : 1;

            _angle = angle + sign * randomAngle;
        }
Exemple #11
0
 void Start()
 {
     InstantiateSelectedPlayer();
     collisionCheckerScript = GetComponentInChildren <CollisionChecker>();
     rb = GetComponent <Rigidbody>();
     //controller = GetComponent<CharacterController>();
     moveDir = transform.forward;
 }
 public AnimatorCommunicator(Rigidbody2D rb2d, Animator animator, CollisionChecker collisionChecker, PlayerMover playerMover, Attacker attacker)
 {
     _rb2d             = rb2d;
     _animator         = animator;
     _attacker         = attacker;
     _playerMover      = playerMover;
     _collisionChecker = collisionChecker;
 }
 private void Awake()
 {
     _attacker             = new Attacker(1f);
     _jumpModifier         = new JumpModifier(rb2d, 2f, 2.5f);
     _collisionChecker     = new CollisionChecker(wallCheckPoints, groundCheckPoint);
     _playerMover          = new PlayerMover(rb2d, moveSpeed, transform, jumpPower, _collisionChecker);
     _animatorCommunicator = new AnimatorCommunicator(rb2d, animator, _collisionChecker, _playerMover, _attacker);
 }
Exemple #14
0
 public PlayerMover(Rigidbody2D rb2d, float moveSpeed, Transform transform, float jumpPower, CollisionChecker collisionChecker)
 {
     _rb2d             = rb2d;
     _moveSpeed        = moveSpeed;
     _transform        = transform;
     _jumpPower        = jumpPower;
     _collisionChecker = collisionChecker;
 }
    void Start()
    {
        movementCooldown = defaultMovementCooldown;
        initialPosition  = transform.position;
        finalPosition    = transform.position;

        collisionChecker = GetComponent <CollisionChecker>();
    }
    private void OnDrawGizmos()
    {
        if (_collisionChecker == null)
        {
            _collisionChecker = new CollisionChecker(wallCheckPoints, groundCheckPoint);
        }

        _collisionChecker.DebugGizmos();
    }
Exemple #17
0
 private void Start()
 {
     collisionChecker   = GetComponent <CollisionChecker>();
     gameManager        = FindObjectOfType <GameManager>();
     animator           = GetComponent <Animator>();
     playerSoundManager = GetComponent <PlayerSoundManager>();
     canMove            = true;
     defaultXScale      = transform.localScale.x;
 }
 public ActorLayer(int x, int y, int layerWidth, int layerHeight,
         int s, bool bounded)
     : base(x, y, layerWidth, layerHeight)
 {
     this.collisionChecker = new CollisionManager();
     this.objects = new ActorTreeSet();
     this.cellSize = s;
     this.Initialize(layerWidth, layerHeight, s);
     this.isBounded = bounded;
 }
Exemple #19
0
 public ActorLayer(int x, int y, int layerWidth, int layerHeight,
                   int s, bool bounded)
     : base(x, y, layerWidth, layerHeight)
 {
     this.collisionChecker = new CollisionManager();
     this.objects          = new ActorTreeSet();
     this.cellSize         = s;
     this.Initialize(layerWidth, layerHeight, s);
     this.isBounded = bounded;
 }
        private CollisionType GetCollisionType(int my, ShipMoveCommand myc, int other, ShipMoveCommand oc)
        {
            uint myMovement;
            uint otherMovement;
            var  collisionType = CollisionChecker.Move(my, myc, other, oc, out myMovement, out otherMovement);

            Console.Out.WriteLine(FastShipPosition.ToShipPosition(FastShipPosition.GetMovedPosition(myMovement)) + " - " + FastShipPosition.ToShipPosition(FastShipPosition.GetFinalPosition(myMovement)));
            Console.Out.WriteLine(FastShipPosition.ToShipPosition(FastShipPosition.GetMovedPosition(otherMovement)) + " - " + FastShipPosition.ToShipPosition(FastShipPosition.GetFinalPosition(otherMovement)));
            return(collisionType);
        }
 public void Start()
 {
     playerInputs = GetComponent <PlayerInputs>();
     // Make sure this object has a collision checker.
     collisionChecker = GetComponent <CollisionChecker>();
     if (collisionChecker == null)
     {
         Debug.LogError(string.Format("There is no CollisionChecker on game object {0} for TopDownMovement to work.", gameObject.name));
         this.enabled = false;
     }
 }
Exemple #22
0
    public void Init(EnemyFlock flock, int id, float healthBonus, float damageBonus, CollisionChecker collisionChecker)
    {
        this.flock = flock;
        flockId = id;

        this.collisionChecker = collisionChecker;

        attackDamage += damageBonus;

        healthComp = new Health(startingHP + (int)healthBonus);
    }
Exemple #23
0
    void Start()
    {
        collisionChecker = GetComponent <CollisionChecker>();
        rb           = GetComponent <Rigidbody2D>();
        spr          = GetComponent <SpriteRenderer>();
        walnutScript = walnut.GetComponent <Walnut>();
        jumpScript   = GetComponent <Jump>();

        yOffset = playerCollisionBox.offset.y;
        ySize   = playerCollisionBox.size.y;
    }
Exemple #24
0
        public void Rotate()
        {
            Square[,] rotatedCells = GenerateShapeCells(type, rotation + 1);
            Grid rotatedGrid = new Grid(grid, rotatedCells);

            if (!CollisionChecker.IsCollision(boardGrid, rotatedGrid))
            {
                grid = rotatedGrid;
                rotation++;
            }
        }
Exemple #25
0
    void Start()
    {
        remainingLife = lifeSpan;
        ratio         = 0;
        multiplier    = 1 / lifeSpan;

        initialPos = transform.position;
        finalPos   = new Vector3(initialPos.x + (distance * direction.x), initialPos.y + (distance * direction.y), transform.position.z);

        collisionChecker           = GetComponent <CollisionChecker>();
        collisionChecker.layerMask = layerMask;
    }
    void Start()
    {
        remainingLife = lifeSpan;
        ratio = 0;
        multiplier = 1 / lifeSpan;

        initialPos = transform.position;
        finalPos = new Vector3(initialPos.x + (distance * direction.x), initialPos.y + (distance * direction.y), transform.position.z);

        collisionChecker = GetComponent<CollisionChecker>();
        collisionChecker.layerMask = layerMask;
    }
    void Start()
    {
        endPosition        = transform.position;
        isMoving           = false;
        isHorizontalGrowth = true;
        wantToGrow         = false;
        collisionChecker   = GetComponentInChildren <CollisionChecker>();
        spriteRender       = GetComponentInChildren <SpriteRenderer>();

        ui           = GameObject.FindGameObjectWithTag("Ui");
        uiController = ui.GetComponent <UIController>();
        animator     = GetComponent <Animator>();
    }
Exemple #28
0
 public static FastGlider.FastGliderTransport CreateGlider(
     Vector3 spawnPosition,
     Quaternion rotation,
     MeshedVehicleDescription vehicle,
     Players.Player playerInside)
 {
     Glider.GliderMovement          mover    = new Glider.GliderMovement(spawnPosition, rotation, settings, playerInside);
     FastGlider.FastGliderTransport vehicle1 = new FastGlider.FastGliderTransport(mover, vehicle, new InventoryItem(ItemTypes.GetType(settings.ItemTypeName).ItemIndex, 1));
     mover.SetParent(vehicle1);
     CollisionChecker.RegisterSource((CollisionChecker.ICollisionSource)mover);
     TransportManager.RegisterTransport((TransportManager.ITransportVehicle)vehicle1);
     return(vehicle1);
 }
    void Start()
    {
        var position = transform.position;

        initialPosition = new Vector3(position.x, position.y, position.z);

        trees = GameObject.FindGameObjectsWithTag("Obstacle");

        SetRewards();

        SetPenalty();

        _collisionChecker = new CollisionChecker(gameObject, transform, dogs, new List <GameObject>(trees));
    }
Exemple #30
0
    private void OnEnable()
    {
        collisionBehaviour = target as CollisionChecker;
        TargetObject       = new SerializedObject(collisionBehaviour);
        Collisions         = TargetObject.FindProperty("collisions");

        collisionShowers = new List <bool>();
        for (int i = 0; i < Collisions.arraySize; i++)
        {
            collisionShowers.Add(false);
        }

        defaultColor = GUI.backgroundColor;
    }
        //public bool IsFlying { get; set; }
        //public override Point Position { get; set; }
        //public new int Width { get; set; }
        //public new int Height { get; set; }

        #endregion

        #region Public Methods

        public override void Collided(BaseUnit baseUnit)
        {
            if (baseUnit.UnitType == UnitType.Player)
            {
                IsFlying = false;
            }

            if (baseUnit.UnitType != UnitType.Bonus)
            {
                double angle       = CollisionChecker.GetAngle(_angle, _lastPosition, this, baseUnit);
                double randomAngle = new Random().NextDouble() / 10;
                int    sign        = new Random().Next() % 2 == 0 ? -1 : 1;
                _angle = angle + sign * randomAngle;
            }
        }
Exemple #32
0
    void Start()
    {
        leftHand         = GetComponentInChildren <PlayerHand>();
        spellHandler     = GetComponent <SpellHandler>();
        gameManager      = GetComponent <GameManager>();
        menuPointer      = GetComponent <LineRenderer>();
        audioSource      = GetComponent <AudioSource>();
        collisionChecker = GetComponent <CollisionChecker>();

        healthComp = new Health(startingHP);

        audioSource.clip = damageSound;

        pointerEnabled = true;
    }
Exemple #33
0
 /// <summary>
 /// 刷新缓存数据,重置世界
 /// </summary>
 ///
 public void Reset()
 {
     if (isClose)
     {
         return;
     }
     if (objects != null)
     {
         lock (objects)
         {
             if (objects != null)
             {
                 objects.Clear();
                 objects = null;
             }
             if (collisionChecker != null)
             {
                 collisionChecker.Clear();
                 collisionChecker = null;
             }
             this.collisionChecker = new CollisionManager();
             this.objects = new ActorTreeSet();
         }
     }
 }
Exemple #34
0
		public void Dispose() {
			 lock (typeof(CollisionManager)) {
						if (freeObjects != null) {
							freeObjects.Clear();
							freeObjects = null;
						}
						if (collisionClasses != null) {
							CollectionUtils.Clear(collisionClasses);
							collisionClasses = null;
						}
						if (collisionChecker != null) {
							collisionChecker.Dispose();
							collisionChecker.Clear();
							collisionChecker = null;
						}
					}
		}
    void Start()
    {
        movementCooldown = defaultMovementCooldown;
        initialPosition = transform.position;
        finalPosition = transform.position;

        collisionChecker = GetComponent<CollisionChecker>();
    }