Changeset 20

	19		20
6		6
7	namespace RPG	7	namespace RPG
8	{	8	{
9	class Character	9	public class Character: GameObject
10	{	10	{
11	public String Name;	11	public String Name;
12	public Vector2 Position;	12	public int[] Coord;
13		13
14	public DisplayObject DO;	14	public string Direction;
		15	public int step;
15		16
16	public Character(DisplayObject D)	17	public Character(DisplayObject DO, Display D):base(DO,D)
17	{	18	{
18	Name = "MyCharacter";	19	Name = "MyCharacter";
19	Position = new Vector2(0, 0);	20	Coord = new int[2];
20	Texture = "perso";	21	Coord[0] = Coord[1] = 0;
		22	this.DO=DO;
		23	this.DO.Position.X = 0;
		24	this.DO.Position.Y = 0;
21		25
22	DO = D;	26	if (DO.SpriteList["Default"].Width >= Globals.GAME_WIDTH/Globals.NB_CASES_X)
23	}	27	{
		28	DO.scale = ( float) Globals.GAME_WIDTH/Globals.NB_CASES_X / (float)DO.SpriteList["Default"].Width;
		29	}
		30	step = 0;
		31	Direction = "None";
		32
24		33
		34	}
		35
		36	public void move(String S)
		37	{
		38	if(Direction.Equals("None"))
		39	{
		40	Direction = S;
		41	step = 0;
		42	}
		43	}
		44
		45	public new void update()
		46	{
		47	if (Direction.Equals("None"))
		48	{
		49	return;
		50	}
		51	if (step < 50)
		52	{
		53
		54	if (Direction.Equals("Left"))
		55	{
		56	this.DO.Shift.X += 7.0f;
		57	}
		58
		59	if (Direction.Equals("Right"))
		60	{
		61	this.DO.Shift.X -= 7.0f;
		62	}
		63
		64
		65	if (Direction.Equals("Up"))
		66	{
		67	this.DO.Shift.Y += 7.0f;
		68	}
		69
		70
		71	if (Direction.Equals("Down"))
		72	{
		73	this.DO.Shift.Y -= 7.0f;
		74	}
		75	step++;
		76	}
		77
		78	else
		79	{
		80	DO.Shift = Vector2.Zero;
		81
		82	if (Direction.Equals("Left"))
		83	{
		84	Coord[0] = Coord[0] - 1 % Globals.NB_CASES_X;
		85	this.DO.Position.X -= (float)Globals.GAME_WIDTH / Globals.NB_CASES_X;
		86	}
		87
		88	if (Direction.Equals("Right"))
		89	{
		90	Coord[0] = Coord[0] + 1 % Globals.NB_CASES_X;
		91	this.DO.Position.X += (float)Globals.GAME_WIDTH / Globals.NB_CASES_X;
		92	}
		93
		94
		95	if (Direction.Equals("Up"))
		96	{
		97	Coord[1] = Coord[1] - 1 % Globals.NB_CASES_Y;
		98	this.DO.Position.Y -= (float)Globals.GAME_HEIGHT / Globals.NB_CASES_Y;
		99	}
		100
		101
		102	if (Direction.Equals("Down"))
		103	{
		104	Coord[1] = Coord[1] + 1 % Globals.NB_CASES_Y;
		105	this.DO.Position.Y += (float)Globals.GAME_HEIGHT / Globals.NB_CASES_Y;
		106	}
		107	step = 0;
		108	Direction = "None";
		109	}
		110
		111	}
		112
		113
		114
25	}	115	}
26	}	116	}

	19		20
65	<Processor>TextureProcessor</Processor>	65	<Processor>TextureProcessor</Processor>
66	</Compile>	66	</Compile>
67	</ItemGroup>	67	</ItemGroup>
		68	<ItemGroup>
		69	<Compile Include="background.jpg">
		70	<Name>background</Name>
		71	<Importer>TextureImporter</Importer>
		72	<Processor>TextureProcessor</Processor>
		73	</Compile>
		74	</ItemGroup>
		75	<ItemGroup>
		76	<Compile Include="Basketball.png">
		77	<Name>Basketball</Name>
		78	<Importer>TextureImporter</Importer>
		79	<Processor>TextureProcessor</Processor>
		80	</Compile>
		81	</ItemGroup>
