public static void Populate(Gamefield gamefield)
{
if (!AllInvaderChuzzles.Any() || AllInvaderChuzzles.Count == MaxInvadersOnLevel)
{
return;
}
var search = new PrimeSearch(AllInvaderChuzzles.Count);
int p;
while ((p = search.GetNext()) != -1)
{
var currentInvader = AllInvaderChuzzles[p];
var targetTile =
gamefield.Level.ActiveChuzzles.Where(x => x is ColorChuzzle).FirstOrDefault(
x =>
(x.Current == currentInvader.Current.Left || x.Current == currentInvader.Current.Right ||
x.Current == currentInvader.Current.Top || x.Current == currentInvader.Current.Bottom));
if (targetTile != null)
{
TilesFactory.Instance.CreateInvader(targetTile.Current);
targetTile.Destroy(false, true, true);
break;
}
}
// var listInvaders = AllInvaderChuzzles.Aggregate("", (current, allInvaderChuzzle) => current + (allInvaderChuzzle + "\n"));
// Debug.Log("Invaders: \n"+listInvaders);
}
public void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.Real = chuzzle.Current = chuzzle.MoveTo;
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
if (isAlreadyChangedState)
{
Debug.LogWarning("Finished in CRNC state ");
}
if (!AnimatedChuzzles.Any() && !isAlreadyChangedState)
{
Gamefield.Level.UpdateActive();
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (combinations.Count > 0)
{
Gamefield.SwitchStateTo(Gamefield.CheckSpecialState);
}
else
{
if (!Gamefield.GameMode.IsWin && !Gamefield.GameMode.IsGameOver)
{
Gamefield.SwitchStateTo(Gamefield.FieldState);
}
else
{
Gamefield.GameMode.Check();
}
}
isAlreadyChangedState = true;
}
}
public bool CreateNew()
{
var hasNew = Gamefield.NewTilesInColumns.Any(x => x > 0);
if (!hasNew)
{
Gamefield.SwitchStateTo(Gamefield.CheckSpecialState);
return(false);
}
//check if need create new tiles
for (var x = 0; x < Gamefield.NewTilesInColumns.Length; x++)
{
var newInColumn = Gamefield.NewTilesInColumns[x];
if (newInColumn > 0)
{
for (var j = 0; j < newInColumn; j++)
{
//create new tiles
var chuzzle = TilesFactory.Instance.CreateChuzzle(Gamefield.Level.GetCellAt(x, Gamefield.Level.Height + j));
chuzzle.Current.IsTemporary = true;
}
}
}
//move tiles to fill positions
for (var x = 0; x < Gamefield.NewTilesInColumns.Length; x++)
{
var newInColumn = Gamefield.NewTilesInColumns[x];
if (newInColumn > 0)
{
for (var y = 0; y < Gamefield.Level.Height; y++)
{
var cell = Gamefield.Level.GetCellAt(x, y, false);
if (Gamefield.Level.At(x, y) == null && cell.Type != CellTypes.Block)
{
while (cell != null)
{
var chuzzle = Gamefield.Level.At(cell.x, cell.y);
if (chuzzle != null)
{
chuzzle.MoveTo = chuzzle.MoveTo.GetBottomWithType();
//Level.GetCellAt(chuzzle.MoveTo.x, chuzzle.MoveTo.y - 1);
}
cell = cell.Top;
}
}
}
}
}
foreach (var c in Gamefield.Level.Chuzzles)
{
if (c.MoveTo.y != c.Current.y)
{
c.AnimateMoveTo(c.MoveTo.Position);
}
}
return(true);
}
private void RemoveEventHandlers(Gamefield gamefield)
{
gamefield.PointSystem.PointChanged -= OnPointsChanged;
gamefield.GameMode.GameOver -= OnGameOver;
gamefield.GameMode.Win -= OnWin;
gamefield.GameMode.TurnsChanged -= OnTurnsChanged;
}
private void RemoveEventHandlers(Gamefield gamefield)
{
gamefield.PointSystem.PointChanged -= OnPointsChanged;
gamefield.GameMode.GameOver -= OnGameOver;
// gamefield.GameMode.Win -= OnWin;
gamefield.GameMode.TurnsChanged -= OnTurnsChanged;
}
public static void Populate(Gamefield gamefield)
{
if (!AllInvaderChuzzles.Any() || AllInvaderChuzzles.Count == MaxInvadersOnLevel)
{
return;
}
var search = new PrimeSearch(AllInvaderChuzzles.Count);
int p;
while ((p = search.GetNext()) != -1)
{
var currentInvader = AllInvaderChuzzles[p];
var targetTile =
gamefield.Level.Chuzzles.GetTiles(x=>x is ColorChuzzle).FirstOrDefault(
x =>
(x.Current == currentInvader.Current.Left || x.Current == currentInvader.Current.Right ||
x.Current == currentInvader.Current.Top || x.Current == currentInvader.Current.Bottom));
if (targetTile != null)
{
Instance.TilesFactory.CreateInvader(targetTile.Current);
targetTile.Destroy(false,true,true);
break;
}
}
// var listInvaders = AllInvaderChuzzles.Aggregate("", (current, allInvaderChuzzle) => current + (allInvaderChuzzle + "\n"));
// Debug.Log("Invaders: \n"+listInvaders);
}
public GameData(uint currentScore, uint prevScore, uint highScore, Gamefield currentGamefield, Gamefield previousGamefield)
{
CurrentGamefield = currentGamefield ?? throw new ArgumentNullException(nameof(currentGamefield));
PreviousGamefield = previousGamefield ?? throw new ArgumentNullException(nameof(previousGamefield));
CurrentScore = currentScore;
PreviousScore = prevScore;
HighScore = highScore;
}
public void AddEventHandlers(Gamefield gamefield)
{
RemoveEventHandlers(gamefield);
gamefield.PointSystem.PointChanged += OnPointsChanged;
gamefield.GameMode.GameOver += OnGameOver;
gamefield.GameMode.Win += OnWin;
gamefield.GameMode.TurnsChanged += OnTurnsChanged;
}
public void AddEventHandlers(Gamefield gamefield)
{
RemoveEventHandlers(gamefield);
gamefield.PointSystem.PointChanged += OnPointsChanged;
gamefield.GameMode.GameOver += OnGameOver;
//gamefield.GameMode.Win += OnWin;
gamefield.GameMode.TurnsChanged += OnTurnsChanged;
}
public void Init(Gamefield gamefield)
{
this.Gamefield = gamefield;
PointSystem = Gamefield.PointSystem;
Reset();
OnDestroy();
OnInit();
InvokeTurnsChanged();
}
// Use this for initialization
void Start()
{
gamefield = new Gamefield(partyGradient, cube, gameFieldObject.transform);
gamefield.RandomPopulation();
gamefield.CreateGameField();
audioSource = GetComponent <AudioSource>();
}
public void OnGameStarted(Gamefield gamefield)
{
AddEventHandlers(gamefield);
TargetScoreLabel.text = LocalizationStrings.GetString(TargetString, GameModeToString.GetString(gamefield.GameMode));
UI.Instance.TaskPopup.Show(gamefield.GameMode);
OnTurnsChanged(gamefield.GameMode.Turns);
OnPointsChanged(gamefield.PointSystem.CurrentPoints);
}
public void Init(Gamefield gamefield)
{
this.Gamefield = gamefield;
PointSystem = Gamefield.PointSystem;
Reset();
OnDestroy();
OnInit();
InvokeTurnsChanged();
}
public void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
if (!AnimatedChuzzles.Any())
{
Gamefield.SwitchStateTo(Gamefield.WinCreateNewChuzzlesState);
}
}
public void OnGameStarted(Gamefield gamefield)
{
AddEventHandlers(gamefield);
//TargetScoreLabel.text = LocalizationStrings.GetString(TargetString, GameModeToString.GetString(gamefield.GameMode));
// UI.Instance.TaskPopup.Show(gamefield.GameMode);
OnTurnsChanged(gamefield.GameMode.Turns, gamefield.GameMode.StartTurns);
OnPointsChanged(gamefield.PointSystem.CurrentPoints, gamefield.GameMode.TargetPoints);
// Camera.main.orthographicSize = gamefield.Level.Width;
}
private void Awake()
{
if (Instance != null)
{
Destroy(Instance.gameObject);
return;
}
Instance = this;
_gamefield = GetComponent <Gamefield>();
}
private void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
chuzzle.Destroy(true, false);
if (!AnimatedChuzzles.Any())
{
Gamefield.SwitchStateTo(Gamefield.WinCreateNewChuzzlesState);
}
}
public override void OnEnter()
{
AnimatedChuzzles.Clear();
Chuzzle.DropEventHandlers();
Chuzzle.AnimationStarted += OnAnimationStarted;
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (!CheckForSpecial(combinations))
{
Gamefield.SwitchStateTo(Gamefield.WinRemoveCombinationState);
}
}
IEnumerator CreateNewPowerUps(List <Chuzzle> newPowerUps)
{
yield return(new WaitForSeconds(1f));
foreach (Chuzzle ch in newPowerUps)
{
ch.Explosion = TileReplaceEffect;
ch.Destroy(false);
yield return(new WaitForSeconds(0.5f));
TilesFactory.Instance.CreateBomb(ch.Current);
}
Gamefield.SwitchStateTo(Gamefield.WinRemoveCombinationState);
}
void Start()
{
self = GameObject.Find("Canvas");
model = FindObjectOfType<Gamefield>();
tilePrefab = Resources.Load<GameObject>("Tile");
tiles = new GameObject[width][];
spritesheet = Resources.LoadAll<Sprite>("Spritesheet");
for (int i = 0; i < width; i++)
{
tiles[i] = new GameObject[height];
}
AddTiles(width, height);
AddHeroTile();
}
private void RemoveCombinations(IEnumerable <List <Chuzzle> > combinations)
{
//remove combinations
foreach (var combination in combinations)
{
Gamefield.InvokeCombinationDestroyed(combination);
//count points
Gamefield.PointSystem.CountForCombinations(combination);
foreach (var chuzzle in combination)
{
chuzzle.Destroy(true);
}
}
}
public override void OnEnter()
{
AnimatedChuzzles.Clear();
Chuzzle.DropEventHandlers();
Chuzzle.AnimationStarted += OnAnimationStarted;
var anyCombination = GamefieldUtility.FindOnlyOneCombination(Gamefield.Level.ActiveChuzzles);
if (anyCombination.Any())
{
StartCoroutine(RemoveCombinations());
}
else
{
Gamefield.SwitchStateTo(Gamefield.FieldState);
}
}
public void Awake()
{
Instance = this;
InitState = GetComponent <InitState>();
CheckSpecialState = GetComponent <CheckSpecialState>();
CreateNewChuzzlesState = GetComponent <CreateNewChuzzlesState>();
RemoveState = GetComponent <RemoveCombinationState>();
GameOverState = GetComponent <GameOverState>();
WinState = GetComponent <WinState>();
FieldState = GetComponent <FieldState>();
WinCheckSpecialState = GetComponent <WinCheckSpecialState>();
WinCreateNewChuzzlesState = GetComponent <WinCreateNewChuzzlesState>();
WinRemoveCombinationState = GetComponent <WinRemoveCombinationState>();
Level = GetComponent <Level>();
StageManager = GetComponent <StageManager>();
PointSystem = GetComponent <Points>();
}
public void CheckCombinations()
{
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (combinations.Any() && (!Tutorial.isActive || (Tutorial.isActive && CurrentChuzzle != null && Tutorial.instance.IsTargetCell(CurrentChuzzle.Real))))
{
foreach (var c in Gamefield.Level.Chuzzles)
{
c.MoveTo = c.Current = c.Real;
}
Gamefield.SwitchStateTo(Gamefield.CheckSpecialState);
Reset();
}
else
{
if (CurrentChuzzle != null)
{
StartReturn();
}
}
}
public void OnAnimationFinished(Chuzzle chuzzle)
{
chuzzle.Real = chuzzle.Current = chuzzle.MoveTo;
chuzzle.AnimationFinished -= OnAnimationFinished;
AnimatedChuzzles.Remove(chuzzle);
if (!AnimatedChuzzles.Any())
{
Gamefield.Level.UpdateActive();
var combinations = GamefieldUtility.FindCombinations(Gamefield.Level.ActiveChuzzles);
if (combinations.Count > 0)
{
Gamefield.SwitchStateTo(Gamefield.WinCheckSpecialState);
}
else
{
Gamefield.SwitchStateTo(Gamefield.WinRemoveCombinationState);
}
}
}
private IEnumerator RemoveCombinations()
{
var powerUpCombination = GamefieldUtility.FindOnlyOneCombinationWithCondition(Gamefield.Chuzzles,
GamefieldUtility.IsPowerUp);
//if has any powerups
if (powerUpCombination.Any())
{
//destroy step by step
PowerUpDestroyManager.Instance.Destroy(powerUpCombination);
if (!AnimatedChuzzles.Any())
{
Gamefield.SwitchStateTo(Gamefield.CreateNewChuzzlesState);
}
}
else
{
var combinations = GamefieldUtility.FindCombinations(Gamefield.Chuzzles);
//remove combinations
foreach (var combination in combinations)
{
Gamefield.InvokeCombinationDestroyed(combination);
foreach (var chuzzle in combination)
{
chuzzle.Destroy(true);
}
if (!AnimatedChuzzles.Any())
{
Gamefield.SwitchStateTo(Gamefield.CreateNewChuzzlesState);
}
yield return(new WaitForSeconds(0.05f));
}
}
yield return(new WaitForEndOfFrame());
}
static async Task Main(string[] args)
{
var gameBoard = new Gamefield();
IGameAnalyser analyser = new BasicGameAnalyser();
var count = gameBoard.GetFreePositions().Count();
for (int i = 0; i < count; i++)
{
var rnd = GenerateRandomNumber(0, 19 - i);
var card = gameBoard.GetUnusedGamecards().Skip(rnd).First();
var result = await analyser.PlayRoundAsync(gameBoard, card);
gameBoard.TrySetCard(result, card);
//gameBoard.SaveRound();
System.Console.WriteLine(gameBoard.ToString());
System.Console.WriteLine("Boardpoints: " + gameBoard.GetBoardPoints());
System.Console.ReadKey();
}
//var result = gameBoard.GetPositioInfo(4, 2, new Gamecard(3, 4, 5));
//System.Console.WriteLine(result);
}
public PauseState(Gamefield gamefield=null)
: base(gamefield)
{
}
public WinState(Gamefield gamefield = null)
: base(gamefield)
{
}
void Awake()
{
Gamefield = GetComponent <Gamefield>();
}
public override void OnEnter()
{
Gamefield.Reset();
Gamefield.InvokeGameStarted();
Gamefield.SwitchStateTo(Gamefield.CheckSpecialState);
}
public InitState(Gamefield gamefield = null)
: base(gamefield)
{
}
public Field(Gamefield gamefield)
: base(gamefield)
{
}
protected GamefieldState(Gamefield gamefield)
{
Gamefield = gamefield;
}
public CreateState(Gamefield gamefield)
: base(gamefield)
{
}
public GameOverState(Gamefield gamefield)
: base(gamefield)
{
}
public PowerUpAnalyzeState(Gamefield gamefield)
: base(gamefield)
{
}
public void Awake()
{
Gamefield = GetComponent<Gamefield>();
}
public FieldState(Gamefield gamefield)
: base(gamefield)
{
}
public DeleteState(Gamefield gamefield)
: base(gamefield)
{
}
public CheckSpecialState(Gamefield gamefield = null)
: base(gamefield)
{
}
public void Test()
{
var gameField = new Gamefield();
}
public RemoveCombinationState(Gamefield gamefield = null)
: base(gamefield)
{
}
private void OnGameStarted(Gamefield gamefield)
{
label.text = gamefield.Level.LevelName;
}
public CreateNewState(Gamefield gamefield = null)
: base(gamefield)
{
}
