public Client(GameController game)
{
this.game = game;
this.player = GameObject.Find ("Player");
/* dan
this.lightController = ((LightController)GameObject.FindObjectOfType(typeof(LightController)));
this.enemies = (Enemy[])GameObject.FindObjectsOfType(typeof(Enemy));
*/
this.playerAvatar = GameObject.Find("AvatarMainPlayer");
this.playerEAvatar = GameObject.Find("AvatarEnemyPlayer");
if (!Config.Instance.IsStandalone)
{ //CaveClient
disableControl();
disableAllRigidBodys();
}
else
{ //GameClient version
this.observer = (NetworkObserver)GameObject.FindObjectOfType(typeof(NetworkObserver));
this.wiiController = (WiiController)GameObject.FindObjectOfType(typeof(WiiController));
this.kinectController = (KinectController)GameObject.FindObjectOfType(typeof(KinectController));
this.cameraRotationTransform = ((KinectController)GameObject.FindObjectOfType(typeof(KinectController))).transform;
}
}
/* this uses the distance from the torso to determine the factor of rotation */
void HandExtensionGestureUpdate()
{
KinectController kinect = Kinect.GetComponent <KinectController>();
/* where are all the joints? */
Body skel = kinect.PlayerSkeleton;
Vector3 rHPosition = skel.GetPosition(JointType.HandRight);
Vector3 lHPosition = skel.GetPosition(JointType.HandLeft);
Vector3 neckPosition = skel.GetPosition(JointType.Neck);
/* how far are the joints from the body center (use neck x position as an approximation)? */
float rHOffsetFromBody = rHPosition.x - neckPosition.x;
float lHOffsetFromBody = lHPosition.x - neckPosition.x;
/* are the hands on their respective side of the body (e.g., left on the left side)? */
/* [Left Hand] [Body Center] [Right Hand]
* ---- 0 --- 1 --- 2 -- 3 -- 4 -- 5 -- 6 -- [+x-axis] ---->
*/
bool rHOnRightSide = rHOffsetFromBody > 0; /* is positive if the right hand is outstretched */
bool lHOnLeftSide = lHOffsetFromBody < 0; /* is negative if the left hand is outstretched */
/* calculate the offset absolute value so that it can be used for thresholding */
rHExtensionFactor = System.Math.Abs(rHOffsetFromBody);
lHExtensionFactor = System.Math.Abs(lHOffsetFromBody);
/*DEBUG: */
rightDebugString.text = rHOffsetFromBody.ToString();
leftDebugString.text = lHOffsetFromBody.ToString();
rightHandMovingRight();
leftHandMovingLeft();
}
private void InitNavigation()
{
avatarConnector = new AvatarAdapterConnector(this);
if (Config.Instance.UseWii)
{
wiiController = GetComponentInChildren <WiiController> ();
//wiiTurnMediator = new SimpleWiiTurnNavigationMediator ( wiiController.WiiMote, avatarConnector );
// RedirectToFrontTurnMediator benutzt Radianten. Da es den selben Callback setTurnVelocity() (siehe unten)
// nutzt, muss das hier auch in Radiant sein.
//wiiTurnMediator.setTargetTurnVelocity ( defaultTurnVelocityDegPerSec*Mathf.Deg2Rad );
//wiiWalkMediator = new SimpleWiiWalkNavigationMediator ( wiiController.WiiMote, avatarConnector );
// wiiWalkMediator.setTargetWalkVelocity ( defaultWalkVelocityMeterPerSec );
}
if (Config.Instance.UseKinect)
{
kinectController = GetComponentInChildren <KinectController> ();
wipWalkMediator = new WalkingInPlaceNavigationMediator(kinectController.Kinect, avatarConnector);
redirectToFrontTurnMediator = new RedirectToFrontNavigationMediator(kinectController.Kinect, avatarConnector);
}
this.ToggleNav();
}
public Client(GameController game)
{
this.game = game;
this.player = GameObject.Find("Player");
/* dan
* this.lightController = ((LightController)GameObject.FindObjectOfType(typeof(LightController)));
* this.enemies = (Enemy[])GameObject.FindObjectsOfType(typeof(Enemy));
*/
this.playerAvatar = GameObject.Find("AvatarMainPlayer");
this.playerEAvatar = GameObject.Find("AvatarEnemyPlayer");
if (!Config.Instance.IsStandalone)
{ //CaveClient
disableControl();
disableAllRigidBodys();
}
else
{ //GameClient version
this.observer = (NetworkObserver)GameObject.FindObjectOfType(typeof(NetworkObserver));
this.wiiController = (WiiController)GameObject.FindObjectOfType(typeof(WiiController));
this.kinectController = (KinectController)GameObject.FindObjectOfType(typeof(KinectController));
this.cameraRotationTransform = ((KinectController)GameObject.FindObjectOfType(typeof(KinectController))).transform;
}
}
private void KeyRelease(object sender, KeyEventArgs e)
{
// Gets the data context.
KinectController model = DataContext as KinectController;
IPausable viewModel = model.NavigationManager.CurrentNavigationContext as IPausable;
// The current view model is not IPausable
if (viewModel == null)
{
return;
}
if (e.Key == Key.Space)
{
if (viewModel.IsPaused)
{
viewModel.Resume();
}
else
{
viewModel.Pause();
}
}
if (e.Key == Key.Escape)
{
model.NavigationManager.GoBack();
}
}
void Start()
{
Kinect = KinectController.Instance;
if (Kinect != null)
{
this.kinectInUse = Kinect.useKinect;
}
else
{
this.kinectInUse = false;
}
camHolder = GameObject.Find("CamHolder").transform;
leftCam = GameObject.Find("CameraLeft");
frontCam = GameObject.Find("CameraFront");
rightCam = GameObject.Find("CameraRight");
bottomCam = GameObject.Find("CameraBottom");
leftCam.GetComponent <Camera> ().stereoSeparation = eyeDistance;
leftCam.GetComponent <Camera> ().stereoConvergence = eyeConvergence;
frontCam.GetComponent <Camera> ().stereoSeparation = eyeDistance;
frontCam.GetComponent <Camera> ().stereoConvergence = eyeConvergence;
rightCam.GetComponent <Camera> ().stereoSeparation = eyeDistance;
rightCam.GetComponent <Camera> ().stereoConvergence = eyeConvergence;
bottomCam.GetComponent <Camera> ().stereoSeparation = eyeDistance;
bottomCam.GetComponent <Camera> ().stereoConvergence = eyeConvergence;
startPos = camHolder.localPosition;
//armaturePlayer1 = new BodyArmature("PlayerMainAvatar");
}
public ClientViewModel(Views.Client window)
{
Window = window;
if (!string.IsNullOrWhiteSpace(Properties.Settings.Default.IP))
{
IP = Properties.Settings.Default.IP;
}
else
{
IP = "";
}
KinectController = new KinectController(false);
KinectController.PropertyChanged += new EventHandler((sender, e) => { RaisePropertyChanged("KinectController"); });
KinectController.NewRemoteFrameArrived += new EventHandler <NewRemoteFrameArgs>((sender, e) => { client.SendFrameToServer(e); });
KinectController.InitKinect();
Client = new Common.TCP.Client(Properties.Settings.Default.Port);
Client.ClientPropertyChanged += new EventHandler((sender, e) => { RaisePropertyChanged("Client"); });
Client.ClientStartRequested += new EventHandler((sender, e) => { KinectController.Start(); });
Client.ClientStopRequested += new EventHandler((sender, e) => { KinectController.Stop(); });
Client.ClientPrepareRequested += new EventHandler((sender, e) => { KinectController.Prepare(); });
client.ClientForceFPSRequested += new EventHandler <bool>((sender, e) => { KinectController.ForceFPS(e); });
Client.ClientCloseRequested += new EventHandler((sender, e) => { CloseTimer.Start(); });
CloseTimer.Tick += CloseTimer_Tick;
}
public MainWindow()
{
InitializeComponent();
KinectController.EnsureKinectConnection();
kinectController = new KinectController();
alarmController = new AlarmController();
kinectController.Setup(
rgbImage: rgbImage,
stopButton: stopButton,
skeletonCanvas: skeletonCanvas,
alarmController: alarmController
);
alarmController.Setup(
initialWindow: initialWindow,
inputGrid: inputGrid,
hourInput: hourInput,
minuteInput: minuteInput,
setButton: setButton,
unsetButton: unsetButton,
stopButton: stopButton,
kinectController: kinectController
);
}
public MainWindow(KinectController controller)
{
InitializeComponent();
if (controller == null)
{
throw new ArgumentNullException("controller", Properties.Resources.KinectControllerInvalid);
}
this.controller = controller;
controller.EngagedUserColor = (Color)Resources["EngagedUserColor"];
controller.TrackedUserColor = (Color)Resources["TrackedUserColor"];
controller.EngagedUserMessageBrush = (Brush)Resources["EngagedUserMessageBrush"];
controller.TrackedUserMessageBrush = (Brush)Resources["TrackedUserMessageBrush"];
kinectRegion.HandPointersUpdated +=
(sender, args) => controller.OnHandPointersUpdated(kinectRegion.HandPointers);
DataContext = controller;
movementDetector = new MouseMovementDetector(this);
movementDetector.IsMovingChanged += OnIsMouseMovingChanged;
movementDetector.Start();
}
void Start()
{
//コンポーネント読み込み
rb2d = GetComponent <Rigidbody2D>();
stst = true;
kinect = new KinectController();
}
private void Start()
{
cavePlayerController = GetComponentInParent <CavePlayerController>();
if (!cavePlayerController.testMode)
{
kinectController = GetComponentInParent <InputController>().GetKinectController();
}
}
void Update()
{
PlayerController player = Player.GetComponent <PlayerController>();
KinectController kinect = Kinect.GetComponent <KinectController>();
FlyDetector fly = Fly.GetComponent <FlyDetector>();
if (kinect.PlayerSkeleton == null)
{
return;
}
if (fly.IsActivated)
{
float elapsedTime = Time.deltaTime;
if (takeOffTimer < takeOffTime)
{
transform.position += Vector3.up * speed * elapsedTime;
takeOffTimer += elapsedTime;
}
else
{
WindowsKinect.Body playerSkeleton = kinect.PlayerSkeleton;
fly.Set(
playerSkeleton.GetPosition(WindowsKinect.JointType.ShoulderLeft),
playerSkeleton.GetPosition(WindowsKinect.JointType.ShoulderRight),
playerSkeleton.GetPosition(WindowsKinect.JointType.ElbowLeft),
playerSkeleton.GetPosition(WindowsKinect.JointType.ElbowRight));
//Debug.Log(string.Format("{0} | {1}", transform.rotation.z, fly.Angle));
if (Mathf.Abs(transform.rotation.z - fly.Angle) > 0.02f)
{
FlyDirection rotation = fly.FlyDirection;
float degree = 0f;
if (rotation == FlyDirection.Right)
{
degree = fly.Angle > transform.rotation.z ? 1f : -1f;
}
else if (rotation == FlyDirection.Left)
{
degree = fly.Angle < transform.rotation.z ? -1f : 1f;
}
transform.Rotate(new Vector3(0f, 0f, 1f), 2f * degree * Mathf.PI / 2f * elapsedTime);
}
//transform.position += new Vector3(0f, 0f, -1f) * speed * elapsedTime;
}
}
else if (!player.renderer.enabled)
{
fly.Activate();
}
}
public void Close(object sender, CancelEventArgs e)
{
kinectController.Dispose();
alarmController.Dispose();
kinectController = null;
alarmController = null;
rgbImage.Source = null;
skeletonCanvas.Children.Clear();
}
public BackgroundTask()
{
EnablePreview = true;
Gradient = BuildGradient(); //Gradiente para colorear las imagenes de profundidad
//Controlador para empezar a capturar imagenes de la camara
kinectController = new KinectController();
kinectController.Frame += new KinectController.NewImageHandler(NewFrameListener);
}
/*Inistializes the controllers*/
void Start()
{
kinect = KinectController.Instance;
if (kinect != null)
{
kinectInUse = kinect.useKinect;
}
/*Gets a referenz of the 'HandOpenControll' of the current Object*/
handOpen = GetComponent <HandOpenControll> ();
}
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
}
}
void Update()
{
KinectController kinect = Kinect.GetComponent <KinectController>();
Vector3 newPostion = kinect.PlayerSkeleton.GetPosition(whichHand);
newPostion.z = 0;
newPostion.x *= speedMultiplier;
newPostion.y *= speedMultiplier;
transform.position = newPostion;
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
KinectOptions options = new KinectOptions()
{
enableDepth = true,
enableTracking = true
};
controller = KinectController.getInstance(options);
controller.DepthImageReady += new KinectController.DepthImageHandler(controller_DepthImageReady);
}
private void Awake()
{
cavePlayerController = GetComponent <CavePlayerController>();
kinectController = GetComponent <KinectController>();
wiiController = GetComponent <WiiController>();
if (cavePlayerController.testMode)
{
kinectController.enabled = false;
wiiController.enabled = false;
}
}
void Start()
{
error = ErrorLog.GetInstance();
player = GameObject.Find("Player");
Kinect = KinectController.Instance;
this.kinectInUse = Kinect.useKinect;
//camHolder = GameObject.Find("CamHolder").transform;
body = GameObject.Find("Player").GetComponent <CapsuleCollider>();
leftArm = GameObject.Find("LeftArm");
rightArm = GameObject.Find("RightArm");
armaturePlayer1 = new BodyArmature("PlayerMainAvatar");
}
private void Awake()
{
userList = GameObject.FindObjectsOfType <KUser>();
if (Instance == null)
{
Instance = this;
}
else if (Instance != null)
{
Debug.LogWarning("Found more than 1 kinectControler instance");
Destroy(gameObject);
}
}
/*Initialises the Intsances and sets default Values on the Collider*/
void Start()
{
kinectC = (KinectController)FindObjectOfType(typeof(KinectController)); // GameObject.Find ("KinectController");
if (kinectC != null)
{
kinectC = KinectController.Instance;
kinectInUse = kinectC.useKinect;
}
playerCollider = GetComponent <CapsuleCollider> ();
playerCollider.radius = 0.2f;
//playerCollider.height = 0.8f;
playerCollider.height = 0.5f;
}
public KinectControllerViewModel(KinectController parent)
{
_parent = parent;
_kinectSensor = KinectSensor.GetDefault();
_kinectSensor.IsAvailableChanged += (_, __) => IsKinectAvailable = _kinectSensor.IsAvailable;
_bodyFrameReader = _kinectSensor.BodyFrameSource.OpenReader();
_bodyFrameReader.FrameArrived += OnFrameArrived;
_kinectSensor.Open();
IsKinectAvailable = _kinectSensor.IsAvailable;
BoneViewer = new BoneViewerViewModel(this);
}
void Update()
{
KinectController kinect = Kinect.GetComponent <KinectController>();
Vector3 newPostion = kinect.PlayerSkeleton.GetPosition(JointType.HandRight);
//Vector3 diff = newPostion - transform.position;
//Debug.Log(diff);
//transform.position += diff.normalized;
//transform.TransformPoint(diff.normalized);
newPostion.z = 0;
newPostion.x *= speedMultiplier;
newPostion.y *= speedMultiplier;
transform.position = newPostion;
}
void Update()
{
KinectController kinect = Kinect.GetComponent <KinectController>();
handWaveController = HandWave.GetComponent <HandWaveDetector>();
jumpController = Jump.GetComponent <JumpDetector>();
if (kinect.PlayerSkeleton == null)
{
rigidbody.velocity = Vector3.zero;
return;
}
UpdateHandWave(kinect);
UpdateJump(kinect);
}
protected void SetupKinect()
{
if (kinectSensor == null)
{
KinectController.AddRef();
kinectSensor = KinectController.sensor;
}
if (KinectController.depthFrameData == null)
{
ShowComponentError("No depth frame data provided by the Kinect.");
return;
}
// Initialize all arrays
trimmedWidth = KinectController.depthWidth - leftColumns - rightColumns;
trimmedHeight = KinectController.depthHeight - topRows - bottomRows;
}
public frmKinect()
{
InitializeComponent();
img = this.SetImageOpacity(img, 0.3f);
btnStream.Enabled = false;
kController = new KinectController(this);
if (kController.KsResult.IsExist)
{
kController.InitValues(this, true, kController.KsResult.KSensor.Status, kController.KsResult.KSensor.DeviceConnectionId);
}
else
{
MessageBox.Show("Device not found!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
kController.InitValues(this, false, KinectStatus.Undefined, string.Empty);
}
}
//private NetworkObserver observer;
/// <summary>
/// Start this instance.
/// alle Bewegungseingaben werden hier behandelt (WASD, oder WII)2
/// </summary>
void Start()
{
wiiController = WiiController.Instance;
kinect = GameObject.FindObjectOfType <KinectController> ();
if (kinect != null)
{
Debug.Log("Kinect found");
useKinect = kinect.useKinect;
}
//this.InitNavigation();
Debug.Log("searching player");
player = GameObject.Find("Player");
Debug.Log(player.ToString());
playerAvatar = GameObject.Find("AvatarMainPlayer");
//this.observer = (NetworkObserver)GameObject.FindObjectOfType(typeof(NetworkObserver));
}
private void UpdateJump(KinectController kinect)
{
if (jumpController.IsActivated)
{
if (jumpController.IsPassing)
{
jumpController.Deactivate();
isMoving = true;
UpdateInstruction(noInstructionText);
}
else
{
WindowsKinect.Body body = kinect.PlayerSkeleton;
jumpController.Set(
body.GetPosition(WindowsKinect.JointType.FootLeft),
body.GetPosition(WindowsKinect.JointType.FootRight));
}
}
}
void UpdateHandOffsetVectors()
{
KinectController kinect = Kinect.GetComponent <KinectController>();
Body skel = kinect.PlayerSkeleton;
Vector3 rHPosition = skel.GetPosition(JointType.HandRight);
Vector3 lHPosition = skel.GetPosition(JointType.HandLeft);
// Which direction has the joint moved since the last time?
Vector3 rHDelta = rHPosition - lastRHCoordinate;
Vector3 lHDelta = lHPosition - lastLHCoordinate;
// Set the new value of last coordinate to the current position
lastRHCoordinate = rHPosition;
lastLHCoordinate = lHPosition;
// will get a 0/0 error if mouse does not move
rightHandDirection = rHDelta.normalized;
leftHandDirection = lHDelta.normalized;
}
/// <summary>
/// Starts the application.
/// </summary>
/// <param name="config">Options to run with.</param>
/// <returns></returns>
private static async Task Run(MambaConfiguration config)
{
using (var experience = new ExperienceController(new ExperienceControllerConfig
{
AppId = config.ExperienceId,
TrellisToken = config.Token,
TrellisUrl = config.TrellisUrl
}))
{
ElementData elements;
// load experience first
try
{
elements = await experience.Initialize();
}
catch (Exception exception)
{
Log.Error($"Could not initialize experience: '{exception}'.");
return;
}
using (var network = new MyceliumController(new MyceliumControllerConfiguration
{
Ip = config.MyceliumIp,
Port = config.MyceliumPort,
Token = config.Token
}))
{
using (var kinect = new KinectController(new KinectControllerConfiguration(), network, elements))
{
network.Start();
kinect.Start();
Console.ReadLine();
Log.Information("Shutting down.");
}
}
}
}
//private GameObject player = null;
//private GameObject playerAvatar = null;
public Server(GameController game, bool isStandalone)
{
this.observer = (NetworkObserver)GameObject.FindObjectOfType(typeof(NetworkObserver));
/* dan this.shootController = ((ShootController)GameObject.FindObjectOfType(typeof(ShootController))); */
this.kinectController = (KinectController)GameObject.FindObjectOfType(typeof(KinectController));
this.cameraRotationTransform = ((KinectController)GameObject.FindObjectOfType(typeof(KinectController))).transform;
this.wiiController = (WiiController)GameObject.FindObjectOfType(typeof(WiiController));
/* dan this.lightController = ((LightController)GameObject.FindObjectOfType(typeof(LightController))); */
this.game = game;
this.isStandalone = isStandalone;
/* dan
* this.enemies = (Enemy[])GameObject.FindObjectsOfType(typeof(Enemy));
* this.doors = (DoorTrigger[])GameObject.FindObjectsOfType(typeof(DoorTrigger));
*
* this.balls = new List<GameObject>();
* this.numberOfBalls = (Config.Instance.IsStandalone) ? shootController.maxNumberOfBallsStandalone : shootController.maxNumberOfBalls;
*
*/
this.playerEAvatar = GameObject.Find("AvatarEnemyPlayer");
}
//private GameObject player = null;
//private GameObject playerAvatar = null;
public Server( GameController game, bool isStandalone )
{
this.observer = (NetworkObserver) GameObject.FindObjectOfType ( typeof(NetworkObserver) );
/* dan this.shootController = ((ShootController)GameObject.FindObjectOfType(typeof(ShootController))); */
this.kinectController = (KinectController) GameObject.FindObjectOfType ( typeof(KinectController) );
this.cameraRotationTransform = ( (KinectController) GameObject.FindObjectOfType ( typeof(KinectController) ) ).transform;
this.wiiController = (WiiController) GameObject.FindObjectOfType ( typeof(WiiController) );
/* dan this.lightController = ((LightController)GameObject.FindObjectOfType(typeof(LightController))); */
this.game = game;
this.isStandalone = isStandalone;
/* dan
this.enemies = (Enemy[])GameObject.FindObjectsOfType(typeof(Enemy));
this.doors = (DoorTrigger[])GameObject.FindObjectsOfType(typeof(DoorTrigger));
this.balls = new List<GameObject>();
this.numberOfBalls = (Config.Instance.IsStandalone) ? shootController.maxNumberOfBallsStandalone : shootController.maxNumberOfBalls;
*/
this.playerEAvatar = GameObject.Find ( "AvatarEnemyPlayer" );
}
private void UpdateHandWave(KinectController kinect)
{
if (handWaveController.IsActivated)
{
if (handWaveController.IsPassing)
{
handWaveController.Deactivate();
isMoving = true;
UpdateInstruction(noInstructionText);
}
else
{
WindowsKinect.Body body = kinect.PlayerSkeleton;
handWaveController.Set(
body.GetPosition(WindowsKinect.JointType.HandLeft),
body.GetPosition(WindowsKinect.JointType.HandRight),
body.GetPosition(WindowsKinect.JointType.ElbowLeft),
body.GetPosition(WindowsKinect.JointType.ElbowRight));
}
}
}
public MainWindow(KinectController kinectController)
{
InitializeComponent();
if (kinectController == null)
{
throw new ArgumentNullException("controller", Properties.Resources.KinectControllerInvalid);
}
this.kinectController = kinectController;
kinectController.EngagedUserColor = (Color)this.Resources["EngagedUserColor"];
kinectController.TrackedUserColor = (Color)this.Resources["TrackedUserColor"];
kinectController.EngagedUserMessageBrush = (Brush)this.Resources["EngagedUserMessageBrush"];
kinectController.TrackedUserMessageBrush = (Brush)this.Resources["TrackedUserMessageBrush"];
this.kinectRegion.HandPointersUpdated += (sender, args) => kinectController.OnHandPointersUpdated(this.kinectRegion.HandPointers);
this.DataContext = kinectController;
this.mouseMovementDetector = new MouseMovementDetector(this);
this.mouseMovementDetector.IsMovingChanged += this.OnIsMouseMovingChanged;
this.mouseMovementDetector.Start();
}
void Update()
{
kinectData = KinectData.GetComponent<KinectController>();
Kinect.Body closestBody = GetClosestBody();
if (closestBody == null)
{
ResetCalibration(null, "body not found");
return;
}
ulong currentClosestTrackingId = closestBody.TrackingId;
if (trackingId != currentClosestTrackingId)
{
ResetCalibration(currentClosestTrackingId, "body not found");
return;
}
Kinect.Body currentBody = kinectData.Bodies.Find(body => body.TrackingId == trackingId);
if (calibrationTimer < calibrationTime)
{
shoulderAndHipRatio.AddData(GetShoulderAndHipRatio(
GetBodyPosition(currentBody, Kinect.JointType.ShoulderLeft),
GetBodyPosition(currentBody, Kinect.JointType.ShoulderRight),
GetBodyPosition(currentBody, Kinect.JointType.HipLeft),
GetBodyPosition(currentBody, Kinect.JointType.HipRight)));
upperbodyLength.AddData(GetUpperbodyLength(
GetBodyPosition(currentBody, Kinect.JointType.Head),
GetBodyPosition(currentBody, Kinect.JointType.Neck),
GetBodyPosition(currentBody, Kinect.JointType.SpineBase)));
DisplayText.text = string.Format("Time: {2}\n\nSH: {0}\nUL: {1}",
shoulderAndHipRatio.ToString(),
upperbodyLength.ToString(),
calibrationTimer.ToString("0.00"));
calibrationTimer += Time.deltaTime;
}
else
{
if (Application.loadedLevelName == "MainMenu" || Application.loadedLevel == 0)
{
SetPlayerPrefs(trackingId.Value, shoulderAndHipRatio.Average, upperbodyLength.Average);
Application.LoadLevel(1); // change this later
}
else
{
if (Match(shoulderAndHipRatio.Average, upperbodyLength.Average))
{
Application.LoadLevel(Application.loadedLevel);
}
else
{
ResetCalibration(null, "not a match");
}
}
}
}
private void InitNavigation()
{
avatarConnector = new AvatarAdapterConnector ( this );
if ( Config.Instance.UseWii )
{
wiiController = GetComponentInChildren<WiiController> ();
//wiiTurnMediator = new SimpleWiiTurnNavigationMediator ( wiiController.WiiMote, avatarConnector );
// RedirectToFrontTurnMediator benutzt Radianten. Da es den selben Callback setTurnVelocity() (siehe unten)
// nutzt, muss das hier auch in Radiant sein.
//wiiTurnMediator.setTargetTurnVelocity ( defaultTurnVelocityDegPerSec*Mathf.Deg2Rad );
//wiiWalkMediator = new SimpleWiiWalkNavigationMediator ( wiiController.WiiMote, avatarConnector );
// wiiWalkMediator.setTargetWalkVelocity ( defaultWalkVelocityMeterPerSec );
}
if ( Config.Instance.UseKinect )
{
kinectController = GetComponentInChildren<KinectController> ();
wipWalkMediator = new WalkingInPlaceNavigationMediator ( kinectController.Kinect, avatarConnector );
redirectToFrontTurnMediator = new RedirectToFrontNavigationMediator ( kinectController.Kinect, avatarConnector );
}
this.ToggleNav ();
}
private void UpdateJump(KinectController kinect)
{
if (jumpController.IsActivated)
{
if (jumpController.IsPassing)
{
jumpController.Deactivate();
isMoving = true;
UpdateInstruction(noInstructionText);
}
else
{
WindowsKinect.Body body = kinect.PlayerSkeleton;
jumpController.Set(
body.GetPosition(WindowsKinect.JointType.FootLeft),
body.GetPosition(WindowsKinect.JointType.FootRight));
}
}
}
