public void MoveRight()
{
if (!CollisionChecker.IsCollision(boardGrid, grid, 1, 0))
{
grid.MoveRight();
}
}
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;
}
}
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);
}
[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);
}
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));
}
public void Start()
{
this.warpSound = GetComponent <AudioSource>();
this.gameObject.AddComponent <CollisionChecker>();
this.collision = this.gameObject.GetComponent <CollisionChecker>();
this.collision.targetTag = "Player";
}
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;
}
}
/// <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();
}
}
}
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);
}
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;
}
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);
}
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();
}
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;
}
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;
}
}
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);
}
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;
}
public void Rotate()
{
Square[,] rotatedCells = GenerateShapeCells(type, rotation + 1);
Grid rotatedGrid = new Grid(grid, rotatedCells);
if (!CollisionChecker.IsCollision(boardGrid, rotatedGrid))
{
grid = rotatedGrid;
rotation++;
}
}
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>();
}
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));
}
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;
}
}
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;
}
/// <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();
}
}
}
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>();
}
