void NeuesSpiel()
{
foreach (Parts parts in snakeParts)
{
if (parts.UiElemente != null)
{
Spielfeld.Children.Remove(parts.UiElemente);
}
}
snakeParts.Clear();
if (futter != null)
{
Spielfeld.Children.Remove(futter);
}
punkte = 0;
laenge = StartLaenge;
richtung = Richtung.Rechts;
snakeParts.Add(new Parts()
{
Position = new Point(TeilGroesse * 5, TeilGroesse * 5)
});
spielTimer.Interval = TimeSpan.FromMilliseconds(StartGeschw);
StatusUpdate();
ZeichneSnake();
ZeichneFutter();
spielTimer.IsEnabled = true;
}
/// <summary>
/// Verändert die Koordinaten des Spielsteins um den angegebenen x bzw. y-Wert
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
public void Verschieben(Richtung richtung)
{
int x = 0, y = 0;
switch (richtung)
{
case Richtung.Rechts:
x = 1;
break;
case Richtung.Links:
x = -1;
break;
case Richtung.Unten:
y = 1;
break;
}
// X-Verschiebung der Kästchen
x1 = x1 + x;
x2 = x2 + x;
x3 = x3 + x;
x4 = x4 + x;
// Y-Verschiebung der Kästchen
y1 = y1 + y;
y2 = y2 + y;
y3 = y3 + y;
y4 = y4 + y;
}
public Enemy(Objectmanager objectmanager, ContentManager contentManager, Mathe mathe, Enemydatabase enemydatabase, Enemytype typ, Vector2 position, Richtung blickrichtung, float skalierung)
{
Gravitation = 0.40f;
MaxSpeed = new Vector2(6, 15);
this.Objectmanager = objectmanager;
this.Mathe = mathe;
this.State = Enemystate.Idle;
this.Blickrichtung = blickrichtung;
this.Skalierung = skalierung;
this.PositionCurrent = position;
this.Typ = typ;
Enemy Tempenemy = enemydatabase.Read(typ);
Texturmaße = new Vector2(Tempenemy.Texturmaße.X, Tempenemy.Texturmaße.Y);
AniGeschwindigkeit = Tempenemy.AniGeschwindigkeit;
Spalten = Tempenemy.Spalten;
Texturname = Tempenemy.Texturname;
Wiederholen = Tempenemy.Wiederholen;
Textur = Tempenemy.Textur;
Kollision = new Rectangle((int)(Texturmaße.X / 2) - 5, (int)Texturmaße.Y - 20, 10, 10);
for (int i = 0; i < Textur.Count(); i++)
{
if (Texturname[i] == "Idle")
{
Animation = new Animation(Textur[i], true, Spalten[i], new Rectangle(0, 0, (int)Texturmaße.X, (int)Texturmaße.Y), skalierung, AniGeschwindigkeit[i]); break;
}
}
}
public override void Angreifen(Richtung richtung, Random zufall, bool Upgrade)
{
FeindVerletzen(Richtung.Links, 300, 10, zufall);
FeindVerletzen(Richtung.Hoch, 300, 10, zufall);
FeindVerletzen(Richtung.Rechts, 300, 10, zufall);
FeindVerletzen(Richtung.Unten, 300, 10, zufall);
}
public void DreheRechts()
{
richtung = richtung.RichtungRechts();
// Das Elementbild aktualisieren.
bild.DrehenRechts();
ElementHatPositionGeaendert();
}
public void Angreifen(Richtung richtung, Random zufall)
{
spieler.Angreifen(richtung, zufall);
foreach (Feind feind in Feind)
{
feind.Bewegen(zufall);
}
}
public Wand(int koordinateX, int koordinateY, int laenge, Richtung richtung)
{
position = new Position(koordinateX, koordinateY);
this.laenge = laenge;
this.richtung = richtung;
ErzeugeListMauersteine();
}
public override void Angreifen(Richtung richtung, Random zufall, bool Upgrade)
{
if (!Aufgebraucht)
{
spiel.SpielerManaErhöhen(100, zufall);
Aufgebraucht = true;
}
}
public Wand(int laenge, Richtung richtung, ConsoleColor farbe, Position position)
{
this.laenge = laenge;
this.richtung = richtung;
this.farbe = farbe;
this.position = new Position(position);
ErzeugeListZiegels();
}
public Wurm(int kopfX, int kopfY, int maxX, int maxY)
{
ARichtung = Richtung.Hoch;
_maxX = maxX;
_maxY = maxY;
_wurmzellen = new Queue<Wurmzelle>();
var kopf = new Wurmzelle(kopfX, kopfY);
_wurmzellen.Enqueue(kopf);
ErweitereWurmUmWurmzellen(3);
}
public void Update(Richtung richtung)
{
switch (richtung)
{
case Richtung.Links: this.Position.X += 1.5f; break;
case Richtung.Rechts: this.Position.X -= 1.5f; break;
case Richtung.Hoch: this.Position.Y += 1.5f; break;
case Richtung.Runter: this.Position.Y -= 1.5f; break;
}
}
public MauerAussen(Position position, Richtung richtung, int laenge, ConsoleColor ziegelFarbe, char ziegelZeichen)
{
this.position = new Position(position);
this.richtung = richtung;
this.laenge = laenge;
this.ziegelFarbe = ziegelFarbe;
this.ziegelZeichen = ziegelZeichen;
ErzeugeListZiegelFuerMauer();
}
public override void Angreifen(Richtung richtung, Random zufall, bool Upgrade)
{
if (!Upgrade)
{
FeindVerletzen(richtung, 150, 1, zufall);
}
else
{
FeindVerletzen(richtung, 200, 5, zufall);
}
}
public FahrWeg(Position startPosition, Position endPosition, int fahrWegBreite, Richtung fahrWegRichtung, char pflasterSteinZeichen, ConsoleColor pflasterSteinFarbe)
{
this.startPosition = new Position(startPosition);
this.endPosition = new Position(endPosition);
this.fahrWegBreite = fahrWegBreite;
this.fahrWegRichtung = fahrWegRichtung;
this.pflasterSteinZeichen = pflasterSteinZeichen;
this.pflasterSteinFarbe = pflasterSteinFarbe;
BestimmeLaengeFahrWeg();
ErzeugeListPflasterSteineFuerFahrweg();
}
private void PositioniereBall(object sender, EventArgs e)
{
/********************************************
* X-Richtung
********************************************/
var x = Canvas.GetLeft(Ball);
if (x >= Spielplatz.ActualWidth - Ball.ActualWidth)
{
BallXRichtung = Richtung.Links;
}
if (x <= 0)
{
BallXRichtung = Richtung.Rechts;
}
if (BallXRichtung == Richtung.Rechts)
{
Canvas.SetLeft(Ball, x + 10);
}
else
{
Canvas.SetLeft(Ball, x - 10);
}
/********************************************
* Y-Richtung
********************************************/
var y = Canvas.GetTop(Ball);
if (y >= Spielplatz.ActualHeight - Ball.ActualHeight)
{
BallYRichtung = Richtung.Rauf;
}
if (y <= 0)
{
BallYRichtung = Richtung.Runter;
}
if (BallYRichtung == Richtung.Runter)
{
Canvas.SetTop(Ball, y + 10);
}
else
{
Canvas.SetTop(Ball, y - 10);
}
}
void SetPosition(Vector3 altePosition, Richtung richtung)
{
try {
if (spieler.GetComponent <ColliderController>().IstCollidiert)
{
gameObject.transform.position = AenderePosition(altePosition, richtung, -10f);
}
else
{
gameObject.transform.position = AenderePosition(altePosition, richtung, 1f);
}
} catch {
Debug.Log("FEHLER");
}
}
/// <summary>
/// Prüft, ob der gegebene Spielstein in die gewünschte Richtung bewegt werden kann
/// </summary>
/// <param name="einSpielstein"></param>
/// <param name="richtung"></param>
/// <returns></returns>
private bool Verschiebbar(Spielstein einSpielstein, Richtung richtung)
{
if (einSpielstein == null)
{
return(false);
}
// "Geisterstein" erzeugen
Spielstein verschobenerSpielstein = einSpielstein.Kopie();
// mit Geisterstein die Bewegung simulieren
verschobenerSpielstein.Verschieben(richtung);
// Wenn Geisterstein an seiner neuen position setzbar, true zurückgeben
return(Setzbar(verschobenerSpielstein));
}
public void Angreifen(Richtung richtung, Random zufall)
{
if (verwendeteWaffe is Sword)
{
if (Schmiede.BenutztfürSchwert == true)
{
verwendeteWaffe.Angreifen(richtung, zufall, true);
}
else
{
verwendeteWaffe.Angreifen(richtung, zufall, false);
}
}
if (verwendeteWaffe is Bogen)
{
if (Schmiede.BenutztfürBogen == true)
{
verwendeteWaffe.Angreifen(richtung, zufall, true);
}
else
{
verwendeteWaffe.Angreifen(richtung, zufall, false);
}
}
if (verwendeteWaffe is Keule)
{
if (Schmiede.BenutztfürKeule == true)
{
verwendeteWaffe.Angreifen(richtung, zufall, true);
}
else
{
verwendeteWaffe.Angreifen(richtung, zufall, false);
}
}
if (verwendeteWaffe is ITrank)
{
verwendeteWaffe.Angreifen(richtung, zufall, false);
}
}
// Initialisierungsfunktion
// Wird vom Konstruktor bzw. wenn ein neues Spiel gestartet wurde, aufgerufen
public void Init()
{
int Zentrum = AnzahlSpielfeldKacheln / 2;
// Kein Segment hinzufügen
SegmentHinzufuegen = false;
// Startricht ist nach rechts
richtung = Richtung.Rechts;
// Eine Schlange mit 4 Segmenten erzeugen
SegmentList = new List <SnakeSegment>();
SegmentList.Add(new SnakeSegment(Zentrum - 0, Zentrum)); // Kopf
SegmentList.Add(new SnakeSegment(Zentrum - 1, Zentrum)); // Rumpf
SegmentList.Add(new SnakeSegment(Zentrum - 2, Zentrum)); // Rumpf
SegmentList.Add(new SnakeSegment(Zentrum - 3, Zentrum)); // Schwanz
}
public override void Angreifen(Richtung richtung, Random zufall, bool Upgrade)
{
if (Upgrade)
{
FeindVerletzen(Richtung.Links, 80, 8, zufall);
FeindVerletzen(Richtung.Hoch, 80, 8, zufall);
FeindVerletzen(Richtung.Rechts, 80, 8, zufall);
FeindVerletzen(Richtung.Unten, 80, 8, zufall);
}
else
{
FeindVerletzen(Richtung.Links, 80, 5, zufall);
FeindVerletzen(Richtung.Hoch, 80, 5, zufall);
FeindVerletzen(Richtung.Rechts, 80, 5, zufall);
FeindVerletzen(Richtung.Unten, 80, 5, zufall);
}
}
public void Draw(SpriteBatch spriteBatch, Vector2 position, Color color, Richtung richtung, float skalierung)
{
switch (richtung)
{
case DyingHope.Richtung.Links: Richtung = 0; break;
case DyingHope.Richtung.Rechts: Richtung = 1; break;
}
spriteBatch.Draw(
Texture,
new Rectangle((int)position.X, (int)position.Y, (int)(skalierung * Frame.Width), (int)(skalierung * Frame.Height)),
new Rectangle(
Frame.X + (AktuelleSpalte * Frame.Width),
Frame.Y + (Richtung * Frame.Height),
Frame.Width, Frame.Height),
color
);
}
protected bool FeindVerletzen(Richtung richtung, int radius, int schaden, Random zufall)
{
Point ziel = spiel.SpielerOrt;
for (int entfernung = 0; entfernung < radius; entfernung++)
{
foreach (Feind feind in spiel.Feind)
{
if (NaheBei(feind.Ort, radius, spiel.SpielerOrt))
{
feind.Bekämpfen(schaden, zufall);
return(true);
}
}
ziel = Bewegen(richtung, spiel.Grenzen);
}
return(false);
}
public void Draw(SpriteBatch spriteBatch, Rectangle feld, Color color, Richtung richtung)
{
switch (richtung)
{
case DyingHope.Richtung.Links: Richtung = 0; break;
case DyingHope.Richtung.Rechts: Richtung = 1; break;
}
spriteBatch.Draw(
Texture,
new Rectangle((int)feld.X, (int)feld.Y, feld.Width, feld.Height),
new Rectangle(
Frame.X + (AktuelleSpalte * Frame.Width),
Frame.Y + (Richtung * Frame.Height),
Frame.Width, Frame.Height),
color
);
}
private void BestimmeNextZiegelPosition(Richtung richtung)
{
if (richtung == Richtung.nachLinks)
{
position.KoordinateX -= 1;
}
if (richtung == Richtung.nachRechts)
{
position.KoordinateX += 1;
}
if (richtung == Richtung.nachOben)
{
position.KoordinateY -= 1;
}
if (richtung == Richtung.nachUnten)
{
position.KoordinateY += 1;
}
}
private void WindowKeyDown(object sender, KeyEventArgs e)
{
Richtung originalRichtung = richtung;
switch (e.Key)
{
case Key.Up:
if (richtung != Richtung.Runter)
{
richtung = Richtung.Hoch;
}
break;
case Key.Down:
if (richtung != Richtung.Hoch)
{
richtung = Richtung.Runter;
}
break;
case Key.Right:
if (richtung != Richtung.Links)
{
richtung = Richtung.Rechts;
}
break;
case Key.Left:
if (richtung != Richtung.Rechts)
{
richtung = Richtung.Links;
}
break;
case Key.Enter:
NeuesSpiel();
break;
}
if (richtung != originalRichtung)
{
Bewegen();
}
}
public void Process(Richtung richtung) {
switch (richtung) {
case Richtung.Erste:
seitennummer = 1;
break;
case Richtung.Nächste:
if (seitennummer < seitenanzahl) {
seitennummer++;
}
break;
case Richtung.Vorige:
if (seitennummer > 1) {
seitennummer--;
}
break;
case Richtung.Letzte:
seitennummer = seitenanzahl;
break;
default:
throw new ArgumentOutOfRangeException("richtung");
}
Result(seitennummer);
}
Vector3 AenderePosition(Vector3 position, Richtung richtung, float amplitude)
{
switch (richtung)
{
case Richtung.LINKS:
position.x -= Kamera.tempo * amplitude;
break;
case Richtung.RECHTS:
position.x += Kamera.tempo * amplitude;
break;
case Richtung.HOCH:
position.y += Kamera.tempo * amplitude;
break;
default:
position.y -= Kamera.tempo * amplitude;
break;
}
return(position);
}
public VisuAnzeigen(MainWindow mw, AlleLastKraftWagen alleLkw)
{
_mainWindow = mw;
_alleLastKraftWagen = alleLkw;
SpsSichtbar = Visibility.Hidden;
SpsVersionLokal = "fehlt";
SpsVersionEntfernt = "fehlt";
SpsStatus = "x";
SpsColor = Brushes.LightBlue;
for (var i = 0; i < 100; i++)
{
Farbe.Add(Brushes.White);
PosLinks.Add(0);
PosOben.Add(0);
Richtung.Add(1);
}
DatenRangieren_AmpelChangedEvent(null, new AmpelZustandEventArgs(AmpelZustand.Aus, AmpelZustand.Aus));
System.Threading.Tasks.Task.Run(VisuAnzeigenTask);
}
public Point Bewegen(Richtung richtung, Rectangle grenzen)
{
Point neuerOrt = ort;
switch (richtung)
{
case Richtung.Hoch:
if (neuerOrt.Y - SchrittGröße >= grenzen.Top)
{
neuerOrt.Y -= SchrittGröße;
}
break;
case Richtung.Unten:
if (neuerOrt.Y + SchrittGröße <= grenzen.Bottom)
{
neuerOrt.Y += SchrittGröße;
}
break;
case Richtung.Links:
if (neuerOrt.X - SchrittGröße >= grenzen.Left)
{
neuerOrt.X -= SchrittGröße;
}
break;
case Richtung.Rechts:
if (neuerOrt.X + SchrittGröße <= grenzen.Right)
{
neuerOrt.X += SchrittGröße;
}
break;
}
return(neuerOrt);
}
public void Bewegen(Richtung richtung)
{
base.ort = Bewegen(richtung, spiel.Grenzen);
if (!spiel.WaffeInRaum.Aufgesammelt)
{
if (NaheBei(spiel.WaffeInRaum.Ort, 30, spiel.SpielerOrt))
{
spiel.WaffeInRaum.WaffeAufnehmen();
inventar.Add(spiel.WaffeInRaum);
if (inventar.Count == 0)
{
Ausrüsten(spiel.WaffeInRaum.Name);
}
}
}
if (spiel.SchmiedeInRaum != null)
{
if (NaheBei(spiel.SchmiedeInRaum.Ort, 50, spiel.SpielerOrt))
{
if (verwendeteWaffe is Sword)
{
spiel.SchmiedeInRaum.FürSchwertBenutzen();
}
if (verwendeteWaffe is Bogen)
{
spiel.SchmiedeInRaum.FürBogenBenutzen();
}
if (verwendeteWaffe is Keule)
{
spiel.SchmiedeInRaum.FürKeuleBenutzen();
}
spiel.SchmiedeInRaum.SchmiedeBenutzen();
}
}
}
public void SetzteRichtung(Richtung richtung)
{
_wurm.ARichtung = richtung;
}
public Player(Mathe mathe, Contents contents, World world, DebugFlag flag)
{
this.Mathe = mathe;
debugFlag = flag;
this.stringBuilder = new StringBuilder();
this.Contents = contents;
PositionCurrent = new Vector2(0, 715);
Texturen[0] = contents.Player1;
Texturen[1] = contents.Player2;
Texturen[2] = contents.Player3;
Texturen[3] = contents.Player4;
Texturen[4] = contents.Player5;
Texturen[5] = contents.Player6;
Animation = new Animation(Texturen[0], true, 1, new Rectangle(0, 0, 200, 200), 1, 6);
Blickrichtung = Richtung.Rechts;
Playerstate = Playerstates.Idle;
MaxSpeed = new Vector2(6, 12);
Beschleunigung = new Vector2(0.25f, 0.60f);
Initialgeschwindigkeit = new Vector2(2.0f, 5.5f);
Reibung = 0.35f;
Gravitation = 0.40f;
jumpCounter = 0;
jumpCounterMax = 11;
jumpCooldown = 0;
jumpCooldownBase = 20;
Ground = 715;
Groundcollision = true;
body = BodyFactory.CreateRectangle(world, 50, 50, 1.0f, PositionCurrent);
}
private Richtung InvertMovement(Richtung richtung)
{
switch (richtung)
{
case Richtung.Links: return Richtung.Rechts;
case Richtung.Rechts: return Richtung.Links;
case Richtung.Hoch: return Richtung.Runter;
case Richtung.Runter: return Richtung.Hoch;
default: return richtung;
}
}
public void Accelerate(Richtung richtung)
{
if ((Playerstate != Playerstates.Dead) && (Playerstate != Playerstates.Spawn) && (Playerstate != Playerstates.Climb2) && (Playerstate != Playerstates.Lever))
{
richtung = (DepressionHandler.isSet(DepressionState.InvertMove)) ? InvertMovement(richtung) : richtung;
this.Beschleunigung = (DepressionHandler.isSet(DepressionState.Slow)) ? new Vector2(0.25f, this.Beschleunigung.Y) : new Vector2(0.25f, 0.60f);
switch (richtung)
{
case Richtung.Links:
if (!((Geschwindigkeit.Y != 0f) && (Playerstate == Playerstates.Climb1)))
{
if (Playerstate == Playerstates.Idle) Statuswechsel(Playerstates.Walk);
if (Playerstate == Playerstates.Climb1) //Seitwärtsbewegung beim Klettern -> Klettern abbrechen
{
isFalling = true;
Statuswechsel(Playerstates.Idle);
}
Blickrichtung = Richtung.Links;
Geschwindigkeit.X -= Beschleunigung.X;
if (Geschwindigkeit.X > -Initialgeschwindigkeit.X) Geschwindigkeit.X = -Initialgeschwindigkeit.X;
if (Geschwindigkeit.X < -(MaxSpeed.X)) Geschwindigkeit.X = -(MaxSpeed.X);
}
break;
case Richtung.Rechts:
if (!((Geschwindigkeit.Y != 0f) && (Playerstate == Playerstates.Climb1)))
{
if (Playerstate == Playerstates.Idle) Statuswechsel(Playerstates.Walk);
if (Playerstate == Playerstates.Climb1) //Seitwärtsbewegung beim Klettern -> Klettern abbrechen
{
isFalling = true;
Statuswechsel(Playerstates.Idle);
}
Blickrichtung = Richtung.Rechts;
Geschwindigkeit.X += Beschleunigung.X;
if (Geschwindigkeit.X < Initialgeschwindigkeit.X) Geschwindigkeit.X = Initialgeschwindigkeit.X;
if (Geschwindigkeit.X > MaxSpeed.X) Geschwindigkeit.X = MaxSpeed.X;
}
break;
case Richtung.Hoch:
isPressingUp = true; //Spieler betätigt Springen/Klettern diesen Frame (zwecks Sprungabbruch wenn unterbrochen)
if (ClimbEnabled) //Klettern möglich -> nicht springen
{
if (!isFalling)
{
if (Playerstate != Playerstates.Climb1) Statuswechsel(Playerstates.Climb1);
Geschwindigkeit.Y = -2f;
Geschwindigkeit.X = 0;
}
}
else if (Playerstate != Playerstates.Climb1) //Klettern nicht möglich -> springen (Statusabfrage unterbindet springen auf Leitern)
{
if ((!isFalling) && (jumpCooldown == 0))
{
//if ((Playerstate != Playerstates.Jump) && (Geschwindigkeit.Y <= 0)) //Sprung initialisieren
if (Playerstate != Playerstates.Jump) //Sprung initialisieren
{
Statuswechsel(Playerstates.Jump);
Geschwindigkeit.X = 0; //Stehen bleiben
//Geschwindigkeit.Y = -Initialgeschwindigkeit.Y; //Startgeschwindigkeit bei Sprung
}
else if (Animation.AktuelleSpalte >= 2) //Sprung gedrückt halten + Sprunganimation erreicht Auslösepunkt
{
if (Geschwindigkeit.Y == 0) Geschwindigkeit.Y = -Initialgeschwindigkeit.Y; //Startgeschwindigkeit bei Sprung
jumpCounter++; //Sprungzeit
Geschwindigkeit.Y -= Beschleunigung.Y; //Beschleunigen
if (Geschwindigkeit.Y < -MaxSpeed.Y) Geschwindigkeit.Y = -MaxSpeed.Y; //Maximale Geschwindigkeit
}
else Geschwindigkeit.X = 0; //Wenn Frame 2 der Sprunganimation noch nicht erreicht X-Bewegung weiterhin einfrieren
}
}
else //Spieler ist an oberer Kletterkante -> Hochziehen
{
Statuswechsel(Playerstates.Climb2);
if (Blickrichtung == Richtung.Links) PositionCurrent.X -= 10;
else if (Blickrichtung == Richtung.Rechts) PositionCurrent.X += 10;
}
break;
case Richtung.Runter:
isPressingDown = true;
if ((Playerstate == Playerstates.Climb1) && (!isFalling))
{
Geschwindigkeit.Y = 2f;
Geschwindigkeit.X = 0;
}
break;
}
}
}
public void AddEnemy(Enemytype typ, Vector2 position, Richtung blickrichtung, float skalierung)
{
Enemys.Add(new Enemy(Objectmanager, ContentManager, Mathe, Enemydatabase, typ, position, blickrichtung, skalierung));
}
public Element()
{
richtung = new RichtungOsten();
pPosition = new Position(0, 0);
name = "";
}
public void SetzeRichtung(Richtung pRichtung)
{
ARichtung = pRichtung;
}
public string Core()
{
return($"{Linie.Name};{Name};{Richtung.ToStr()};{(IstRund ? 1 : 0)}");
}
public void Bewegen(Richtung richtung)
{
Vector3 altePosition = gameObject.transform.position;
this.SetPosition(altePosition, richtung);
}
public Position PositionInRichtung(Richtung richtung)
{
return richtung.PunktVor(this);
}
public abstract void Angreifen(Richtung richtung, Random zufall, bool Upgrade);
public override void Angreifen(Richtung richtung, Random zufall, bool Upgrade)
{
if (Upgrade == false)
{
switch (richtung)
{
case Richtung.Hoch:
if (FeindVerletzen(Richtung.Hoch, 80, 3, zufall))
{
FeindVerletzen(Richtung.Hoch, 80, 3, zufall);
}
else if (FeindVerletzen(Richtung.Rechts, 80, 3, zufall))
{
FeindVerletzen(Richtung.Rechts, 80, 3, zufall);
}
else if (FeindVerletzen(Richtung.Links, 80, 3, zufall))
{
FeindVerletzen(Richtung.Links, 80, 3, zufall);
}
break;
case Richtung.Rechts:
if (FeindVerletzen(Richtung.Rechts, 80, 3, zufall))
{
FeindVerletzen(Richtung.Rechts, 80, 3, zufall);
}
else if (FeindVerletzen(Richtung.Unten, 80, 3, zufall))
{
FeindVerletzen(Richtung.Unten, 80, 3, zufall);
}
else if (FeindVerletzen(Richtung.Hoch, 80, 3, zufall))
{
FeindVerletzen(Richtung.Hoch, 80, 3, zufall);
}
break;
case Richtung.Unten:
if (FeindVerletzen(Richtung.Unten, 80, 3, zufall))
{
FeindVerletzen(Richtung.Unten, 80, 3, zufall);
}
else if (FeindVerletzen(Richtung.Links, 80, 3, zufall))
{
FeindVerletzen(Richtung.Links, 80, 3, zufall);
}
else if (FeindVerletzen(Richtung.Rechts, 80, 3, zufall))
{
FeindVerletzen(Richtung.Rechts, 80, 3, zufall);
}
break;
case Richtung.Links:
if (FeindVerletzen(Richtung.Links, 80, 3, zufall))
{
FeindVerletzen(Richtung.Links, 80, 3, zufall);
}
else if (FeindVerletzen(Richtung.Unten, 80, 3, zufall))
{
FeindVerletzen(Richtung.Unten, 80, 3, zufall);
}
else if (FeindVerletzen(Richtung.Hoch, 80, 3, zufall))
{
FeindVerletzen(Richtung.Hoch, 80, 3, zufall);
}
break;
}
}
if (Upgrade == true)
{
switch (richtung)
{
case Richtung.Hoch:
if (FeindVerletzen(Richtung.Hoch, 100, 6, zufall))
{
FeindVerletzen(Richtung.Hoch, 100, 6, zufall);
}
else if (FeindVerletzen(Richtung.Rechts, 100, 6, zufall))
{
FeindVerletzen(Richtung.Rechts, 100, 6, zufall);
}
else if (FeindVerletzen(Richtung.Links, 100, 6, zufall))
{
FeindVerletzen(Richtung.Links, 100, 6, zufall);
}
break;
case Richtung.Rechts:
if (FeindVerletzen(Richtung.Rechts, 100, 6, zufall))
{
FeindVerletzen(Richtung.Rechts, 100, 6, zufall);
}
else if (FeindVerletzen(Richtung.Unten, 100, 6, zufall))
{
FeindVerletzen(Richtung.Unten, 100, 6, zufall);
}
else if (FeindVerletzen(Richtung.Hoch, 100, 6, zufall))
{
FeindVerletzen(Richtung.Hoch, 100, 6, zufall);
}
break;
case Richtung.Unten:
if (FeindVerletzen(Richtung.Unten, 100, 6, zufall))
{
FeindVerletzen(Richtung.Unten, 100, 6, zufall);
}
else if (FeindVerletzen(Richtung.Links, 100, 6, zufall))
{
FeindVerletzen(Richtung.Links, 100, 6, zufall);
}
else if (FeindVerletzen(Richtung.Rechts, 100, 6, zufall))
{
FeindVerletzen(Richtung.Rechts, 100, 6, zufall);
}
break;
case Richtung.Links:
if (FeindVerletzen(Richtung.Links, 100, 6, zufall))
{
FeindVerletzen(Richtung.Links, 100, 6, zufall);
}
else if (FeindVerletzen(Richtung.Unten, 100, 6, zufall))
{
FeindVerletzen(Richtung.Unten, 100, 6, zufall);
}
else if (FeindVerletzen(Richtung.Hoch, 100, 6, zufall))
{
FeindVerletzen(Richtung.Hoch, 100, 6, zufall);
}
break;
}
}
}
public void Update(float elapsed, Player player)
{
switch (State)
{
case Enemystate.Idle:
PositionLast = new Vector2(PositionCurrent.X, PositionCurrent.Y); //Alte Position speichern für Kollisionsrücksetzung
PositionCurrent += Geschwindigkeit; //Geschwindigkeit verarbeiten
Physik();
CollisionCheck(player);
float Distanz = Mathe.Distanzberechnung(new Vector2(PositionCurrent.X + (Texturmaße.X / 2), player.PositionCurrent.Y), new Vector2(player.PositionCurrent.X + 640, player.PositionCurrent.Y));
if (Distanz < (Texturmaße.X / 2) + 60) //Spieler nah genug für umdrehen
{
float DistanzX = Mathe.Distanzberechnung(new Vector2(PositionCurrent.X + (Texturmaße.X / 2), PositionCurrent.Y + (Texturmaße.Y / 2)), new Vector2(player.PositionCurrent.X + 640, player.PositionCurrent.Y));
if ((PositionCurrent.X + (Texturmaße.X / 2) < player.PositionCurrent.X + 640) && (Blickrichtung == Richtung.Links)) Blickrichtung = Richtung.Rechts;
if ((PositionCurrent.X + (Texturmaße.X / 2) > player.PositionCurrent.X + 640) && (Blickrichtung == Richtung.Rechts)) Blickrichtung = Richtung.Links;
if (DistanzX < (Texturmaße.X / 2) + 40) //Spieler nah genug für Angriff
{
ChangeStatus(Enemystate.Attack);
player.DepressionSoll += (float)35 / 100;
}
}
break;
case Enemystate.Attack:
if (Animation.Abgeschlossen) ChangeStatus(Enemystate.Idle);
break;
}
Animation.Update(elapsed);
}
private void WagenNachRechts_Click(object sender, RoutedEventArgs e)
{
WagenRichtung = Richtung.nachRechts;
}
/// <summary>
/// Stein wird im Spielfeld in die gewünschte Richtung verschoben
/// </summary>
/// <param name="einSpielstein"></param>
/// <param name="richtung"></param>
private void Verschieben(Spielstein einSpielstein, Richtung richtung)
{
Loeschen(einSpielstein);
einSpielstein.Verschieben(richtung);
Setzen(einSpielstein);
}
public void VerschiebeInRichtung(Richtung richtung)
{
Position positionNeu = PositionInRichtung(richtung);
position.X = positionNeu.X();
position.Y = positionNeu.Y();
}