68	<Import Project="$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\$(XnaFrameworkVersion)\Microsoft.Xna.GameStudio.ContentPipeline.targets" />	82	<Import Project="$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\$(XnaFrameworkVersion)\Microsoft.Xna.GameStudio.ContentPipeline.targets" />
69	<!-- To modify your build process, add your task inside one of the targets below and uncomment it.	83	<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
70	Other similar extension points exist, see Microsoft.Common.targets.	84	Other similar extension points exist, see Microsoft.Common.targets.

 namespace RPG
 {
-    class Display
+    public class Display
     {
         public Rectangle viewportRect;
         public GraphicsDeviceManager graphics;
         List<DisplayObject> Objects;
+        Texture2D background;
         public Display(Game1 G)
         {
             game = G;
             {
                 throw new NullReferenceException();
             }
+            graphics.PreferredBackBufferHeight = 600;
+            graphics.PreferredBackBufferWidth = 800;
+            background = null;
         }
         public void Initialize()
             Objects = new List<DisplayObject>(10);
             //Create a Rectangle that represents the full
             //drawable area of the game screen.
             viewportRect = new Rectangle(0, 0,
             }
         }
         public bool removeDisplayObject(DisplayObject DO)
         {
             return Objects.Remove(DO);
         }
+        public void setBG(string BG)
+        {
+            if (background != null)
+            {
+                background.Dispose();
+            }
+            background = game.Content.Load<Texture2D>(BG);
+        }
         public void Draw()
         {
             graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
             spriteBatch.Begin(SpriteBlendMode.AlphaBlend);
            //spriteBatch.Draw(backgroundTexture, viewportRect,         Color.White);
+            if (background != null)
+                spriteBatch.Draw(background, new Rectangle(0, 0, graphics.GraphicsDevice.Viewport.Width, graphics.GraphicsDevice.Viewport.Height), Color.White);
              foreach (DisplayObject GO in Objects)
             {
                             null,
                             Color.White,
                             GO.Rotation,
-                            Vector2.Zero, 1.0f,
+                            GO.Shift, GO.scale,
                             SpriteEffects.None, 0);
                     }
                 }
                     {
                         spriteBatch.Draw(TextureToDraw,
                         GO.Position,
-                        null,
+                       null ,
                         Color.White,
                         GO.Rotation,
-                        Vector2.Zero, 1.0f,
+                        GO.Shift, GO.scale,
                         SpriteEffects.None, 0);
                     }
                     spriteBatch.DrawString(game.Font1, ((DisplayText)GO).Text, GO.Position, ((DisplayText)GO).TextColor,
-            GO.Rotation, Vector2.Zero, 1.0f, SpriteEffects.None, 0.5f);
+            GO.Rotation, GO.Shift, 1.0f, SpriteEffects.None, 0.5f);
                 }
              }

 namespace RPG
 {
-    class DisplayObject
+    public class DisplayObject
     {
         public Dictionary<String, Texture2D> SpriteList;
         protected String SpriteToUse;
         public Vector2 Position;
         public float Rotation;
-        public Vector2 Center;
+        public Vector2 Shift;
+        public float scale;
         public DisplayObject()
             Rotation = 0.0f;
             Position = Vector2.Zero;
             SpriteList = new Dictionary<string, Texture2D>();
-            Center = Vector2.Zero;
+            Shift = Vector2.Zero;
+            scale = 1;
         }
         public DisplayObject(Texture2D loadedTexture)
         {
             Position = Vector2.Zero;
             SpriteList = new Dictionary<string, Texture2D>();
             SpriteList["Default"]= loadedTexture;
+            scale = 1;
             SpriteToUse = "Default";
-            Center = new Vector2( loadedTexture.Width / 2, loadedTexture.Height / 2);
+            Shift = Vector2.Zero;
         }
+        public void setShift(Vector2 newShift)
+        {
+            Shift= newShift;
+        }
         public int addSprite(Texture2D NewSprite, String SpriteName)
         {
             if (NewSprite != null && SpriteName != null)
             Font = font;
             TextColor = Color.Lime;
             SpriteList = null;
-            Center = new Vector2 ( Font.MeasureString(S).X/2 , Font.MeasureString(S).Y /2);
+            Shift = new Vector2 ( Font.MeasureString(S).X/2 , Font.MeasureString(S).Y /2);
         }
             SpriteList["Default"] = loadedTexture;
             SpriteToUse = "Default";
-            Center = new Vector2(Math.Max(loadedTexture.Width / 2, Font.MeasureString(S).X), Math.Max(Font.MeasureString(S).Y, loadedTexture.Height / 2));
+            Shift = new Vector2(Math.Max(loadedTexture.Width / 2, Font.MeasureString(S).X), Math.Max(Font.MeasureString(S).Y, loadedTexture.Height / 2));
         }

	19		20
