// Use this for initialization
void Start()
{
gamestate = GameObject.Find("GameSetup").GetComponent<Gamestate>();
maxlength = 1.5f;
DistanciaEntreB = 3.0f;
anim = papito.GetComponent<Animator>();
P1 = GameObject.FindGameObjectWithTag ("Player1").GetComponent<Animator>();
P2 = GameObject.FindGameObjectWithTag ("Player2").GetComponent<Animator>();
}
public void Lost()
{
if (ignoreTrigger) {
ignoreTrigger = false;
return;
}
Debug.Log("lost game");
gamestate = Gamestate.Lost;
goalRenderer.enabled = false;
bgRenderer.sprite = LostSprite;
}
public void Update(Vector2 spieler, bool mouseovergui, Gamestate gamestate)
{
CurrentMousestate = Mouse.GetState();
if (gamestate != Gamestate.Game) //Im Spiel nur Zoom benötigt
{
if (Settings.Widescreen) Mouseposition = new Vector2(CurrentMousestate.X, ((float)CurrentMousestate.Y / 720) * 1024);
else Mouseposition = new Vector2(CurrentMousestate.X, CurrentMousestate.Y);
FensterVerschieben();
Buttons(mouseovergui);
}
Scrollwheel(gamestate);
OldMousestate = CurrentMousestate;
}
// Use this for initialization
void Start()
{
estado = GameObject.Find("GameSetup").GetComponent<Gamestate>();
r1 = GameObject.Find("first1").GetComponent<SpriteRenderer>();
r2 = GameObject.Find("first2").GetComponent<SpriteRenderer>();
r3 = GameObject.Find("first3").GetComponent<SpriteRenderer>();
r4 = GameObject.Find("first4").GetComponent<SpriteRenderer>();
r5 = GameObject.Find("first5").GetComponent<SpriteRenderer>();
r6 = GameObject.Find("first6").GetComponent<SpriteRenderer>();
r7 = GameObject.Find("first7").GetComponent<SpriteRenderer>();
r8 = GameObject.Find("first8").GetComponent<SpriteRenderer>();
r9 = GameObject.Find("first9").GetComponent<SpriteRenderer>();
r10 = GameObject.Find("first10").GetComponent<SpriteRenderer>();
}
// Use this for initialization
void Start () {
level = 1;
gamestate = Gamestate.SetUp;
oldTickLocation = 0;
oldGoalLocation = 0;
turns = 1;
tickRenderer = tick.GetComponent<SpriteRenderer> ();
goalRenderer = goal.GetComponent<SpriteRenderer> ();
bgRenderer = bg.GetComponent<SpriteRenderer> ();
ignoreTrigger = false;
tickRenderer.enabled = false;
goalRenderer.enabled = false;
rotatingClockwise = false;
gtc = goal.GetComponent<GoalTriggerCheck> ();
Setup ();
}
void Start()
{
state = GetComponent<Gamestate>();
r01 = GameObject.Find("p1").GetComponent<SpriteRenderer>().transform;
r02 = GameObject.Find("p2").GetComponent<SpriteRenderer>().transform;
r1 = GameObject.Find("first1").GetComponent<SpriteRenderer>().transform;
r2 = GameObject.Find("first2").GetComponent<SpriteRenderer>().transform;
r3 = GameObject.Find("first3").GetComponent<SpriteRenderer>().transform;
r4 = GameObject.Find("first4").GetComponent<SpriteRenderer>().transform;
r5 = GameObject.Find("first5").GetComponent<SpriteRenderer>().transform;
r6 = GameObject.Find("first6").GetComponent<SpriteRenderer>().transform;
r7 = GameObject.Find("first7").GetComponent<SpriteRenderer>().transform;
r8 = GameObject.Find("first8").GetComponent<SpriteRenderer>().transform;
r9 = GameObject.Find("first9").GetComponent<SpriteRenderer>().transform;
r10 = GameObject.Find("first10").GetComponent<SpriteRenderer>().transform;
}
public void Draw(Gamestate gamestate, SpriteBatch spriteBatch, GraphicsDevice device)
{
if (gamestate == Gamestate.Game)
{
foreach (Background background in Backgrounds)
{
background.Draw(spriteBatch, device, Color.White, Player.PositionCurrent);
}
}
else if (gamestate == Gamestate.Editor)
{
foreach (Background background in Backgrounds)
{
if (background == Editor.AuswahlHintergrund) background.Draw(spriteBatch, device, new Color(255, 60, 60), Player.PositionCurrent);
else background.Draw(spriteBatch, device, Color.White, Player.PositionCurrent);
}
}
}
public void Update(Gamestate gamestate, float elapsed)
{
foreach (Enemy enemy in Delete)
{
Enemys.Remove(enemy);
}
Delete.Clear();
if (gamestate == Gamestate.Game)
{
foreach (Enemy enemy in Enemys)
{
enemy.Update(elapsed, Player);
}
}
}
public ReturnButton(Position position, Gamestate gamestate, Texture backgroundTexture, ScreenType screenToReturn) : base(position, gamestate, backgroundTexture, 0.6F)
{
ScreenToReturn = screenToReturn;
}
void MouseClicked(int x, int y)
{
mouseClick = new Rectangle(x, y, 10, 10);
if (gameState == Gamestate.StartMenu)
{
if (mouseClick.Intersects(playButton))
{
gameState = Gamestate.Playing;
IsMouseVisible = false;
}
else if (mouseClick.Intersects(exitButton))
{
Exit();
}
}
}
public MainGame()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
gameState = new Gamestate(this);
}
public Symbol(SymbolData symbolData, Gamestate gamestate) : this(symbolData.texture, symbolData.color, gamestate)
{
}
protected override void Update(GameTime gameTime)
{
if (Keyboard.GetState().IsKeyDown(Keys.Escape))
this.Exit();
oldMouseState = mouseState;
mouseState = Mouse.GetState();
Point mousePoint = new Point(mouseState.X, mouseState.Y);
oldKeyboardState = keyboardState;
keyboardState = Keyboard.GetState();
switch (currentGameState)
{
case Gamestate.Start:
if (keyboardState.IsKeyDown(Keys.Enter) && oldKeyboardState.IsKeyUp(Keys.Enter))
{
currentGameState = Gamestate.randomPlacePieces;
}
break;
case Gamestate.randomPlacePieces:
if (keyboardState.IsKeyDown(Keys.Enter) && !oldKeyboardState.IsKeyDown(Keys.Enter))
{
currentGameState = Gamestate.rePlacePieces1;
}
break;
case Gamestate.rePlacePieces1:
HandleInput();
currentPlayer = 0;
if (mouseState.LeftButton == ButtonState.Pressed && oldMouseState.LeftButton == ButtonState.Released)
{
players[currentPlayer].UsePieces(mouseState.X, mouseState.Y, players[0], players[1]);
}
players[currentPlayer].MovePiece(mouseState.X, mouseState.Y);
if (keyboardState.IsKeyDown(Keys.Enter) && !oldKeyboardState.IsKeyDown(Keys.Enter))
{
currentGameState = Gamestate.rePlacePieces2;
players[currentPlayer].SetPiecesVisibilty(false);
}
break;
case Gamestate.rePlacePieces2:
currentPlayer = 1;
if (mouseState.LeftButton == ButtonState.Pressed && oldMouseState.LeftButton == ButtonState.Released)
{
players[currentPlayer].UsePieces(mouseState.X, mouseState.Y, players[1], players[0]);
}
players[currentPlayer].MovePiece(mouseState.X, mouseState.Y);
if (keyboardState.IsKeyDown(Keys.Enter) && !oldKeyboardState.IsKeyDown(Keys.Enter))
{
currentGameState = Gamestate.playP1;
players[currentPlayer].SetPiecesVisibilty(false);
}
break;
case Gamestate.playP1:
currentPlayer = 0;
players[currentPlayer].isPlayerVisible = false;
if (mouseState.LeftButton == ButtonState.Pressed && oldMouseState.LeftButton == ButtonState.Released)
{
if (players[1].HitPiece(mousePoint))
{
int i = 0;
i++;
}
}
if(players[1].GameOver())
{
this.Exit();
}
if (keyboardState.IsKeyDown(Keys.Enter) && !oldKeyboardState.IsKeyDown(Keys.Enter))
{
currentGameState = Gamestate.playP2;
}
break;
case Gamestate.playP2:
currentPlayer = 1;
players[currentPlayer].isPlayerVisible = false;
if (mouseState.LeftButton == ButtonState.Pressed && oldMouseState.LeftButton == ButtonState.Released)
{
players[0].HitPiece(mousePoint);
}
if (players[0].GameOver())
{
this.Exit();
}
if (keyboardState.IsKeyDown(Keys.Enter) && !oldKeyboardState.IsKeyDown(Keys.Enter))
{
currentGameState = Gamestate.playP1;
}
break;
case Gamestate.gameover:
break;
default:
break;
}
players[currentPlayer].MovePiece(mouseState.X, mouseState.Y);
base.Update(gameTime);
}
public void Win()
{
if (State != Gamestate.NONE) return;
State = Gamestate.Win;
dataObject.RemainingMoney = Player.Cash;
dataObject.didWin = true;
dataObject.ElapsedTime = ElapsedGameTime;
DontDestroyOnLoad( dataObject );
Application.LoadLevel(2);
}
protected override void Update(GameTime gameTime)
{
KEYBOARD = Keyboard.GetState();
MOUSE = Mouse.GetState();
mouse.Update();
// Update SCREEN selection.
SwitchUpdate();
if (Helper.Keypress(Keys.Escape))
{
// Toggle between menu and gameplay.
if (STATE == Gamestate.Play)
STATE = Gamestate.Menu;
else if ((STATE == Gamestate.Menu) && (PLAYER.RemainingLives() > 0))
STATE = Gamestate.Play;
}
base.Update(gameTime);
PREV_MOUSE = MOUSE;
PREV_KEYBOARD = KEYBOARD;
}
protected override void Update(GameTime gameTime)
{
loadAnimation();
#region GamestateLoading
if (gamestate == Gamestate.ladebildschirm)
{
if (start)
{
spieler.position.X = -20;
start = false;
}
if (spieler.position.X <= 512)
{
spieler.position.X++;
hintergrund.Update(3);
}
else
{
hintergrund.Update();
}
spieler.Update();
// nur die Tastenbelegung im Hud Updaten
hud.UpdateHelp();
NewKeyState = Keyboard.GetState();
if (Keyboard.GetState().IsKeyDown(Keys.Enter) && OldKeyState.IsKeyUp(Keys.Enter))
{
spieler.position.X = 1280 / 2 - 128;
start = true;
gamestate = Gamestate.running;
}
#region Tastaturabfrage
// Teleport bei Curser Taste nach Oben
if (spieler.teleport && Keyboard.GetState().IsKeyDown(Keys.Up) )
{
spieler.teleport = false;
((Fallen)spieler.fallen).beschleunigung = 0;
spieler.setPlayerPosition(10);
}
// Leertaste zum Springen
if (Keyboard.GetState().IsKeyDown(Keys.Space))
{
spieler.doSpringen();
}
// Wenn Gleiten und Leertaste loslassen dann Fallen
if (spieler.aktuellerZustand == spieler.gleiten && Keyboard.GetState().IsKeyUp(Keys.Space))
spieler.doFallen();
#endregion
OldKeyState = NewKeyState;
#region Kollisionserkennung
// Erstellen einer Liste mit Hitboxen aus Bereich 2 & 3
List<Hitbox> kollisionsListe = new List<Hitbox>();
List<Hitbox> kollisionsListeStacheln = new List<Hitbox>();
// Hitbox Listen aufbauen
foreach (Hindernis hindernis in hindernisListe.GetRange(2, 3))
{
// Stacheln Liste erstellen
foreach (Hitbox hitbox in hindernis.gibSterben())
{
kollisionsListeStacheln.Add(hitbox);
}
//Boden Liste erstellen
foreach (Hitbox hitbox in hindernis.gibHitboxen())
{
kollisionsListe.Add(hitbox);
}
}
// Boolean Werte für Kollisionserkennung (für Füße)
Boolean kollidiert = false;
// Boden Kollisionserkennung mit allen Hitboxen
// Prüfe erst alle hitboxen ab ob eine Kollision entstanden ist
// siehe boolean kollidiert
foreach (Hitbox hitbox in kollisionsListe)
{
if (spieler.hitboxFuss.Intersects(hitbox.hitboxRect))
{
kollidiert = true;
// Spieler kann sich nur ducken wenn er Läuft
if (Keyboard.GetState().IsKeyDown(Keys.Down) && spieler.aktuellerZustand != spieler.fallen)
spieler.doDucken();
else
{
spieler.teleport = true;
spieler.doLaufen();
}
spieler.setPlayerPosition(hitbox.hitboxRect.Y - 110);
}
}
// Prüfe auf Stacheln
foreach (Hitbox hitbox in kollisionsListeStacheln)
{
if (menue.spielAktiv && spieler.hitboxBeine.Intersects(hitbox.hitboxRect))
{
((Sterben)spieler.sterben).aktuell = ((Sterben)spieler.sterben).pieksen;// Passt den Todeszustand an
menue.spielAktiv = false; // setzt Menü nach Tod wieder auf anfang
spieler.setPlayerPosition((int)hitbox.hitboxPosition.Y - 80);
hud.soundGameOverSoundInstance.Play();
spieler.doSterben();
}
}
// wenn keine Kollision ist und er spieler nicht gerade am springen ist dann falle.
if (!kollidiert && spieler.aktuellerZustand != spieler.springen && spieler.aktuellerZustand != spieler.gleiten)
{
spieler.doFallen();
}
#endregion
}
#endregion
#region GamestateRunning
if (gamestate == Gamestate.running)
{
// Hud Update
hud.UpdateMitTimer(gameTime);
// Update spieler
spieler.Update();
#region Tastaturabfrage
// Teleport bei Curser Taste nach Oben
if (spieler.teleport == true && Keyboard.GetState().IsKeyDown(Keys.Up) && spieler.aktuellerZustand != spieler.sterben && spieler.aktuellerZustand != spieler.gewinnen)
{
spieler.teleport = false; // Teleportresource Verbrauchen
((Fallen)spieler.fallen).beschleunigung = 0;
spieler.setPlayerPosition(10);
}
// Leertaste zum Springen
if (Keyboard.GetState().IsKeyDown(Keys.Space))
spieler.doSpringen();
// Wenn Gleiten und Leertaste loslassen dann Fallen
if (spieler.aktuellerZustand == spieler.gleiten && Keyboard.GetState().IsKeyUp(Keys.Space))
spieler.doFallen();
// Escape ins Menü zurück kehren
if (Keyboard.GetState().IsKeyDown(Keys.Escape) && OldKeyState.IsKeyUp(Keys.Escape))
{
menue.auswahl = 2; // Auswahl auf Forsetzen bzw. Starten setzten
gamestate = Gamestate.menue;
}
if (spieler.aktuellerZustand == spieler.laufen && Keyboard.GetState().IsKeyDown(Keys.LeftControl) && Keyboard.GetState().IsKeyDown(Keys.LeftAlt) && Keyboard.GetState().IsKeyDown(Keys.Back))
{
hintergrund.aktuelleTextur = hintergrund.hintergrundTexturCheat;
spieler.aktuellerZustand = spieler.cheaten;
hud.schriftFarbe = Color.White;
gamestate = Gamestate.cheat;
cheat = true;
}
if ((spieler.aktuellerZustand == spieler.sterben || spieler.aktuellerZustand == spieler.gewinnen) && Keyboard.GetState().IsKeyDown(Keys.Enter))
{
gamestate = Gamestate.menue;
}
#endregion
#region Aktualisierung_Hindernisse_Punkte
// Aktualisiere Hindernisse (schiebe Hindernisse Weiter)
if (hindernisListe.Count > 6 && spieler.aktuellerZustand != spieler.sterben)
{
// Listen mit Punkten Clearen
punkteListeDraw.Clear();
punkteListeKollisionen.Clear();
hindernisListe[0].Update();
punkteListeDraw.AddRange(hindernisListe[0].gibPunkte());
hindernisListe[1].Update();
punkteListeDraw.AddRange(hindernisListe[1].gibPunkte());
hindernisListe[2].Update();
punkteListeKollisionen.AddRange(hindernisListe[2].gibPunkte());
hindernisListe[3].Update();
punkteListeKollisionen.AddRange(hindernisListe[3].gibPunkte());
hindernisListe[4].Update();
punkteListeDraw.AddRange(hindernisListe[4].gibPunkte());
hindernisListe[5].Update();
punkteListeDraw.AddRange(hindernisListe[5].gibPunkte());
// Wenn das Hindernis an Position 1 Außerhalb des Bildes ist lösche das Hindernis an Position 0
if (hindernisListe[1].hindernisPosition.X <= -320)
hindernisListe.RemoveAt(0);
hintergrund.Update();
}
else
hindernisListe[hindernisListe.Count - 4].UpdateAnimation();
#endregion
#region Noten/Powerup Animation aktualisierung
punkt1.punktAnimation.Update();
punkt2.punktAnimation.Update();
punkt5.punktAnimation.Update();
punkt10.punktAnimation.Update();
powerUp.punktAnimation.Update();
#endregion
#region GewonnenAktionen
if (hindernisListe.Count == 6)
{
if (spieler.aktuellerZustand == spieler.laufen)
{
spieler.doGewinnen(); // Wenn weniger als 6 Hindernisse vorhanden sind gehe in den Gewinnenzustand über
if (menue.spielAktiv)
{
menue.spielAktiv = false;
gewonnen++;
hud.gewonnen = true;
konfig.WriteFile(gewonnen.ToString());
}
}
if (hud.gewonnen)
hud.UpdateAchievment();
}
#endregion
#region PunkteKollisionen
if (spieler.aktuellerZustand != spieler.sterben)
{
foreach (NotenHitbox hitbox in punkteListeKollisionen)
{
if (spieler.hitboxKoerper.Intersects(hitbox.hitboxRect))
{
notenPlatzerAnimation.index = 0;
notenPlatzerPosition = hitbox.hitboxPosition - new Vector2(16, 16);
if (hitbox.punkt.wertigkeit != 0)
{
spieler.punkte += hitbox.punkt.wertigkeit;
hitbox.zielPosition += new Vector2(new Random().Next(640), new Random().Next(100));
spieler.gesammelteNoten.Add(hitbox);
hitbox.platzerAnimation = new Animation(notenPlatzerTextur, 2, 2, 5);
}
else
spieler.teleport = true;
hitbox.hindernis.loescheHitboxPunkt(hitbox);
hitbox.punkt.playSound();
}
}
}
#endregion
#region Kollisionserkennung
// Erstellen einer Liste mit Hitboxen aus Bereich 2 & 3
List<Hitbox> kollisionsListe = new List<Hitbox>();
List<Hitbox> kollisionsListeStacheln = new List<Hitbox>();
// Hitbox Listen aufbauen
foreach (Hindernis hindernis in hindernisListe.GetRange(2, 3))
{
// Stacheln Liste erstellen
foreach (Hitbox hitbox in hindernis.gibSterben())
{
kollisionsListeStacheln.Add(hitbox);
}
//Boden Liste erstellen
foreach (Hitbox hitbox in hindernis.gibHitboxen())
{
kollisionsListe.Add(hitbox);
}
}
// Boolean Werte für Kollisionserkennung (für Füße)
Boolean kollidiert = false;
// Boden Kollisionserkennung mit allen Hitboxen
// Prüfe erst alle hitboxen ab ob eine Kollision entstanden ist
// siehe boolean kollidiert
foreach (Hitbox hitbox in kollisionsListe)
{
if (spieler.hitboxFuss.Intersects(hitbox.hitboxRect))
{
kollidiert = true;
// Spieler kann sich nur ducken wenn er Läuft
if (Keyboard.GetState().IsKeyDown(Keys.Down) && spieler.aktuellerZustand != spieler.fallen)
spieler.doDucken();
else
spieler.doLaufen();
spieler.setPlayerPosition(hitbox.hitboxRect.Y - 110);
}
}
// Prüfe auf Stacheln
foreach (Hitbox hitbox in kollisionsListeStacheln)
{
if (menue.spielAktiv && spieler.hitboxBeine.Intersects(hitbox.hitboxRect))
{
((Sterben)spieler.sterben).aktuell = ((Sterben)spieler.sterben).pieksen;// Passt den Todeszustand an
menue.spielAktiv = false; // setzt Menü nach Tod wieder auf anfang
spieler.setPlayerPosition((int)hitbox.hitboxPosition.Y - 80);
hud.soundGameOverSoundInstance.Play();
spieler.doSterben();
}
}
// wenn keine Kollision ist und er spieler nicht gerade am springen ist dann falle.
if (!kollidiert && spieler.aktuellerZustand != spieler.springen && spieler.aktuellerZustand != spieler.gleiten)
{
spieler.doFallen();
}
// Kopf Kollisionserkennung
if (menue.spielAktiv && spieler.aktuellerZustand == spieler.laufen)
{
foreach (Hitbox hitbox in kollisionsListe)
{
if (spieler.hitboxKopf.Intersects(hitbox.hitboxRect)) // Wenn Kopf kollidiert
{
((Sterben)spieler.sterben).aktuell = ((Sterben)spieler.sterben).koepfen;// Passt den Todeszustand an
menue.spielAktiv = false; // setzt Menü nach Tod wieder auf anfang
hud.soundGameOverSoundInstance.Play();
spieler.doSterben();
}
if (spieler.hitboxBeine.Intersects(hitbox.hitboxRect)) // Wenn Beine kollidiert
{
((Sterben)spieler.sterben).aktuell = ((Sterben)spieler.sterben).stolpern; // Passt den Todeszustand an
menue.spielAktiv = false; // setzt Menü nach Tod wieder auf anfang
hud.soundGameOverSoundInstance.Play();
spieler.doSterben();
}
}
}
else if (menue.spielAktiv) // Kollisionerkennung im Flug/Fallen/Gleiten
{
foreach (Hitbox hitbox in kollisionsListe) // für Sonstige Kollisionen in Zuständen die oben noch nicht abgefangen werden
{
if (spieler.position.Y > 378 && spieler.hitboxKopf.Intersects(hitbox.hitboxRect) && spieler.hitboxBeine.Intersects(hitbox.hitboxRect))
{
menue.spielAktiv = false;
((Sterben)spieler.sterben).aktuell = ((Sterben)spieler.sterben).klatscher; // Passt den Todeszustand an
hud.soundGameOverSoundInstance.Play();
spieler.doSterben();
}
else if (spieler.position.Y <= 378 && spieler.hitboxKopf.Intersects(hitbox.hitboxRect) && spieler.hitboxBeine.Intersects(hitbox.hitboxRect)) // Spieler gegen Taschenrechner
{
Console.WriteLine("Taschenrechner");
menue.spielAktiv = false;
Boolean kollidiertBoden = false;
((Sterben)spieler.sterben).aktuell.soundTod.Play();
while (!kollidiertBoden && spieler.position.Y < 900)
{
foreach (Hitbox hb in kollisionsListe)
{
if (spieler.hitboxFuss.Intersects(hb.hitboxRect))
{
kollidiertBoden = true;
}
}
spieler.movePlayerDown(1);
}
spieler.setPlayerPositionRelativ(-256);
((Sterben)spieler.sterben).aktuell = ((Sterben)spieler.sterben).klatscher_oben; // Passt den Todeszustand an
hud.soundGameOverSoundInstance.Play();
menue.spielAktiv = false;
spieler.doSterben();
}
else if (spieler.hitboxKopf.Intersects(hitbox.hitboxRect))// && !spieler.hitboxBeine.Intersects(hitbox.hitboxRect))
{
menue.spielAktiv = false;
Boolean kollidiertBoden = false;
while (!kollidiertBoden)
{
foreach (Hitbox hb in kollisionsListe)
{
if (spieler.hitboxFuss.Intersects(hb.hitboxRect) || spieler.position.Y > 720)
{ kollidiertBoden = true; }
}
spieler.movePlayerDown(1);
}
((Sterben)spieler.sterben).aktuell = ((Sterben)spieler.sterben).koepfen; // Passt den Todeszustand an
hud.soundGameOverSoundInstance.Play();
menue.spielAktiv = false;
spieler.doSterben();
}
else if (spieler.hitboxBeine.Intersects(hitbox.hitboxRect)) //&& !spieler.hitboxKopf.Intersects(hitbox.hitboxRect))
{
spieler.setPlayerPosition(hitbox.hitboxRect.Top - 80);
menue.spielAktiv = false;
((Sterben)spieler.sterben).aktuell = ((Sterben)spieler.sterben).stolpern; // Passt den Todeszustand an
spieler.doSterben();
}
}
}
}
#endregion
#region Notenfreilassen nach Tod
if (spieler.aktuellerZustand == spieler.sterben)
{
if (spieler.gesammelteNoten.Count > 0)
{
int zufall = new Random().Next(spieler.gesammelteNoten.Count % 5) + 1;
if (gameTime.TotalGameTime.Milliseconds % 500 == 0)
{
spieler.gesammelteNoten.GetRange(0, zufall).ForEach(delegate(NotenHitbox note)
{
if (spieler.position.Y > 120)
{
note.setRichtung(spieler);
}
else
note.setRichtung(spieler, new Vector2(0,256));
});
notenFreilassen.AddRange(spieler.gesammelteNoten.GetRange(0, zufall));
spieler.gesammelteNoten.RemoveRange(0, zufall);
}
}
foreach (NotenHitbox note in notenFreilassen)
{
if (note.hitboxPosition.Y <= note.zielPosition.Y)
note.faellt = false;
note.UpdateFreilassen(spieler);
}
}
#endregion
// Sterben wenn der Spieler auserhalb des Bildschirms ist
if (spieler.position.Y >= 800 && menue.spielAktiv)
{
menue.spielAktiv = false; // setzt Menü nach Tod wieder auf anfang
hud.soundGameOverSoundInstance.Play();
spieler.doSterben();
}
#region Noten/Punkte_Animation
if (spieler.aktuellerZustand == spieler.sterben)
{
if (gameTime.TotalGameTime.Milliseconds % 10 == 0)
notenFallSchrittweite++;
foreach (NotenHitbox notenhitbox in punkteListeDraw)
{
notenhitbox.Update();
if (notenhitbox.punkt.wertigkeit != 0)
{
if (notenhitbox.faellt)
{
foreach (Hitbox bodenHitbox in notenhitbox.hindernis.gibHitboxen())
{
if (notenhitbox.faellt && notenhitbox.hitboxRect.Y < 800 && !notenhitbox.hitboxRect.Intersects(bodenHitbox.hitboxRect))
{
notenhitbox.moveY(-(1 + notenFallSchrittweite));
}
else if (notenhitbox.hitboxRect.Y >= 800)
{
notenhitbox.faellt = false;
}
else if (notenhitbox.faellt)
{
notenhitbox.faellt = false;
notenhitbox.setPositionY((int)bodenHitbox.hitboxPosition.Y - 33);
}
}
}
}
}
foreach (NotenHitbox notenhitbox in punkteListeKollisionen)
{
notenhitbox.Update();
if (notenhitbox.punkt.wertigkeit != 0)
{
if (notenhitbox.faellt)
{
foreach (Hitbox bodenHitbox in notenhitbox.hindernis.gibHitboxen())
{
if (notenhitbox.faellt && notenhitbox.hitboxRect.Y < 800 && !notenhitbox.hitboxRect.Intersects(bodenHitbox.hitboxRect))
{
notenhitbox.moveY(-(1 + notenFallSchrittweite));
}
else if (notenhitbox.hitboxRect.Y >= 800)
{
notenhitbox.faellt = false;
}
else if (notenhitbox.faellt)
{
notenhitbox.faellt = false;
notenhitbox.setPositionY((int)bodenHitbox.hitboxPosition.Y - 30);
}
}
}
}
}
}
notenPlatzerPosition.X -= 4;
notenPlatzerAnimation.UpdateNoLoop();
#endregion
#endregion
#region GamestateCheat
if (gamestate == Gamestate.cheat)
{
// Hud Update
hud.Update();
// Update spieler
spieler.Update();
#region Spieler Position anpassen
// Fallen einleiten
if (hindernisListe.Count == 11)
{
zielInSicht = true;
}
// Spieler hochschieben
if (spieler.position.Y >= 80 && !zielInSicht)
{
spieler.movePlayerUp(1.5f *(float)Math.Sin((spieler.position.Y ) / 360));
}
else if (spieler.position.Y <= hindernisListe[hindernisListe.Count-1].hitboxListe[0].hitboxPosition.Y - 110) // Spieler runterschieben
{
spieler.movePlayerDown((float)Math.Sin((1200 - spieler.position.Y) / 1000));
}
else // Wenn Spieler im Ziel angekommen ist
{
hintergrund.aktuelleTextur = hintergrund.hintergrundTextur;
cheat = false;
menue.spielAktiv = false;
hud.schriftFarbe = Color.Black;
gamestate = Gamestate.running;
spieler.doGewinnen(); // Wenn weniger als 6 Hindernisse vorhanden sind gehe in den Gewinnenzustand über
}
#endregion
#region Aktualisierung_Hindernisse_Punkte
// Aktualisiere Hindernisse (schiebe Hindernisse Weiter)
if (hindernisListe.Count > 6 && spieler.aktuellerZustand != spieler.sterben)
{
// Listen mit Punkten Clearen
punkteListeDraw.Clear();
punkteListeKollisionen.Clear();
hindernisListe[0].Update();
punkteListeDraw.AddRange(hindernisListe[0].gibPunkte());
hindernisListe[1].Update();
punkteListeDraw.AddRange(hindernisListe[1].gibPunkte());
hindernisListe[2].Update();
punkteListeKollisionen.AddRange(hindernisListe[2].gibPunkte());
hindernisListe[3].Update();
punkteListeKollisionen.AddRange(hindernisListe[3].gibPunkte());
hindernisListe[4].Update();
punkteListeDraw.AddRange(hindernisListe[4].gibPunkte());
hindernisListe[5].Update();
punkteListeDraw.AddRange(hindernisListe[5].gibPunkte());
// Wenn das Hindernis an Position 1 Außerhalb des Bildes ist lösche das Hindernis an Position 0
if (hindernisListe[1].hindernisPosition.X <= -320)
hindernisListe.RemoveAt(0);
hintergrund.Update(gameTime, 1);
}
else // Wenn Spieler im Ziel, nur noch Zielanimation updaten
hindernisListe[hindernisListe.Count - 4].UpdateAnimation();
#endregion
#region Noten/Powerup Animation aktualisierung
punkt1.punktAnimation.Update();
punkt2.punktAnimation.Update();
punkt5.punktAnimation.Update();
punkt10.punktAnimation.Update();
powerUp.punktAnimation.Update();
#endregion
// Berechne Vektor für Zielbestimmung der Noten
foreach (NotenHitbox note in punkteListeKollisionen)
{
note.zielPosition = Vector2.Normalize(spieler.position + new Vector2(20, 50) - note.hitboxPosition);
note.UpdateSammeln();
}
#region Kollisionen von Noten mit Körper
foreach (NotenHitbox hitbox in punkteListeKollisionen)
{
if (spieler.hitboxKoerper.Intersects(hitbox.hitboxRect))
{
notenPlatzerAnimation.index = 0;
notenPlatzerPosition = hitbox.hitboxPosition - new Vector2(16, 16);
if (hitbox.punkt.wertigkeit != 0) // Gesammelte Noten speichern
{
spieler.punkte += hitbox.punkt.wertigkeit;
hitbox.zielPosition += new Vector2(new Random().Next(640), 0);
spieler.gesammelteNoten.Add(hitbox);
}
else
spieler.teleport = true;
hitbox.hindernis.loescheHitboxPunkt(hitbox);
hitbox.punkt.playSound();
}
}
#endregion
}
#endregion
#region GamestateMenue
if (gamestate == Gamestate.menue)
{
// Menü Animationen laden
if (menue.start_m_ani == null) menue.start_m_ani = new Animation(menue.startTextur, 1, 4, 6);
if (menue.option_m_ani == null) menue.option_m_ani = new Animation(menue.optionenTexture, 1, 4, 6);
if (menue.exit_m_ani == null) menue.exit_m_ani = new Animation(menue.exitTexture, 1, 4, 6);
if (menue.neu_m_ani == null) menue.neu_m_ani = new Animation(menue.neuTexture, 1, 4, 6);
if (menue.fortsetzen_m_ani == null) menue.fortsetzen_m_ani = new Animation(menue.fortsetzenTexture, 1, 4, 6);
// Auswahl im Menü ber Tastatur (Pfeiltasten)
NewKeyState = Keyboard.GetState();
if (Keyboard.GetState().IsKeyDown(Keys.Up) && OldKeyState.IsKeyUp(Keys.Up))
menue.prevMenue();
if (Keyboard.GetState().IsKeyDown(Keys.Down) && OldKeyState.IsKeyUp(Keys.Down))
menue.nextMenue();
if (Keyboard.GetState().IsKeyDown(Keys.Right) && OldKeyState.IsKeyUp(Keys.Right))
menue.rightMenue();
if (Keyboard.GetState().IsKeyDown(Keys.Left) && OldKeyState.IsKeyUp(Keys.Left))
menue.leftMenue();
// Auswahl ausführen
if (Keyboard.GetState().IsKeyDown(Keys.Enter) && OldKeyState.IsKeyUp(Keys.Enter))
{
switch (menue.auswahl)
{
case 0: // Beenden
this.Exit();
break;
case 1: // Optionen
gamestate = Gamestate.options;
break;
case 2: // Starten/Fortsetzen
if (!menue.spielAktiv)
{
neustart();
gamestate = Gamestate.ladebildschirm;
}
else
gamestate = Gamestate.running;
menue.spielAktiv = true;
break;
case 3: // Spieler zurücksetzen (TODO)
neustart();
gamestate = Gamestate.ladebildschirm;
menue.spielAktiv = true;
break;
}
}
OldKeyState = NewKeyState;
menue.Update();
}
#endregion
#region GamestateOptions
// Wieder ins Haupmenü zurück
if (gamestate == Gamestate.options)
{
optionen.Update();
NewKeyState = Keyboard.GetState();
int freischalten = 1;
if (gewonnen >= 1)
freischalten++;
if (gewonnen >= 5)
freischalten++;
if (gewonnen >= 10)
freischalten++;
if (Keyboard.GetState().IsKeyDown(Keys.Down) && OldKeyState.IsKeyUp(Keys.Down))
optionen.auswahl = (optionen.auswahl + 1) % freischalten;
if (Keyboard.GetState().IsKeyDown(Keys.Up) && OldKeyState.IsKeyUp(Keys.Up))
optionen.auswahl = (optionen.auswahl + freischalten - 1) % freischalten;
if (Keyboard.GetState().IsKeyDown(Keys.Enter) && OldKeyState.IsKeyUp(Keys.Enter))
{
spieler.aktuellerSkin = optionen.skinListe[optionen.auswahl];
menue.auswahl = 2;
gamestate = Gamestate.menue;
}
OldKeyState = NewKeyState;
if (Keyboard.GetState().IsKeyDown(Keys.Escape))
gamestate = Gamestate.menue;
}
#endregion
base.Update(gameTime);
}
public void Update(Gamestate gamestate, float elapsed)
{
if (gamestate == Gamestate.Game)
{
foreach (Item item in Items)
{
if (item.Update()) Delete.Add(item);
}
}
foreach (Item item in Delete)
{
Items.Remove(item);
}
Delete.Clear();
}
public void Setup()
{
gamestate = new Gamestate();
}
public Symbol(Texture texture, Color color, Gamestate gamestate) : this(texture, color, new Position(0, 0, 0, 0), gamestate)
{
}
public Symbol(SymbolData symbolData, Position position, Gamestate gamestate) : this(symbolData.texture, symbolData.color, position, gamestate)
{
}
void OnServerInitialized()
{
GameObject gamestateGO = Network.Instantiate(gamestate, Vector3.zero, Quaternion.identity, 1) as GameObject;
instantiatedGamestate = gamestateGO.GetComponent<Gamestate>();
instantiatedGamestate.SetInfo(serverRoundLength);
SpawnPlayer();
connected = true;
waiting = false;
}
// Use this for initialization
void Start()
{
GameObject gamestateGO = GameObject.FindGameObjectWithTag("Gamestate");
gamestate = gamestateGO.GetComponent<Gamestate>();
GameObject canvasGO = GameObject.FindGameObjectWithTag("MainCamera");
canvas = canvasGO.GetComponent<PixelArtistCanvas>();
if(!GetComponent<NetworkView>().isMine)
return;
gamestate.chat = new string[gamestate.chat_max_count];
for(int i = 0; i < gamestate.chat_max_count; i++)
{
gamestate.chat[i] = "";
}
lastMousePos = Vector2.zero;
curMousePos = Vector2.zero;
}
public Menuestate Update(Gamestate gamestate, Menuestate menuestate)
{
//this.Gamestate = gamestate;
this.Menuestate = menuestate;
Editor.VorschauRuecksetzen();
Keymanager.Update();
Cursor.Update(Player.PositionCurrent, Windowmanager.MouseOverGUI, gamestate);
Windowmanager.Update();
Aktionen(gamestate);
foreach (Windowelement Eingabezelle in Windowmanager.Eingabezellen) EingabezelleWertLesen(Eingabezelle);
return Menuestate;
}
private void Zahlenbereiche(Gamestate gamestate)
{
if (Mathe.ZahlImBereich(310, 349, Windowmanager.Befehl)) //Level laden Fenster
{
Levelmanager.LoadLevel(Levelmanager.Levels[Windowmanager.Befehl - 310].Name);
Editor.ChangeTool(Editortool.Start);
Windowmanager.RemoveWindow(Windowtype.Laden);
}
if (Mathe.ZahlImBereich(410, 449, Windowmanager.Befehl)) //Hintergrundtextur
{
Editor.AuswahlHintergrund.Textur = Backgrounddatabase.Backgrounds[Windowmanager.Befehl - 410].Textur;
Editor.AuswahlHintergrund.Name = Backgrounddatabase.Backgrounds[Windowmanager.Befehl - 410].Name;
Editor.ChangeTool(Editortool.Hintergrund);
}
else if (Mathe.ZahlImBereich(610, 649, Windowmanager.Befehl)) //Hintergründeauswahlfenster
{
Editor.AuswahlHintergrund = Backgroundmanager.Backgrounds[Windowmanager.Befehl - 610];
Editor.ChangeTool(Editortool.Hintergrund);
}
else if (Mathe.ZahlImBereich(810, 849, Windowmanager.Befehl)) //Objektkategorie
{
if (Editor.Tool == Editortool.Objektkategorie)
{
Editor.AuswahlObjektkategorie = Objectdatabase.Objektdaten[Windowmanager.Befehl - 810];
Editor.ChangeTool(Editortool.Objektvariante);
}
else if (Editor.Tool == Editortool.Aktion)
{
Editor.AuswahlAction.Objecttyp = Objectdatabase.Objektdaten[Windowmanager.Befehl - 810];
Editor.AuswahlAction.Wert = 0;
Editor.ChangeTool(Editortool.Event); Editor.ChangeTool(Editortool.Aktion);
}
}
else if (Mathe.ZahlImBereich(910, 949, Windowmanager.Befehl)) //Objektvariante
{
if (Editor.Tool == Editortool.Objektvariante) Editor.AuswahlObjektvariation = Editor.AuswahlObjektkategorie.Variante[Windowmanager.Befehl - 910];
else if (Editor.Tool == Editortool.Aktion)
{
Windowmanager.GetWindowOfType(Windowtype.Objektvariante).Feld = Windowmanager.GetWindowPosition(Windowtype.Objektkategorie);
Editor.AuswahlAction.Wert = Windowmanager.Befehl- 910;
Editor.ChangeTool(Editortool.Event); Editor.ChangeTool(Editortool.Aktion);
}
}
else if (Mathe.ZahlImBereich(950, 990, Windowmanager.Befehl)) //Objektvariante Vorschau
{
Editor.VorschauObjektvariation = Editor.AuswahlObjektkategorie.Variante[Windowmanager.Befehl - 950];
}
else if (Mathe.ZahlImBereich(1010, 1049, Windowmanager.Befehl)) //Eventdetails
{
Editor.AuswahlEvent = Eventmanager.Events[Windowmanager.Befehl - 1010];
Editor.ChangeTool(Editortool.Event);
}
else if (Mathe.ZahlImBereich(1100, 1124, Windowmanager.Befehl)) //Auslöser
{
Editor.AuswahlTrigger = Editor.AuswahlEvent.Triggers[Windowmanager.Befehl - 1100];
Editor.ChangeTool(Editortool.Start); /*Editor.ChangeTool(Editortool.Event);*/ Editor.ChangeTool(Editortool.Ausloeser);
}
else if (Mathe.ZahlImBereich(1125, 1149, Windowmanager.Befehl)) //Bedingungen
{
Editor.AuswahlCondition = Editor.AuswahlEvent.Conditions[Windowmanager.Befehl - 1125];
Editor.ChangeTool(Editortool.Start); /*Editor.ChangeTool(Editortool.Event);*/ Editor.ChangeTool(Editortool.Bedingung);
}
else if (Mathe.ZahlImBereich(1150, 1199, Windowmanager.Befehl)) //Aktion
{
Editor.AuswahlAction = Editor.AuswahlEvent.Actions[Windowmanager.Befehl - 1150];
Editor.ChangeTool(Editortool.Start); /*Editor.ChangeTool(Editortool.Event);*/ Editor.ChangeTool(Editortool.Aktion);
}
else if (Mathe.ZahlImBereich(1510, 1549, Windowmanager.Befehl)) //Eventelementtyp
{
if (Editor.AuswahlTrigger != null) { Editor.AuswahlTrigger.Type = (Triggertype)Enum.Parse(typeof(Triggertype), Enum.GetName(typeof(Triggertype), Windowmanager.Befehl - 1510).ToString()); Editor.ChangeTool(Editortool.Event); Editor.ChangeTool(Editortool.Ausloeser); }
else if (Editor.AuswahlCondition != null) { Editor.AuswahlCondition.Type = (Conditiontype)Enum.Parse(typeof(Conditiontype), Enum.GetName(typeof(Conditiontype), Windowmanager.Befehl - 1510).ToString()); Editor.ChangeTool(Editortool.Event); Editor.ChangeTool(Editortool.Bedingung); }
else if (Editor.AuswahlAction != null) { Editor.AuswahlAction.Type = (Actiontype)Enum.Parse(typeof(Actiontype), Enum.GetName(typeof(Actiontype), Windowmanager.Befehl - 1510).ToString()); Editor.ChangeTool(Editortool.Event); Editor.ChangeTool(Editortool.Aktion); }
}
else if (Mathe.ZahlImBereich(1610, 1649, Windowmanager.Befehl)) //Gegnertyp
{
Editor.AuswahlGegner = Enemymanager.Enemydatabase.Enemys[Windowmanager.Befehl - 1610];
}
else if (Mathe.ZahlImBereich(1650, 1690, Windowmanager.Befehl)) //Gegnertyp Vorschau
{
Editor.VorschauGegner = Enemymanager.Enemydatabase.Enemys[Windowmanager.Befehl - 1650];
}
else if (Mathe.ZahlImBereich(1710, 1749, Windowmanager.Befehl)) //Itemtyp
{
Editor.AuswahlItem = Itemmanager.Datenbank[Windowmanager.Befehl - 1710];
}
else if (Mathe.ZahlImBereich(1750, 1790, Windowmanager.Befehl)) //Itemtyp Vorschau
{
Editor.VorschauItem = Itemmanager.Datenbank[Windowmanager.Befehl - 1750];
}
else if (Mathe.ZahlImBereich(1810, 1849, Windowmanager.Befehl)) //Schalter
{
Editor.AuswahlLever = Levermanager.Levers[Windowmanager.Befehl - 1810];
Editor.ChangeTool(Editortool.Schaltereinstellungen);
}
}
// Use this for initialization
void Start()
{
difficulty = Difficulty.MEDIUM;
gameState = Gamestate.TITLE;
}
private void Collisions()
{
// TODO: Put somewhere better.
if (Helper.RightClick())
if (playerNukes > 0)
{
playerNukes--;
for (int i = 0; i < mines.Count; i++)
{
mines[i].State(3);
scores.Bump(10);
}
}
// Player/mine + mine/bullet collisions.
for (int i = 0; i < mines.Count; i++)
{
if (!DEBUG)
{
// Player/mine. Condition to not interact if it is animating an explosion.
if (Helper.CircleCollision(PLAYER.Rectangle(), mines[i].Rectangle()))
if (mines[i].ReportState() == 1)
STATE = Gamestate.Death;
}
// Bullet/mine.
for (int j = 0; j < Gun.BULLETS.Count; j++)
if ((Helper.CircleCollision(mines[i].Rectangle(), Gun.BULLETS[j].Rectangle()) && (mines[i].ReportState() != 4)))
{
Gun.BULLETS[j].State(3);
mines[i].State(4, Gun.BULLETS[j].Position());
scores.Bump(10);
}
}
// Player/bonus collision.
if (Helper.CircleCollision(PLAYER.Rectangle(), bonus.Rectangle()))
{
if (bonus.ReportType() == 1)
bonus.State(2);
PLAYER.Lives(1);
if (bonus.ReportType() == 2)
playerNukes++;
bonus.State(2);
}
}
public ChangePageButton(Position position, Gamestate gamestate, Vector2f margins, int fontSize, TextPosition horizontalPosition, TextPosition verticalPosition, string text, Action <MouseButtonEventArgs, bool> action, bool changeToNext) : base(position, gamestate, margins, fontSize, horizontalPosition, verticalPosition, text)
{
Action = action;
this.changeToNext = changeToNext;
}
protected override void Update(GameTime gameTime)
{
Menuestate TempMenuestate = Inputmanager.Update(Gamestate, Menuestate); //Input verarbeiten und resultierenden Menüzustand speichern
if (Menuestate != TempMenuestate) //Vergleich mit aktuellem Menüzustand -> Bei Änderung Menü starten und Zustand übernehmen
{
Gamestate = Gamestate.Menue;
Menuestate = TempMenuestate;
}
switch (Gamestate)
{
case Gamestate.Menue:
switch (Menuestate)
{
case Menuestate.Started:
menue.Update(gameTime);
if (Settings.Music)
{
if (BackgroundMusic.isStooped()) BackgroundMusic.changeTrackList(menueTheme);
BackgroundMusic.Update();
}
else BackgroundMusic.Stop();
break;
case Menuestate.Pause:
menue.Update(gameTime);
if (Settings.Music)
{
if (BackgroundMusic.isStooped()) BackgroundMusic.changeTrackList(menueTheme);
BackgroundMusic.Update();
}
break;
case Menuestate.New:
Gamestate = Gamestate.Game;
Windowmanager.ClearWindows();
Keymanager.TastenSpiel();
if (Settings.Music)
{
BackgroundMusic.Stop();
BackgroundMusic.changeTrackList(levelTheme);
}
break;
case Menuestate.Continue:
Gamestate = Gamestate.Game;
Windowmanager.ClearWindows();
Keymanager.TastenSpiel();
if (Settings.Music) BackgroundMusic.Resume();
break;
case Menuestate.Load: break;
case Menuestate.Save: break;
case Menuestate.Options: break;
case Menuestate.Controls: break;
case Menuestate.Credits: break;
case Menuestate.Exit:
this.Exit();
break;
case Menuestate.StartEditor:
Gamestate = Gamestate.Editor;
Editor.ChangeTool(Editortool.Start);
Windowmanager.ClearWindows();
Windowmanager.AddWindow(Windowtype.Topbar);
Windowmanager.AddWindow(Windowtype.Editor);
Keymanager.TastenEditor();
Cursor.Kamera.Zoom = 1;
break;
case Menuestate.LeaveEditor:
Gamestate = Gamestate.Game;
Windowmanager.ClearWindows();
Keymanager.TastenSpiel();
break;
}
break;
case Gamestate.Game:
//IsMouseVisible = false;
DepressionHandler.Update();
if (onGo > 0) modShader();
Animationsmanager.Update((float)gameTime.ElapsedGameTime.TotalSeconds);
Player.Update((float)gameTime.ElapsedGameTime.TotalSeconds);
Backgroundmanager.Update();
Objectmanager.Update();
Levermanager.Update();
Itemmanager.Update(Gamestate, (float)gameTime.ElapsedGameTime.TotalSeconds);
Enemymanager.Update(Gamestate, (float)gameTime.ElapsedGameTime.TotalSeconds);
if (Player.Playerstate != Playerstates.Dead) Eventmanager.Update();
//testEmitter.Update(gameTime);
//rainEmitter.Update(gameTime);
if (Settings.Sound) light.checkDistanze(Player.PositionCurrent);
//rain.checkDistanze(Player.PositionCurrent);
if (Settings.Music) BackgroundMusic.Update();
break;
case Gamestate.Editor:
//IsMouseVisible = true;
Animationsmanager.Update((float)gameTime.ElapsedGameTime.TotalSeconds);
Editor.Update();
Itemmanager.Update(Gamestate, (float)gameTime.ElapsedGameTime.TotalSeconds);
Enemymanager.Update(Gamestate, (float)gameTime.ElapsedGameTime.TotalSeconds);
Backgroundmanager.Update();
Objectmanager.Update();
break;
//case Gamestate.Exit:
// this.Exit();
// break;
}
Debug.Update();
base.Update(gameTime);
}
private void NewGame()
{
collated = false;
scores.Reset();
PLAYER.Lives(5);
playerNukes = 1;
for (int i = 0; i < mines.Count; i++)
mines[i].State(2);
STATE = Gamestate.Play;
}
private void Aktionen(Gamestate gamestate)
{
//Keyboardaktionen--------------------------------------------------------------------------------------------------------------------------------------
for (int i = 0; i < Keymanager.Befehle.Count(); i++)
{
switch (Keymanager.Befehle[i])
{
//Spiel
case 1: Player.Accelerate(Richtung.Hoch); break;
case 2: Player.Accelerate(Richtung.Runter); break;
case 3: Player.Accelerate(Richtung.Links); break;
case 4: Player.Accelerate(Richtung.Rechts); break;
case 5: Levermanager.Use(); break;
case 6: Player.DepressionEnabled = !Player.DepressionEnabled; break;
//Kamera
//case 5: Camera.Update(Richtung.Rechts); break;
//case 6: Camera.Update(Richtung.Links); break;
//case 7: Camera.Update(Richtung.Hoch); break;
//case 8: Camera.Update(Richtung.Runter); break;
//Debug & Menue
// Debug Toogle
case 20: DebugView.setFlag(DebugFlag.PlayerStats, false); break;
case 21: DebugView.setFlag(DebugFlag.CollisonShape, true); break;
case 22: DebugView.setFlag(DebugFlag.ObjectInformation, true); break;
case 23: DebugView.setFlag(DebugFlag.ObjectmanagerStats, false); break;
case 24: DebugView.setFlag(DebugFlag.EditorStats, false); break;
case 25: DebugView.setFlag(DebugFlag.Inputstats, false); break;
case 26: DebugView.setFlag(DebugFlag.KammeraStats, false); break;
case 27: DebugView.setFlag(DebugFlag.Pertikle, true); break;
case 28: DebugView.setFlag(DebugFlag.BackgrundStats, false); break;
case 29: DebugView.setFlag(DebugFlag.WindowStats, false); break;
//Depression Flags
case 40: Depression.setFlag(DepressionState.InvertMove); break;
case 41: Depression.setFlag(DepressionState.Slow); break;
case 42: Depression.setFlag(DepressionState.InvertScreen); break;
case 43: Depression.setFlag(DepressionState.ModifyWorld); break;
case 44: Depression.setFlag(DepressionState.ReduceFOV); break;
case 45: Depression.setFlag(DepressionState.Srink); break;
case 46: Depression.setFlag(DepressionState.GrayScal); break;
//case 11: if (Menuestate == Menuestate.Pause) Menuestate = Menuestate.Continue; else if (gamestate != Gamestate.Menue) { Menuestate = Menuestate.Pause; Windowmanager.AddWindow(Windowtype.MainMenue); Keymanager.TastenMenü(); bg.Stop(); } break; //Gamestate = Gamestate.Exit; break;
case 11:
switch (gamestate)
{
case Gamestate.Editor: if (Editor.VectorWaehlen) Editor.VectorWaehlen = false; else { Menuestate = Menuestate.Pause; Windowmanager.AddWindow(Windowtype.MainMenue); Keymanager.TastenMenü(); bg.Stop(); } break;
case Gamestate.Game: Menuestate = Menuestate.Pause; Windowmanager.AddWindow(Windowtype.MainMenue); Keymanager.TastenMenü(); bg.Stop(); break;
case Gamestate.Menue: if (Menuestate == Menuestate.Pause) Menuestate = Menuestate.Continue; break;
}
break;
case 997: if (Menuestate != Menuestate.Started) Menuestate = Menuestate.StartEditor; break; //Gamestate = Gamestate.Editor; Editor.Starten(); break;
case 998: Debug = !Debug; break;
case 999: Collision = !Collision; break;
//Editor
case 2000: Player.PositionCurrent.X -= Editor.AuswahlScrolling; break;
case 2001: Player.PositionCurrent.X += Editor.AuswahlScrolling; break;
case 2002: Menuestate = Menuestate.LeaveEditor; break; //Gamestate = Gamestate.Game; Editor.Beenden(); break;
//Eingabezellen
case 3001: Editor.AuswahlLayer = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3002: Editor.AuswahlScrolling = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3003: Editor.AuswahlSkalierung = (float)Convert.ToDouble(Keymanager.Texteingabe) / 100; break;
case 3004: Editor.Raster = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3005: Editor.AuswahlHintergrund.versatzY = Convert.ToInt32(Keymanager.Texteingabe); Backgroundmanager.Update(); break;
case 3006: Editor.AuswahlHintergrund.Scrollgeschwindigkeit.X = (float)Convert.ToDouble(Keymanager.Texteingabe) / 100; break;
case 3007: Editor.AuswahlHintergrund.Scrollgeschwindigkeit.Y = (float)Convert.ToDouble(Keymanager.Texteingabe) / 100; break;
case 3008: Editor.AuswahlHintergrund.Transparenz = (float)Convert.ToDouble(Keymanager.Texteingabe) / 100; break;
case 3009: Editor.ChangeTool(Editortool.Start); Editor.NewLevel(Keymanager.Texteingabe); break;
case 3010: Editor.AuswahlEvent.Name = Keymanager.Texteingabe; break;
case 3016: Editor.AuswahlTrigger.Position.X = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3017: Editor.AuswahlTrigger.Wert = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3019: Editor.AuswahlCondition.Position.X = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3020: Editor.AuswahlCondition.Depression = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3022: Editor.AuswahlEvent.CooldownStart = Convert.ToInt32(Keymanager.Texteingabe) * 60; break;
case 3024: Editor.AuswahlAction.Wert = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3033: Levelmanager.AktuellesLevel.Walkline = Convert.ToInt32(Keymanager.Texteingabe);
Player.Ground = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3036: Levelmanager.AktuellesLevel.DepressionRate = (float)Convert.ToDouble(Keymanager.Texteingabe) / 100;
Player.DepressionRate = (float)Convert.ToDouble(Keymanager.Texteingabe) / 100; break;
case 3037: Editor.RasterOffset = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3038: Levelmanager.AktuellesLevel.VordergrundAbdunkelung = Convert.ToInt32((Convert.ToDouble(Keymanager.Texteingabe) / 100) * 255); break;
case 3039: Editor.AuswahlLever.Name = Keymanager.Texteingabe; break;
case 3046: Editor.AuswahlAction.Layer = Convert.ToInt32(Keymanager.Texteingabe); break;
case 3048: Editor.AuswahlAction.Skalierung = (float)Convert.ToDouble(Keymanager.Texteingabe) / 100; break;
case 3054: Editor.Autosaveintervall = Convert.ToInt32(Keymanager.Texteingabe) * 60; break;
//case 3055: Editor.AuswahlHintergrund.Startposition = Convert.ToInt32(Keymanager.Texteingabe); break;
//case 3056: Editor.AuswahlHintergrund.Endposition = Convert.ToInt32(Keymanager.Texteingabe); break;
}
}
//UI-Aktionen-------------------------------------------------------------------------------------------------------------------------------------------
switch (Windowmanager.Befehl)
{
//Hauptmenü
case 1: Menuestate = Menuestate.New; break;
//case 2: Menuestate = Menuestate.Load; break;
case 3: Menuestate = Menuestate.Exit; Levelmanager.AutoSaveEditor(); break;
//case 4: Menuestate = Menuestate.Settings; break;
//Editor: Toolfenster
case 10: Windowmanager.AddWindow(Windowtype.Editor); break;
case 11: Windowmanager.RemoveWindow(Windowtype.Editor); break;
case 12: Windowmanager.AddWindow(Windowtype.Infofenster); break;
case 13: Editor.ChangeTool(Editortool.Editoreinstellungen); break;
case 14: Editor.ChangeTool(Editortool.Laden); break;
case 15: Levelmanager.SaveLevelEditor(); Editor.RückmeldungAnzeigen = 100; break;
case 16: Editor.ChangeTool(Editortool.Leveleinstellungen); break;
case 17: Editor.ChangeTool(Editortool.Hintergruende); break;
case 18: Editor.ChangeTool(Editortool.Objektkategorie); break;
case 19: Editor.ChangeTool(Editortool.Events); break;
case 20: Editor.ChangeTool(Editortool.Gegner); break;
case 21: Editor.ChangeTool(Editortool.Items); break;
case 22: Editor.ChangeTool(Editortool.Schalter); break;
case 29: Menuestate = Menuestate.LeaveEditor; break; //Gamestate = Gamestate.Game; Editor.Beenden(); break;
case 30: Menuestate = Menuestate.Exit; Levelmanager.AutoSaveEditor(); break; //Gamestate = Gamestate.Exit; break;
case 31: Editor.ChangeTool(Editortool.Neu); break;
//Editor: Infofenster
case 100: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Infofenster); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Infofenster).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Infofenster).Feld.Y); break; //Fenster verschieben
case 101: Windowmanager.RemoveWindow(Windowtype.Infofenster); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
case 102: Editor.Rasterplatzierung = false; break;
case 103: Editor.Rasterplatzierung = true; break;
case 104: Editor.AuswahlRichtung = Richtung.Links; break;
case 105: Editor.AuswahlRichtung = Richtung.Rechts; break;
//Editor: Editoreinstellungsfenster
case 200: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Editoreinstellungen); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Editoreinstellungen).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Editoreinstellungen).Feld.Y); break; //Fenster verschieben
case 201: Windowmanager.RemoveWindow(Windowtype.Editoreinstellungen); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//Editor: Editoreinstellungsfenster
case 298: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Neu); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Neu).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Neu).Feld.Y); break; //Fenster verschieben
case 299: Windowmanager.RemoveWindow(Windowtype.Neu); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//Editor: Map-Laden Fenster
case 300: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Laden); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Laden).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Laden).Feld.Y); break; //Fenster verschieben
case 301: Windowmanager.RemoveWindow(Windowtype.Laden); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//310-349 als Bereich vergeben
//Editor: Hintergrundtextur Fenster
case 400: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Hintergrundtextur); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Hintergrundtextur).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Hintergrundtextur).Feld.Y); break; //Fenster verschieben
case 401: Windowmanager.RemoveWindow(Windowtype.Hintergrundtextur); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//410-449 als Bereich vergeben
//Editor: Leveleinstellungsfenster
case 500: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Leveleinstellungen); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Leveleinstellungen).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Leveleinstellungen).Feld.Y); break; //Fenster verschieben
case 501: Windowmanager.RemoveWindow(Windowtype.Leveleinstellungen); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
case 502:
if (Levelmanager.AktuellesLevel.Name != "Stadt")
{
System.IO.Directory.Delete(@"Levels\" + Levelmanager.AktuellesLevel.Name, true);
Levelmanager.Levels.Remove(Levelmanager.AktuellesLevel);
Levelmanager.LoadLevel("Stadt");
}
break;
//Editor: Hintergründeauswahlfenster
case 600: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Hintergruende); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Hintergruende).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Hintergruende).Feld.Y); break; //Fenster verschieben
case 601: Windowmanager.RemoveWindow(Windowtype.Hintergruende); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//610-649 als Bereich vergeben
case 650: Backgroundmanager.Backgrounds.Add(new Background("Neu", new Vector2(0, 0), 1.0f, 0, 0, 0, Contentmanager));
Editor.ChangeTool(Editortool.Start); Editor.ChangeTool(Editortool.Hintergruende); //Hintergrundsliste neu Laden für Buttonerstellung
break;
//Editor: Hintergrundoptionsfenster
case 700: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Hintergrund); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Hintergrund).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Hintergrund).Feld.Y); break; //Fenster verschieben
case 701: Windowmanager.RemoveWindow(Windowtype.Hintergrund); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
case 702: Editor.ChangeTool(Editortool.Hintergruende); break; //Zurück
//710-749 als Bereich vergeben
case 750: Editor.ChangeTool(Editortool.Hintergrundtextur); break;
case 751:
int TempInt = Backgroundmanager.Backgrounds.IndexOf(Editor.AuswahlHintergrund);
if (TempInt < Backgroundmanager.Backgrounds.Count() - 1)
{
Background TempBackground = Backgroundmanager.Backgrounds[Backgroundmanager.Backgrounds.IndexOf(Editor.AuswahlHintergrund) + 1];
Backgroundmanager.Backgrounds[TempInt + 1] = Backgroundmanager.Backgrounds[TempInt];
Backgroundmanager.Backgrounds[TempInt] = TempBackground;
}
break;
case 752:
TempInt = Backgroundmanager.Backgrounds.IndexOf(Editor.AuswahlHintergrund);
if (Backgroundmanager.Backgrounds.IndexOf(Editor.AuswahlHintergrund) > 0)
{
Background TempBackground = Backgroundmanager.Backgrounds[TempInt - 1];
Backgroundmanager.Backgrounds[TempInt - 1] = Backgroundmanager.Backgrounds[TempInt];
Backgroundmanager.Backgrounds[TempInt] = TempBackground;
}
break;
case 753:
Backgroundmanager.Backgrounds.Remove(Editor.AuswahlHintergrund);
Editor.ChangeTool(Editortool.Hintergruende);
break;
//Editor: Objektkategoriefenster
case 800: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Objektkategorie); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Objektkategorie).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Objektkategorie).Feld.Y); break; //Fenster verschieben
case 801: Windowmanager.RemoveWindow(Windowtype.Objektkategorie); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//810-849 als Bereich vergeben
//Editor: Objektvariationsfenster
case 900: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Objektvariante); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Objektvariante).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Objektvariante).Feld.Y); break; //Fenster verschieben
case 901: Windowmanager.RemoveWindow(Windowtype.Objektvariante); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
case 902: if (Editor.Tool == Editortool.Objektvariante) Editor.ChangeTool(Editortool.Objektkategorie);
else if (Editor.Tool == Editortool.Aktion) { Editor.ChangeTool(Editortool.Event); Editor.ChangeTool(Editortool.Aktion); } break; //Zurück
//910-949 als Bereich vergeben -> Auswahl
//950-990 als Bereich vergeben -> Vorschau
//Editor: Eventsfenster
case 1000: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Events); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Events).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Events).Feld.Y); break; //Fenster verschieben
case 1001: Windowmanager.RemoveWindow(Windowtype.Events); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//1110-1149 als Bereich vergeben
case 1050: Eventmanager.NewEvent(); //Neues Event
Editor.ChangeTool(Editortool.Start); Editor.ChangeTool(Editortool.Events); break; //Eventliste neu Laden für Buttonerstellung
//Editor: Eventfenster
case 1060: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Event); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Event).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Event).Feld.Y); break; //Fenster verschieben
case 1061: Windowmanager.RemoveWindow(Windowtype.Event); //Fenster schließen
Windowmanager.RemoveWindow(Windowtype.Ausloeser);
Windowmanager.RemoveWindow(Windowtype.Bedingung);
Windowmanager.RemoveWindow(Windowtype.Aktion);
Editor.ChangeTool(Editortool.Start);
break;
case 1062: Editor.ChangeTool(Editortool.Events); break; //Zurück
case 1063: Editor.AuswahlEvent.Triggers.Add(new Eventtrigger(Enemymanager, Mathe, Player)); //Neuer Auslöser
Editor.ChangeTool(Editortool.Start); Editor.ChangeTool(Editortool.Event); break; //Eventfenster neu Laden für Buttonerstellung
case 1064: Editor.AuswahlEvent.Conditions.Add(new Eventcondition(Mathe, Player)); //Neue Bedingung
Editor.ChangeTool(Editortool.Start); Editor.ChangeTool(Editortool.Event); break; //Eventfenster neu Laden für Buttonerstellung
case 1065: Editor.AuswahlEvent.Actions.Add(new Eventaction(Mathe, Player, Levelmanager, Enemymanager, Depression, Eventmanager, Objectmanager, Objectdatabase,bg)); //Neue Aktion
Editor.ChangeTool(Editortool.Start); Editor.ChangeTool(Editortool.Event); break; //Eventfenster neu Laden für Buttonerstellung
case 1066: Eventmanager.Events.Remove(Editor.AuswahlEvent); Editor.ChangeTool(Editortool.Events); break; //Event löschen
//1100-1199 als Bereich vergeben
//Editor: Eventausloeser
case 1200: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Ausloeser); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Ausloeser).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Ausloeser).Feld.Y); break; //Fenster verschieben
case 1201: Editor.ChangeTool(Editortool.Event); break; //Zurück
case 1209: Editor.AuswahlEvent.Triggers.Remove(Editor.AuswahlTrigger); Editor.ChangeTool(Editortool.Event); break; //Auslöser löschen
//1210-1249 als Bereich vergeben
//Editor: Eventbedingung
case 1300: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Bedingung); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Bedingung).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Bedingung).Feld.Y); break; //Fenster verschieben
case 1301: Editor.ChangeTool(Editortool.Event); break; //Zurück
case 1309: Editor.AuswahlEvent.Conditions.Remove(Editor.AuswahlCondition); Editor.ChangeTool(Editortool.Event); break; //Bedingung löschen
//1310-1349 als Bereich vergeben
//Editor: Eventaktion
case 1400: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Aktion); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Aktion).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Aktion).Feld.Y); break; //Fenster verschieben
case 1401: Editor.ChangeTool(Editortool.Event); break; //Zurück
case 1409: Editor.AuswahlEvent.Actions.Remove(Editor.AuswahlAction); Editor.ChangeTool(Editortool.Event); break; //Aktion löschen
//1410-1449 als Bereich vergeben
//Editor: Eventelementtyp
case 1500: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Typ); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Typ).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Typ).Feld.Y); break; //Fenster verschieben
//case 1501: Windowmanager.RemoveWindow(Windowtype.Typ); break; //Fenster schließen
case 1501: if (Editor.AuswahlTrigger != null) Editor.ChangeTool(Editortool.Ausloeser);
else if (Editor.AuswahlCondition != null) Editor.ChangeTool(Editortool.Bedingung);
else if (Editor.AuswahlAction != null) Editor.ChangeTool(Editortool.Aktion);
break; //Zurück
//1510-1549 als Bereich vergeben
//Editor: Gegnerfenster
case 1600: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Gegner); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Gegner).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Gegner).Feld.Y); break; //Fenster verschieben
case 1601: Windowmanager.RemoveWindow(Windowtype.Gegner); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//1610-1649 als Bereich vergeben -> Auswahl
//1650-1690 als Bereich vergeben -> Vorschau
//Editor: Itemfenster
case 1700: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Items); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Items).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Items).Feld.Y); break; //Fenster verschieben
case 1701: Windowmanager.RemoveWindow(Windowtype.Items); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//1710-1749 als Bereich vergeben -> Auswahl
//1750-1790 als Bereich vergeben -> Vorschau
//Editor: Schalterfenster
case 1800: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Lever); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Lever).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Lever).Feld.Y); break; //Fenster verschieben
case 1801: Windowmanager.RemoveWindow(Windowtype.Lever); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
case 1802: Editor.ChangeTool(Editortool.Schalter); break; //Zurück
case 1803: Editor.VectorWaehlen = true; break;
case 1809: Levermanager.Levers.Remove(Editor.AuswahlLever); Editor.ChangeTool(Editortool.Schalter); break; //Schalter löschen
//1810-1849 als Bereich vergeben -> Auswahl
case 1850: Levermanager.AddLever();
Editor.ChangeTool(Editortool.Start); Editor.ChangeTool(Editortool.Schalter); break; //Schalterliste neu Laden für Buttonerstellung
//Editor: Schaltereinstellungsfenster
case 1900: Cursor.Fenster = Windowmanager.GetWindowOfType(Windowtype.Levers); Cursor.Bezugspunkt = new Vector2(Cursor.Mouseposition.X - Windowmanager.GetWindowOfType(Windowtype.Levers).Feld.X, Cursor.Mouseposition.Y - Windowmanager.GetWindowOfType(Windowtype.Levers).Feld.Y); break; //Fenster verschieben
case 1901: Windowmanager.RemoveWindow(Windowtype.Levers); Editor.ChangeTool(Editortool.Start); break; //Fenster schließen
//Eingabezellen
case 3000: Editor.AnzeigenKollision = !Editor.AnzeigenKollision; break;
case 3001: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Infofenster), 5); break;
case 3002: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Editoreinstellungen), 4); break;
case 3003: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Infofenster), 11); break;
case 3004: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Infofenster), 15); break;
case 3005: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Hintergrund), 7); break;
case 3006: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Hintergrund), 9); break;
case 3007: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Hintergrund), 11); break;
case 3008: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Hintergrund), 13); break;
case 3009: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Neu), 3); break;
case 3010: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Event), 6); break;
case 3011: Editor.ChangeTool(Editortool.Typ); break;
case 3012: Editor.Rasterplatzierung = !Editor.Rasterplatzierung; break;
case 3013: if (Editor.AuswahlRichtung == Richtung.Links) Editor.AuswahlRichtung = Richtung.Rechts; else Editor.AuswahlRichtung = Richtung.Links; break;
case 3014: switch (Editor.AuswahlObjektebene)
{
case Objektebene.Hintergrund: Editor.AuswahlObjektebene = Objektebene.Spielfeld; break;
case Objektebene.Spielfeld: Editor.AuswahlObjektebene = Objektebene.Vordergrund; break;
case Objektebene.Vordergrund: Editor.AuswahlObjektebene = Objektebene.Hintergrund; break;
}
break;
case 3015: Editor.AuswahlEvent.Repeat = !Editor.AuswahlEvent.Repeat; break;
case 3016: Editor.VectorWaehlen = true; break;
case 3017: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Ausloeser), 5); break;
case 3018: Editor.AuswahlTrigger.Ausrichtung = !Editor.AuswahlTrigger.Ausrichtung; break;
case 3019: switch (Editor.AuswahlAction.Gegneraktion)
{
case Gegneraktionstyp.Erstellen: Editor.AuswahlAction.Gegneraktion = Gegneraktionstyp.Entfernen; break;
case Gegneraktionstyp.Entfernen: Editor.AuswahlAction.Gegneraktion = Gegneraktionstyp.Status; break;
case Gegneraktionstyp.Status: Editor.AuswahlAction.Gegneraktion = Gegneraktionstyp.Erstellen; break;
}
Editor.ChangeTool(Editortool.Event); Editor.ChangeTool(Editortool.Aktion);
break;
case 3020: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Bedingung), 5); break;
case 3021: Editor.AuswahlCondition.Ausrichtung = !Editor.AuswahlCondition.Ausrichtung; break;
case 3022: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Event), 13); break;
case 3023: Editor.AuswahlAction.Ausrichtung = !Editor.AuswahlAction.Ausrichtung; break;
case 3024: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Aktion), 7); break;
case 3025: switch (Editor.AuswahlAction.DepressionState)
{
case DepressionState.GrayScal: Editor.AuswahlAction.DepressionState = DepressionState.InvertMove; break;
case DepressionState.InvertMove: Editor.AuswahlAction.DepressionState = DepressionState.InvertScreen; break;
case DepressionState.InvertScreen: Editor.AuswahlAction.DepressionState = DepressionState.ModifyWorld; break;
case DepressionState.ModifyWorld: Editor.AuswahlAction.DepressionState = DepressionState.ReduceFOV; break;
case DepressionState.ReduceFOV: Editor.AuswahlAction.DepressionState = DepressionState.Slow; break;
case DepressionState.Slow: Editor.AuswahlAction.DepressionState = DepressionState.Srink; break;
case DepressionState.Srink: Editor.AuswahlAction.DepressionState = DepressionState.GrayScal; break;
}
break;
case 3026: switch (Editor.AuswahlAction.Effektwechsel)
{
case Effektwechsel.Einschalten: Editor.AuswahlAction.Effektwechsel = Effektwechsel.Ausschalten; break;
case Effektwechsel.Ausschalten: Editor.AuswahlAction.Effektwechsel = Effektwechsel.Umschalten; break;
case Effektwechsel.Umschalten: Editor.AuswahlAction.Effektwechsel = Effektwechsel.Einschalten; break;
}
break;
case 3027: switch (Editor.AuswahlAction.Gegnertyp)
{
case Enemytype.Greif: Editor.AuswahlAction.Gegnertyp = Enemytype.Messerkreatur; break;
case Enemytype.Messerkreatur: Editor.AuswahlAction.Gegnertyp = Enemytype.Schatten; break;
case Enemytype.Schatten: Editor.AuswahlAction.Gegnertyp = Enemytype.Wolf; break;
case Enemytype.Wolf: Editor.AuswahlAction.Gegnertyp = Enemytype.Greif; break;
}
break;
case 3028: if (Editor.AuswahlAction.Richtung == Richtung.Links) Editor.AuswahlAction.Richtung = Richtung.Rechts; else Editor.AuswahlAction.Richtung = Richtung.Links; break;
case 3029: switch (Editor.AuswahlAction.Gegnerstatus)
{
case Enemystate.Idle: Editor.AuswahlAction.Gegnerstatus = Enemystate.Attack; break;
//case Enemystate.Chase: Editor.AuswahlAction.Gegnertyp = Enemytype.Schatten; break;
case Enemystate.Attack: Editor.AuswahlAction.Gegnerstatus = Enemystate.Idle; break;
//case Enemystate.Dead: Editor.AuswahlAction.Gegnertyp = Enemytype.Greif; break;
}
break;
case 3030:
foreach (Level level in Levelmanager.Levels)
{
if (Editor.AuswahlAction.Name == level.Name)
{
if (Levelmanager.Levels.IndexOf(level) + 1 == Levelmanager.Levels.Count()) Editor.AuswahlAction.Name = Levelmanager.Levels[0].Name;
else Editor.AuswahlAction.Name = Levelmanager.Levels[Levelmanager.Levels.IndexOf(level) + 1].Name;
break;
}
}
break;
case 3031: Editor.AnzeigenEvents = !Editor.AnzeigenEvents; break;
case 3032: Editor.AuswahlHeilung = !Editor.AuswahlHeilung; break;
case 3033: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Leveleinstellungen), 7); break;
case 3034: Editor.VectorWaehlen = true; Editor.NurX = true; break;
case 3035: Editor.VectorWaehlen = true; Editor.NurY = true; break;
case 3036: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Leveleinstellungen), 9); break;
case 3037: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Infofenster), 13); break;
case 3038: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Leveleinstellungen), 11); break;
case 3039: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Lever), 3); break;
case 3040: Editor.AuswahlLever.Einmalig = !Editor.AuswahlLever.Einmalig; break;
case 3041: break;
case 3042: Editor.AuswahlLever.Betätigt = !Editor.AuswahlLever.Betätigt; break;
case 3043: Editor.AuswahlLever.Rücksetzen = !Editor.AuswahlLever.Rücksetzen; break;
case 3044: switch (Editor.AuswahlAction.Objektaktion)
{
case Objektaktionstyp.Erstellen: Editor.AuswahlAction.Objektaktion = Objektaktionstyp.Entfernen; break;
case Objektaktionstyp.Entfernen: Editor.AuswahlAction.Objektaktion = Objektaktionstyp.Austauschen; break;
case Objektaktionstyp.Austauschen: Editor.AuswahlAction.Objektaktion = Objektaktionstyp.Erstellen; break;
}
Editor.ChangeTool(Editortool.Event); Editor.ChangeTool(Editortool.Aktion);
break;
case 3045: Windowmanager.RemoveWindow(Windowtype.Aktion);
Editor.AuswahlObjektkategorie = Editor.AuswahlAction.Objecttyp;
Windowmanager.AddWindow(Windowtype.Objektvariante);
Windowmanager.GetWindowOfType(Windowtype.Objektvariante).Feld = Windowmanager.GetWindowPosition(Windowtype.Aktion);
int LäuferY = 40;
int LäuferLinksklick = 910;
foreach (Objectvariation Variation in Editor.AuswahlAction.Objecttyp.Variante)
{
Windowmanager.GetWindowOfType(Windowtype.Objektvariante).AddButton(new Button(new Rectangle(10, LäuferY, 200, 15), Contents.Meiryo8, Variation.Name, false, Color.Blue, LäuferLinksklick, 0, LäuferLinksklick + 40));
LäuferY += 15; LäuferLinksklick++;
}
break;
case 3046: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Aktion), 9); break;
case 3047: Windowmanager.RemoveWindow(Windowtype.Aktion);
Editor.AuswahlObjektkategorie = Editor.AuswahlAction.Objecttyp;
Windowmanager.AddWindow(Windowtype.Objektkategorie);
Windowmanager.GetWindowOfType(Windowtype.Objektkategorie).Feld = Windowmanager.GetWindowPosition(Windowtype.Aktion);
LäuferY = 40;
LäuferLinksklick = 810;
foreach (ObjectType Objekttyp in Objectdatabase.Objektdaten)
{
Windowmanager.GetWindowOfType(Windowtype.Objektkategorie).AddButton(new Button(new Rectangle(10, LäuferY, 200, 15), Contents.Meiryo8, Objekttyp.ObjectClass.ToString(), false, Color.Blue, LäuferLinksklick, 0, 0));
LäuferY += 15; LäuferLinksklick++;
}
break;
case 3048: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Aktion), 15); break;
case 3049:
switch (Editor.AuswahlAction.Objektebene)
{
case Objektebene.Hintergrund: Editor.AuswahlAction.Objektebene = Objektebene.Spielfeld; break;
case Objektebene.Spielfeld: Editor.AuswahlAction.Objektebene = Objektebene.Vordergrund; break;
case Objektebene.Vordergrund: Editor.AuswahlAction.Objektebene = Objektebene.Hintergrund; break;
}
break;
case 3050: switch (Editor.AuswahlTrigger.Enemytype)
{
case Enemytype.Greif: Editor.AuswahlTrigger.Enemytype = Enemytype.Messerkreatur; break;
case Enemytype.Messerkreatur: Editor.AuswahlTrigger.Enemytype = Enemytype.Schatten; break;
case Enemytype.Schatten: Editor.AuswahlTrigger.Enemytype = Enemytype.Wolf; break;
case Enemytype.Wolf: Editor.AuswahlTrigger.Enemytype = Enemytype.Greif; break;
}
break;
case 3051: switch (Editor.AuswahlTrigger.Enemystate)
{
case Enemystate.Attack: Editor.AuswahlTrigger.Enemystate = Enemystate.Dead; break;
case Enemystate.Dead: Editor.AuswahlTrigger.Enemystate = Enemystate.Idle; break;
case Enemystate.Idle: Editor.AuswahlTrigger.Enemystate = Enemystate.Attack; break;
}
break;
case 3052: Editor.AuswahlStatisch = !Editor.AuswahlStatisch; break;
case 3053: Editor.AuswahlAction.Statisch = !Editor.AuswahlAction.Statisch; break;
case 3054: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Editoreinstellungen), 6); break;
case 3055: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Hintergrund), 15); break;
case 3056: Keymanager.NeueEingabe(Windowmanager.GetWindowOfType(Windowtype.Hintergrund), 17); break;
//Zahlenbereiche abfragen-------------------------------------------------------------------------------------------------------------------------------
default: Zahlenbereiche(gamestate); break;
}
}
private void UpdateDeath()
{
if (!collated)
{
scores.Collate();
collated = true;
}
for (int i = 0; i < mines.Count; i++)
mines[i].State(3);
PLAYER.X(100);
PLAYER.Y(HEIGHT / 2 - PLAYER.Rectangle().Height / 2);
PLAYER.Minus();
if (PLAYER.RemainingLives() <= 0)
STATE = Gamestate.End;
else
STATE = Gamestate.Play;
}
private void UpdateEnd()
{
for (int i = 0; i < mines.Count; i++)
mines[i].State(2);
bonus.State(2);
if ((Helper.Keypress(Keys.Escape)) || (Helper.LeftClick()))
{
STATE = Gamestate.Menu;
deathScreenTimer.Reset();
}
}
private void UpdateMenu()
{
// Menu opts.
if ((Helper.Keypress(Keys.D1)) && (PLAYER.RemainingLives() > 0))
STATE = Gamestate.Play;
if (Helper.Keypress(Keys.D2))
STATE = Gamestate.New;
if (Helper.Keypress(Keys.D3))
STATE = Gamestate.Scores;
if (Helper.Keypress(Keys.D4))
STATE = Gamestate.About;
if (Helper.Keypress(Keys.D5))
this.Exit();
}
public void OnMouseDown()
{
switch (gamestate) {
case(Gamestate.Playing):
Debug.Log (gtc.tickOverlap);
if (gtc.tickOverlap) {
if (turns == 1) {
gamestate = Gamestate.Won;
Debug.Log ("won");
} else {
turns--;
rotatingClockwise = !rotatingClockwise;
float goalLocation = Random.Range (40, 170) * (rotatingClockwise ? 1 : -1);
goal.transform.RotateAround (tick.transform.parent.position, new Vector3(0,0,1), goalLocation);
ignoreTrigger = true;
}
} else {
Lost ();
gamestate = Gamestate.Lost;
}
break;
case(Gamestate.SetUp):
gamestate = Gamestate.Playing;
break;
case(Gamestate.Lost):
gamestate = Gamestate.SetUp;
bgRenderer.sprite = WinSprite;
tickRenderer.enabled = false;
goalRenderer.enabled = false;
Setup ();
break;
case (Gamestate.Won):
level++;
gamestate = Gamestate.SetUp;
tickRenderer.enabled = false;
goalRenderer.enabled = false;
Setup ();
break;
}
}
private void UpdatePlay()
{
// Update player + gun position..
PLAYER.Update();
gun.Update(PLAYER.Position());
// Increment mine position.
for (int i = 0; i < mines.Count; i++)
mines[i].Update(PLAYER.Rectangle());
// Music.
soundtrack.Update();
// Calculate any collisions.
Collisions();
// Update backdrop.
cloudyBackdrop.Update(5);
// Tick scores.
scores.Update();
// Increment bonus position.
bonus.Update();
// Goodnight, sweet prince.
if (PLAYER.RemainingLives() <= 0)
{
STATE = Gamestate.End;
}
}
protected override void Update(GameTime gameTime)
{
/// <ControlManetteDeJeu>
/// if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed) // De base, no use???
/// this.Exit();
/// GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);
/// </ControlManetteDeJeu>
/// <ExitButtom>
KeyboardState keyboardState = Keyboard.GetState(); //
//
// Check to see if the user has exited
mouseState = Mouse.GetState();
/// <check if mouseclick>
if (previousmouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton == ButtonState.Released)
{
MouseClicked(mouseState.X, mouseState.Y);
}
/// </check if mouseclick>
previousmouseState = mouseState;
if (gameState == Gamestate.Playing)
{
fantome.Update(Mouse.GetState(), Keyboard.GetState(), GraphicsDevice, decors, gameTime);
if (checkExitKey(keyboardState))
{
gameState = Gamestate.StartMenu;
IsMouseVisible = true;
}
}
base.Update(gameTime);
}
private void UpdateScores()
{
if (Helper.Keypress(Keys.Escape))
STATE = Gamestate.Menu;
}
protected override void Initialize()
{
// TODO: Add your initialization logic here
IsMouseVisible = true;
gameState = Gamestate.StartMenu;
double ScreenWidth = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width;
double ScreenHeight = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height;
double coeffX = 1680d / ScreenWidth;
double coeffY = 1050d / ScreenHeight;
playButton = new Rectangle(Convert.ToInt32(700 / coeffX), Convert.ToInt32(450 / coeffY), Convert.ToInt32(352 / coeffX), Convert.ToInt32(88 / coeffY));
optionsButton = new Rectangle(Convert.ToInt32(700 / coeffX), Convert.ToInt32(600 / coeffY), Convert.ToInt32(352 / coeffX), Convert.ToInt32(88 / coeffY));
exitButton = new Rectangle(Convert.ToInt32(700 / coeffX), Convert.ToInt32(750 / coeffY), Convert.ToInt32(352 / coeffX), Convert.ToInt32(88 / coeffY));
base.Initialize();
}
public ReturnButton(Position position, Gamestate gamestate, Texture backgroundTexture, ScreenType screenToReturn, ScreenType screenToSetAsPrevious) : this(position, gamestate, backgroundTexture, screenToReturn)
{
ScreenToSetAsPrevious = screenToSetAsPrevious;
SetPrevious = true;
}
