public void SetAugmentType(string newType)
{
type = newType;
MeshFilter mesh = this.gameObject.GetComponentInChildren <MeshFilter>();
if (mesh != null)
{
mesh.mesh = Towers.GetMesh(Towers.GetAugmentType(newType));
}
buildingOffset = -0.02f;
buildingSpeed = 10;
Dictionary <string, float> values = Towers.instance.GetAugment(newType);
LoadBuildingStats(values);
LoadAugmentStats(values);
buildingSpeed = Mathf.Abs(buildingOffset / buildingSpeed);
if (building == Building.no)
{
modelObject.transform.Translate(new Vector3(0, buildingOffset, 0), Space.World);
building = Building.yes;
}
}
public void ThrowsException_WhenFromNToAreSame()
{
int discs = 3;
Towers t1 = new Towers(discs);
Assert.ThrowsException <InvalidMoveException>(() => t1.Move(1, 1));
}
public static void GameComplete(Towers pMyTowers, int pFrom, int pTo, Stack <MoveRecord> pUndoStack, Stack <MoveRecord> pRedoStack)
{
if (pMyTowers.IsComplete)
{
WriteLine($"\nCongratulations, you completed the puzzle in {pMyTowers.NumberOfMoves} moves.");
if (pMyTowers.MinimumPossibleMoves == pMyTowers.NumberOfMoves)
{
WriteLine($"\nThat's the fewest number of moves possible. I ANOINT YOU THE RULER OF HANOI!");
}
else
{
WriteLine($"\nYou completed the puzzle in {pMyTowers.NumberOfMoves} moves but the fewest possible is {pMyTowers.MinimumPossibleMoves}");
WriteLine("\nLet's give it another shot. What do you say?");
}
}
else if (pFrom == -2) // redo
{
MoveRecord redoMoveDetails = pUndoStack.Peek();
WriteLine($"\nMove {pMyTowers.NumberOfMoves} complete by redo of move {pMyTowers.NumberOfMoves - 1}. Disc {redoMoveDetails.Disc} restored to tower {redoMoveDetails.To} from tower {redoMoveDetails.From}.");
}
else if (pFrom == -3) // undo
{
MoveRecord undoMoveDetails = pRedoStack.Peek();
WriteLine($"\nMove {pMyTowers.NumberOfMoves} complete by undo of move {undoMoveDetails.MoveNumber}. Disc {undoMoveDetails.Disc} restored to tower {undoMoveDetails.From} from tower {undoMoveDetails.To}.");
}
else
{
WriteLine($"\nMove {pMyTowers.NumberOfMoves} complete. Successfully moved disc {pUndoStack.Peek().Disc} from tower {pFrom} to tower {pTo}.");
}
}
static void Main(string[] args)
{
/*
* Tower Defense
* Towers/Torn
* direktion
* Fire Rate/"eldhastighet"
* Kill Counter/Slaktar Räknare
* Hp/Liv
* Enemies/Fiender
* mängd
*
* Pengar?
*/
Towers t = new Towers();
Enemies E = new Enemies();
t.name1 = "firetower";
E.Alive = 3;
Console.WriteLine(t);
Console.ReadLine();
}
public void AddTower(int id)
{
if (GetTower(id) == null)
{
Towers.Add(new Tower(this, id));
}
}
public ActionResult DeleteTower(Towers tower)
{
Data_access da = new Data_access();
int towerId = da.DeleteTower(tower);
TextWriter writer; //для записи в .json-файл
JObject parsed; //распаршенный json
using (StreamReader r = new StreamReader(Server.MapPath("/Content/data.json")))
{
string json = r.ReadToEnd(); //считываем и записываем в строку
var items = JsonConvert.DeserializeObject <JObject>(json); //десериализуем строку
parsed = JObject.Parse(json);
for (int i = 0; i < parsed["features"].Count(); i++)
{
var idInJson = (int)parsed["features"][i]["id"];
if (idInJson == towerId)
{
parsed["features"][i].Remove();
}
}
}
using (writer = new StreamWriter(Server.MapPath("/Content/data.json"), append: false))
{
writer.WriteLine(JsonConvert.SerializeObject(parsed, Formatting.Indented)); //перезаписываем файл data.json
}
return(Json("Опора успешно удалена!"));
}
public void SetBuilding(string buildingType)
{
buildingOffset = -0.02f;
buildingSpeed = 10;
this.buildingType = buildingType;
this.gameObject.name = buildingType;
LoadBuildingStats(Towers.instance.GetBuilding(buildingType));
MeshFilter buildingMesh = this.gameObject.GetComponentInChildren <MeshFilter>();
if (buildingMesh != null)
{
buildingMesh.mesh = Towers.GetMesh(GetBuildingType(buildingType));
}
buildingSpeed = Mathf.Abs(buildingOffset / buildingSpeed);
//modelObject.transform.Translate(new Vector3(0, buildingOffset, 0), Space.World);
if (building == Building.no)
{
modelObject.transform.Translate(new Vector3(0, buildingOffset, 0), Space.World);
building = Building.yes;
}
if (buildingType == "base")
{
GameObject goal = new GameObject("Goal");
goal.transform.position = this.transform.position;
TerrainGen.goal = goal;
GetComponentInChildren <MeshCollider>().sharedMesh = Towers.baseColl;
}
health = maxHealth;
}
public void ThrowsException_WhenFromTowerHaveNoDiscs()
{
int discs = 3;
Towers t1 = new Towers(discs);
Assert.ThrowsException <InvalidMoveException>(() => t1.Move(2, 1));
}
void Start()
{
platformController = PlatformController.Instance;
towers = Towers.Instance;
playerStats = PlayerStats.Instance;
}
public void ReturnsJaggedArrayCorrectly_WhenMoveSuccessfully()
{
// Arrange
Towers sa = new Towers(5);
int[][] towers;
int[][] asExpected = new int[][]
{
new int[] { 2, 3, 4, 5 },
new int[] { 1 },
new int[] { }
};
bool result = true;
sa.Move(0, 1);
// Act
towers = sa.ToArray();
// Assert
for (int i = 0; i < towers.Length; i++)
{
for (int j = 0; j < towers[i].Length; j++)
{
if (towers[i][j] != asExpected[i][j])
{
result = false;
}
}
}
Assert.IsTrue(result);
}
private static int AutoPlay(Towers myTowers, string input)
{
int from = 1;
int to = 3;
int other = 2;
string algorithm = input;
if (algorithm == "A")
{
Recursive(myTowers, myTowers.NumberOfDiscs, from, to, other);
}
else
{
Iterative(myTowers, myTowers.NumberOfDiscs, from, to, other);
WriteLine();
WriteLine();
if (myTowers.IsComplete == false)
{
Write("Step-through aborted. ");
}
else
{
Write("Step-through completed. ");
}
}
WriteLine($"Number of moves: {myTowers.NumberOfMoves}");
WriteLine();
PostGameReview(myTowers);
WriteLine();
WriteLine();
return(AskForPlayAgain());
}
public void Tear_RemovesDisksFromTowers()
{
var towers = new Towers();
towers.Clear();
towers.Tower1.Count.ShouldEqual(0);
towers.Tower2.Count.ShouldEqual(0);
towers.Tower3.Count.ShouldEqual(0);
}
public Castle AddTower()
{
var tower = new Tower();
Destructables.Add(tower);
Towers.Add(tower);
return(this);
}
public Towers TowerState; // A copy of the Towers object (all three stacks) as of the end of the move.
public MoveRecord(int moveNumber, int disc, int from, int to, Towers towers)
{
this.MoveNumber = moveNumber;
this.Disc = disc;
this.From = from;
this.To = to;
this.TowerState = towers;
}
public static void CreateTowersAssetFile()
{
Towers asset = CustomAssetUtility.CreateAsset <Towers>();
asset.SheetName = "gogtowerdefence";
asset.WorksheetName = "Towers";
EditorUtility.SetDirty(asset);
}
public string[] GetAllMoves(int disks)
{
// cunoscand A, B, C turnuri: 1 disc = AB; 2 discuri = AC, AB, CB; 3 discuri = AB, AC, BC, AB, CA, CB si AB; 4 discuri ..., mutari = (AC discuri - 1) + AB + (CB discuri - 1) => (2 ^ n) - 1
Towers towers = new Towers( "A", "B", "C");
string[] moves = new string[0];
return DoAllSteps(towers, disks, moves);
}
public void DeactivateTower()
{
type = null;
damage = 0;
currentlvl = 1;
range = 0;
price = 0;
}
public void ThrowsException_WhenFrom_To_RangeInvalid()
{
int discs = 3;
Towers t1 = new Towers(discs);
Assert.ThrowsException <InvalidMoveException>(() => t1.Move(4, 1));
Assert.ThrowsException <InvalidMoveException>(() => t1.Move(0, 3));
}
public void ThrowException_WhenInputsAreInvalid()
{
// Arrange
Towers sa = new Towers(5);
// Act-Assert
Assert.ThrowsException <InvalidMoveException>(() => sa.Move(2, 1));
}
public static void DisplayTowers(Towers towers)
{
//Calculate tower width. We'll make each disc twice as wide as its number, plus 1 so the pole can go up the middle
int[][] poles;
string[][] poleDiscs = new string[NumberOfPoles][];
string rowToPrint;
int posX, posY;
int towerWidth = (towers.NumberOfDiscs * 2 + 1);
string towerBase = new string('=', towerWidth * 3);
int towerHeight = towers.NumberOfDiscs + 2;
DisplayTowerTop(towerWidth);
poles = towers.ToArray(); //Returns a jagged array - Dim 1 - 3 poles, Dim 2 - n discs on each pole
//
//Load one array per pole with the visualization of the discs on each pole
//
for (int i = 0; i < NumberOfPoles; i++)
{
poleDiscs[i] = new string[towers.NumberOfDiscs];
posY = poleDiscs[i].Length - 1;
int stackIndex = poles[i] == null ? -1 : poles[i].Length - 1;
while (stackIndex >= 0)
{
poleDiscs[i][posY] = new string('X', poles[i][stackIndex] * 2 + 1);
posY--;
stackIndex--;
}
}
//Now to print the contents of the three pole arrays one line at a time.
for (posY = 0; posY < towers.NumberOfDiscs; posY++) //Iterate from the top of the poles to the base, by column then by row.
{
rowToPrint = "";
for (posX = 0; posX < NumberOfPoles; posX++)
{
if (poleDiscs[posX][posY] == null)
{
rowToPrint = FormatRow(rowToPrint, TowerPole, towerWidth);
}
else
{
rowToPrint = FormatRow(rowToPrint, poleDiscs[posX][posY], towerWidth);
}
}
WriteLine(rowToPrint);
}
WriteLine(towerBase);
InitializeTextArea();
WriteLine();
}
/// <summary>
/// Places towers on the field
/// </summary>
/// <param name="tower">Which tower</param>
public void CreateTower(Towers tower)
{
//Load from resources then instantiate copy - KC
GameObject prefab = Resources.Load <GameObject>(tower.name);
GameObject.Instantiate(prefab, new Vector3(0, 1, 0), Quaternion.identity);
GameEngine.User.UpdateCoins(-tower.Cost);
GameEngine.UI.UpdateDefensesButton(tower.Cost);
}
public void ThrowException_WhenInputIsInvalid()
{
// Arrange
Towers sa;
int input = 10;
// Act-Assert
Assert.ThrowsException <InvalidHeightException>(() => sa = new Towers(input));
}
public void StartGame()
{
CurrentLevel = 1;
CurrentScore = 0;
Towers.Clear();
Levels.Clear();
PrintWelcome(); // Print Welcome-Screen and Highscore
SetDifficulty(); // Set difficulty and generate map & path
AskToPlaceTowers(); // Ask player to place tower
GenerateInvaderAndLevels(); // Generate all levels with their relative invaders
try
{
// Run all levels, calculate score and increase towerpoints
// After each level player can place more towers
foreach (var level in Levels)
{
level.Towers = Towers.ToArray();
if (level.Play())
{
foreach (var invader in level._invaders)
{
CurrentScore += invader.Score;
}
CurrentScore += 5;
Console.WriteLine("Level {0} completed, you earned {1} points!", CurrentLevel, CurrentScore);
CurrentLevel++;
continue;
}
else
{
Console.WriteLine();
Console.WriteLine("Game Over - You have lost!");
Console.WriteLine("You have reached level {0}", CurrentLevel);
Console.Write("Play again? (y/n): ");
if (Console.ReadKey().Key == ConsoleKey.Y)
{
StartGame();
}
else
{
throw new Exception("Game Over!");
}
}
}
}
catch (Exception ex)
{
// GameOver();
// CheckForHighscore();
Console.WriteLine(ex);
SaveHighscore();
}
}
/// <summary>
/// Buys given tower and places it on the map. Buying a tower resets the SelectedShopTower.
/// If the player does not have enough money, no tower will be placed and SelectedShopTower
/// will still be reset.
/// </summary>
/// <param name="tower">Instance of a tower to be placed</param>
public void BuyTower(ITower tower)
{
if (Money >= tower.Price)
{
Towers.Add(tower);
Money -= tower.Price;
}
DeselectShopTower();
}
public void HaveAllDiscsInTowerOne_WhenCreatedSuccessfully()
{
int discs = 5;
Towers t1 = new Towers(discs);
int[][] towers = t1.ToArray();
Assert.AreEqual(towers.Length, 3); // # of towers
Assert.AreEqual(towers[0].Length, discs); // 1st tower has all discs
}
public void UpgradeTower()
{
towers = towerSpawner.PickableGameObject.gameObject.GetComponent <TowerArack>().towers;
if (statistics.Gold >= towers.NextUpgrate.BuildPrice && towers.NextUpgrate != null)
{
upgradePanel.SetActive(false);
towerSpawner.PickableGameObject.GetComponent <TowerArack>().Upgrade();
statistics.Gold -= towerSpawner.PickableGameObject.GetComponent <TowerArack>().towers.BuildPrice;
}
}
public void ThrowsException_WhenFromDiscIsGreaterThanToTopDisc()
{
int discs = 3;
Towers t1 = new Towers(discs);
t1.Move(1, 3);
// Trying to move 2 on top of 1
Assert.ThrowsException <InvalidMoveException>(() => t1.Move(1, 3));
}
// END CUT HERE
// BEGIN CUT HERE
public static void Main()
{
try {
Towers ___test = new Towers();
___test.run_test(-1);
} catch(Exception e) {
//Console.WriteLine(e.StackTrace);
Console.WriteLine(e.ToString());
}
}
// END CUT HERE
// BEGIN CUT HERE
public static void Main()
{
try {
Towers ___test = new Towers();
___test.run_test(-1);
} catch (Exception e) {
//Console.WriteLine(e.StackTrace);
Console.WriteLine(e.ToString());
}
}
public static void IterativeAutoSolve(Towers poles, int discs, Queue <MoveRecord> moveLog, int pTower1, int pTower2, int pTower3)
{
MoveRecord tempMoveRecord;
string userInput;
bool done = false;
if (discs % 2 == 0)
{
int temp = pTower3;
pTower3 = pTower2;
pTower2 = temp;
}
do
{
for (int i = 1; i <= poles.MinimumPossibleMoves; i++)
{
if (i % 3 == 1)
{
tempMoveRecord = MoveBetweenPoles(poles, pTower1, pTower3);
moveLog.Enqueue(tempMoveRecord);
TowerUtilities.DisplayTowers(poles);
Console.WriteLine($"\nMove {poles.NumberOfMoves}. Successfully moved disc from pole {pTower1} to pole {pTower3}.");
}
else if (i % 3 == 2)
{
tempMoveRecord = MoveBetweenPoles(poles, pTower1, pTower2);
moveLog.Enqueue(tempMoveRecord);
TowerUtilities.DisplayTowers(poles);
Console.WriteLine($"\nMove {poles.NumberOfMoves}. Successfully moved disc from pole {pTower1} to pole {pTower3}.");
}
else if (i % 3 == 0)
{
tempMoveRecord = MoveBetweenPoles(poles, pTower2, pTower3);
moveLog.Enqueue(tempMoveRecord);
TowerUtilities.DisplayTowers(poles);
Console.WriteLine($"\nMove {poles.NumberOfMoves}. Successfully moved disc from pole {pTower1} to pole {pTower3}.");
}
Console.WriteLine("\nPress Enter to move to the next step or \"X\" to quit.");
userInput = Console.ReadKey().Key.ToString().ToUpper();
if (userInput.ToUpper() == "X")
{
done = true;
break;
}
}
done = true;
} while (!done);
}
Stack<int> GetTower(Towers Tower)
{
switch (Tower)
{
case Towers.Left:
return _tower1;
case Towers.Middle:
return _tower2;
}
return _tower3;
}
public Tower GetTower(int id)
{
List <Tower> towers = Towers.Where(tower1 => tower1.Number == id).ToList();
if (towers.Any())
{
return(towers.First());
}
return(null);
}
void SetButtonInfo(TextMeshProUGUI costText, GameObject button, Towers tower)
{
var newSpriteState = new SpriteState();
costText.text = "$" + TowerManager.Instance.GetTowerInfo(tower).price.ToString();
button.GetComponent <Image>().sprite = TowerManager.Instance.GetTowerInfo(tower).buttonBaseSprite;
newSpriteState.disabledSprite = TowerManager.Instance.GetTowerInfo(tower).buttonDisabledSprite;
newSpriteState.highlightedSprite = TowerManager.Instance.GetTowerInfo(tower).buttonHighlightSprite;
newSpriteState.pressedSprite = TowerManager.Instance.GetTowerInfo(tower).buttonPressedSprite;
button.GetComponent <Button>().spriteState = newSpriteState;
}
public DrillTower GetDrillTower(string designation)
{
if (designation?.Length != 1)
{
return(null);
}
DrillTower tower;
Towers.TryGetValue(designation, out tower);
return(tower);
}
private string[] DoAllSteps(Towers towers, int disks, string[] moves)
{
if(disks == 1)
moves = AddNewMove(moves, towers.From +""+ towers.To);
else
{
// A > C
Towers fromAtoC = new Towers(towers.From, towers.Helper, towers.To);// new Towers("A", "C", "B");
moves = DoAllSteps(fromAtoC, disks - 1, moves);
moves = AddNewMove(moves, towers.From + "" + towers.To);
// C > B
Towers fromCtoB = new Towers(towers.Helper, towers.To, towers.From);// new Towers("C", "B", "A");
moves = DoAllSteps(fromCtoB, disks - 1, moves);
}
return moves;
}
public bool Move(Towers From, Towers To)
{
var fromTower = GetTower(From);
var toTower = GetTower(To);
if (fromTower.Count < 1)
return false;
var fromStep = fromTower.Peek();
var toStep = toTower.Count < 1 ? 10 : toTower.Peek();
if (fromStep >= toStep)
return fromStep == toStep;
toTower.Push(fromTower.Pop());
return true;
}
public IReadOnlyList<int> this[Towers Tower]
{
get
{
switch (Tower)
{
case Towers.Left:
return _tower1.ToList();
case Towers.Middle:
return _tower2.ToList();
case Towers.Right:
return _tower3.ToList();
default:
return null;
}
}
}
public int GetStep(Towers From)
{
var fromTower = GetTower(From);
return fromTower.Count < 1 ? 0 : fromTower.Peek();
}
void Awake()
{
instance = this;
}
public Tower(Towers tower, MainEncounterLogic caller, TriggeredAbility ability)
{
whichTower = tower;
parent = caller;
warningAbility = ability;
nextTick = new TriggeredAbility();
nextTick.warningTime = TimeSpan.Zero;
nextTick.warningCallback = this.tick;
parent.timedAbilities.Add(warningAbility);
parent.timedAbilities.Add(nextTick);
}
public override void step(Towers.Tower tower)
{
tower.stats.stunned = true;
}
