/*private int CalculateUnits(int neighborCount, int min, int max)
* {
* switch (neighborCount)
* {
* case 0:
* case 1:
* case 2:
* case 3:
* return Random.Range(min, max / 3);
* case 4:
* case 5:
* case 6:
* return Random.Range(max / 3, max / 3 * 2);
* case 7:
* case 8:
* return Random.Range(max / 3 * 2, max);
* }
*
* throw new System.InvalidOperationException("Nicht gut.");
* }*/
public Feld[,] genTilePos(Feld[,] oldMap)
{
Feld[,] newMap = new Feld[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Dictionary <FeldTerrain, int> neighbors = CountNeighbors(oldMap, x, y);
var oldTerrain = oldMap[x, y].Terrain;
var nemTerrain = GetNem(oldTerrain);
if (neighbors[oldTerrain] < nemTerrain)
{
newMap[x, y] = new Feld {
Terrain = getNewTerrain(neighbors)
};
}
else
{
newMap[x, y] = new Feld {
Terrain = oldTerrain
};
}
}
}
return(newMap);
}
private bool checkattackable(Feld element, int reich)
{
if (gesamt.moving.Aktiondone == true)
{
return(false);
}
if (element.Kreatur.Player != gesamt.moving.Player)
{
if (gesamt.moving.Reichweite == 1 || reich >= 0)
{
if (!(element.Kreatur.checkSpezial(8) && element.Kreatur.getCount() > 2))
{ //unsichtbar
if (!(element.Kreatur.checkeffekt(5)))
{ //Eisblock
if (!(gesamt.moving.checkSpezial(4) && gesamt.moving.Spezialused == true))
{ //MoveAttack
return(true);
}
}
}
}
}
return(false);
}
public void changeFieldTyp(Feld replacer)
{
GameObject tempobject = (GameObject)Instantiate(replacer.gameObject, gameObject.transform.position, gameObject.transform.rotation);
Feld tempfeld = tempobject.GetComponent <Feld>();
if (gesamt.Spell.spezial == 6)
{
GameManager.s_instance.letSoundPlay(Enumerations.enSfxAndPfx.Eiswand);
GameManager.s_instance.letParticlePlayField(Enumerations.enSfxAndPfx.Eiswand, 2, this);
}
else
{
GameManager.s_instance.letSoundPlay(Enumerations.enSfxAndPfx.FieldChange);
GameManager.s_instance.letParticlePlayField(Enumerations.enSfxAndPfx.FieldChange, 2, this);
}
if (Kreatur != null)
{
tempfeld.Kreatur = Kreatur;
tempfeld.Kreatur.Platzfeld = tempfeld;
tempfeld.Kreatur.MoveTo();
}
gesamt.Felder.Add(tempfeld);
destroyField();
gesamt.allFelderNachbarnNeuzuweisung();
}
public Spiel(List<LeiterSchlange> leiterSchlangen)
{
Feld[] felder = new Feld[Program.Spielfelder];
for (int i = felder.Length - 1; i >= 0; i--)
{
felder[i] = new Feld(i + 1);
for (int j = 0; j < felder[i].Ziele.Length; j++)
{
felder[i].Ziele[j] = (i + j + 1) > felder.Length - 1 ? felder[i] : felder[i + j + 1];
}
}
Felder = felder;
foreach (var leiterSchlange in leiterSchlangen)
{
for (int i = 0; i < Felder.Length; i++)
{
for (int j = 0; j < Felder[i].Ziele.Length; j++)
{
if (Felder[i].Ziele[j].FeldNummer == leiterSchlange.Start)
{
Felder[i].Ziele[j] = Felder[leiterSchlange.Ziel - 1];
}
}
}
}
}
public void SetFlag()
{
// Given
int rowCoordiante = 0;
int columnCoodinate = 0;
InitializeTestField();
// When
MinesweeperSpiel minesweeperSpiel = new MinesweeperSpiel(testField);
// Set Flag /Than Field is Market with Flag
minesweeperSpiel.SetzeFahnenMarkierung(rowCoordiante, columnCoodinate);
Assert.That(minesweeperSpiel[rowCoordiante, columnCoodinate], Is.EqualTo(Feld.Fahne));
// Set Flag at Flag that Market Field /Than Flag is Removed from Field
minesweeperSpiel.SetzeFahnenMarkierung(rowCoordiante, columnCoodinate);
Assert.That(minesweeperSpiel[rowCoordiante, columnCoodinate], Is.EqualTo(Feld.Unbekannt));
// open Field that is marked with Flag
minesweeperSpiel.DeckeAuf(0, 4);
Feld zustand = minesweeperSpiel[0, 4];
minesweeperSpiel.SetzeFahnenMarkierung(4, 0);
// Than wont be marked with flag
Assert.That(minesweeperSpiel[0, 4], Is.EqualTo(zustand));
}
/// <summary>
/// Liest zwei Zeichen ein und ordnet sie einem Feld zu
/// </summary>
/// <param name="aktuellerSpieler">Der aktuelle Spieler</param>
/// <returns>Eine Instanz vom Typ Spielzug</returns>
public Spielzug LeseEingabe(Spieler aktuellerSpieler)
{
Console.WriteLine(aktuellerSpieler.ToString());
Feld ausgewähltesFeld = Feld.Ungültig;
while (ausgewähltesFeld == Feld.Ungültig)
{
string aktuelleZeile = Console.ReadLine() + "";
string erstesZeichen = string.Empty;
string zweitesZeichen = string.Empty;
if (aktuelleZeile.Length == 2)
{
erstesZeichen = aktuelleZeile[0].ToString();
zweitesZeichen = aktuelleZeile[1].ToString();
}
ausgewähltesFeld = EingabeAuswerten(erstesZeichen.Trim().ToLower(), zweitesZeichen.Trim().ToLower());
if (ausgewähltesFeld == Feld.Ungültig)
{
Console.WriteLine(konsolenWert.ungültigeEingabe);
}
}
Spielzug ausgewählerSpielzug = new Spielzug(aktuellerSpieler, ausgewähltesFeld);
return(ausgewählerSpielzug);
}
public void Move(KreaturChip moving, Feld target)
{
//beendet die bewegung auf jedem Feld und entfernt die Kreatur vom Feld wo es herkam
foreach (Feld element in Felder)
{
if (element.Kreatur == moving)
{
element.Kreatur = null;
}
element.MoveEnd();
}
moving.Platzfeld = target;
moving.MoveTo();
target.Kreatur = moving;
moving.Aktiondone = true;
//War zuerst die Summon Phase so wird diese beendet
if (getPhase() == 0)
{
nextPhase();
}
else
{
//Wenn keine andere Kreatur sich bewegen kann wird die nexte phase ausgewählt
if (NoMoreMovment())
{
nextPhase();
}
}
}
private GameObject createField(Feld input, int i, int n, float abweichung, float scaleX, float scaleZ)
{
Vector3 temp = new Vector3(n * scaleX + abweichung, 0, i * scaleZ);
Quaternion temp1 = new Quaternion(0.5f, 0, 0, -0.5f);
GameObject tempobject = (GameObject)Instantiate(input.gameObject, temp, temp1);
GameManager.s_instance.Felder.Add(tempobject.GetComponent <Feld>());
return(tempobject);
}
public ActionResult Edit([Bind(Include = "Id,Name,Sensibel,PK")] Feld feld, int?id, int?did)
{
if (ModelState.IsValid)
{
db.Entry(feld).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Details", "Datentypen", new { Id = did }));
}
return(View(feld));
}
public void Computer_Zug(Controller c)
{
Wuerfeln(c);
do
{
Waehle_Figur(c);
pruefe = Modell.Figuren[c.Gewaehlt].Aktuell;
Bewege_Figur(c);
} while (Modell.Figuren[c.Gewaehlt].Aktuell == pruefe);
}
//Beendet eine bestehende aktion
public void actionend()
{
Debug.Log("actionend");
allMoveEnd();
moving = null;
Spell = null;
equip = null;
summon = null;
chargeFeld = null;
attackedField = null;
}
public ActionResult Create([Bind(Include = "Id,Name,Sensibel,PK")] Feld feld, int?id)
{
if (ModelState.IsValid)
{
db.Feld.Add(feld);
db.SaveChanges();
return(RedirectToAction("Edit", "Datentypen", new { Id = id }));
}
return(View(feld));
}
public Knoten(int _hafen, Edge _adjEdge1, Edge _adjEdge2, Edge _adjEdge3, Feld _feld1, Feld _feld2, Feld _feld3)
{
this.building = new EmptyBuilding();
this.hafen = _hafen;
this.adjEdge1 = _adjEdge1;
this.adjEdge2 = _adjEdge2;
this.adjEdge3 = _adjEdge3;
this.feld1 = _feld1;
this.feld2 = _feld2;
this.feld3 = _feld3;
}
public static void SpawnSpellParticles(GameObject particles, int duration, Feld target)
{
if (particles == null)
{
return;
}
Quaternion rotation = new Quaternion(0.7f, 0.5f, 0.7f, -0.7f);
GameObject gObj = (GameObject)Instantiate(particles, target.transform.position + new Vector3(0.0f, 0.0f, -0.075f), Quaternion.identity);
Destroy(gObj, duration);
}
private void Kicke_Figur(Feld feld)
{
int figur = Gib_Figur(feld);
if (figur == -1)
{
return;
}
ZuKicken = p[feld.Besetzt].Figuren[figur];
Setze_Ins_Haus(feld.Besetzt, figur);
}
// setzt ein Feld auf ein normalFeld zurück und wenn es vorher ein Energiefeld war, wird diese nue positioniert
public void noMoreEnergie(Feld target, bool newEnergieField)
{
for (; newEnergieField == true;)
{
int ran = Random.Range(0, Felder.Count - 1);
if (Felder[ran].gameObject.tag != "Energie_Feld" && Felder[ran].gameObject.tag != "Start_Feld")
{
Felder[ran].changeFieldTyp(energieFeld);
newEnergieField = false;
}
}
target.changeFieldTyp(normalFeld);
}
// GET: Felder/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Feld feld = db.Feld.Find(id);
if (feld == null)
{
return(HttpNotFound());
}
return(View(feld));
}
/// <summary>
/// Gibt den Spieler zurück, der das übergebene Feld gestzt hat
/// </summary>
/// <param name="feld">Das gesetzte Feld</param>
/// <returns></returns>
public Spieler GibSpielerDesFeldesZurück(Feld feld)
{
Spieler spieler;
switch (feld)
{
case Feld.A1:
spieler = a1;
break;
case Feld.A2:
spieler = a2;
break;
case Feld.A3:
spieler = a3;
break;
case Feld.B1:
spieler = b1;
break;
case Feld.B2:
spieler = b2;
break;
case Feld.B3:
spieler = b3;
break;
case Feld.C1:
spieler = c1;
break;
case Feld.C2:
spieler = c2;
break;
case Feld.C3:
spieler = c3;
break;
default:
spieler = Spieler.Undefiniert;
break;
}
return(spieler);
}
public int Gib_Figur(Feld pos)
{
if (pos.Besetzt == -1)
{
return(-1);
}
for (int i = 0; i < 4; i++)
{
if (p[pos.Besetzt].Figuren[i].Aktuell == pos)
{
return(i);
}
}
return(-1);
}
//Ameise erstellen
public Ameise(Form1 f)
{
HomePosX = 5;
HomePosY = 5;
HomeAnzahl = 0;
Trgt = false;
PositionX = 5;
PositionY = 5;
Wiese = new Feld(f);
PrepoX = 5;
PrepoY = 5;
Wiese.Butbut[HomePosX, HomePosY].BackColor = Color.Black;
Wiese.Butbut[HomePosX, HomePosY].Text = "A";
Wiese.Butbut[HomePosX, HomePosY].ForeColor = Color.White;
}
/// <summary>
/// Bestimmt anhand des Spielers das in die Konsole zu verwendende Symbol (String)
/// </summary>
/// <param name="feld">Das Feld, welches ausgegeben werden soll</param>
/// <param name="spielerZuFeldZuordnung">Eine Instanz vom Typ ISpielerZuFeldZuordnung </param>
/// <returns>Ein String, der für den zum Feld gehörenden Spieler steht</returns>
private String KonvertiereSpielerInSymbol(Feld feld, ISpielerZuFeldZuordnung spielerZuFeldZuordnung)
{
Konsolenwerte wert = new Konsolenwerte();
Spieler spieler = spielerZuFeldZuordnung.GibSpielerDesFeldesZurück(feld);
if (spieler == Spieler.Spieler1)
{
return(wert.spieler1Symbol);
}
if (spieler == Spieler.Spieler2)
{
return(wert.spieler2Symbol);
}
return(" ");
}
public void initPos()
{
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
var randomValue = Random.Range(1, (iniWald + iniWasser + iniGestein + iniSand + iniWiese));
if (randomValue <= (iniWald))
{
var feld = new Feld {
Terrain = FeldTerrain.Wald
};
_gameData.SetFeld(feld, x, y);
}
else if (randomValue <= (iniWald + iniWasser))
{
var feld = new Feld {
Terrain = FeldTerrain.Wasser
};
_gameData.SetFeld(feld, x, y);
}
else if (randomValue <= (iniWald + iniWasser + iniGestein))
{
var feld = new Feld {
Terrain = FeldTerrain.Gestein
};
_gameData.SetFeld(feld, x, y);
}
else if (randomValue <= (iniWald + iniWasser + iniGestein + iniSand))
{
var feld = new Feld {
Terrain = FeldTerrain.Sand
};
_gameData.SetFeld(feld, x, y);
}
else if (randomValue <= (iniWald + iniWasser + iniGestein + iniSand + iniWiese))
{
var feld = new Feld {
Terrain = FeldTerrain.Wiese
};
_gameData.SetFeld(feld, x, y);
}
}
}
}
public void OpenField()
{
//Given
InitializeTestField();
MinesweeperSpiel minesweeperSpiel = new MinesweeperSpiel(testField);
//When /Than
Assert.That(() => minesweeperSpiel.DeckeAuf(2, 2), Throws.InvalidOperationException);
//When /Than
Assert.That(() => minesweeperSpiel.DeckeAuf(20, 20), Throws.ArgumentException);
//When
minesweeperSpiel.DeckeAuf(0, 0);
Feld zustand = minesweeperSpiel[0, 0];
minesweeperSpiel.DeckeAuf(0, 0);
//Than
Assert.That(minesweeperSpiel[0, 4], Is.EqualTo(zustand));
}
private void initFelds()
{
felds = new Feld[20];
int _type;
int _nummer;
for (int i = 1; i < 20; i++)
{
_type = this.stash.getRndFeldFromStash();
if (_type != 0)
{
_nummer = this.stash.getNextNummer();
}
else
{
_nummer = 0;
}
felds[i] = new Feld(_nummer, _type);
}
}
private string GibZeichenZurück(Feld feld)
{
switch (feld)
{
case Feld.Unbekannt:
return(" ");
case Feld.Fahne:
return("P");
case Feld.Mine:
return(" ");
default:
{
int minenInNachbarschaft = (int)feld;
return(minenInNachbarschaft.ToString());
}
}
}
static void Main(string[] args)
{
Feld[,] result = new Feld[, ] {
};
for (int x = 0; x < 100; x++)
{
for (int y = 0; y < 100; y++)
{
if (result[x, y].IsFilled)
{
Console.Write("x");
}
else
{
Console.Write("O");
}
}
Console.Write(Environment.NewLine);
}
Console.Read();
}
public void letParticlePlayField(Enumerations.enSfxAndPfx e, int duration, Feld target)
{
GameObject play = null;
switch (e)
{
case Enumerations.enSfxAndPfx.Beschwoeren:
play = summonPfx;
break;
case Enumerations.enSfxAndPfx.Eiswand:
play = eiswandPfx;
break;
case Enumerations.enSfxAndPfx.FieldChange:
play = fieldChangePfx;
break;
}
SpellParticleManager.SpawnSpellParticles(play, duration, target);
}
private Color GetFieldColor(Feld feld)
{
switch (feld)
{
case Feld.Unbekannt:
return(Color.Goldenrod);
case Feld.Fahne:
return(Color.IndianRed);
case Feld.Mine:
return(Color.Indigo);
case Feld.N0:
return(Color.Silver);
default:
{
return(Color.Snow);
}
}
}
//Erstellt eine neue Kreatur und plaziert diese auf das target Feld
public void Beschwoerung(Feld target)
{
moving.gesamt = this;
moving.Platzfeld = target;
Vector3 temp = target.transform.position;
Quaternion temp1 = new Quaternion(0.7f, 0, 0, -0.7f);
Instantiate(moving.gameObject, temp, temp1);
letSoundPlay(Enumerations.enSfxAndPfx.Beschwoeren);
letParticlePlayField(Enumerations.enSfxAndPfx.Beschwoeren, 2, target);
foreach (Feld element in Felder)
{
if (element.Kreatur == moving)
{
element.Kreatur = null;
}
element.MoveEnd();
}
target.Kreatur = moving;
GetAktuellSpieler().KarteGespielt(summon);
actionend();
}
public void SetFeld(Feld feld, int x, int y)
{
_data[x, y] = feld;
}
/// <summary>
/// Wertet die Eingabe aus
/// </summary>
/// <param name="erster">Das erste übergebene Zeichen</param>
/// <param name="zweiter">Das zweite übergebene Zeichen</param>
/// <returns>Gibt ein Wert der Enumeration Feld zurück</returns>
private TicTocLib.Feld EingabeAuswerten(string erster, string zweiter)
{
Feld erkanntesEingabefeld = Feld.Ungültig;
if (erster != konsolenWert.A && erster != konsolenWert.B && erster != konsolenWert.C)
{
return(erkanntesEingabefeld);
}
if (zweiter != konsolenWert.EINS && zweiter != konsolenWert.ZWEI && zweiter != konsolenWert.DREI)
{
return(erkanntesEingabefeld);
}
if (erster == konsolenWert.A)
{
if (zweiter == konsolenWert.EINS)
{
erkanntesEingabefeld = Feld.A1;
}
else if (zweiter == konsolenWert.ZWEI)
{
erkanntesEingabefeld = Feld.A2;
}
else if (zweiter == konsolenWert.DREI)
{
erkanntesEingabefeld = Feld.A3;
}
}
else if (erster == konsolenWert.B)
{
if (zweiter == konsolenWert.EINS)
{
erkanntesEingabefeld = Feld.B1;
}
else if (zweiter == konsolenWert.ZWEI)
{
erkanntesEingabefeld = Feld.B2;
}
else if (zweiter == konsolenWert.DREI)
{
erkanntesEingabefeld = Feld.B3;
}
}
else if (erster == konsolenWert.C)
{
if (zweiter == konsolenWert.EINS)
{
erkanntesEingabefeld = Feld.C1;
}
else if (zweiter == konsolenWert.ZWEI)
{
erkanntesEingabefeld = Feld.C2;
}
else if (zweiter == konsolenWert.DREI)
{
erkanntesEingabefeld = Feld.C3;
}
}
return(erkanntesEingabefeld);
}
