public void RandomBrick_Passing()
{
BaseBrick brick = BrickFactory.RandomBrick;
Assert.NotNull(brick);
Assert.True(brick.GetType().IsSubclassOf(typeof(BaseBrick)));
}
public void GenerateDefaultLevelGrid()
{
CreateLevelScript();
Grid2D grid = new Grid2D(worldSize, gridSpace);
levelLogic = new LevelLogic(grid, gameGraphics);
for (int x = 0; x < grid.gridSizeX; x++)
{
for (int y = 0; y < grid.gridSizeY; y++)
{
Node2D currentNode = grid.Grid[x, y];
BaseBrick brick = GenerateRandomBaseBrick(currentNode.ID);
if (brick != null)
{
brick.transform.SetParent(brickGridParent);
brick.SwitchPositions(currentNode.worldPosition);
AddBrickToLevelController(brick);
}
}
}
Debug.Log("Bricks added to level controller");
AddPathToLevelController();
}
private void GenerateAdjacentBricks(BaseBrick currentBrick)
{
if (currentAdjacentBricks == null)
{
currentAdjacentBricks = new List <BaseBrick>();
}
else
{
currentAdjacentBricks.Clear();
}
if (currentBrick != null)
{
BaseBrick brickLeft = _levelManager.GetBrickInDirectionFrom(currentBrick, Direction.LEFT, currentBrick.transform.position);
if (brickLeft != null && brickLeft.currentType != BrickType.UNBREAKABLE)
{
currentAdjacentBricks.Add(brickLeft);
}
BaseBrick brickRight = _levelManager.GetBrickInDirectionFrom(currentBrick, Direction.RIGHT, currentBrick.transform.position);
if (brickRight != null && brickRight.currentType != BrickType.UNBREAKABLE)
{
currentAdjacentBricks.Add(brickRight);
}
BaseBrick brickUp = _levelManager.GetBrickInDirectionFrom(currentBrick, Direction.UP, currentBrick.transform.position);
if (brickUp != null && brickUp.currentType != BrickType.UNBREAKABLE)
{
currentAdjacentBricks.Add(brickUp);
}
BaseBrick brickDown = _levelManager.GetBrickInDirectionFrom(currentBrick, Direction.DOWN, currentBrick.transform.position);
if (brickDown != null && brickDown.currentType != BrickType.UNBREAKABLE)
{
currentAdjacentBricks.Add(brickDown);
}
}
}
public void CreateBricksAndTestApperance_Passing(string brickName, Type type, bool[,] result)
{
BaseBrick brick = BrickFactory.CreateBrick(brickName);
Assert.NotNull(brick);
Assert.Equal(type.Name, brick.GetType().Name);
Assert.Equal(brick.Apperance, result);
}
public void CreateBrick_Failing()
{
BaseBrick brick = null;
NullReferenceException ex = Assert.Throws <NullReferenceException>(() => brick = BrickFactory.CreateBrick(string.Empty));
Assert.Null(brick);
Assert.Equal($"{nameof(BrickFactory)}.{nameof(BrickFactory.CreateBrick)}", ex.Message);
}
private void AddBrickToLevelController(BaseBrick brick)
{
if (brick != null && levelController != null)
{
if (levelController.levelBricks != null)
{
levelController.levelBricks.Add(brick);
}
}
}
public BaseBrick GetBrickInDirectionFrom(BaseBrick currentBrick, Direction direction, Vector2 fromPosition)
{
if (currentLevel != null)
{
return(currentLevel.GetBrickInDirectionFrom(currentBrick, direction, fromPosition));
}
else
{
Debug.LogError("Current level is null, cannot find brick in direction: " + direction.ToString());
return(null);
}
}
private void Dash(BaseBrick nextBrickCell) {
if(nextBrickCell != null) {
dashing = true;
_player.currentBrickCell = nextBrickCell;
_player.PlaySFX(_settings.dashSFX);
tweenSequence.Append(_player.transform.DOMove(nextBrickCell.transform.position, _settings.dashSpeed).OnComplete(delegate () {
dashing = false;
}));
} else {
Debug.LogError("Next brick cell is null, moving back to previous state");
_player.ChangeState(PlayerStates.Moving);
}
}
public void Brick(Graphics dev, Point start, Point offset, BaseBrick brick, Color color)
{
for (int y = 0; y < brick.Apperance.GetLength(0); y++)
{
for (int x = 0; x < brick.Apperance.GetLength(1); x++)
{
if (brick.Apperance[y, x])
{
this.Block(dev, color, new Point(start.X + this.BrickSize * (offset.X + x), start.Y - this.BrickSize * (offset.Y - y)));
}
}
}
}
public void ModifyDashSequence(BaseBrick brick, int brickLimit, out BaseBrick lastBrick)
{
lastBrick = brick;
if (dashSequence != null)
{
//checking if sequence already has the brick in sequence or not. If not then we will add it to sequence
if (!dashSequence.ContainsKey(brick.ID) && brick != null)
{
brick.ToggleSelectState(true);
dashSequence.Add(brick.ID, brick);
Debug.Log("Added to seq brick ID : " + brick.ID);
}
else
{
//if brick is already present then we want to remove it from the sequence if user selected the brick again
List <string> toRemove = new List <string>();
//finding all the bricks from the end of the sequence to the point user has touched
foreach (KeyValuePair <string, BaseBrick> pair in dashSequence.Reverse())
{
if (pair.Key != brick.ID)
{
toRemove.Add(pair.Key);
}
if (pair.Key == brick.ID)
{
toRemove.Add(pair.Key);
break;
}
}
//removing it from the sequence
foreach (string key in toRemove)
{
dashSequence[key].ToggleSelectState(false);
dashSequence.Remove(key);
Debug.Log("Brick removed with ID : " + key);
}
//last brick is needed to find the next adjacent bricks to avoid adjacent movements
if (dashSequence.Count > 0)
{
lastBrick = dashSequence[dashSequence.Keys.Last()];
}
else
{
//if all the items were removed then we want the current cell player is in to be returned
lastBrick = currentBrickCell;
}
}
}
}
/// <summary>
/// Removes bricks which are not supposed to be blown
/// </summary>
/// <param name="bricksInView">List of brick colliders</param>
/// <returns></returns>
private List <BaseBrick> FetchModifiedBrickList(Collider2D[] bricksInView)
{
List <BaseBrick> bricks = new List <BaseBrick>();
for (int i = 0; i < bricksInView.Length; i++)
{
BaseBrick brick = bricksInView[i].GetComponent <BaseBrick>();
if (brick != null && brick.currentType != BrickType.END && brick.currentType != BrickType.PATH)
{
bricks.Add(brick);
}
}
return(bricks);
}
public void CreateConstructorAndRotateLeft_Passing(BaseBrick brick, bool[,] result)
{
Assert.NotNull(brick);
bool[,] temp = result;
for (int i = 0; i < 3; i++)
{
temp = this.Rotate(this.Rotate(this.Rotate(temp)));
brick.Rotate(Rotation.Left);
Assert.Equal(brick.Apperance, temp);
}
}
public void CreateBricksAndTestApperance_Passing(BaseBrick brick, Type type, Point point, Color color)
{
FieldBrick fieldBrick = new FieldBrick(brick)
{
Position = point,
Color = color
};
Assert.NotNull(fieldBrick);
Assert.Equal(type.Name, fieldBrick.Brick.GetType().Name);
Assert.True(fieldBrick.Position == point);
Assert.True(fieldBrick.Color == color);
}
private bool CheckIfAdjacentBrick(string brickID, out BaseBrick brick)
{
brick = null;
if (currentAdjacentBricks != null)
{
int index = currentAdjacentBricks.FindIndex(x => x.ID == brickID);
if (index >= 0)
{
brick = currentAdjacentBricks[index];
return(true);
}
}
return(false);
}
public BaseBrick GetBrickInDirectionFrom(BaseBrick currentBrick, Direction direction, Vector2 position)
{
RaycastHit2D[] hits = Physics2D.RaycastAll(position, UserInput.ConvertDirection(direction), 5f, brickLayerMask); //layerMask of Brick is 9
foreach (RaycastHit2D hit in hits)
{
if (hit.collider != null)
{
BaseBrick brick = hit.collider.GetComponent <BaseBrick>();
if (brick != null && currentBrick.ID != brick.ID)
{
return(brick);
}
}
}
Debug.LogError("Could not find brick in the direction : " + direction.ToString());
return(null);
}
private void ReplaceInLevel(BaseBrick oldB, BaseBrick newB)
{
if (levelController != null && levelController.levelBricks != null)
{
int index = levelController.levelBricks.FindIndex(x => x.ID == oldB.ID);
if (index >= 0)
{
GameObject aboutToBeDeleted = levelController.levelBricks[index].gameObject;
levelController.levelBricks[index] = newB;
Debug.Log("Changed original : " + oldB.currentType.ToString() + " to : " + newB.currentType.ToString());
DestroyImmediate(aboutToBeDeleted);
}
else
{
Debug.LogError("Could not find brick in level");
}
}
}
public override void Update()
{
if (!EventSystem.current.IsPointerOverGameObject())
{
if (Input.GetMouseButtonDown(0))
{
RaycastHit2D[] hits = Physics2D.RaycastAll(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.down, 2f);
foreach (RaycastHit2D hit in hits)
{
if (hit.collider != null && hit.collider.CompareTag("Player"))
{
canDash = true;
GenerateAdjacentBricks(currentBrickInTouch = _player.currentBrickCell);
Debug.Log("Player Found, Staring to dash");
}
}
_player.ResetDash();
}
if (Input.GetMouseButton(0) && canDash)
{
Vector2 direction = Camera.main.ScreenToWorldPoint(Input.mousePosition) - _player.transform.position;
float angle = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;
Quaternion rotation = Quaternion.AngleAxis(angle, Vector3.forward);
_player.transform.rotation = Quaternion.Slerp(_player.transform.rotation, rotation, 15 * Time.unscaledDeltaTime);
RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.down, 2f, brickLayerMask);
if (hit.collider != null)
{
BaseBrick brick = hit.collider.GetComponent <BaseBrick>();
if (brick != null && CheckIfAdjacentBrick(brick.ID, out BaseBrick adj))
{
_player.ModifyDashSequence(adj, _settings.bricksToMove, out currentBrickInTouch);
GenerateAdjacentBricks(currentBrickInTouch);
}
}
}
if (Input.GetMouseButtonUp(0))
{
currentBrickInTouch = null;
canDash = false;
_player.ChangeState(PlayerStates.Dash);
}
}
}
private void CheckBombsAroundPlayer()
{
Collider2D[] itemsInRange = Physics2D.OverlapCircleAll(_player.transform.position, _settings.radius, _settings.layersToShowOnRadar);
if (itemsInRange != null)
{
foreach (Collider2D collider in itemsInRange)
{
if (!colliders.Contains(collider))
{
BaseBrick brick = collider.GetComponent <BaseBrick>();
if (brick != null && brick.currentType == BrickType.BOMB)
{
GameObject.Instantiate(_settings.radarEnemyPrefab, collider.transform.position, Quaternion.identity);
colliders.Add(collider);
}
}
}
}
}
private void SwitchBrickToType(BaseBrick brick, BrickType type)
{
GameObject obj = levelLogic.GetBrickBasedOnType(type);
BrickData newData = new BrickData {
gridNodeID = brick.GetComponent <BaseBrick>().ID,
type = type
};
BaseBrick newB = obj.GetComponent <BaseBrick>();
newB.Initialize(newData);
newB.SwitchPositions(brick.transform.position);
obj.transform.SetParent(brickGridParent);
ReplaceInLevel(brick, newB);
if (type == BrickType.PATH)
{
brick.SwitchToPath();
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.CompareTag("Player") && currentType != BrickType.PATH)
{
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, Range, brickLayerMask);
if (colliders != null && colliders.Length > 0)
{
for (int i = 0; i < colliders.Length; i++)
{
BaseBrick brick = colliders[i].GetComponent <BaseBrick>();
if (brick != null && brick.currentType != BrickType.END && brick.currentType != BrickType.PATH)
{
brick.DestroyBrick();
}
}
}
DestroyBrick();
_signalBus.Fire <BrickDestroyedSignal>(new BrickDestroyedSignal {
data = brickData
});
}
}
public void ResetPlayerPosition(BaseBrick brickCell)
{
if (gameObject != null)
{
if (!gameObject.activeSelf)
{
gameObject.SetActive(true);
}
brickCell.SwitchToPath();
currentBrickCell = brickCell;
transform.position = brickCell.transform.position;
if (dashSequence == null)
{
dashSequence = new Dictionary <string, BaseBrick>();
}
else
{
dashSequence.Clear();
}
ChangeState(PlayerStates.WaitingToStart);
}
}
/// <summary>
/// Shuffles the current level items
/// </summary>
public void ShuffleLevel()
{
if (levelBricks != null)
{
//making a copy to shuffle items
List <BaseBrick> levelCopy = new List <BaseBrick>(levelBricks);
//levelCopy.RemoveAll(x => safePathIDs.Any(y => y == x.IDOnGrid));
List <BaseBrick> shuffle = new List <BaseBrick>();
while (levelCopy.Count != 0)
{
int index = Random.Range(0, levelCopy.Count);
shuffle.Add(levelCopy[index]);
levelCopy.RemoveAt(index);
} //shuffling the bricks
shuffle.RemoveAll(x => safePathIDs.Any(y => y == x.ID));
//reassigning the shuffled bricks to thier positions
foreach (BaseBrick brick in levelBricks)
{
if (!safePathIDs.Contains(brick.ID))
{
int sIndex = levelBricks.FindIndex(x => x.ID == shuffle[0].ID);
Vector2 tempPos = levelBricks[sIndex].transform.position;
levelBricks[sIndex].SwitchPositions(brick.transform.position);
brick.SwitchPositions(tempPos);
}
brick.ResetBrick();
}
}
//resetting start brick
BaseBrick b = GetStartBrick();
if (b != null)
{
b.ResetBrick();
}
}
private BaseBrick GenerateRandomBaseBrick(string id)
{
BrickType type = levelLogic.GetRandomBrickType(bombChance);
GameObject obj = levelLogic.GetBrickBasedOnType(type);
if (obj != null)
{
BrickData data = new BrickData {
gridNodeID = id,
type = type,
};
BaseBrick baseBrick = obj.GetComponent <BaseBrick>();
if (baseBrick != null)
{
baseBrick.Initialize(data);
return(baseBrick);
}
else
{
Debug.LogError("Base Class not found in the brick prefab, is it being inherited from base brick?");
}
}
return(null);
}
public static CAnimationObject MakeObject(IDObject _type, Vector2 _pos)
{
CAnimationObject _object = null;
switch (_type)
{
//case IDObject.SMALL_MARIO:
// _object = new Mario(_pos);
// break;
case IDObject.ENEMY_GOOMBA_OW:
_object = new Goomba(_pos, IDDir.LEFT);
break;
case IDObject.ENEMY_KOOPA_OW:
_object = new Koopa(_pos);
break;
case IDObject.MISC_BASE_BRICK:
_object = new BaseBrick(_pos);
break;
case IDObject.MISC_BIG_GRASS:
_object = new BigGrass(_pos);
break;
case IDObject.MISC_BIG_MOUNTAIN:
_object = new BigMountain(_pos);
break;
case IDObject.MISC_CASTLE:
_object = new Castle(_pos);
break;
case IDObject.ENEMY_BOSS:
_object = new Boss(_pos);
break;
//case IDObject.MISC_GATE_PIPE:
//_object = new GatePipe(_pos, IDStatus.GATE_PIPE_DOWN);
//break;
case IDObject.MISC_HARD_BRICK:
_object = new HardBrick(_pos);
break;
case IDObject.MISC_IRON_BRICK:
_object = new HardBrick(_pos);
break;
case IDObject.MISC_STOCK_PIPE:
_object = new StockPipe(_pos);
break;
case IDObject.MISC_MEDIUM_GRASS:
_object = new MediumGrass(_pos);
break;
case IDObject.MISC_MEDIUM_MOUNTAIN:
_object = new MediumMountain(_pos);
break;
case IDObject.MISC_PIECE:
_object = new Piece(_pos);
break;
case IDObject.MISC_QUESTION_BRICK:
_object = new QuestionBrick(_pos, IDObject.ITEM_COIN_ACTIVATED);
break;
case IDObject.MISC_SMALL_GRASS:
_object = new SmallGrass(_pos);
break;
case IDObject.MISC_SOFT_BRICK:
_object = new SoftBrick(_pos);
break;
case IDObject.MISC_GOAL_POLE:
_object = new GoalPole(_pos);
break;
case IDObject.MISC_GATE_PIPE:
_object = new GatePipe(_pos);
break;
case IDObject.MISC_FLAG:
_object = new Flag(_pos);
break;
//case IDObject.BRICK_COIN:
// _object = new QuestionBrick(_pos, IDObject.ITEM_COIN_ACTIVATED);
// break;
case IDObject.ITEM_STARMAN:
_object = new ItemStarman(_pos);
break;
//case IDObject.MISC_UP_PIPE:
// _object = new UpPipe(_pos);
// break;
case IDObject.ITEM_1UP_MUSHROOM:
_object = new Item1UpMushroom(_pos);
break;
case IDObject.MISC_SMALL_CLOUND:
_object = new SmallClound(_pos);
break;
case IDObject.MISC_MEDIUM_CLOUND:
_object = new MediumClound(_pos);
break;
case IDObject.MISC_BIG_CLOUND:
_object = new BigClound(_pos);
break;
case IDObject.ITEM_COIN_ACTIVATED:
_object = new ItemCoin(_pos, IDObject.ITEM_COIN_ACTIVATED);
break;
case IDObject.ITEM_COIN_NORMAL:
_object = new ItemCoin(_pos, IDObject.ITEM_COIN_NORMAL);
break;
case IDObject.ITEM_FIRE_FLOWER:
_object = new ItemFireFlower(_pos);
break;
case IDObject.ITEM_SUPER_MUSHROOM:
_object = new ItemSuperMushroom(_pos);
break;
case IDObject.ITEM_GROW_UP:
_object = new ItemGrowUp(_pos);
break;
//case IDObject.BRICK_COIN:
// _object = new QuestionBrick(_pos, IDObject.ITEM_COIN_ACTIVATED);
// break;
//case IDObject.BRICK_FLOWER:
// _object = new QuestionBrick(_pos, IDObject.ITEM_FIRE_FLOWER);
// break;
//case IDObject.BRICK_SUPPERMUSHROOM:
// _object = new QuestionBrick(_pos, IDObject.ITEM_SUPER_MUSHROOM);
// break;
//case IDObject.BRICK_1UPMUSHROOM:
// _object = new QuestionBrick(_pos, IDObject.BRICK_1UPMUSHROOM);
// break;
//case IDObject.BRICK_STAR:
// _object = new QuestionBrick(_pos, IDObject.ITEM_STARMAN);
// break;
default:
break;
}
return(_object);
}
public void CreateBricksAndTestApperance_Passing(BaseBrick brick, bool[,] result)
{
Assert.NotNull(brick);
Assert.Equal(brick.Apperance, result);
}
public FieldBrick(BaseBrick brick)
{
this.Brick = brick;
}