46	GameStates GameState;	46	GameStates GameState;
47	string output;	47	string output;
48	Random rand;	48	Random rand;
		49	Carte MaCarte;
		50	Character MyCharacter;
		51
		52	GameMotor GM;
		53
49	public Game1()	54	public Game1()
50	{	55	{
51	/*	56	/*
...		...
89		94
90	//DisplayObject balle2 = new DisplayObject(Content.Load<Texture2D>("e"));	95	//DisplayObject balle2 = new DisplayObject(Content.Load<Texture2D>("e"));
91		96
92	DisplayObject perso= new DisplayObject(Content.Load<Texture2D>("perso"));	97	DisplayObject perso= new DisplayObject(Content.Load<Texture2D>("Basketball"));
93		98
94	DisplayObject balle2 = new DisplayText("Hello World", Font1);	99	MyCharacter= new Character(perso, display);
		100	MyCharacter.setVisible(true);
		101
		102	MaCarte = new Carte("background", display );
		103	MaCarte.Cases[0, 0].wall[(int)Directions.RIGHT] = true;
		104
		105	MaCarte.setActive();
		106
		107	GM = new GameMotor(this, MyCharacter, MaCarte);
		108
		109	/*
		110	DisplayObject balle2 = new DisplayText("Hello World", Font1);
95	balle2.Position = new Vector2(display.viewportRect.Width/3, display.viewportRect.Height/3);	111	balle2.Position = new Vector2(display.viewportRect.Width/3, display.viewportRect.Height/3);
96
97	balle = new GameObject(balle2, display);	112	balle = new GameObject(balle2, display);
98
99	balle.setVisible(true);	113	balle.setVisible(true);
100
101	Infos = new DisplayText("Init", Font1);	114	Infos = new DisplayText("Init", Font1);
102	Vector2 FontPos = new Vector2(50,	115	Vector2 FontPos = new Vector2(50,
103	display.graphics.GraphicsDevice.Viewport.Height - 100);	116	display.graphics.GraphicsDevice.Viewport.Height - 100);
104	Infos.Position = FontPos;	117	Infos.Position = FontPos;
105	display.addDisplayObject(Infos);	118	display.addDisplayObject(Infos);
		119	*/
106		120
107		121	Infos = new DisplayText("Init", Font1);
		122	Vector2 FontPos = new Vector2(50,
		123	display.graphics.GraphicsDevice.Viewport.Height - 100);
		124	Infos.Position = FontPos;
		125	display.addDisplayObject(Infos);
108		126
109	base.LoadContent();	127	base.LoadContent();
110	}	128	}
...		...
132		150
133		151
134	// Needed for keyboard events	152	// Needed for keyboard events
135	float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;	153
136	TotalElapsedTime += elapsed;
137	// KeyboardState ks= Keyboard.GetState();	154	// KeyboardState ks= Keyboard.GetState();
138	KeyboardState keyboardState = Keyboard.GetState();	155	KeyboardState keyboardState = Keyboard.GetState();
139	MouseState mouseState = Mouse.GetState();	156	MouseState mouseState = Mouse.GetState();
140		157
		158
		159	GM.update(gameTime);
		160
		161	Infos.Text = MyCharacter.step.ToString();
		162
		163	/*
141	// Normal game loop	164	// Normal game loop
142	if (GameState == GameStates.Normal)	165	if (GameState == GameStates.Normal)
143	{	166	{
...		...
183	balle.acceleration = new Vector2(0.0f, 0.0f);	206	balle.acceleration = new Vector2(0.0f, 0.0f);
184	}	207	}
185	}	208	}
		209	*/
