20.05.2012 - 14:38
YouTubeUnterliegtGEMAimUrheberrechtsstreit

Only http://programming-motherfucker.com/

:D

20.05.2012 - 12:07
YouTubeUnterliegtGEMAimUrheberrechtsstreit

Ist das nicht lebenswert? Läuft...

20.05.2012 - 06:45
cougarten

i always see what you did there

19.05.2012 - 21:47
Herzflattern

ich werde mein bestes geben :)
danke dir*

19.05.2012 - 21:15
YouTubeUnterliegtGEMAimUrheberrechtsstreit

Nein, ich wollte es mit meinem Vater lernen, doch er riet mir davon ab, vermutlich aus Zeitmangel. :( War früher Amateurfunker und hat sich alles selbst gebaut!

Ich kann doch deinen Code nirgends includen, hier hast du mein Hauptskript eines meiner XBOX Spiele, sogar mit Namenszertifikat und auch nur wegen der Länge, die Kameraklasse ist eigentlich interessanter!

Dumme Gästebucheinträge sind das wohl.

//XNA 4.0 PROJECT CHRISTIAN MÜRNER
//OCCUPIED
//
//using Direktiven .Net Framework
//using Direktiven XNA Framework
//using Direktiven namespace
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using myEngine.Objects;
using myEngine.GameObjects;
using myEngine.GUI;

namespace myEngine
{
//Deklarierung des enum GameState mit den verschieden Indexen
public enum GameState { Start, Scene, Pause, GameOver };

//Hauptklasse des Spiels
public class Game1 : Microsoft.Xna.Framework.Game
{
#region Propertys

//Schnittstelle für die Grafikkarte; Ermöglicht das Zeichnen von Sprites;
GraphicsDeviceManager graphics;
//Deklarieren der Klassen SpriteBatch mit dem Namen spriteBatch
SpriteBatch spriteBatch;

//Deklarieren der Klassen Gameobjects.Camera mit dem Namen ActiveCamera
public static Camera ActiveCamera;
//Deklarieren der Klassen ModellObjects.Hero mit dem Namen HeroVariable
public static Hero HeroVariable;
//Deklarierung der Klasse UserInterface als myUserInterface
UserInterface myUserInterface;

//Deklarierung und Setzen eines Booleans für die Feststellung, ob GUI.myUserInterface geladen oder nicht
bool GUIgeladen = false;

//Deklarieren einer KeyboardState Variable zur Feststellung, ob eine Taste gedrückt war oder nicht
KeyboardState old;

//Setzen der Variable myGameState 0
public static GameState myGameState;

#region Font

//Deklarierung der Variable HummaType vom Typ SpriteFont
SpriteFont HummaType;

#endregion

#region Sprite

//Deklarieren der Texture2D Variablen
Texture2D logo;
Texture2D warenkorb;
Texture2D score;
Texture2D hand;

//Animationsarray Texture2D
Texture2D aniSpray;
Texture2D aniShake;

//Deklarieren und Setzen der Indexwerte für das Animations-Array Texture2d
int aniIndex = 0;
int aniIndexShake = 0;

#endregion

#region Modell

//Deklarieren des Model-Array
public static Model mapModels;

#endregion

#region Musik & Sound

//Deklarieren der Musik und Sound Variablen

//Musik
Song intro;
Song mainSound;

//SoundEffects
SoundEffect introToMain;
SoundEffect sprayAttack;
SoundEffect canShake;
//SoundEffectInstance Deklarierung
SoundEffectInstance soundShake;
SoundEffectInstance soundAttack;

//Deklarieren und Setzen von Booleans für die Soundsteuerung
bool SoundIntro = false;
bool SoundMain = false;
bool SoundSpray = false;

#endregion

#region TileMap

//Deklarieren der Klasse Map mit dem Namen myMap
public static Map myMap;

//Setzen der konstanten Werte des MapIndes in Hoehe und Breite
const int mapHoehe = 20;
const int mapBreite = 20;

#region MapDeklaration
//Deklarieren und Zuweisen der Werte, Array-Größe wird durch die oben gesetzten Konstanten bestimmt
int[,] map01 = new int[mapHoehe, mapBreite]
{
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
};

#endregion

//Deklarieren eines Boolean-Array für die Abfrage, ob ArrayIndexNummer betreten true oder nicht betreten false
public static bool mapBetretbar;

#endregion

#region GameTime

//Setzen der Timestamp Variablen
TimeSpan aniTime = TimeSpan.FromSeconds(.25d);
TimeSpan aniTimer = TimeSpan.Zero;
TimeSpan aniTimeSpray = TimeSpan.FromSeconds(0.25d);
TimeSpan aniTimerSpray = TimeSpan.Zero;
TimeSpan canAttackTime = TimeSpan.FromSeconds(0.25d);
TimeSpan canAttackTimer = TimeSpan.Zero;

#endregion

#endregion

public Game1()
{

graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";

//Setzen des Viewport-Settings
graphics.PreferredBackBufferHeight = 768;
graphics.PreferredBackBufferWidth = 1024;

}

protected override void Initialize()
{
base.Initialize();
}

protected override void LoadContent()
{
//Initialisieren des SpriteBatch
spriteBatch = new SpriteBatch(GraphicsDevice);

//Instanz der Klasse GameObjects.Camera erstellen
ActiveCamera = new Camera();

#region Laden der Schriftart

//Laden der Schriftart für GUI
HummaType = Content.Load(@"Fonts\HummaType");

#endregion

#region Laden der für die Sprites nötigen Daten

//Laden der SpriteTexturen
logo = Content.Load(@"Textures\logo_top_b");
warenkorb = Content.Load(@"Textures\warenkorbstateInGame");
score = Content.Load(@"Textures\scoregameIngame");
hand = Content.Load(@"Textures\canattackIngame");

//Setzen des Animations-Array
aniSpray = new Texture2D[3];
//Laden der Texturen für das Array
aniSpray[0] = Content.Load(@"Textures\backware");
aniSpray[1] = Content.Load(@"Textures\middleware");
aniSpray[2] = Content.Load(@"Textures\frontware");

//Setzen des Animations-Array
aniShake = new Texture2D[2];
//Laden der Texturen für das Array
aniShake[0] = Content.Load(@"Textures\canpeaceIngameDown");
aniShake[1] = Content.Load(@"Textures\canpeaceIngameUP");

#endregion

#region Laden der für die TileMap und 3D-Objekte nötigen Daten

//neue Instanz der Klasse ModellObjects.Hero erstellen und ein Modell übergeben, eigentlich nicht nötig
HeroVariable = new Hero(Content.Load(@"Models\redcube"));

//Setzen des Model-Array
mapModels = new Model[3];
//Laden des Model-Array
mapModels[0] = Content.Load(@"Models\floor");
mapModels[1] = Content.Load(@"Models\wall_xbox");

//gleiche Wertzuweisung da ansonsten nur der Spieler an diesem Wert gezeichnet wird
mapModels[2] = mapModels[0];

//Deklarieren eines Boolean-Array
mapBetretbar = new bool[3];
//Wertzuweisung für das Boolean-Array
mapBetretbar[0] = true;
mapBetretbar[1] = false;
mapBetretbar[2] = true;

//Instanz der Klasse TileMap.Map erstellen und Parameter "map01, hoehe, breite" an dessen Konstruktor übergeben
myMap = new Map(map01, mapHoehe, mapBreite);

#endregion

#region Laden der Audio-Materie

//Laden Musik
intro = Content.Load(@"Audio\soundIntroBackground");
mainSound = Content.Load(@"Audio\soundMainBackground");

//Laden SoundEffects
introToMain = Content.Load(@"Audio\soundSwitchGame");
canShake = Content.Load(@"Audio\soundCanShake");
sprayAttack = Content.Load(@"Audio\soundCanSprayAttack");

#endregion

}

protected override void UnloadContent()
{
}

protected override void Update(GameTime gameTime)
{
#region Animations-Array Bedingungsabfrage

//Wertzuweisung des AnimationsTimer
aniTimer += gameTime.ElapsedGameTime;

//Bedingungsabfrage des Timer, falls Animationstimer größer als das gesetzte Intervall, führe Anweisung aus
if (aniTimer > aniTime)
{
//inkrementäre Erhöhung des AnimationsIndex
aniIndex++;
//Timer wird wieder zurückgesetzt
aniTimer = TimeSpan.Zero;

//Bedingungsabfrage des Timer, falls Länge des Animationsarray -1 kleiner als AnimationsIndex, führe Anweisung aus
if (aniShake.Length - 1 < aniIndex)
{
//Zurücksetzen des Index auf seinen Anfangswert
aniIndex = 0;
}
}

//Bedingungsabfrage der Keyboard.GetState, wenn Leertaste gedrückt ist, führe Anweisung aus
if (Keyboard.GetState().IsKeyDown(Keys.Space))
{
//Wertzuweisung des AnimationsTimer
aniTimerSpray += gameTime.ElapsedGameTime;

//Bedingungsabfrage des Timer, falls Animationstimer größer als das gesetzte Intervall, führe Anweisung aus
if (aniTimerSpray > aniTimeSpray)
{
//inkrementäre Erhöhung des AnimationsIndex
aniIndexShake++;
//Timer wird wieder zurückgesetzt
aniTimerSpray = TimeSpan.Zero;


//Bedingungsabfrage des Timer, falls die Länge des Animationsarray kleiner als Animationsindex, führe Anweisung aus
if (aniShake.Length < aniIndexShake)
{
//Zurücksetzen des Index auf seinen Anfangswert
aniIndexShake = 0;
}
}
}

#endregion

#region Steuerung des GameState

//switch-Bedingung basierend auf den aktuellen GameState
switch (myGameState)
{
#region GameState.Start

//Fall GameState.Start
case GameState.Start:

//Bedingungsabfrage des Boolean GUIgeladen, falls false, führe Anweisung aus
if (!GUIgeladen)
{
//GUI "überschreiben" mit neuen Parameter
String myMenue = { "New Game", "Options", "Quit Game" };
//Instanz der Klasse GUI.UserInterface erstellen
myUserInterface = new UserInterface(myMenue, HummaType);

//Setzen des Boolean-Wertes GUIgeladen auf true
GUIgeladen = true;
}

//Bedingungsabfrage des Boolean SoundIntro, falls false, führe Anweisung aus
if (!SoundIntro)
{
//Mediaplayer wird mit Play angewiesen Variable Intro vom Typ Song zu spielen
MediaPlayer.Play(intro);
//MediaPlayer wird angewiesen das Intro zu wiederholen
MediaPlayer.IsRepeating = true;

//Setzen des Boolean-Wertes SoundIntro auf true
SoundIntro = true;
}

#endregion

#region GUI Start

//Update-Methode für die Menüsteuerung der Klasse UserInterface
myUserInterface.Update();

//Bedingungsabfrage der Keyboard.GetState, wenn Enter gedrückt ist und,
//wenn im letzten Update die Taste nicht gedrückt wurde, führe Anweisung aus
if (Keyboard.GetState().IsKeyDown(Keys.Enter) && old.IsKeyUp(Keys.Enter))
{
GUIgeladen = true;
//switch-Bedingung für die Steuerung des GUI
switch (myUserInterface.Index)
{
//Fall 1 = Übergang zu GameState.Scene, starte Spiel
case 0:
//Setzen des GameStates auf Gamestate.Scene
myGameState = GameState.Scene;
//Setzen des Boolean-Wertes GUIgeladen auf false
GUIgeladen = false;
//Verlassen der Anweisung
break;

//Fall2 = //ToDo Übergang zu GameState.Options
case 1:
//Verlassen der Anweisung
break;

//Fall3 = Ende der Anwendung
case 2:
Exit();
//Verlassen der Anweisung
break;
}
}
//Verlassen der Anweisung
break;

#endregion


#region GameState.Scene

//Fall GameState.Scene
case GameState.Scene:

//Update der Instanz von ModellObject.Hero
HeroVariable.Update();
//Update der Methode updateCam für die Sicht der Kamera
updateCam();

#region Musik und Sound im Spiel

//Bedingungsabfrage des Boolean SoundMain, falls false, führe Anweisung aus
if (!SoundMain)
{
//SoundEffect soll gespielt werden
introToMain.Play();
//SoundEffectInstance Wertzuweisung
soundShake = canShake.CreateInstance();
//SoundEffectInstance soundShake wird angewiesen canShake zu wiederholen
soundShake.IsLooped = true;
//SoundEffectInstance wird mit Play angewiesen Variable canShake vom Typ SoundEffect zu spielen
soundShake.Play();
//Mediaplayer wird mit Stop angewiesen Variable Intro vom Typ Song zu beenden
MediaPlayer.Stop();
//Mediaplayer wird mit Play angewiesen Variable mainSound vom Typ Song zu spielen
MediaPlayer.Play(mainSound);

//Setzen des Boolean-Wertes SoundMain auf true
SoundMain = true;
}

//Wertzuweisung des Animationstimer
canAttackTimer += gameTime.ElapsedGameTime;

//Bedingungsabfrage des Timer, falls erster Wert größer als zweiter Wert, führe Anweisung aus
if (canAttackTimer >= canAttackTime)
{
//Setzen des Boolean-Wertes SoundSpray auf true
SoundSpray = true;
}
else
{
//Setzen des Boolean-Wertes SoundSpray auf false
SoundSpray = false;
}

//Bedingungsabfrage der Keyboard.GetState, wenn Taste Leertaste gedrückt ist, führe Anweisung aus
if (SoundSpray && (Keyboard.GetState().IsKeyDown(Keys.Space)))
{
//SoundEffect soundShake stoppen
soundShake.Stop();
//SoundEffectInstance Wertzuweisung
soundAttack = sprayAttack.CreateInstance();
//SoundEffectInstance soundShake wird mit Play angewiesen canShake zu spielen
soundAttack.Play();

//Timer wird wieder zurückgesetzt
canAttackTimer = TimeSpan.Zero;

//Setzen des Boolean-Wertes SoundSpray auf false
SoundSpray = false;
}
else
{
//Bedingungsabfrage der Keyboard.GetState, wenn Taste Leertaste nicht gedrückt ist, führe Anweisung aus
if(Keyboard.GetState().IsKeyUp(Keys.Space))
//SoundEffectInstance soundShake wird mit Play angewiesen canShake zu spielen
soundShake.Play();

//Setzen des Boolean-Wertes SoundMain auf true
SoundMain = true;
}
#endregion

#endregion

#region GUI Scene

//Wechsel zu GameState.Pause = Pause-Screen
//Bedingungsabfrage der Keyboard.GetState, wenn Escape gedrückt ist, führe Anweisung aus
if (Keyboard.GetState().IsKeyDown(Keys.Escape))
{
//Setzen des GameStates auf Gamestate.Pause
myGameState = GameState.Pause;
//Setzen des Boolean-Wertes GUIgeladen auf false
GUIgeladen = false;
}
//Verlassen der Anweisung
break;

#endregion


#region GameState.Pause;

//Fall GameState.Pause
case GameState.Pause:

//Update der Instanz von GUI.UserInterface
myUserInterface.Update();

//Bedingungsabfrage des Boolean GUIgeladen, falls false, führe Anweisung aus
if (!GUIgeladen)
{
//GUI "überschreiben" mit neuen Parameter
String myMenue = { "Weiter", "Back to Main", "Quit Game" };
//Instanz der Klasse GUI.UserInterface erstellen
myUserInterface = new UserInterface(myMenue, HummaType);

//Setzen des Boolean-Wertes GUIgeladen auf true
GUIgeladen = true;
}

#endregion

#region GUI Pause

//Bedingungsabfrage der Keyboard.GetState, wenn Enter gedrückt ist und,
//wenn im letzten Update die Taste nicht gedrückt wurde, führe Anweisung aus
if (Keyboard.GetState().IsKeyDown(Keys.Enter) && old.IsKeyUp(Keys.Enter))
{
//switch-Bedingung für die Steuerung des GUI
switch (myUserInterface.Index)
{
//Fall1
case 0:
//Setzen des GameStates auf Gamestate.Scene
myGameState = GameState.Scene;
//Verlassen der Anweisung
break;

//Fall2
case 1:
//Setzen des GameStates auf Gamestate.Start
myGameState = GameState.Start;
//Setzen des Boolean-Wertes GUIgeladen auf false
GUIgeladen = false;
//Verlassen der Anweisung
break;

//Fall3 = Ende der Anwendung
case 2:
Exit();
//Verlassen der Anweisung
break;
}
}
//Verlassen der Anweisung
break;

#endregion


#region GameState.GameOver

case GameState.GameOver:
//ToDo //Update nach Timerablauf zu GameState.Start
//Verlassen der Anweisung
break;

#endregion
}

//alten KeyboardState auf aktuellen KeyboardState setzen
old = Keyboard.GetState();

#endregion

base.Update(gameTime);
}

protected override void Draw(GameTime gameTime)
{
#region Draw-Methode "Eigenschaften"

//vorherige Grafiken entfernen und Bildschirm basierend auf die Farbmischung Kornblumenblau reseten
GraphicsDevice.Clear(Color.CornflowerBlue);

//Fix zur Darstellung der 3D-Models in XNA 4.0
DepthStencilState depthBufferState;
depthBufferState = new DepthStencilState();
depthBufferState.DepthBufferEnable = true;
GraphicsDevice.DepthStencilState = depthBufferState;

//Deklarieren und Setzen eines Vector2 mit dem Namen displaymid zur Feststellung der Viewport-Mitte
Vector2 displaymid = new Vector2(graphics.PreferredBackBufferWidth / 2 - logo.Width / 2, 100);

#endregion

#region Draw-Methode nach GameState

//switch-Bedingung für die Steuerung der Draw-Methode Steuerung durch enum GameState
switch (myGameState)
{
//Fall 1 GameState.Start
case GameState.Start:
//Ausführen des Rendering basierend auf die Farbmischung Schwarz
GraphicsDevice.Clear(Color.Black);
//SpriteBatch Operation wird gestartet
spriteBatch.Begin();
//Zeichne Textur logo in der Viewport-Mitte mit Farbmischung Weiß
spriteBatch.Draw(logo, displaymid, Color.White);
//SpriteBatch Operation wird beendet
spriteBatch.End();

//Aufrufen der Draw-Methode von GUI.UserInterface
myUserInterface.Draw(spriteBatch);
//Verlassen der Anweisung
break;

case GameState.Scene:
//Zeichnen der Draw-Methode von Instanz von TileMap.Map
myMap.Draw();
//SpriteBatch Operation wird gestartet
spriteBatch.Begin();
//Zeichne Textur warenkorb an die angegebene Vektorenposition mit Farbmischung Weiß
spriteBatch.Draw(warenkorb, new Vector2(15, 20), Color.White);
//Zeichne Textur score an die Hälfte der Viewportbreite und die angegebene Vektorenposition mit Farbmischung Weiß
spriteBatch.Draw(score, new Vector2(graphics.PreferredBackBufferWidth - score.Width - 20, 20), Color.White);
//SpriteBatch Operation wird beendet
spriteBatch.End();

//Bedingungsabfrage der Keyboard.GetState, wenn Leertaste gedrückt ist, führe Anweisung aus
if (Keyboard.GetState().IsKeyDown(Keys.Space))
{
//SpriteBatch Operation wird gestartet
spriteBatch.Begin();
//Zeichne Textur aus dem Animations-Array anispray anhand des aktuellen Indexwertes an die angegebene Vektorenposition mit Farbmischung Weiß
spriteBatch.Draw(aniSpray[aniIndexShake], new Vector2(280, 30), Color.White);
//Zeichne Textur hand an die Hälfte des Viewport-Settings minus hand-Setting und die angegebene Vektorenposition mit Farbmischung Weiß
spriteBatch.Draw(hand, new Vector2(graphics.PreferredBackBufferWidth - hand.Width, graphics.PreferredBackBufferHeight - hand.Height), Color.White);
//SpriteBatch Operation wird beendet
spriteBatch.End();
}
else
{
//SpriteBatch Operation wird gestartet
spriteBatch.Begin();
//Zeichne Textur aus dem Animations-Array aniShake anhand des aktuellen Indexwertes an die Hälfte des Viewport-Settings minus hand-Setting mit Farbmischung Weiß
spriteBatch.Draw(aniShake[aniIndex], new Vector2(graphics.PreferredBackBufferWidth - hand.Width, graphics.PreferredBackBufferHeight - hand.Height), Color.White);
//SpriteBatch Operation wird beendet
spriteBatch.End();
}
//Verlassen der Anweisung
break;

case GameState.Pause:
//Aufrufen der Draw-Methode der Instanz von TileMap.Map
myMap.Draw();
//Aufrufen der Draw-Methode von GUI.UserInterface
myUserInterface.Draw(spriteBatch);
//Verlassen der Anweisung
break;

case GameState.GameOver:
//ToDo
//Zurück nach Timerablauf zu GameState.Start
//Verlassen der Anweisung
break;
}
#endregion

base.Draw(gameTime);
}

#region Methode First Person Camera

public void updateCam()
{
//Deklarieren der Variable als Vector3 und Abstand Kamerasicht zum Zielobjekt festlegen
Vector3 CamAbstand = new Vector3(0, 0, 1);
//Abstand Kamerasicht in die Matrix interpolieren
CamAbstand = Vector3.Transform(CamAbstand, HeroVariable.OrientationMatrix);
//Abstand Kamerasicht Wertzuweisung durch Addition der ModellObjects.Hero.Position
CamAbstand += HeroVariable.Position;
//Setzen von Abstand Kamerasicht an GameObjects.Camera.Position
ActiveCamera.Position = CamAbstand;

//Setzen des Ziels ModellOnjects.Hero an GameObjects.Camera.CamTarget festlegen
ActiveCamera.CamTarget = HeroVariable.Position;

//Setzen der Draufsicht der Kamera in GameObjects.Camera.camUp
Vector3 camUp = new Vector3(0, 1, 0);
//Draufsicht der Kamera in die Matrix interpolieren
camUp = Vector3.Transform(camUp, HeroVariable.OrientationMatrix);
//Gleichsetzen dieser Draufsicht der Kamera in GameObjects.Camera
ActiveCamera.CamUp = camUp;

////Update der Instanz von GameObjects.CameraCam Updaten (Matrix)
ActiveCamera.Update();
}

#endregion
}
}