RealDev

///
/// EExtensions
///
/// Basically my aim currently is to throw together a whole
/// bunch of usefull classes for c# and XNA to bundle together
/// all the things I will repeatedly use to make it easier.
///
/// Currently it is far from complete and I am making some
/// small (and some large) adjustments to the code to make it
/// faster/more reliable/etc.
///
/// I hope that this can help other people as much as i plan
/// for it to help me.
///
/// I have left commented out a bunch of placeholder classes
/// that I hope to implement soon. If you wish to add on to
/// what I have here already feel free to send the code to me
/// and I'll add it on.
///
/// Regards,
/// Ernest Loveland
///

///USAGE Example 1:
///------
///EExtension.Media media = new EExtension.Media();
///media.AddEffect(Content.Load("somefile"));
///media.PlayEffect(1);

///USAGE Example 2: (think charged shooting here)
///------
///EExtension.KeyB keyb = new EExtension.KeyB();
/// //update method
/// keyb.UpdateKeyboard();
/// if (keyb.Pressed(Keys.Enter))
/// {
/// //some code
/// } else if (keyb.Released(Keys.Enter))
/// {
/// //some other code
/// }

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
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 Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;
using System.Threading;

namespace CodeTest
{
class EExtension
{

///
/// Media basically controls songs (eg background music)
/// and sound effects (gunshots, etc)
///
public class Media
{
public int SongCount = 0, EffectCount = 0;
private Dictionary SongList = new Dictionary();
private Dictionary EffectList = new Dictionary();
private Random RSong = new Random();
public float VOL = 0.8f;

public int AddSong(Song Addition)
{
SongCount++;
SongList.Add(SongCount, Addition);
return 0;
}

public int AddEffect(SoundEffect Addition)
{
EffectCount++;
EffectList.Add(EffectCount, Addition);
return 0;
}

public int PlaySong(int SongNumber)
{
if ((SongNumber > 0) && (SongNumber <= SongCount))
{
MediaPlayer.Volume = VOL;
MediaPlayer.Play(SongList[SongNumber]);
}
return 0;
}

public int PlayEffect(int EffectNumber)
{
if ((EffectNumber > 0) && (EffectNumber <= EffectCount))
{
EffectList[EffectNumber].Play(VOL);
}
return 0;
}
}

///
/// Handles Keyboard input,
/// Released, Pressed, Held
///
public class KeyB
{
KeyboardState PreviousState;
KeyboardState CurrentState;

public int Init()
{
PreviousState = Keyboard.GetState();
CurrentState = Keyboard.GetState();

return 0;
}

public int UpdateKeyboard()
{
PreviousState = CurrentState;
CurrentState = Keyboard.GetState();

return 0;
}
public bool Released(Keys k)
{
return ((PreviousState.IsKeyDown(k)) && (!CurrentState.IsKeyDown(k)));
}

public bool Pressed(Keys k)
{
return ((!PreviousState.IsKeyDown(k)) && (CurrentState.IsKeyDown(k)));
}

public bool Held(Keys k)
{
return ((PreviousState.IsKeyDown(k)) && (CurrentState.IsKeyDown(k)));
}
}

///
/// Handles mouse input,
/// Released, Pressed, Held
///
public class Mous
{
MouseState previousState = Mouse.GetState();
MouseState currentState = Mouse.GetState();

int UpdateMouse()
{
previousState = currentState;
currentState = Mouse.GetState();
return 0;
}

Vector2 mousePos()
{
return new Vector2(currentState.X, currentState.Y);
}
bool leftClicked()
{
return (currentState.LeftButton == ButtonState.Pressed);
}

//Todo: finish the mouse class

}

public class GPad
{
GamePadState[] PreviousState = new GamePadState[4];
GamePadState[] CurrentState = new GamePadState[4];

public int Init()
{
PreviousState[0] = GamePad.GetState(PlayerIndex.One);
PreviousState[1] = GamePad.GetState(PlayerIndex.Two);
PreviousState[2] = GamePad.GetState(PlayerIndex.Three);
PreviousState[3] = GamePad.GetState(PlayerIndex.Four);

CurrentState[0] = GamePad.GetState(PlayerIndex.One);
CurrentState[1] = GamePad.GetState(PlayerIndex.Two);
CurrentState[2] = GamePad.GetState(PlayerIndex.Three);
CurrentState[3] = GamePad.GetState(PlayerIndex.Four);

return 0;
}

public int UpdateGamePad()
{
PreviousState[0] = CurrentState[0];
PreviousState[1] = CurrentState[1];
PreviousState[2] = CurrentState[2];
PreviousState[3] = CurrentState[3];

CurrentState[0] = GamePad.GetState(PlayerIndex.One);
CurrentState[1] = GamePad.GetState(PlayerIndex.Two);
CurrentState[2] = GamePad.GetState(PlayerIndex.Three);
CurrentState[3] = GamePad.GetState(PlayerIndex.Four);

return 0;
}

//triggers
public float LeftTriggerVal(int ControllerNum)
{
return CurrentState[ControllerNum - 1].Triggers.Left;
}
public float RightTrigerVal(int ControllerNum)
{
return CurrentState[ControllerNum - 1].Triggers.Right;
}
public bool LeftTriggerPre(int ControllerNum)
{
return ((PreviousState[ControllerNum- 1].Triggers.Left == 0.0f) && (CurrentState[ControllerNum-1].Triggers.Left > 0.0f));
}
public bool RightTriggerPre(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Triggers.Right == 0.0f) && (CurrentState[ControllerNum - 1].Triggers.Right > 0.0f));
}
public bool LeftTriggerRel(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Triggers.Left > 0.0f) && (CurrentState[ControllerNum - 1].Triggers.Left == 0.0f));
}
public bool RightTriggerRel(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Triggers.Right > 0.0f) && (CurrentState[ControllerNum - 1].Triggers.Right == 0.0f));
}

