public void BasicTests()
{
Assert.AreEqual(string.Join(",", new[] { "*" }), string.Join(",", BuildTower.TowerBuilder(1)));
Assert.AreEqual(string.Join(",", new[] { " * ", "***" }), string.Join(",", BuildTower.TowerBuilder(2)));
Assert.AreEqual(string.Join(",", new[] { " * ", " *** ", "*****" }),
string.Join(",", BuildTower.TowerBuilder(3)));
}
bool AttemptBuilt(BuildTower tower)
{
if (tower.done)
{
return(false);
}
unitStats stats = Central.Instance.getToy(tower.toy_id.rune_type, tower.toy_id.toy_type);
string toy_name = stats.name;
bool force = (force_all_towers || tower.force);
if (canBuildTower(stats, force))
{
Toy f = null;
GameObject o = Peripheral.Instance.makeToy(toy_name, tower.island, !force, ref f, false);
o.GetComponent <Toy>().my_tower_stats.name = tower.label;
if (tower.toy_id.toy_type == ToyType.Temporary)
{
ghosts.Add(o.GetComponent <Toy>());
}
if (tower.disable_tower)
{
StartCoroutine(DisableTower(o));
}
tower.done = true;
return(true);
}
return(false);
}
public void BasicTests(string[] outputStrings, int inputNum)
{
var kata = new BuildTower();
var actual = string.Join(",", kata.TowerBuilder(inputNum));
var excepted = string.Join(",", outputStrings);
Assert.AreEqual(excepted, actual);
}
public void TestBuildTower()
{
var expected = string.Join(",", new[] { "*" });
var actual = string.Join(",", BuildTower.TowerBuilder(1));
Assert.Equal(expected, actual);
expected = string.Join(",", new[] { " * ", "***" });
actual = string.Join(",", BuildTower.TowerBuilder(2));
Assert.Equal(expected, actual);
expected = string.Join(",", new[] { " * ", " *** ", "*****" });
actual = string.Join(",", BuildTower.TowerBuilder(3));
Assert.Equal(expected, actual);
}
IEnumerator BuildTowers()
{
int built = 0;
foreach (BuildTower tower in towers)
{
if (tower.done)
{
continue;
}
if (!force_all_towers && !tower.force)
{
continue;
}
if (AttemptBuilt(tower))
{
built++;
}
//yield return new WaitForSeconds(0.1f);
}
if (force_all_towers)
{
yield return(null);
}
int order = 0;
while (built < towers.Count)
{
BuildTower tower = towers[order];
if (tower.done)
{
built++; order++; continue;
}
if (AttemptBuilt(tower))
{
built++;
order++;
yield return(new WaitForSeconds(1f));
}
yield return(new WaitForSeconds(.1f));
}
yield return(null);
}
public void OnPointerClick()
{
if (SelectedTowerDummy == null || SelectedTowerDummy.Cost > currency.TotalLights)
{
return;
}
SelectedTowerDummy.transform.localPosition = Vector3.zero;
var towerObject = Instantiate(towerPrefabs.Find(x => x.name == SelectedTowerDummy.name), transform.parent);
var towerComponent = towerObject.GetComponent <Tower>();
towerObject.transform.position = transform.position;
BuildTower?.Invoke(towerComponent);
gameObject.SetActive(false);
}
/**
* Returns WAIT if Alexander can't mine anymore and has enough buildings.
*/
private IAction ChoseBuildMove(List <Site> closestUnbuiltMines, Site touchedSite, int owned_mines,
int owned_knight_barrackses, int owned_archer_barrackses, int owned_giant_barrackses, int owned_towers, Unit myQueen)
{
IAction chosenBuildMove = null;
//touchedSite == closestUnbuiltMine
bool siteHasGold = touchedSite.gold > 0;
if (owned_mines < MAX_CONCURRENT_MINES && currGameState.touchedSiteId == closestUnbuiltMines.First().siteId &&
siteHasGold)
{
//chosenMove.queenAction = new BuildMine(currGameState.touchedSiteId);
chosenBuildMove = new BuildMine(currGameState.touchedSiteId);
}
else if (owned_archer_barrackses < MAX_BARRACKSES_ARCER)
{
//chosenMove.queenAction = new BuildBarracks(currGameState.touchedSiteId, BarracksType.Archer);
chosenBuildMove = new BuildBarracks(currGameState.touchedSiteId, BarracksType.Archer);
}
else if (owned_knight_barrackses < MAX_BARRACKSES_KNIGHTS)
{
//chosenMove.queenAction = new BuildBarracks(currGameState.touchedSiteId, BarracksType.Knight);
chosenBuildMove = new BuildBarracks(currGameState.touchedSiteId, BarracksType.Knight);
}
else if (owned_towers < MAX_TOWERS)
{
chosenBuildMove = new BuildTower(currGameState.touchedSiteId);
}
else if (owned_giant_barrackses < MAX_BARRACKSES_GIANT)
{
//chosenMove.queenAction = new BuildBarracks(currGameState.touchedSiteId, BarracksType.Archer);
chosenBuildMove = new BuildBarracks(currGameState.touchedSiteId, BarracksType.Giant);
}
else if (siteHasGold == false)
{
chosenBuildMove = new BuildTower(currGameState.touchedSiteId);
}
else
{
chosenBuildMove = new Wait();
}
return(chosenBuildMove);
}
private void OnEnable()
{
// add color to cube
GetComponent <Renderer>().material.color = GetRandomColor();
// the first cube
if (LastCube == null)
{
// LastCube is the tower base
LastCube = GameObject.Find("Tower Base").GetComponent <BuildTower>();
LastCube.moveSpeed = 0;
return;
}
// set current cube
CurrentCube = this;
CurrentCube.moveSpeed += 1f;
transform.localScale = new Vector3(LastCube.transform.localScale.x, transform.localScale.y,
LastCube.transform.localScale.z);
}
public void TowerBulder_BuildTower_ReturnString()
{
Assert.AreEqual(string.Join(",", new [] { "*" }), string.Join(",", BuildTower.TowerBuilder(1)));
Assert.AreEqual(string.Join(",", new [] { " * ", "***" }), string.Join(",", BuildTower.TowerBuilder(2)));
Assert.AreEqual(string.Join(",", new [] { " * ", " *** ", "*****" }), string.Join(",", BuildTower.TowerBuilder(3)));
}
public void ShouldReturnStringToCorrectlyResembleATower(int floors, string[] expected)
{
Assert.Equal(expected, BuildTower.Build(floors));
}
// Update is called once per frame
void Update()
{
Drums = GameObject.FindGameObjectsWithTag("Drum");
Tiles = GameObject.FindObjectsOfType(typeof(BuildTower)) as BuildTower[];
Groups = new Vector2[Drums.Length];
for (int i = 0; i < Drums.Length; i++)
{
Groups[i] = new Vector2(999, 999);
}
for (int i = 0; i < Drums.Length; i++)
{
k = 0;
d1 = Drums[i].GetComponent <Transform>().position;
for (int j = 0; j < Drums.Length; j++)
{
d2 = Drums[j].GetComponent <Transform>().position;
if (Vector2.Distance(d1, d2) < 2f)
{
k++;
}
}
if (k >= 3)
{
bool isGrouped = false;
for (int r = 0; r < i; r++)
{
if (Vector2.Distance(Groups[r], d1) < 2f)
{
isGrouped = true;
}
}
if (!isGrouped)
{
Groups[i] = d1;
}
}
}
foreach (Vector2 pos in Groups)
{
foreach (GameObject drum in Drums)
{
if (Vector2.Distance(pos, drum.GetComponent <Transform>().position) < 2f)
{
foreach (BuildTower tile in Tiles)
{
if (tile.GetComponent <Transform>().position == drum.GetComponent <Transform>().position)
{
tile.GetComponent <BuildTower>().placed = 0;
}
}
Destroy(drum);
}
}
BuildTower t = null;
foreach (BuildTower tile in Tiles)
{
if (((Vector2)tile.t.position == pos))
{
t = tile;
}
}
if (t != null && t.buildable)
{
GameObject d = Instantiate(UpgradedDrum, t.t);
t.placed = 1;
d.transform.localScale = new Vector3(0.50f, 0.50f, 1);
}
}
}
internal void Stop()
{
moveSpeed = 0;
//if GameManager.SCORE is odd - split cube on z axis
if (GameManager.SCORE % 2 == 1)
{
hangover = transform.position.z - LastCube.transform.position.z;
if (Mathf.Abs(hangover) >= LastCube.transform.localScale.z)
{
CurrentCube = null;
LastCube = null;
SceneManager.LoadScene("End_Scene");
}
else
{
if (hangover > 0)
{
direction = 1f;
}
else
{
direction = -1f;
}
// fixes slicing error on initigal click
if (hangover != 0)
{
SplitOnZ(hangover, direction);
}
LastCube = this;
LastCube.moveSpeed = 0;
}
}
else//else GameManager.SCORE is even - split cube on x axis
{
hangover = transform.position.x - LastCube.transform.position.x;
if (Mathf.Abs(hangover) >= LastCube.transform.localScale.x)
{
CurrentCube = null;
LastCube = null;
SceneManager.LoadScene("End_Scene");
}
else
{
if (hangover > 0)
{
direction = 1f;
}
else
{
direction = -1f;
}
// fixes slicing error on initigal click
if (hangover != 0)
{
SplitOnX(hangover, direction);
}
LastCube = this;
LastCube.moveSpeed = 0;
}
}
}
public void RandomTests()
{
var rand = new Random();
Func <int, string[]> myTowerBuilder = delegate(int nFloors)
{
string[] lines = new string[nFloors];
for (var i = 1; i <= nFloors; i++)
{
lines[i - 1] = (new string(' ', nFloors - i) + new string('*', i * 2 - 1) +
new string(' ', nFloors - i));
}
return(lines);
};
var seq = Enumerable.Range(1, 100).ToArray();
for (int r = 0; r < 100; r++)
{
for (int p = 0; p < 100; p++)
{
if (rand.Next(0, 2) == 0)
{
var temp = seq[r];
seq[r] = seq[p];
seq[p] = temp;
}
}
}
for (int r = 0; r < 100; r++)
{
var n = seq[r];
//Console.WriteLine(n);
Assert.AreEqual(string.Join(",", myTowerBuilder(n)), string.Join(",", BuildTower.TowerBuilder(n)));
}
}
/// <summary>
/// Metoda sprawdzająca czy gracz posiada odpowiednią liczbę zasobów potrzebną do wybudowania danej wieży.
/// </summary>
/// <param name="type">Argument typu BuildTower.TowerType określający, który koszt wieży ma zostać sprawdzony.</param>
/// <returns>Zwraca wartość bool = true, gdy gracz posiada wystarczającą liczbę zasobów albo false, gdy gracz nie posida wystarczającej liczby zasobów.</returns>
private bool HasEnoughResources(BuildTower.TowerType type)
{
int temp = 0;
switch (type)
{
case BuildTower.TowerType.Wall:
temp = FindObjectOfType<BuildTower>().WallTower.Cost;
break;
case BuildTower.TowerType.Shooting:
temp = FindObjectOfType<BuildTower>().ShootingTower.Cost;
break;
case BuildTower.TowerType.Aoe:
temp = FindObjectOfType<BuildTower>().AoeTower.Cost;
break;
}
return _resources - temp >= 0;
}