186		210
187	/*	211	/*
188	double ANorm = Math.Sqrt((float)Math.Pow(mouseState.X - balle.DO.Position.X , 2)+(float)Math.Pow(mouseState.Y - balle.DO.Position.Y, 2) );	212	double ANorm = Math.Sqrt((float)Math.Pow(mouseState.X - balle.DO.Position.X , 2)+(float)Math.Pow(mouseState.Y - balle.DO.Position.Y, 2) );
...		...
190	double newAy = (mouseState.Y - balle.DO.Position.Y) / Math.Pow(ANorm/50, 5);	214	double newAy = (mouseState.Y - balle.DO.Position.Y) / Math.Pow(ANorm/50, 5);
191	balle.acceleration = new Vector2((float)newAx, (float)newAy);	215	balle.acceleration = new Vector2((float)newAx, (float)newAy);
192	*/	216	*/
		217	/*
193	balle.update();	218	balle.update();
194		219
195		220
...		...
225		250
226	}	251	}
227	}	252	}
		253	*/
228		254
229		255
230		256

	19		20
3	using System.Linq;	3	using System.Linq;
4	using System.Text;	4	using System.Text;
5	using Microsoft.Xna.Framework;	5	using Microsoft.Xna.Framework;
		6	using Microsoft.Xna.Framework.Input;
6		7
7	namespace RPG	8	namespace RPG
8	{	9	{
9	public class GameMotor	10	public class GameMotor
10	{	11	{
11	Character Ch;	12	Character Ch;
12	Carte C;	13	Carte C;
13	GameTime LastUpdate;	14	Game game;
		15	float time;
14		16
15	public GameMotor (GameTime G, Character newCh, Carte newC)	17	public GameMotor (Game G, Character newCh, Carte newC)
16	{	18	{
17	LastUpdate= G;	19	game = G;
18	Ch = newCh;	20	Ch = newCh;
19	newC = C;	21	C = newC;
		22	time = 0;
20	}	23	}
21		24
22	void update()	25	public void update(GameTime gametime)
23	{	26	{
24	if (KeyboardState.IsKeyDown(Keys.Right) && C.Case.GO != null){	27	float elapsed = (float)gametime.ElapsedGameTime.TotalSeconds;
25	Ch.Move("right");	28	time += elapsed;
26	};	29
27	if (KeyboardState.IsKeyDown(Keys.Left)){	30	KeyboardState keyboardState = Keyboard.GetState();
28	Ch.Move("left");	31
		32	if (time > 0.1f)
		33	{
		34	time = 0;
		35	if (keyboardState.IsKeyDown(Keys.Right) && Ch.Coord[0] < Globals.NB_CASES_X - 1)
		36	{
		37	if(!C.Cases[Ch.Coord[0],Ch.Coord[1]].wall[(int)Directions.RIGHT])
		38	Ch.move("Right");
		39
29	};	40	};
30	if (KeyboardState.IsKeyDown(Keys.Up)){	41	if (keyboardState.IsKeyDown(Keys.Left) && Ch.Coord[0] > 0)
31	Ch.Move("up");	42	{
		43	if (!C.Cases[Ch.Coord[0], Ch.Coord[1]].wall[(int)Directions.LEFT])
		44	Ch.move("Left");
32	};	45	};
33	if (KeyboardState.IsKeyDown(Keys.Down)){	46	if (keyboardState.IsKeyDown(Keys.Up) && Ch.Coord[1] > 0)
34	Ch.Move("down");	47	{
		48	if (!C.Cases[Ch.Coord[0], Ch.Coord[1]].wall[(int)Directions.UP])
		49	Ch.move("Up");
35	};	50	};
		51	if (keyboardState.IsKeyDown(Keys.Down) && Ch.Coord[1] < Globals.NB_CASES_Y - 1)
		52	{
		53	if (!C.Cases[Ch.Coord[0], Ch.Coord[1]].wall[(int)Directions.DOWN])
		54	Ch.move("Down");
		55	};
		56	}
		57	else
		58	{
		59	Ch.update();
		60	}
36	}	61	}
37	}	62	}
38	}	63	}

	19		20