//bumpers
public bool LeftBumberPre(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.LeftShoulder == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.LeftShoulder == ButtonState.Pressed));
}
public bool RightBumberPre(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.RightShoulder == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.RightShoulder == ButtonState.Pressed));
}
public bool LeftBumberRel(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.LeftShoulder == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.LeftShoulder == ButtonState.Released));
}
public bool RightBumberRel(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.RightShoulder == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.RightShoulder == ButtonState.Released));
}
public bool LeftBumberHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.LeftShoulder == ButtonState.Pressed);
}
public bool RightBumberHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.RightShoulder == ButtonState.Pressed);
}

//Sticks
public Vector2 LeftStick(int ControllerNum)
{
return CurrentState[ControllerNum - 1].ThumbSticks.Left;
}
public Vector2 RightStick(int ControllerNum)
{
return CurrentState[ControllerNum - 1].ThumbSticks.Right;
}
public int LeftStickDirection(int ControllerNum)
{
float _x = CurrentState[ControllerNum - 1].ThumbSticks.Left.X, _y = CurrentState[ControllerNum - 1].ThumbSticks.Left.Y;
return (int)Math.Atan(_y / _x);
}
public int RightStickDirection(int ControllerNum)
{
float _x = CurrentState[ControllerNum - 1].ThumbSticks.Right.X, _y = CurrentState[ControllerNum - 1].ThumbSticks.Right.Y;
return (int)Math.Atan(_y / _x);
}
public bool LeftStickPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.LeftStick == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.LeftStick == ButtonState.Pressed));
}
public bool RightStickPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.RightStick == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.RightStick == ButtonState.Pressed));
}
public bool LeftStickReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.LeftStick == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.LeftStick == ButtonState.Released));
}
public bool RightStickReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.RightStick == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.RightStick == ButtonState.Released));
}
public bool LeftStickHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.LeftStick == ButtonState.Pressed);
}
public bool RightStickHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.RightStick == ButtonState.Pressed);
}

//DPad
public bool LeftPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum-1].DPad.Left == ButtonState.Released)&&(CurrentState[ControllerNum-1].DPad.Left == ButtonState.Pressed));
}
public bool LeftReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].DPad.Left == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].DPad.Left == ButtonState.Released));
}
public bool LeftHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].DPad.Left == ButtonState.Pressed);
}
public bool RightPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].DPad.Right == ButtonState.Released) && (CurrentState[ControllerNum - 1].DPad.Right == ButtonState.Pressed));
}
public bool RightReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].DPad.Right == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].DPad.Right == ButtonState.Released));
}
public bool RightHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].DPad.Right == ButtonState.Pressed);
}
public bool UpPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].DPad.Up == ButtonState.Released) && (CurrentState[ControllerNum - 1].DPad.Up == ButtonState.Pressed));
}
public bool UpReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].DPad.Up == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].DPad.Up == ButtonState.Released));
}
public bool UpHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].DPad.Up == ButtonState.Pressed);
}
public bool DownPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].DPad.Down == ButtonState.Released) && (CurrentState[ControllerNum - 1].DPad.Down == ButtonState.Pressed));
}
public bool DownReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].DPad.Down == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].DPad.Down == ButtonState.Released));
}
public bool DownHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].DPad.Down == ButtonState.Pressed);
}

