/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
_manchotsPosition = Vector2.Zero;
_manchotsDisplacement = Vector2.One;
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
base.Initialize();
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the current launcher orientation
currentOrientation = ApplicationLauncher.Orientation;
// Subscribe to surface application activation events
ApplicationLauncher.ApplicationActivated += OnApplicationActivated;
ApplicationLauncher.ApplicationPreviewed += OnApplicationPreviewed;
ApplicationLauncher.ApplicationDeactivated += OnApplicationDeactivated;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
base.Initialize();
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
screenWidth = Program.WindowSize.Width;
screenHeight = Program.WindowSize.Height;
manager = new Manager();
manager.Behaviour = new Behaviour(screenWidth, screenHeight);
manager.Initialize(this, touchTarget, Manager.SelectionMode.NONE);
batLeft = new Sprite("raquette1", "raquette1");
batLeft.Initialize(touchTarget);
batLeft.Weight = 1;
manager.register(batLeft);
batRight = new Sprite("raquette2", "raquette2");
batRight.Initialize(touchTarget);
batRight.Weight = 1;
batRight.Position = new Vector2(screenWidth - 140, screenHeight - 455);
manager.register(batRight);
bignou = new Sprite("bignou", "paletGame");
bignou.Initialize(touchTarget);
bignou.Position = new Vector2((screenWidth - 250) / 2, (screenHeight - 250) / 2);
manager.register(bignou);
base.Initialize();
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
screenWidth = Program.WindowSize.Width;
screenHeight = Program.WindowSize.Height;
BignouPosition = Vector2.Zero;
BignouDep = Vector2.Zero;
batLeft = new Bat();
batLeft.Initialize(touchTarget);
batRight = new Bat();
batRight.Initialize(touchTarget);
batRight.Position = new Vector2(screenWidth - 140, screenHeight - 455);
/*raquetteGauchePosition = new Vector2(0,0);
* raquetteGaucheDep = new Vector2(0,1);
* raquetteGaucheCurrentDep = new Vector2(0, 0);*/
/*raquetteDroitePosition = new Vector2(screenWidth - 140, screenHeight-455);
* raquetteDroiteDep = new Vector2(0, 1);
* raquetteDroiteCurrentDep = new Vector2(0, 0);*/
//raqetteSpeed = 5;
base.Initialize();
}
/// <summary>
/// Reset the application's orientation and transform based on the current launcher orientation.
/// </summary>
private void ResetOrientation()
{
UserOrientation newOrientation = ApplicationLauncher.Orientation;
if (newOrientation == currentOrientation)
{
return;
}
currentOrientation = newOrientation;
screenTransform = currentOrientation == UserOrientation.Top ? inverted : Matrix.Identity;
}
/// <summary>
/// Constructor
/// </summary>
public ContactDataVisualizer()
{
diagrams = new Dictionary<Contact, ContactDiagram>();
InitializeComponent();
UpdateStatistics();
orientation = ApplicationLauncher.Orientation;
//Event handlers for ContactDown, ContactChanged and LostContactCapture are
//added in ContactDataVisualizer.xaml.
sharedController = ContacDataController.Instance;
serverController = ServerController.Instance;
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the current launcher orientation
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface application activation events
ApplicationServices.WindowInteractive += OnApplicationActivated;
//ApplicationLauncher.ApplicationActivated += OnApplicationActivated;
ApplicationServices.WindowNoninteractive += OnApplicationPreviewed;
//ApplicationLauncher.ApplicationPreviewed += OnApplicationPreviewed;
ApplicationServices.WindowUnavailable += OnApplicationPreviewed;
//ApplicationLauncher.ApplicationDeactivated += OnApplicationDeactivated;
// Setup the UI to transform if the UI is rotated.
//if (currentOrientation == UserOrientation.Top)
//{
// Create a rotation matrix to orient the screen so it is viewed correctly when the user orientation is 180 degress different.
//Matrix rotation = Matrix.CreateRotationZ(MathHelper.ToRadians(180));
//Matrix translation = Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width, graphics.GraphicsDevice.Viewport.Height, 0);
//screenTransform = rotation * translation;
//}
base.Initialize();
//int port = 0;
//bool parseSucc = int.TryParse(ConfigurationSettings.AppSettings["RemotePort"], out port);
_OSCSender = new OSCTransmitter(Properties.Settings.Default.RemoteHost, Properties.Settings.Default.RemotePort);
//_OSCSender = new OSCTransmitter("127.0.0.1", 3333);
_Frame = 0;
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
controller = new UIController(touchTarget, HitTestCallback);
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Create a rotation matrix to orient the screen so it is viewed correctly,
// when the user orientation is 180 degress different.
Matrix rotation = Matrix.CreateRotationZ(MathHelper.ToRadians(180));
Matrix translation = Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height, 0);
Matrix inverted = rotation * translation;
PopulateGameWorld();
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
scatterView.Transform = screenTransform;
base.Initialize();
}
/// <summary>
/// Allow derived classes to perform additional operations
/// when orientation changes. This would be necessary for items not
/// affected by the SpriteBatch transform.
/// </summary>
/// <param name="newOrientation">The new user orientation.</param>
/// <param name="transform">The transform associated with the new orientation.</param>
protected virtual void OnOrientationReset(UserOrientation newOrientation, Matrix transform)
{
// Empty.
}
/// <summary>
/// Updates UIElements when Shell orientation changes.
/// </summary>
/// <param name="newOrientation"></param>
/// <param name="transform"></param>
public void ResetOrientation(UserOrientation newOrientation, Matrix transform)
{
if (newOrientation == currentOrientation) return;
currentOrientation = newOrientation;
ScreenTransform = transform;
OnOrientationReset(newOrientation, transform);
foreach (UIElement child in children)
{
child.ResetOrientation(newOrientation, transform);
}
}
/// <summary>
/// Private contructor invoked by overloaded base contructors to build the UIElement.
/// </summary>
/// <param name="game"></param>
/// <param name="controller"></param>
/// <param name="textureFile"></param>
/// <param name="texture"></param>
/// <param name="position">Position of the UIElement (relative or screen coordinates)</param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="parent"></param>
private UIElement(Game game,
UIController controller,
string textureFile, Texture2D texture,
Vector2? position,
int width, int height,
UIElement parent)
: base(game)
{
// Should only set one or the other, not both.
Debug.Assert(textureFile == null || texture == null);
this.controller = controller;
this.textureSourceFile = textureFile;
this.texture = texture;
this.width = width;
this.height = height;
this.parent = parent;
instanceCount++;
Name = "UIElement " + instanceCount.ToString(CultureInfo.InvariantCulture);
if (parent != null)
{
// Inherit some properties from the parent (containing) UIElement.
currentOrientation = parent.currentOrientation;
screenTransform = parent.ScreenTransform;
spriteBlendState = parent.SpriteBlendState;
spriteSortMode = parent.spriteSortMode;
// Draw children in front of parents.
layerDepth = parent.layerDepth * 0.9f;
// Position is a relative to parent's Center.
if (position != null)
{
relativePosition = Vector2.Clamp(position.Value,
new Vector2(-0.5f, -0.5f),
new Vector2(0.5f, 0.5f));
Vector2 center = parent.Center;
float x = center.X + relativePosition.X * parent.Width;
float y = center.Y + relativePosition.Y * parent.Height;
Center = new Vector2(x, y);
}
// Add this to parent's liest of children.
parent.AddChild(this);
}
else
{
// Position is in screen coordinates.
if (position != null)
{
Center = position.Value;
}
}
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
readConfigurationFile();
Resources.Instance.GraphicsDevice = GraphicsDevice;
Resources.Instance.Graphics = graphics;
Resources.Instance.Content = Content;
Resources.Instance.Game = this;
TouchPanel.EnabledGestures = GestureType.FreeDrag | GestureType.Tap;
TouchPanel.WindowHandle = this.Window.Handle;
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
//Custom Initialize
paseoVirtual = new PaseoVirtual();
paseoVirtual.Create("PaseoVirtualFast.xml");
loadingTimerAnimation = new Timer(40); //25 fps
loadingTimerAnimation.Elapsed += new ElapsedEventHandler(loadingTimerAnimation_Elapsed);
loadingTimerAnimation.Enabled = true;
base.Initialize();
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
Console.WriteLine("Initialisation du jeu");
loadConfig();
Background bBackground = new Background(new Vector2(0, 0), Background.Track.Menu);
DrawableObjects.Add("background", bBackground);
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
base.Initialize();
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the current launcher orientation
currentOrientation = ApplicationLauncher.Orientation;
// Subscribe to surface application activation events
ApplicationLauncher.ApplicationActivated += OnApplicationActivated;
ApplicationLauncher.ApplicationPreviewed += OnApplicationPreviewed;
ApplicationLauncher.ApplicationDeactivated += OnApplicationDeactivated;
// Setup the UI to transform if the UI is rotated.
if (currentOrientation == UserOrientation.Top)
{
// Create a rotation matrix to orient the screen so it is viewed correctly when the user orientation is 180 degress different.
Matrix rotation = Matrix.CreateRotationZ(MathHelper.ToRadians(180));
Matrix translation = Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width, graphics.GraphicsDevice.Viewport.Height, 0);
screenTransform = rotation * translation;
}
base.Initialize();
}
/// <summary>
/// Reset the application's orientation and transform based on the current launcher orientation.
/// </summary>
private void ResetOrientation()
{
UserOrientation newOrientation = ApplicationLauncher.Orientation;
if (newOrientation == currentOrientation) { return; }
currentOrientation = newOrientation;
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
else
{
screenTransform = Matrix.Identity;
}
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
_currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(_graphics.GraphicsDevice.Viewport.Width,
_graphics.GraphicsDevice.Viewport.Height,
0);
if (_currentOrientation == UserOrientation.Top)
{
_screenTransform = inverted;
}
//Setup User and Projectile Managers
_userManager = new UserManager(this);
_projectileManager = new ProjectileManager(this);
_inputManager = new InputManager(this, _userManager, _projectileManager);
_weaponsManager = new WeaponsManager(this);
_collisionManager = new CollisionManager(this, _userManager, _projectileManager, _weaponsManager);
Components.Add(_userManager);
Components.Add(_projectileManager);
Components.Add(_inputManager);
Components.Add(_weaponsManager);
Components.Add(_collisionManager);
PubNubObservable.Publish(Constants.SURFACE_CHANNEL, new { start = true });
base.Initialize();
}
/// <summary>
/// Re-orients items not affected by SpriteBatch screenTransform.
/// </summary>
/// <remarks>Overrides OnOrientationReset method from UIElement.</remarks>
/// <param name="newOrientation">The new user orientation.</param>
/// <param name="transform">The transform associated with the new orientation.</param>
protected override void OnOrientationReset(UserOrientation newOrientation, Matrix transform)
{
// Compute new scissorRectange based on newOrientation.
if (newOrientation == UserOrientation.Top)
{
Vector2 topLeft = new Vector2(scissorRectangle.X, scissorRectangle.Y);
topLeft = Vector2.Transform(topLeft, transform);
scissorRectangle = new Rectangle(Convert.ToInt32(topLeft.X) - maxWidth,
Convert.ToInt32(topLeft.Y) - maxHeight,
maxWidth, maxHeight);
}
else
{
scissorRectangle = new Rectangle(Convert.ToInt32(Left), Convert.ToInt32(Top), maxWidth, maxHeight);
}
}
/// <summary>
/// Resets the application's orientation and screen transform
/// based on the current launcher orientation.
/// </summary>
private void ResetOrientation(UserOrientation newOrientation)
{
if (newOrientation == currentOrientation)
{
return;
}
currentOrientation = newOrientation;
switch (currentOrientation)
{
case UserOrientation.Bottom:
screenTransform = Matrix.Identity;
break;
case UserOrientation.Top:
screenTransform = inverted;
break;
}
// Re-orient top-level components.
textiles.ScreenTransform = screenTransform;
foreach (GameComponent component in Components)
{
UIElement element = component as UIElement;
if (element != null)
{
if (element == meshCanvas) continue;
element.ResetOrientation(newOrientation, screenTransform);
}
}
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
screenWidth = Program.WindowSize.Width;
screenHeight = Program.WindowSize.Height;
manager = new Manager();
manager.Behaviour = new Behaviour(screenWidth, screenHeight);
manager.Initialize(this, touchTarget, Manager.SelectionMode.NONE);
batLeft = new Sprite("raquette1", "raquette1");
batLeft.Initialize(touchTarget);
batLeft.Weight = 1;
manager.register(batLeft);
batRight = new Sprite("raquette2", "raquette2");
batRight.Initialize(touchTarget);
batRight.Weight = 1;
batRight.Position = new Vector2(screenWidth - 140, screenHeight - 455);
manager.register(batRight);
bignou = new Sprite("bignou", "paletGame");
bignou.Initialize(touchTarget);
bignou.Position = new Vector2((screenWidth - 250) / 2, (screenHeight - 250) / 2);
manager.register(bignou);
base.Initialize();
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
screenWidth = Program.WindowSize.Width;
screenHeight = Program.WindowSize.Height;
manager = new Manager();
manager.Initialize(this, touchTarget, Manager.SelectionMode.MONO);
manager.Behaviour = new BehaviourPlane(screenWidth, screenHeight, _serverIP);
aircraftCarrier = new Sprite("aircraftCarrier", "aircraftCarrier");
aircraftCarrier.Initialize(touchTarget);
aircraftCarrier.Touchable = false;
manager.Register(aircraftCarrier);
plane1 = new enib.pa.Plane("plane1");
plane1.Initialize(touchTarget);
plane1.Scale = 0.13f;
plane1.Weight = 1;
plane1.Rotation = -(float)0;
plane1.ShowBoundingRect = true;
plane1.Dragable = false;
manager.Register(plane1);
plane2 = new enib.pa.Plane("plane2");
plane2.Initialize(touchTarget);
plane2.Scale = 0.13f;
plane2.Weight = 1;
plane2.Rotation = (float)Math.PI / 2;
plane2.ShowBoundingRect = true;
plane2.Dragable = false;
manager.Register(plane2);
plane3 = new enib.pa.Plane("plane3");
plane3.Initialize(touchTarget);
plane3.Scale = 0.13f;
plane3.Weight = 1;
plane3.Rotation = (float)Math.PI;
plane3.ShowBoundingRect = true;
plane3.Dragable = false;
manager.Register(plane3);
plane4 = new enib.pa.Plane("plane4");
plane4.Initialize(touchTarget);
plane4.Scale = 0.13f;
plane4.Weight = 1;
plane4.Rotation = -(float)Math.PI / 2;
plane4.ShowBoundingRect = true;
plane4.Dragable = false;
manager.Register(plane4);
menu_pt1 = new Plane_Menu_Elevator("ascenseur1");
menu_pt1.setPlaneur(plane1);
menu_pt2 = new Plane_Menu_Catapulte1("catapulte1");
menu_pt2.setPlaneur(plane1);
menu_pt3 = new Plane_Menu_Catapulte2("catapulte2");
menu_pt3.setPlaneur(plane1);
menu = new Enib.SurfaceLib.Menu(manager, plane1);
menu.Initialize(touchTarget);
menu.addMenuEntry(menu_pt1);
menu.addMenuEntry(menu_pt2);
menu.addMenuEntry(menu_pt3);
menu.Hide();
base.Initialize();
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the current launcher orientation
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface application activation events
ApplicationServices.WindowInteractive += OnApplicationActivated;
//ApplicationLauncher.ApplicationActivated += OnApplicationActivated;
ApplicationServices.WindowNoninteractive += OnApplicationPreviewed;
//ApplicationLauncher.ApplicationPreviewed += OnApplicationPreviewed;
ApplicationServices.WindowUnavailable += OnApplicationPreviewed;
//ApplicationLauncher.ApplicationDeactivated += OnApplicationDeactivated;
// Setup the UI to transform if the UI is rotated.
//if (currentOrientation == UserOrientation.Top)
//{
// Create a rotation matrix to orient the screen so it is viewed correctly when the user orientation is 180 degress different.
//Matrix rotation = Matrix.CreateRotationZ(MathHelper.ToRadians(180));
//Matrix translation = Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width, graphics.GraphicsDevice.Viewport.Height, 0);
//screenTransform = rotation * translation;
//}
base.Initialize();
//int port = 0;
//bool parseSucc = int.TryParse(ConfigurationSettings.AppSettings["RemotePort"], out port);
_OSCSender = new OSCTransmitter(Properties.Settings.Default.RemoteHost, Properties.Settings.Default.RemotePort);
//_OSCSender = new OSCTransmitter("127.0.0.1", 3333);
_Frame = 0;
}
/// <summary>
/// Constructor.
/// </summary>
public ContactDiagram(UserOrientation startingOrientation)
{
InitializeComponent();
orientation = startingOrientation;
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
screenTransform = inverted;
}
screenWidth = Program.WindowSize.Width;
screenHeight = Program.WindowSize.Height;
manager = new Manager();
manager.Initialize(this, touchTarget, Manager.SelectionMode.MONO);
manager.Behaviour = new BehaviourPlane(screenWidth, screenHeight, _serverIP);
aircraftCarrier = new Sprite("aircraftCarrier", "aircraftCarrier");
aircraftCarrier.Initialize(touchTarget);
aircraftCarrier.Touchable = false;
manager.Register(aircraftCarrier);
plane1 = new enib.pa.Plane("plane1");
plane1.Initialize(touchTarget);
plane1.Scale = 0.13f;
plane1.Weight = 1;
plane1.Rotation = -(float)0;
plane1.ShowBoundingRect = true;
plane1.Dragable = false;
manager.Register(plane1);
plane2 = new enib.pa.Plane("plane2");
plane2.Initialize(touchTarget);
plane2.Scale = 0.13f;
plane2.Weight = 1;
plane2.Rotation = (float)Math.PI /2;
plane2.ShowBoundingRect = true;
plane2.Dragable = false;
manager.Register(plane2);
plane3 = new enib.pa.Plane("plane3");
plane3.Initialize(touchTarget);
plane3.Scale = 0.13f;
plane3.Weight = 1;
plane3.Rotation = (float)Math.PI;
plane3.ShowBoundingRect = true;
plane3.Dragable = false;
manager.Register(plane3);
plane4 = new enib.pa.Plane("plane4");
plane4.Initialize(touchTarget);
plane4.Scale = 0.13f;
plane4.Weight = 1;
plane4.Rotation = -(float)Math.PI / 2;
plane4.ShowBoundingRect = true;
plane4.Dragable = false;
manager.Register(plane4);
menu_pt1 = new Plane_Menu_Elevator("ascenseur1");
menu_pt1.setPlaneur(plane1);
menu_pt2 = new Plane_Menu_Catapulte1("catapulte1");
menu_pt2.setPlaneur(plane1);
menu_pt3 = new Plane_Menu_Catapulte2("catapulte2");
menu_pt3.setPlaneur(plane1);
menu = new Enib.SurfaceLib.Menu(manager, plane1);
menu.Initialize(touchTarget);
menu.addMenuEntry(menu_pt1);
menu.addMenuEntry(menu_pt2);
menu.addMenuEntry(menu_pt3);
menu.Hide();
base.Initialize();
}
/// <summary>
/// Allows the app to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
IsMouseVisible = true; // easier for debugging not to "lose" mouse
SetWindowOnSurface();
InitializeSurfaceInput();
// Set the application's orientation based on the orientation at launch
currentOrientation = ApplicationServices.InitialOrientation;
// Subscribe to surface window availability events
ApplicationServices.WindowInteractive += OnWindowInteractive;
ApplicationServices.WindowNoninteractive += OnWindowNoninteractive;
ApplicationServices.WindowUnavailable += OnWindowUnavailable;
// Setup the UI to transform if the UI is rotated.
// Create a rotation matrix to orient the screen so it is viewed correctly
// when the user orientation is 180 degress different.
Matrix inverted = Matrix.CreateRotationZ(MathHelper.ToRadians(180)) *
Matrix.CreateTranslation(graphics.GraphicsDevice.Viewport.Width,
graphics.GraphicsDevice.Viewport.Height,
0);
if (currentOrientation == UserOrientation.Top)
{
//screenTransform = inverted;
}
graphics.IsFullScreen = true;
graphics.PreferredBackBufferHeight = GraphicsDevice.Viewport.Height;
graphics.PreferredBackBufferWidth = GraphicsDevice.Viewport.Width;
myInitialize();
base.Initialize();
}
