protected override void OnUpdate()
{
if (boardModel == null || gameStateModel.State != Match3State.MatchesFall)
{
return;
}
for (int x = 0; x < boardModel.BoardWidth; x++)
{
if (boardModel.HasEntityAt(new int2(x, boardModel.BoardHeight - 1)) == false)
{
var levelConfig = gameStateModel.GetCurrentLevelConfig();
var boardPosition = new int2(x, boardModel.BoardHeight);
var spawnPosition = BoardCalculator.ConvertBoardPositionToTransformPosition(boardPosition);
if (HasGemInProximityInColumn(x, spawnPosition))
{
continue;
}
var entity = EntitiesHelper.CreateGem(EntitiesHelper.GetRandomColor(levelConfig.availableColors),
BoardCalculator.ConvertBoardPositionToTransformPosition(boardPosition), boardPosition);
signalBus.Fire(new Match3Signals.GemCreatedSignal(entity, BoardCalculator.ConvertBoardPositionToTransformPosition(boardPosition)));
EntityManager.AddComponent <IsFallingComponent>(entity);
}
}
}
// POST api/<controller>
public IHttpActionResult Post([FromBody] int[,] board)
{
BoardCalculator calculator = new BoardCalculator();
var newBoard = calculator.PerformStep(board);
return(Ok(newBoard));
}
// Start is called before the first frame update
void Start()
{
boardCalculator = GameObject.Find("GameBoard").GetComponent <BoardCalculator>();
var positionWorld = transform.position;
position.x = (int)positionWorld.x;
position.y = (int)positionWorld.z;
}
private void OnBoardCreated()
{
var scaleX = 8 / BoardCalculator.GetBoardWidthSize();
var scaleY = 11 / BoardCalculator.GetBoardHeightSize();
boardScale = Mathf.Min(scaleX, scaleY);
gemsContainer.transform.localScale = new Vector3(boardScale, boardScale, 1);
}
private void CheckSwipe(GemView gem1, GemView gem2)
{
Debug.Log("Swipe attempt " + gem1.Entity.Index + " - " + gem1.Entity.Index);
var gem1Position = entityManager.GetComponentData <BoardPositionComponent>(gem1.Entity);
var gem2Position = entityManager.GetComponentData <BoardPositionComponent>(gem2.Entity);
if (BoardCalculator.IsNextToEachOther(gem1Position.Position, gem2Position.Position))
{
StartSwap(gem1.Entity, gem2.Entity);
}
}
public void Execute(Match3Signals.CreateBoardSignal createBoardSignal)
{
Debug.Log("Create board -> " + gameStateModel.State);
var levelConfig = gameStateModel.GetCurrentLevelConfig();
playerScoreModel.Reset();
playerScoreModel.Turns = levelConfig.Turns;
boardModel.ResetBoard(levelConfig);
BoardCalculator.InitBoardSize(boardModel.BoardWidth, boardModel.BoardHeight);
CreateGems(levelConfig);
signalBus.Fire <Match3Signals.OnBoardCreatedSignal>();
}
private void CreateGems(LevelConfig levelConfig)
{
for (int x = 0; x < levelConfig.Width; x++)
{
for (int y = 0; y < levelConfig.Height; y++)
{
var gemColor = EntitiesHelper.GetRandomColor(levelConfig.availableColors);
var boardPosition = new int2(x, y);
var position = BoardCalculator.ConvertBoardPositionToTransformPosition(boardPosition);
var gemEntity = EntitiesHelper.CreateGem(gemColor,
position,
boardPosition);
signalBus.Fire(new Match3Signals.GemCreatedSignal(gemEntity, position));
boardModel.SetEntityAt(x, y, gemEntity);
}
}
}
private void SelectGem(GemView gem)
{
if (selectedGem == null)
{
Select(gem);
}
else
{
var gemPosition = entityManager.GetComponentData <BoardPositionComponent>(gem.Entity);
var selectedGemPosition = entityManager.GetComponentData <BoardPositionComponent>(selectedGem.Entity);
Debug.Log("Select second gem " + gem.Entity.Index);
if (BoardCalculator.IsNextToEachOther(gemPosition.Position, selectedGemPosition.Position))
{
StartSwap(gem.Entity, selectedGem.Entity);
}
else
{
Select(gem);
}
}
}
protected override void OnUpdate()
{
if (gameStateModel == null)
{
return;
}
var time = Time.DeltaTime;
Entities.WithStructuralChanges().ForEach(
(Entity entity,
int entityInQueryIndex,
ref Translation translation,
ref BoardPositionComponent boardPositionComponent,
in SwappingComponent swapComponent) =>
{
var startPosition = BoardCalculator.ConvertBoardPositionToTransformPosition(swapComponent.OriginBoardPosition);
var targetPosition = BoardCalculator.ConvertBoardPositionToTransformPosition(swapComponent.TargetBoardPosition);
var direction = targetPosition - translation.Value;
if (math.distancesq(translation.Value, targetPosition) < 0.01f)
{
boardPositionComponent = new BoardPositionComponent {
Position = swapComponent.TargetBoardPosition
};
boardModel.SetEntityAt(swapComponent.TargetBoardPosition.x, swapComponent.TargetBoardPosition.y, entity);
translation = new Translation {
Value = targetPosition
};
EntityManager.RemoveComponent <SwappingComponent>(entity);
}
else
{
var velocity = math.normalize(direction) * 7 * time;
translation.Value += velocity;
}
}).Run();
}
public void TestOverCrowding()
{
int[,] board = new int[, ] {
{ 1, 1, 1, 0, 0 },
{ 1, 1, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 }
};
int[,] newGeneration = new int[, ] {
{ 1, 0, 1, 0, 0 },
{ 1, 0, 1, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 }
};
BoardCalculator steps = new BoardCalculator();
var stepResult = steps.PerformStep(board);
Assert.IsTrue(newGeneration.Cast <int>().SequenceEqual(stepResult.Cast <int>()));
}
void Start()
{
boardDrawer = GameObject.Find("GameBoard").GetComponent <BoardDrawer>();
boardCalculator = GameObject.Find("GameBoard").GetComponent <BoardCalculator>();
}
protected override void Start()
{
base.Start();
boardCalculator = GameObject.Find("GameBoard").GetComponent <BoardCalculator>();
}
protected override void OnUpdate()
{
if (gameStateModel == null || gameStateModel.State != Match3State.MatchesFall)
{
return;
}
var time = Time.DeltaTime;
Entities.WithAll <IsFallingComponent>().WithNone <DestroyedComponent>().WithStructuralChanges().ForEach(
(Entity entity, int entityInQueryIndex, ref BoardPositionComponent boardPositionComponent) =>
{
var positionUnder = new int2(boardPositionComponent.Position.x, boardPositionComponent.Position.y - 1);
if (boardModel.IsPositionInBorders(positionUnder) && !boardModel.HasEntityAt(positionUnder))
{
boardModel.ClearAt(boardPositionComponent.Position);
if (EntityManager.HasComponent <MoveToBoardPositionComponent>(entity) == false)
{
EntityManager.AddComponentData(entity, new MoveToBoardPositionComponent {
TargetPosition = positionUnder
});
}
else
{
EntityManager.SetComponentData(entity, new MoveToBoardPositionComponent {
TargetPosition = positionUnder
});
}
boardPositionComponent = new BoardPositionComponent {
Position = positionUnder
};
boardModel.SetEntityAt(positionUnder.x, positionUnder.y, entity);
}
else
{
if (boardModel.IsPositionInBorders(positionUnder) == false)
{
EntityManager.RemoveComponent <IsFallingComponent>(entity);
}
else
{
var entityUnder = boardModel.GetEntityAt(positionUnder.x, positionUnder.y);
if (EntityManager.HasComponent <IsFallingComponent>(entityUnder) == false)
{
EntityManager.RemoveComponent <IsFallingComponent>(entity);
}
}
}
}).Run();
Entities.WithNone <DestroyedComponent>().WithStructuralChanges().ForEach(
(Entity entity,
int entityInQueryIndex,
ref Translation translation,
in BoardPositionComponent boardPositionComponent,
in MoveToBoardPositionComponent moveComponent) =>
{
var targetPosition = BoardCalculator.ConvertBoardPositionToTransformPosition(boardPositionComponent.Position);
var direction = targetPosition - translation.Value;
if (math.distancesq(translation.Value, targetPosition) < 0.01f || translation.Value.y < targetPosition.y)
{
translation = new Translation {
Value = targetPosition
};
EntityManager.RemoveComponent <MoveToBoardPositionComponent>(entity);
}
else
{
var velocity = math.normalize(direction) * 10 * time;
translation.Value += velocity;
}
}).Run();