//ABXY
public bool XPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.X == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.X == ButtonState.Pressed));
}
public bool XReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.X == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.X == ButtonState.Released));
}
public bool XHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.X == ButtonState.Pressed);
}
public bool YPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.Y == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.Y == ButtonState.Pressed));
}
public bool YReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.Y == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.Y == ButtonState.Released));
}
public bool YHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.Y == ButtonState.Pressed);
}
public bool APressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.A == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.A == ButtonState.Pressed));
}
public bool AReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.A == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.A == ButtonState.Released));
}
public bool AHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.A == ButtonState.Pressed);
}
public bool BPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.B == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.B == ButtonState.Pressed));
}
public bool BReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.B == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.B == ButtonState.Released));
}
public bool BHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.B == ButtonState.Pressed);
}

//Start/Back
public bool StartPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum-1].Buttons.Start == ButtonState.Released) && (CurrentState[ControllerNum-1].Buttons.Start == ButtonState.Pressed));
}
public bool StartReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.Start == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.Start == ButtonState.Released));
}
public bool StartHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.Start == ButtonState.Pressed);
}
public bool BackPressed(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.Back == ButtonState.Released) && (CurrentState[ControllerNum - 1].Buttons.Back == ButtonState.Pressed));
}
public bool BackReleased(int ControllerNum)
{
return ((PreviousState[ControllerNum - 1].Buttons.Back == ButtonState.Pressed) && (CurrentState[ControllerNum - 1].Buttons.Back == ButtonState.Released));
}
public bool BackHeld(int ControllerNum)
{
return (CurrentState[ControllerNum - 1].Buttons.Back == ButtonState.Pressed);
}

}

///
/// Takes screenshots on a seperate thread so that there is no pause
/// Adapted from http://www.xnawiki.com/index.php?title=Threaded_Screenshot_Capture
/// Thanks to whoever wrote it, change marked with comments of the old code
///
/// I didnt want to use Windows.Forms, and I might just have to modify this a bit more
/// to be Xbox 360 friendly, but I hope for now it works fine.
///
public class Screenshot
{
private ResolveTexture2D screenshotRT;
private string screenshotPath;

public Screenshot()
{
screenshotPath = AppDomain.CurrentDomain.BaseDirectory + "\\screenshots";
//Original Line:
// screenshotPath = System.Windows.Forms.Application.StartupPath + "\\screenshots";

if (!System.IO.Directory.Exists(screenshotPath))
System.IO.Directory.CreateDirectory(screenshotPath);
}

public void TakeScreenshot(GraphicsDevice device)
{
int w = device.PresentationParameters.BackBufferWidth;
int h = device.PresentationParameters.BackBufferHeight;

screenshotRT = new ResolveTexture2D(device, w, h, 1, SurfaceFormat.Bgr32);

device.ResolveBackBuffer(screenshotRT);

Thread newThread = new Thread(ScreenshotThread);
newThread.Start();
}

private void ScreenshotThread()
{
if (!screenshotRT.IsDisposed)
{
string timestampName = DateTime.Now.ToString("yyyyMMdd_HHmmss");

int i = 1;
while (File.Exists(String.Format("{0}\\{1}.png", screenshotPath, timestampName)))
{
timestampName += " (" + i + ")";
i++;
}

string filename = String.Format("{0}\\{1}.png", screenshotPath, timestampName);

screenshotRT.Save(filename, ImageFileFormat.Png);

screenshotRT.Dispose();
}
}

///
/// Conclussion of EExtensions base code
/// Usable by anyone, all code written by Ernest Loveland unless otherwise specified
/// (eg. Screenshot class from XNAWiki)
///

///TODO List:
/// -----------------------------------------------------------
//public class Collision3D
//public class EMathHelper
//public class ScreenManager
//public class ViewPortManager
//public class GameStateManager
/// -----------------------------------------------------------
/// Emath helper may seem like a funny thing to have seeing as
/// XNA already has a MathHelper, but its more for things like
/// finding the (x,y) or (x,z) co-ordinates in a certain direction
/// and so on and so forth.
}

public class Collision2D
{
bool SimpleCollision(Texture2D AreaToCheck, Vector2 PointToCheck, Vector2 AreaTranslation)
{
return ((Vector2.X >= AreaTranslation.X) &&
(Vector2.X <= AreaToCheck.Height + AreaTranslation.X) &&
(Vector2.Y >= AreaTranslation.Y) &&
(Vector2.Y <= AreaToCheck.Width + AreaTranslation.Y));
}
//bool pixelperfectcollision(texture2D Im1, Texture2D Im2, Vector2 Pos1, Vector2 Pos2
}
}
}