6		6
7	namespace RPG	7	namespace RPG
8	{	8	{
9	class GameObject	9	public class GameObject
10	{	10	{
11	static Vector2 zero2= new Vector2(0,0);	11	static Vector2 zero2= new Vector2(0,0);
12		12
...		...
35	{	35	{
36	Dimension = new Vector2(DO.getSprite().Width, DO.getSprite().Height);	36	Dimension = new Vector2(DO.getSprite().Width, DO.getSprite().Height);
37	}*/	37	}*/
38	Dimension = DO.Center * 2;	38	Dimension = DO.Shift * 2;
39	}	39	}
40		40
41	public void setVisible(bool V)	41	public void setVisible(bool V)

 namespace RPG
 {
-    class Globals
+    public enum Directions { LEFT, RIGHT, UP, DOWN };
+    public class Globals
     {
         public static int NB_CASES_X = 16;
         public static int NB_CASES_Y = 12;
+        public static int GAME_WIDTH = 800;
+        public static int GAME_HEIGHT = 600;
     }
 }

	19		20
87	<Compile Include="Character.cs" />	87	<Compile Include="Character.cs" />
88	<Compile Include="Display.cs" />	88	<Compile Include="Display.cs" />
89	<Compile Include="DisplayObject.cs" />	89	<Compile Include="DisplayObject.cs" />
		90	<Compile Include="GameMotor.cs" />
90	<Compile Include="GameObject.cs" />	91	<Compile Include="GameObject.cs" />
91	<Compile Include="Globals.cs" />	92	<Compile Include="Globals.cs" />
92	<Compile Include="Properties\AssemblyInfo.cs" />	93	<Compile Include="Properties\AssemblyInfo.cs" />

 namespace RPG
 {
-	class Zone
+	public class Zone
 	{
 		public string Name;
 		Carte[] Cartes;
         public Zone()
         {
-            Name= null;
+            Name = null;
-            Cartes= null;
+            Cartes = null;
+        }
 		public int addCarte (Carte C)
 			/*Ajoute une carte dans la zone.
 		}
 	}
-	class Carte
+	public class Carte
 	{
         public string Background;
-        Case[,] Cases;
+        public Case[,] Cases;
+        Display Disp;
         public Carte()
         {
             }
         }
-         public Carte(String Back)
+         public Carte(String Back, Display D)
         {
+             Disp= D;
             Background = Back;
             Cases = new Case[Globals.NB_CASES_X,Globals.NB_CASES_Y];
             for(int i=0; i<Globals.NB_CASES_X; i++)
             }
         }
+      public void setActive()
+      {
+          Disp.setBG(Background);
+      }
         public int put_Object(GameObject Obj, int X, int Y)
 		{
             if (Cases[X,Y] != null)
 		}
 	}
-	class Case
+	public class Case
 	{
         public string Texture;
         public GameObject GO;
         {
             GO=null;
             Texture=null;
+            wall = new bool[4];
+            for (int i = 0; i < 4; i++)
+            {
+                wall[i] = false;
+            }
         }
 		public Case(string T)
 		{
             GO = null;
 			Texture=T;
+            wall = new bool[4];
+            for(int i=0; i<4; i++)
+            {
+                wall[i]=false;
+            }
 		}
-		bool[] wall; //Tableau des murs, wall[i]=true s'il y'a un mur sur l'arrête.
+        public bool[] wall; //Tableau des murs, wall[i]=true s'il y'a un mur sur l'arrête.
 		//wall de taille 4, dans l'ordre : haut, droite, bas, gauche.
 	}

RPG-XNA

Affected files

RPG/Character.cs Download diff

RPG/Content/Content.contentproj Download diff

RPG/Display.cs Download diff

RPG/DisplayObject.cs Download diff

RPG/Game1.cs Download diff

RPG/GameMotor.cs Download diff

RPG/GameObject.cs Download diff

RPG/Globals.cs Download diff

RPG/RPG.csproj Download diff

RPG/Zone.cs Download diff