public void Position2DY()
{
tlog.Debug(tag, $"Position2DY START");
var testingTarget = new Position2D(2, 3);
Assert.IsNotNull(testingTarget, "null handle");
Assert.IsInstanceOf <Position2D>(testingTarget, "Should return Position2D instance.");
Assert.AreEqual(3, testingTarget.Y, "The Y property of position is not correct here.");
testingTarget.Y = 2;
Assert.AreEqual(2, testingTarget.Y, "The Y property of position is not correct.");
testingTarget.Dispose();
tlog.Debug(tag, $"Position2DY END (OK)");
}
public void Position2DNotEqualTo()
{
tlog.Debug(tag, $"Position2DNotEqualTo START");
var testingTarget = new Position2D(10, 20);
Assert.IsNotNull(testingTarget, "null handle");
Assert.IsInstanceOf <Position2D>(testingTarget, "Should return Position2D instance.");
using (Position2D position = new Position2D(1, 2))
{
Assert.IsTrue((testingTarget.NotEqualTo(position)), "Should be equal");
}
testingTarget.Dispose();
tlog.Debug(tag, $"Position2DNotEqualTo END (OK)");
}
public void Position2DUnaryNegation()
{
tlog.Debug(tag, $"Position2DUnaryNegation START");
var testingTarget = new Position2D(2, 3);
Assert.IsNotNull(testingTarget, "null handle");
Assert.IsInstanceOf <Position2D>(testingTarget, "Should return Position2D instance.");
var result = -testingTarget;
Assert.AreEqual(-2, result.X, "The X value of the position is not correct!");
Assert.AreEqual(-3, result.Y, "The Y value of the position is not correct!");
testingTarget.Dispose();
tlog.Debug(tag, $"Position2DUnaryNegation END (OK)");
}
public void Position2DMultiplyByInteger()
{
tlog.Debug(tag, $"Position2DMultiplyByInteger START");
var testingTarget = new Position2D(2, 3);
Assert.IsNotNull(testingTarget, "null handle");
Assert.IsInstanceOf <Position2D>(testingTarget, "Should return Position2D instance.");
var result = testingTarget * 10;
Assert.AreEqual(20, result.X, "The X value of the position is not correct!");
Assert.AreEqual(30, result.Y, "The Y value of the position is not correct!");
testingTarget.Dispose();
tlog.Debug(tag, $"Position2DMultiplyByInteger END (OK)");
}
public void WindowSetPosition()
{
tlog.Debug(tag, $"WindowSetPosition START");
try
{
Position2D p1 = null;
myWin.SetPosition(p1);
}
catch (Exception e)
{
Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
Assert.Fail("Caught Exception" + e.ToString());
}
tlog.Debug(tag, $"WindowSetPosition END (OK)");
Assert.Pass("WindowSetPosition");
}
private void CalculateContentPosition()
{
var size = Size2D;
var parent = GetParent();
Size2D parentSize;
if ((parent != null) && (parent is View))
{
parentSize = ((View)parent).Size;
}
else
{
parentSize = NUIApplication.GetDefaultWindow().Size;
}
Position2D = new Position2D((parentSize.Width - size.Width) / 2, (parentSize.Height - size.Height) / 2);
}
public void KeyValuePosition2DValue()
{
tlog.Debug(tag, $"KeyValuePosition2DValue START");
Position2D b1 = new Position2D(1, 1);
KeyValue a1 = new KeyValue
{
Position2DValue = b1
};
b1 = a1.Position2DValue;
b1.Dispose();
a1.Dispose();
tlog.Debug(tag, $"KeyValuePosition2DValue END (OK)");
Assert.Pass("KeyValuePosition2DValue");
}
public override void _Ready()
{
player = GetNode("Player") as PlayerObject;
startPosition = GetNode("StartPosition") as Position2D;
startTimer = GetNode("StartTimer") as Timer;
scoreTimer = GetNode("ScoreTimer") as Timer;
mobTimer = GetNode("MobTimer") as Timer;
mobSpawnLocation = GetNode("MobPath").GetNode("MobSpawnLocation") as PathFollow2D;
hud = GetNode("HUD") as HUDObject;
deathSound = GetNode("DeathSound") as AudioStreamPlayer;
music = GetNode("Music") as AudioStreamPlayer;
hud.Connect("StartGame", this, "NewGame");
player.Connect("Hit", this, "GameOver");
randomGenerator = new Random();
}
public override void _Ready()
{
line = GetNode <Line2D>("Line");
end = GetNode <Position2D>("End");
rayCast = GetNode <RayCast2D>("RayCast2D");
int rand = (int)GD.RandRange(0, 1);
if (rand == 0)
{
isClockWise = true;
}
else if (rand == 1)
{
isClockWise = false;
}
}
public override void _Ready()
{
base._Ready();
Map = GetNode <Node2D>("Map");
Spawn = Map.GetNode <Position2D>("Spawn");
Corpses = GetNode <Node2D>("Corpses");
Camera = GetNode <Camera2D>("MainCamera");
UI = GetNode <UI>("CanvasLayer/UI");
RotationAnimationPlayer = GetNode <RotationAnimationPlayer>("RotationAnimationPlayer");
Emitter.Instance.Connect(nameof(Emitter.NewPlayerSignal), this, nameof(OnNewPlayer));
Emitter.Instance.Connect(nameof(Emitter.ActivateCheckPoint), this, nameof(OnActivateCheckPoint));
Emitter.Instance.Connect(nameof(Emitter.Finish1Game), this, nameof(OnFinish1Game));
Emitter.Instance.Connect(nameof(Emitter.Finish2Game), this, nameof(OnFinish2Game));
SpawnPlayer();
}
/*
* @ValidateStartPosition -> Valida a posicao da peca de acordo com o valor de origem
*/
public void ValidateStartPosition(Position2D pos)
{
if (Board.GetPiece(pos) == null)
{
throw new BoardException("Não existe peça na posição de origem selecionada!");
}
if (CurrentPlayer != Board.GetPiece(pos).Color)
{
throw new BoardException("A peça de origem escolhida não é sua!");
}
if (!Board.GetPiece(pos).ExistMoviments())
{
throw new BoardException("Não existem moviemntos possíveis para a peça escolhida!");
}
}
public Position3D TryToFitObject(Object3D selectedObject)
{
double bestFittingQuality = Double.MaxValue;
double localFittingQuality;
Position2D positionToPlace = null;
GuillotineCutContainer2D selectedContainer = GuillotineContainer;
// No space in container - return from function
if (selectedContainer.Subcontainers.Count == 0)
{
return(null);
}
GuillotineCutSubcontainer2D selectedSubcontainer = selectedContainer.Subcontainers.First() as GuillotineCutSubcontainer2D;
// flattens object to 2D during single shelf placement
Object2D selectedObject2D = new Object2D(selectedObject.Width, selectedObject.Height);
foreach (GuillotineCutSubcontainer2D subcontainer in selectedContainer.Subcontainers)
{
if (ValidateObjectPlacement(selectedObject2D, subcontainer))
{
localFittingQuality = CalculateFittingQuality(selectedObject2D, subcontainer);
if (localFittingQuality < bestFittingQuality)
{
bestFittingQuality = localFittingQuality;
selectedSubcontainer = subcontainer;
positionToPlace = subcontainer.Position;
}
}
}
if (positionToPlace != null)
{
var newPlacedObject = selectedContainer.PlaceObject(selectedObject2D, positionToPlace) as PlacedObject2D;
UpdateMaxDepth(selectedObject.Depth);
selectedContainer.SplitSubcontainer(selectedSubcontainer, newPlacedObject);
return(new Position3D(positionToPlace.X, positionToPlace.Y, this.Depth));
}
else
{
return(null);
}
}
public static Position2D NoteToGridPos(byte note)
{
byte[,] grid = GetButtons();
Position2D holder = new Position2D(0, 0);
for (int xscan = 0; xscan < grid.GetLength(0); xscan++)
{
for (int yscan = 0; yscan < grid.GetLength(1); yscan++)
{
if (grid[xscan, yscan] == note)
{
holder = new Position2D(xscan, yscan);
}
}
}
return(holder);
}
public IEnumerator WHEN_BalloonRoundAdded1Round_THEN_BalloonRoundGetterReturnsCorrectValues()
{
balloonsData = new BalloonsStorage();
balloonsData.Rounds = new List <BalloonsRound>();
round = new BalloonsRound();
round.BalloonSize = 180;
double expectedBalloonSize = 180;
round.DestinationClickTime = 1.5;
double expectedDestinationClickTime = 1.5;
round.DestinationPoint = new Position2D(0, 0);
Position2D expectedDestinationPoint = new Position2D(0, 0);
round.SuccessClickPoint = new Position2D(-200, 67);
Position2D expectedSuccessClickPoint = new Position2D(-200, 67);
TimeAndPosition testItem1 = new TimeAndPosition(0.5, new Position2D(10, 20));
TimeAndPosition testItem2 = new TimeAndPosition(1.5, new Position2D(0.1, -40));
round.Clicks = new List <TimeAndPosition>();
round.Clicks.Add(testItem1);
round.Clicks.Add(testItem2);
balloonsData.Rounds.Add(round);
BalloonsRound actualCirclesRound = balloonsData.Rounds[0];
yield return(null);
Assert.IsTrue(expectedBalloonSize == actualCirclesRound.BalloonSize);
Assert.IsTrue(expectedDestinationClickTime == actualCirclesRound.DestinationClickTime);
Assert.IsTrue(Math.Abs(expectedDestinationPoint.X - actualCirclesRound.DestinationPoint.X) <= tolerance &&
Math.Abs(expectedDestinationPoint.Y - actualCirclesRound.DestinationPoint.Y) <= tolerance);
Assert.IsTrue(Math.Abs(expectedSuccessClickPoint.X - actualCirclesRound.SuccessClickPoint.X) <= tolerance &&
Math.Abs(expectedSuccessClickPoint.Y - actualCirclesRound.SuccessClickPoint.Y) <= tolerance);
Assert.IsTrue(2 == actualCirclesRound.Clicks.Count);
Assert.IsTrue(Math.Abs(testItem1.Time - actualCirclesRound.Clicks[0].Time) <= tolerance &&
Math.Abs(testItem1.Position.X - actualCirclesRound.Clicks[0].Position.X) <= tolerance &&
Math.Abs(testItem1.Position.Y - actualCirclesRound.Clicks[0].Position.Y) <= tolerance);
Assert.IsTrue(Math.Abs(testItem2.Time - actualCirclesRound.Clicks[1].Time) <= tolerance &&
Math.Abs(testItem2.Position.X - actualCirclesRound.Clicks[1].Position.X) <= tolerance &&
Math.Abs(testItem2.Position.Y - actualCirclesRound.Clicks[1].Position.Y) <= tolerance);
}
public void Init(Vector2 _position, int score, Mode mode = Mode.Normal)
{
player = null;
animationPlayer = GetNode <AnimationPlayer>("AnimationPlayer");
gemPivot = GetNode <Node2D>("GemPivot");
if (score < 10)
{
SetNormalSpawnRate(100, mode, score);
}
else if (score < 20)
{
SetNormalSpawnRate(70, mode, score);
radius = 148;
}
else if (score < 25)
{
SetNormalSpawnRate(40, mode, score);
radius = 144;
}
else
{
SetNormalSpawnRate(10, mode, score);
radius = 140;
}
Position = _position;
var collisionShape = GetNode <CollisionShape2D>("CollisionShape2D");
collisionShape.Shape = (Shape2D)collisionShape.Shape.Duplicate();
collisionShape.Shape.Set("radius", radius);
var imgSize = GetNode <Sprite>("Sprite").Texture.GetSize().x / 2;
GetNode <Sprite>("Sprite").Scale = new Vector2(1, 1) * radius / imgSize;
orbitPosition = GetNode <Position2D>("Pivot/Orbit");
var pos = new Vector2(radius + 25, orbitPosition.Position.y);
orbitPosition.Position = pos;
rotationSpeed *= Mathf.Pow(-1, GD.Randi() % 2);
SetLuckyGem();
}
public void PositionConstructorWithPosition2D()
{
tlog.Debug(tag, $"PositionConstructorWithPosition2D START");
Position2D position2D = new Position2D(50, 50);
var testingTarget = new Position(position2D);
Assert.IsNotNull(testingTarget, "null handle");
Assert.IsInstanceOf <Position>(testingTarget, "Should return Position instance.");
Assert.AreEqual(50.0f, testingTarget.X, "Should be equal!");
Assert.AreEqual(50.0f, testingTarget.Y, "Should be equal!");
Assert.AreEqual(0.0f, testingTarget.Z, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"PositionConstructorWithPosition2D END (OK)");
}
public override void _Ready()
{
cannon = GetNode <Position2D>("Cannon");
animationPlayer = GetNode <AnimationPlayer>("AnimationPlayer");
bulletCaseParticle = GetNode <CPUParticles2D>("BulletCaseParticle");
shootSound = GetNode <AudioStreamPlayer2D>("ShootAudioPlayer");
STATE_READY = new FSM.State(WeaponReadyUpdate)
{
Name = "Ready"
};
STATE_TIMEOUT = new WaitState(TimeoutDuration, STATE_READY)
{
Name = "Reloading"
};
machine = new FSM(STATE_READY);
}
public void Position2DConstructorWithPosition()
{
tlog.Debug(tag, $"Position2DConstructorWithPosition START");
using (Position position = new Position(5.0f, 5.0f, 0.5f))
{
var testingTarget = new Position2D(position);
Assert.IsNotNull(testingTarget, "null handle");
Assert.IsInstanceOf <Position2D>(testingTarget, "Should return Position2D instance.");
Assert.AreEqual(5.0f, testingTarget.X, "The X property of position is not correct here.");
Assert.AreEqual(5.0f, testingTarget.Y, "The Y property of position is not correct here.");
testingTarget.Dispose();
}
tlog.Debug(tag, $"Position2DConstructorWithPosition END (OK)");
}
public void InitializeGame()
{
Debug.Log("Initialize ECS cubespawner");
var entityManager = World.Active.GetExistingManager <EntityManager>();
for (int i = 0; i < cubeCount; i++)
{
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
var cubeEntity = cube.AddComponent <GameObjectEntity>().Entity;
var endPosition = new Position2D();
endPosition.Value = new float2(Random.Range(-1000, 1000), Random.Range(-1000, 1000));
entityManager.AddComponentData(cubeEntity, new CubeComponent()
{
EndPosition = endPosition
});
}
}
private void MovePlayerInCurrentDirection(bool append = false, Action onAppend = null)
{
playerBody.Enqueue(playerPosition);
playerPosition += lastDirection = currentDirection;
freeCells.Remove(playerPosition);
if (append)
{
onAppend?.Invoke();
return;
}
if (playerBody.Count > 0)
{
freeCells.Add(playerBody.Dequeue());
}
}
public Transform CreateRepresentation(IPlaceable placeable)
{
//TODO replace this with good code
if (!(placeable is GroundTile))
{
return(null);
}
GroundTile.GroundTileType type = ((GroundTile)placeable).GetTileType();
Position pos = placeable.GetPosition();
Position2D pos2D = pos.AsPosition2D();
tileTypes [(int)type].transform.position = new Vector3(pos2D.GetX(), pos2D.GetY(), 0);
Transform newTile = GameObject.Instantiate(tileTypes [(int)type]);
activeTiles.Add(newTile);
return(newTile);
}
public void Position2DEquals()
{
tlog.Debug(tag, $"Position2DEquals START");
var testingTarget = new Position2D(1, 1);
Assert.IsNotNull(testingTarget, "null handle");
Assert.IsInstanceOf <Position2D>(testingTarget, "Should return Position2D instance.");
using (Position2D position = new Position2D(1, 1))
{
var result = testingTarget.Equals(position);
Assert.IsTrue(result, "Should be true here!");
}
testingTarget.Dispose();
tlog.Debug(tag, $"Position2DEquals END (OK)");
}
public void SiblingTest1()
{
Position2D _myPos = new Position2D(100, 30);
for (int i = 0; i < 10; i++)
{
PushButton _view = new PushButton();
_view.Name = "sibling" + i;
_view.LabelText = "view" + i;
_view.MinimumSize = new Size2D(100, 50);
_view.ParentOrigin = ParentOrigin.TopLeft;
_view.PivotPoint = PivotPoint.TopLeft;
_view.Position2D = _myPos + new Position2D(20 * i, 10 * i);
_window.Add(_view);
}
}
public List <Position2D> GetMinionPositions(int minionCount)
{
List <Position2D> minionList = new List <Position2D>();
Position2D upPos = new Position2D(basePosition.x, basePosition.y + 1);
Position2D downPos = new Position2D(basePosition.x, basePosition.y - 1);
if (map.getTileTypeAt(upPos.x, upPos.y) != TileType.Water)
{
minionList.Add(upPos);
}
else
{
minionList.Add(downPos);
}
return(minionList);
}
public void NewGame()
{
GetNode <Timer>("MobTimer").SetWaitTime(_waitTime);
GetNode <AudioStreamPlayer>("Music").Play();
_score = 0;
Player player = GetNode <Player>("Player");
Position2D startposition = GetNode <Position2D>("StartPosition");
player.Start(startposition.Position);
GetNode <Timer>("StartTimer").Start();
HUD hud = GetNode <HUD>("HUD");
hud.UpdateScore(_score);
hud.ShowMessage("Get Ready!");
}
public IsotropicGasParticle(double d, double hmax) : base(hmax)
{
Vel = new Position2D();
Vel.Name = "Vel";
AddChild(Vel);
AddDiffVect(Vel);
this.D = d;
dV = new Position2D();
dV.Name = "dV";
AddChild(dV);
Vel.AddDiffVect(dV, false);
// AddDiffPropToParam(pRo,pdRo);
AddDiffPropToParam(pE, pdE);
}
/// <summary>
/// Returns null if the position is not valid
/// </summary>
private Position2D GetPosition2D(Position position)
{
Position2D position2D = position.AsPosition2D();
if (position2D == null)
{
Debug.Log("is not a 2D position");
return(null);
}
int x = position2D.GetX();
int y = position2D.GetY();
if (x >= _sizeX || y >= _sizeY)
{
return(null);
}
return(position2D);
}
public void addFrontier(Position2D frontier, bool blockedByRiver, bool canCrossMountains)
{
if (isFrontier(frontier.x, frontier.y))
{
if (map.isPassable(map.getTileTypeAt(frontier.x, frontier.y), canCrossMountains))
{
if (!blockedByRiver)
{
frontiers.Add(frontier);
}
else
{
riverFrontiers.Add(frontier);
setState(State.needsBridge, true);
}
}
}
}
public override void Execute(ObjectSet originalObjects)
{
int selectedFitContainerIndex = 0;
Position2D positionToPlace = null;
SkylineContainer2D selectedContainer = containers.First() as SkylineContainer2D;
var objectsCopy = originalObjects.ToObjectList();
while (objectsCopy.Any())
{
Object2D selectedObject = objectsCopy.First() as Object2D;
for (int i = 0; i < containers.Count; i++)
{
positionToPlace = FindMostBottomFittingSkyline(containers[i] as SkylineContainer2D, selectedObject);
if (positionToPlace != null)
{
selectedFitContainerIndex = i;
break;
}
}
// Object not placed, create new container, place object bottom-left
if (positionToPlace == null)
{
AddContainer();
selectedContainer = containers.Last() as SkylineContainer2D;
positionToPlace = new Position2D(0, 0);
}
else
{
selectedContainer = containers[selectedFitContainerIndex] as SkylineContainer2D;
}
objectsCopy.Remove(selectedObject);
selectedContainer.PlaceNewObject(selectedObject, positionToPlace);
selectedFitContainerIndex = 0;
}
}
private void handlePizzaComplete(int pizzaIndex)
{
Entity pizzaEntity = pizzaData.Entities[pizzaIndex];
PizzaGroup pizzaGroup = pizzaData.PizzaGroup[pizzaIndex];
Position2D pizzaPosition = pizzaData.Position[pizzaIndex];
PizzaCost pizzaCost = pizzaData.PizzaCost[pizzaIndex];
// Pizza is done.
Debug.Log("PIZZA DONE - " + pizzaGroup.PizzaId + ": " + pizzaCost.OrderCost + " | " + pizzaCost.ActualCost);
// Update global score.
PostUpdateCommands.CreateEntity();
PostUpdateCommands.AddComponent(new DeductScore {
Value = pizzaCost.ActualCost
});
PostUpdateCommands.AddSharedComponent(new ScoringGroup {
GroupId = 0
});
// Delete this Pizza.
MoveSpeed toWindow = new MoveSpeed {
speed = BootStrap.GameSettings.ArrowSpeed
};
TimedLife timedLife = new TimedLife {
TimeToLive = 10.0f
};
PostUpdateCommands.AddComponent(pizzaEntity, toWindow);
PostUpdateCommands.AddComponent(pizzaEntity, timedLife);
PostUpdateCommands.RemoveComponent <PizzaGroup>(pizzaEntity);
// TODO: While ingredients are flying off with the pizza, arrows could hit them.
for (int i = 0; i < IngredientData.CalculateLength(); i++)
{
Entity ingredientEntity = IngredientData.GetEntityArray()[i];
//PostUpdateCommands.AddComponent(ingredientEntity, toWindow);
//PostUpdateCommands.AddComponent(ingredientEntity, timedLife);
//PostUpdateCommands.RemoveComponent<PizzaGroup>(ingredientEntity);
PostUpdateCommands.DestroyEntity(ingredientEntity);
}
// Create new Pizza.
createNewPizza(pizzaIndex);
}
public bool SwapPositions(Position2D first, Position2D second)
{
return SwapPositions(first.Y, first.X, second.Y, second.X);
}
private void bubblePositionUp(ref int i, int j)
{
if (BulletBubbling != null)
{
BulletBubbling(new BulletActionEventArgs(new Position2D(j, i), null));
}
while (i > 0)
{
var first = new Position2D(j, i);
var second = new Position2D(j, --i);
SwapPositions(first, second);
Debug_PrintAndSleep();
}
}
public void Set(Position2D upperLeft, Position2D lowerRight)
{
UpperLeftCorner = upperLeft;
LowerRightCorner = lowerRight;
}
public bool CanSwapPositions(Position2D first, Position2D second)
{
Position2D[] compass = createCompass(first);
bool areNotEqual = !(first.Equals(second));
return !IsOutOfBounds(first) && !IsOutOfBounds(second) && areNotEqual && compass.Any(a => a.Equals(second));
}
public void Set(int x1, int y1, int x2, int y2)
{
UpperLeftCorner = new Position2D(x1, y1);
LowerRightCorner = new Position2D(x2, y2);
}
private bool IsOutOfBounds(Position2D position)
{
return position.Y < 0 || position.Y >= this.Height
|| position.X < 0 || position.X >= this.Width;
}
private bool isStreak(Position2D pos)
{
return isStreak(pos.Y, pos.X);
}
private bool positionCanMakeMatches(Position2D position)
{
Position2D[] compass = createCompass(position);
foreach (Position2D direction in compass)
{
if (CanSwapPositions(direction, position))
{
SwapPositions(position, direction);
bool swapSuccess = CollectMatchedBullets().Count > 0;
SwapPositions(position, direction);
if (swapSuccess)
{
return true;
}
}
}
return false;
}
public void Set(Position2D pos, Dimension2D size)
{
UpperLeftCorner = pos;
LowerRightCorner = new Position2D(pos.X + size.Width, pos.Y + size.Height);
}
public void SpawnFullGrid()
{
if (this.BulletSpawned != null)
{
StepThroughGrid((i, j) =>
{
var position = new Position2D(j, (Height - 1) - i);
var bullet = GetBulletAt(position);
BulletSpawned(new BulletActionEventArgs(position, bullet));
});
}
}
public Position2D GetBulletPosition(JDBullet bullet)
{
Position2D position = new Position2D();
StepThroughGrid(
(i, j) =>
{
if (grid[i, j] == bullet)
{
position.X = j;
position.Y = i;
}
});
return position;
}
public static Rect From(Position2D upperL, Position2D lowerR)
{
Rect toR = new Rect();
toR.Set(upperL, lowerR);
return toR;
}
public bool IsBadSwap(Position2D first, Position2D second)
{
SwapPositions(first, second);
#if DEBUG || RELEASE
if (this.enablePrinting)
{
Debug_PrintAndSleep();
}
#endif
bool anyMatches = CollectMatchedBullets().Count > 0;
SwapPositions(first, second);
#if DEBUG || RELEASE
if (this.enablePrinting)
{
Debug_PrintAndSleep();
}
#endif
return anyMatches;
}
public PositionTransferEventArgs(Position2D origin, Position2D next)
{
this.origin = origin;
this.next = next;
}
public JDBullet GetBulletAt(Position2D position)
{
if (position.X >= this.Width || position.X < 0 || position.Y >= this.Height || position.Y < 0)
{
return null;
}
return grid[position.Y, position.X];
}
public Rect(Position2D pos, Dimension2D size)
{
UpperLeftCorner = new Position2D();
LowerRightCorner = new Position2D();
Set(pos, size);
}
public bool CanSwapPositions(int i, int j, int i2, int j2)
{
Position2D first = new Position2D(j, i);
Position2D second = new Position2D(j2, i2);
return CanSwapPositions(first, second);
}
public void AddInternalPoint(Position2D pos)
{
AddInternalPoint(pos.X, pos.Y);
}
public BulletActionEventArgs(Position2D point, JDBullet bulletSpawned)
{
this.point = point;
this.bulletSpawned = bulletSpawned;
}
/// <summary>
/// Returns if a 2d point is within this rectangle.
/// </summary>
/// <param name="pos"> Position to test if it lies within this rectangle.</param>
/// <returns> Returns true if the position is within the rectangle, false if not.</returns>
public bool IsPointInside(Position2D pos)
{
return UpperLeftCorner.X <= pos.X && UpperLeftCorner.Y <= pos.Y &&
LowerRightCorner.X >= pos.X && LowerRightCorner.Y >= pos.Y;
}
public GameObjectTransferEventArgs(GameObject gameObject, Position2D position)
{
this.gameObject = gameObject;
this.position = position;
}
private Position2D[] createCompass(Position2D center)
{
int i = center.X;
int j = center.Y;
return new Position2D[]
{
new Position2D(i + 1, j),
new Position2D(i - 1, j),
new Position2D(i, j + 1),
new Position2D(i, j - 1)
};
}
public Rect(Position2D upperLeft, Position2D lowerRight)
{
UpperLeftCorner = new Position2D();
LowerRightCorner = new Position2D();
Set(upperLeft, lowerRight);
}
private void QueueBulletInSpawner(JDBullet bullet, Position2D point)
{
BulletSpawner spawner = GetBulletSpawner(point.X);
GameObject fallingBullet = spawner.SpawnBullet(bullet);
FallingBullet group = this.GetBulletGroup(bullet);
if (group != null)
{
fallingBullet.transform.parent = group.gameObject.transform;
}
FallingBullet fallingBulletScript = fallingBullet.GetComponent<FallingBullet>();
if (fallingBulletScript != null)
{
fallingBulletScript.MySpawner = spawner;
this.AllBullets.Add(fallingBulletScript);
}
toSpawn.Enqueue(fallingBullet);
}
