/// <summary>
/// Called by the Input Manager to notify a key is being pressed
/// </summary>
/// <param name="key">The key being pressed</param>
public override void noticeInput(EnumInput key, Touch[] inputs)
{
if (loaded)
{
foreach (var t in inputs)
{
if (t.position.y < Screen.height / 2) // partie inférience de l'écran
{
if (t.position.x < Screen.width / 2) // partie gauche de l'écran
{
player.rotate(1);
}
else // partie droite
{
player.goForward();
}
}
else // partie supérieure de l'écran
{
if (t.position.x < Screen.width / 2) // partie gauche de l'écran
{
player.rotate(-1);
}
else // partie droite
{
player.fire();
}
}
}
}
}
/// <summary>
/// Called by the Input Manager to notify a key/touch screen action going on
/// </summary>
/// <param name="key">The key being pressed</param>
/// <param name="inputs">A touch screen action</param>
public override void noticeInput(EnumInput key, Touch[] inputs)
{
if (loaded)
{
foreach (var t in inputs)
{
if (t.phase == TouchPhase.Began || t.phase == TouchPhase.Stationary || t.phase == TouchPhase.Moved)
{
if (t.position.x < Screen.width / 2)
{
if (t.position.y > Screen.height / 2)
{
player.goUp();
}
else
{
player.goDown();
}
}
else
{
gameScript.launchCoupSpecial(-1);
}
}
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key, Touch[] inputs)
{
if (loaded)
{
base.noticeInput(key, inputs);
foreach (var t in inputs)
{
if (t.phase == TouchPhase.Began || t.phase == TouchPhase.Stationary || t.phase == TouchPhase.Moved)
{
if (t.position.y < Screen.height / 2)
{
if (t.position.x > Screen.width / 2)
{
playerScript_.moveRight();
}
else if (t.position.x < Screen.width / 2)
{
playerScript_.moveLeft();
}
}
else
{
playerScript_.jump();
}
}
else if (t.phase == TouchPhase.Canceled || t.phase == TouchPhase.Ended)
{
if (t.position.y < Screen.height / 2)
{
playerScript_.stop();
}
}
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key)
{
if (key == EnumInput.ESCAPE || key == EnumInput.MENU)
{
togglePauseGame();
}
}
/// <summary>
/// Recieves all the necessary inputs (keyboard, gamepad and mouse).
/// </summary>
/// <param name="key">The input sent when it's a keyboard</param>
/// <param name="inputs">The inputs sent when it's a touchscreen of a mobile for example.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key, Touch[] inputs)
{
if (loaded)
{
foreach (var t in inputs)
{
if (t.phase == TouchPhase.Began && t.position.y > 2 * Screen.height / 3)
{
Tetromino.fallingTetromino.rotate();
}
else if (t.phase == TouchPhase.Began || t.phase == TouchPhase.Stationary || t.phase == TouchPhase.Moved)
{
if (t.position.y < Screen.height / 4)
{
Tetromino.fallingTetromino.moveDown();
}
else if (t.position.x > 2 * Screen.width / 3)
{
Tetromino.fallingTetromino.moveRight();
}
else if (t.position.x < Screen.width / 3)
{
Tetromino.fallingTetromino.moveLeft();
}
}
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key, Touch[] inputs)
{
if (loaded)
{
foreach (var t in inputs)
{
if (t.phase == TouchPhase.Began || t.phase == TouchPhase.Stationary || t.phase == TouchPhase.Moved)
{
if (t.position.y > 2 * Screen.height / 3)
{
playerScript_.goUp();
}
else if (t.position.y < Screen.height / 3)
{
playerScript_.goDown();
}
else if (t.position.x < Screen.width / 2)
{
playerScript_.goLeft();
}
else if (t.position.x > Screen.width / 2)
{
playerScript_.goRight();
}
}
}
}
}
/// <summary>Recieves all the necessary inputs from a keyboard.</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key)
{
if (loaded)
{
base.noticeInput(key);
if (Tetromino.fallingTetromino != null)
{
switch (key)
{
case EnumInput.RIGHT:
Tetromino.fallingTetromino.moveRight();
break;
case EnumInput.LEFT:
Tetromino.fallingTetromino.moveLeft();
break;
case EnumInput.UPDOWN:
Tetromino.fallingTetromino.rotate();
break;
case EnumInput.DOWN:
Tetromino.fallingTetromino.moveDown();
break;
default:
break;
}
}
}
}
public override void noticeInput(EnumInput key)
{
if (loaded)
{
//base.noticeInput(key);
if (key == EnumInput.SPACE)
{
playerScript_.fire();
}
if (key == EnumInput.LEFT)
{
playerScript_.rotLeftRight -= playerScript_.speed;
}
else if (key == EnumInput.RIGHT)
{
playerScript_.rotLeftRight += playerScript_.speed;
}
if (key == EnumInput.UP)
{
playerScript_.rotUpDown -= playerScript_.speed;
}
else if (key == EnumInput.DOWN)
{
playerScript_.rotUpDown += playerScript_.speed;
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key)
{
if (loaded)
{
if (key == EnumInput.TAB)
{
connectionMenu.switchUiSelect();
}
else if (key == EnumInput.RETURN)
{
connectionMenu.onConnectionStartClick();
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key)
{
if (loaded)
{
base.noticeInput(key);
if (key == EnumInput.SPACE)
{
playerScript_.fire();
}
if (key == EnumInput.LEFT)
{
playerScript_.move(-1);
}
else if (key == EnumInput.RIGHT)
{
playerScript_.move(1);
}
}
}
/// <summary>
/// Called by the Input Manager to notify a key is being pressed
/// </summary>
/// <param name="key">The key being pressed</param>
public override void noticeInput(EnumInput key)
{
if (loaded)
{
base.noticeInput(key);
if (key == EnumInput.SPACE)
{
gameScript.launchCoupSpecial(-1);
}
if (key == EnumInput.UP)
{
player.goUp();
}
if (key == EnumInput.DOWN)
{
player.goDown();
}
}
}
public override void noticeInput(EnumInput key, Touch[] inputs)
{
if (loaded)
{
foreach (var t in inputs)
{
if (t.phase == TouchPhase.Began || t.phase == TouchPhase.Stationary || t.phase == TouchPhase.Moved)
{
if (t.position.x > 2 * Screen.width / 3)
{
playerScript_.moveRight(true);
}
else if (t.position.x < Screen.width / 3)
{
playerScript_.moveRight(false);
}
if (t.position.y > 2 * Screen.height / 3)
{
playerScript_.moveUp(true);
}
else if (t.position.y < Screen.height / 3)
{
playerScript_.moveUp(false);
}
// if we touch the center part of the screen, we fire
// fire handles cooldown
if (t.position.x < 2 * Screen.width / 3 &&
t.position.x > Screen.width / 3 &&
t.position.y < 2 * Screen.height / 3 &&
t.position.y > Screen.height / 3)
{
playerScript_.fire();
}
}
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key, Touch[] inputs)
{
if (loaded)
{
base.noticeInput(key, inputs);
foreach (var t in inputs)
{
if (t.phase == TouchPhase.Stationary || t.phase == TouchPhase.Moved)
{
if (t.position.x < Screen.width / 2)
{
if (t.position.y > Screen.height / 2)
{
playerScript_.rotate(-1);
}
else if (t.position.y < Screen.height / 2)
{
playerScript_.rotate(1);
}
}
}
if (t.phase == TouchPhase.Began)
{
if (t.position.x > Screen.width / 2)
{
if (t.position.y > Screen.height / 2)
{
playerScript_.increaseReactorState();
}
else if (t.position.y < Screen.height / 2)
{
playerScript_.decreaseReactorState();
}
}
}
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key)
{
if (loaded)
{
base.noticeInput(key);
if (key == EnumInput.UP)
{
playerScript_.goUp();
}
if (key == EnumInput.LEFT)
{
playerScript_.goLeft();
}
if (key == EnumInput.RIGHT)
{
playerScript_.goRight();
}
if (key == EnumInput.DOWN)
{
playerScript_.goDown();
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key)
{
if (loaded)
{
base.noticeInput(key);
if (key == EnumInput.SPACE)
{
playerScript_.jump();
}
if (key == EnumInput.LEFT)
{
playerScript_.moveLeft();
}
else if (key == EnumInput.RIGHT)
{
playerScript_.moveRight();
}
else
{
playerScript_.stop();
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key)
{
if (loaded)
{
base.noticeInput(key);
if (key == EnumInput.UPDOWN)
{
playerScript_.increaseReactorState();
}
if (key == EnumInput.DOWNDOWN)
{
playerScript_.decreaseReactorState();
}
if (key == EnumInput.LEFT)
{
playerScript_.rotate(1);
}
if (key == EnumInput.RIGHT)
{
playerScript_.rotate(-1);
}
}
}
/// <summary>
/// Called by the Input Manager to notify a key/touch screen action going on
/// </summary>
/// <param name="key">The key being pressed</param>
/// <param name="inputs">A touch screen action</param>
public override void noticeInput(EnumInput key)
{
if (loaded)
{
base.noticeInput(key);
if (key == EnumInput.SPACE)
{
player.fire();
}
if (key == EnumInput.LEFT)
{
player.rotate(1);
}
else if (key == EnumInput.RIGHT)
{
player.rotate(-1);
}
if (key == EnumInput.UP)
{
player.goForward();
}
}
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key, Touch[] inputs)
{
if (loaded)
{
foreach (var t in inputs)
{
if (t.phase == TouchPhase.Began || t.phase == TouchPhase.Stationary || t.phase == TouchPhase.Moved)
{
if (t.position.x > 3 * Screen.width / 4)
{
playerScript_.move(1);
}
else if (t.position.x < Screen.width / 4)
{
playerScript_.move(-1);
}
else if (!paused)
{
playerScript_.fire();
}
}
}
}
}
public void noticeInput(EnumInput key)
{
currentState.noticeInput(key);
}
public void noticeInput(EnumInput key, Touch[] inputs)
{
currentState.noticeInput(key, inputs);
}
public void StartRecording()
{
source_type = Source.FILE;
//NEED to run this world-sycnrhonously
World currentWorld = metagen_comp.World;
int currentTotalUpdates = currentWorld.TotalUpdates;
Slot logix_slot = metagen_comp.World.RootSlot.AddSlot("temporary logix slot");
bool added_logix = false;
currentWorld.RunSynchronously(() =>
{
foreach (var userItem in metagen_comp.userMetaData)
{
User user = userItem.Key;
UserMetadata metadata = userItem.Value;
if (!metadata.isRecording || (metagen_comp.LocalUser == user && !metagen_comp.record_local_user))
{
continue;
}
RefID user_id = user.ReferenceID;
current_tracked_users.Add(user_id);
ReferenceRegister <User> userRegister = logix_slot.AttachComponent <ReferenceRegister <User> >();
userRegister.Target.Target = user;
StandardController standardControllerLeft = logix_slot.AttachComponent <FrooxEngine.LogiX.Input.StandardController>();
EnumInput <Chirality> nodeEnum = logix_slot.AttachComponent <EnumInput <Chirality> >();
nodeEnum.Value.Value = Chirality.Left;
standardControllerLeft.User.Target = userRegister;
standardControllerLeft.Node.Target = nodeEnum;
SyncRef <ValueStream <bool> > _primaryStreamLeft = (SyncRef <ValueStream <bool> >) typeof(StandardController).GetField("_primaryStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerLeft);
SyncRef <ValueStream <bool> > _secondaryStreamLeft = (SyncRef <ValueStream <bool> >) typeof(StandardController).GetField("_secondaryStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerLeft);
SyncRef <ValueStream <bool> > _grabStreamLeft = (SyncRef <ValueStream <bool> >) typeof(StandardController).GetField("_grabStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerLeft);
SyncRef <ValueStream <bool> > _menuStreamLeft = (SyncRef <ValueStream <bool> >) typeof(StandardController).GetField("_menuStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerLeft);
SyncRef <ValueStream <float> > _strengthStreamLeft = (SyncRef <ValueStream <float> >) typeof(StandardController).GetField("_strengthStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerLeft);
SyncRef <ValueStream <float2> > _axisStreamLeft = (SyncRef <ValueStream <float2> >) typeof(StandardController).GetField("_axisStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerLeft);
StandardController standardControllerRight = logix_slot.AttachComponent <FrooxEngine.LogiX.Input.StandardController>();
EnumInput <Chirality> nodeEnum2 = logix_slot.AttachComponent <EnumInput <Chirality> >();
nodeEnum2.Value.Value = Chirality.Right;
standardControllerRight.User.Target = userRegister;
standardControllerRight.Node.Target = nodeEnum2;
SyncRef <ValueStream <bool> > _primaryStreamRight = (SyncRef <ValueStream <bool> >) typeof(StandardController).GetField("_primaryStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerRight);
SyncRef <ValueStream <bool> > _secondaryStreamRight = (SyncRef <ValueStream <bool> >) typeof(StandardController).GetField("_secondaryStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerRight);
SyncRef <ValueStream <bool> > _grabStreamRight = (SyncRef <ValueStream <bool> >) typeof(StandardController).GetField("_grabStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerRight);
SyncRef <ValueStream <bool> > _menuStreamRight = (SyncRef <ValueStream <bool> >) typeof(StandardController).GetField("_menuStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerRight);
SyncRef <ValueStream <float> > _strengthStreamRight = (SyncRef <ValueStream <float> >) typeof(StandardController).GetField("_strengthStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerRight);
SyncRef <ValueStream <float2> > _axisStreamRight = (SyncRef <ValueStream <float2> >) typeof(StandardController).GetField("_axisStream", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(standardControllerRight);
primaryStreamsRefs[user_id] = new Tuple <SyncRef <ValueStream <bool> >, SyncRef <ValueStream <bool> > >(_primaryStreamLeft, _primaryStreamRight);
secondaryStreamsRefs[user_id] = new Tuple <SyncRef <ValueStream <bool> >, SyncRef <ValueStream <bool> > >(_secondaryStreamLeft, _secondaryStreamRight);
grabStreamsRefs[user_id] = new Tuple <SyncRef <ValueStream <bool> >, SyncRef <ValueStream <bool> > >(_grabStreamLeft, _grabStreamRight);
menuStreamsRefs[user_id] = new Tuple <SyncRef <ValueStream <bool> >, SyncRef <ValueStream <bool> > >(_menuStreamLeft, _menuStreamRight);
strengthStreamsRefs[user_id] = new Tuple <SyncRef <ValueStream <float> >, SyncRef <ValueStream <float> > >(_strengthStreamLeft, _strengthStreamRight);
axisStreamsRefs[user_id] = new Tuple <SyncRef <ValueStream <float2> >, SyncRef <ValueStream <float2> > >(_axisStreamLeft, _axisStreamRight);
}
added_logix = true;
UniLog.Log("Added logix");
});
metagen_comp.StartTask(async() =>
{
Task task = Task.Run(() =>
{
bool all_streams_not_null = false;
List <RefID> good_tracking_users = new List <RefID>();
//UniLog.Log("HO");
while (!all_streams_not_null & currentWorld.TotalUpdates <= currentTotalUpdates + 60)
{
if (!added_logix)
{
continue;
}
//UniLog.Log("HI");
bool all_user_streams_not_null = true;
all_streams_not_null = true;
foreach (RefID user_id in current_tracked_users)
{
//HMM: why does using .Target here rather than .RawTarget give a NullReferenceException??
bool primary_streams_not_null = (primaryStreamsRefs[user_id].Item1.RawTarget != null) & (primaryStreamsRefs[user_id].Item2.RawTarget != null);
bool secondary_streams_not_null = (secondaryStreamsRefs[user_id].Item1.RawTarget != null) & (secondaryStreamsRefs[user_id].Item2.RawTarget != null);
bool grab_streams_not_null = (grabStreamsRefs[user_id].Item1.RawTarget != null) & (grabStreamsRefs[user_id].Item2.RawTarget != null);
bool menu_streams_not_null = (menuStreamsRefs[user_id].Item1.RawTarget != null) & (menuStreamsRefs[user_id].Item2.RawTarget != null);
bool strength_streams_not_null = (strengthStreamsRefs[user_id].Item1.RawTarget != null) & (strengthStreamsRefs[user_id].Item2.RawTarget != null);
bool axis_streams_not_null = (axisStreamsRefs[user_id].Item1.RawTarget != null) & (axisStreamsRefs[user_id].Item2.RawTarget != null);
all_user_streams_not_null = primary_streams_not_null & secondary_streams_not_null & grab_streams_not_null & menu_streams_not_null & strength_streams_not_null & axis_streams_not_null;
if (all_user_streams_not_null)
{
if (!good_tracking_users.Contains(user_id))
{
good_tracking_users.Add(user_id);
UniLog.Log("Added user " + user_id.ToString());
}
}
all_streams_not_null &= all_user_streams_not_null;
}
}
current_tracked_users = good_tracking_users;
//Get CommonToolStreamDriver
List <RefID> good_tracking_users2 = new List <RefID>();
foreach (RefID user_id in current_tracked_users)
{
User user = currentWorld.GetUser(user_id);
List <CommonToolStreamDriver> commonToolStreamDrivers = user.Root.Slot.GetComponents <CommonToolStreamDriver>();
ValueStream <bool> primaryBlockedStreamLeft = null;
ValueStream <bool> secondaryBlockedStreamLeft = null;
ValueStream <bool> laserActiveStreamLeft = null;
ValueStream <bool> showLaserToOthersStreamLeft = null;
ValueStream <float3> laserTargetStreamLeft = null;
ValueStream <float> grabDistanceStreamLeft = null;
ValueStream <bool> primaryBlockedStreamRight = null;
ValueStream <bool> secondaryBlockedStreamRight = null;
ValueStream <bool> laserActiveStreamRight = null;
ValueStream <bool> showLaserToOthersStreamRight = null;
ValueStream <float3> laserTargetStreamRight = null;
ValueStream <float> grabDistanceStreamRight = null;
foreach (CommonToolStreamDriver driver in commonToolStreamDrivers)
{
if (driver.Side.Value == Chirality.Left)
{
primaryBlockedStreamLeft = driver.PrimaryBlockedStream.Target;
secondaryBlockedStreamLeft = driver.SecondaryBlockedStream.Target;
laserActiveStreamLeft = driver.LaserActiveStream.Target;
showLaserToOthersStreamLeft = driver.ShowLaserToOthersStream.Target;
laserTargetStreamLeft = driver.LaserTargetStream.Target;
grabDistanceStreamLeft = driver.GrabDistanceStream.Target;
}
else if (driver.Side.Value == Chirality.Right)
{
primaryBlockedStreamRight = driver.PrimaryBlockedStream.Target;
secondaryBlockedStreamRight = driver.SecondaryBlockedStream.Target;
laserActiveStreamRight = driver.LaserActiveStream.Target;
showLaserToOthersStreamRight = driver.ShowLaserToOthersStream.Target;
laserTargetStreamRight = driver.LaserTargetStream.Target;
grabDistanceStreamRight = driver.GrabDistanceStream.Target;
}
}
bool all_common_tool_streams_not_null = primaryBlockedStreamLeft != null & primaryBlockedStreamRight != null
& secondaryBlockedStreamLeft != null & secondaryBlockedStreamRight != null
& laserActiveStreamLeft != null & laserActiveStreamRight != null
& showLaserToOthersStreamLeft != null & showLaserToOthersStreamRight != null
& laserTargetStreamLeft != null & laserActiveStreamRight != null
& grabDistanceStreamLeft != null & grabDistanceStreamRight != null;
if (all_common_tool_streams_not_null)
{
good_tracking_users2.Add(user_id);
primaryBlockedStreams[user_id] = new Tuple <ValueStream <bool>, ValueStream <bool> >(primaryBlockedStreamLeft, primaryBlockedStreamRight);
secondaryBlockedStreams[user_id] = new Tuple <ValueStream <bool>, ValueStream <bool> >(secondaryBlockedStreamLeft, secondaryBlockedStreamRight);
laserActiveStreams[user_id] = new Tuple <ValueStream <bool>, ValueStream <bool> >(laserActiveStreamLeft, laserActiveStreamRight);
showLaserToOthersStreams[user_id] = new Tuple <ValueStream <bool>, ValueStream <bool> >(showLaserToOthersStreamLeft, showLaserToOthersStreamRight);
laserTargetStreams[user_id] = new Tuple <ValueStream <float3>, ValueStream <float3> >(laserTargetStreamLeft, laserTargetStreamRight);
grabDistanceStreams[user_id] = new Tuple <ValueStream <float>, ValueStream <float> >(grabDistanceStreamLeft, grabDistanceStreamRight);
}
}
current_tracked_users = good_tracking_users2;
foreach (RefID user_id in current_tracked_users)
{
primaryStreams[user_id] = new Tuple <ValueStream <bool>, ValueStream <bool> >(primaryStreamsRefs[user_id].Item1.RawTarget, primaryStreamsRefs[user_id].Item2.RawTarget);
secondaryStreams[user_id] = new Tuple <ValueStream <bool>, ValueStream <bool> >(secondaryStreamsRefs[user_id].Item1.RawTarget, secondaryStreamsRefs[user_id].Item2.RawTarget);
grabStreams[user_id] = new Tuple <ValueStream <bool>, ValueStream <bool> >(grabStreamsRefs[user_id].Item1.RawTarget, grabStreamsRefs[user_id].Item2.RawTarget);
menuStreams[user_id] = new Tuple <ValueStream <bool>, ValueStream <bool> >(menuStreamsRefs[user_id].Item1.RawTarget, menuStreamsRefs[user_id].Item2.RawTarget);
strengthStreams[user_id] = new Tuple <ValueStream <float>, ValueStream <float> >(strengthStreamsRefs[user_id].Item1.RawTarget, strengthStreamsRefs[user_id].Item2.RawTarget);
axisStreams[user_id] = new Tuple <ValueStream <float2>, ValueStream <float2> >(axisStreamsRefs[user_id].Item1.RawTarget, axisStreamsRefs[user_id].Item2.RawTarget);
RegisterUserStream(user_id, "controller_streams");
}
//Destroy LogiX nodes
currentWorld.RunSynchronously(() =>
{
logix_slot.Destroy();
});
isRecording = true;
});
//await CancelAfterAsync(ct=>task, TimeSpan.FromSeconds(30), CancellationToken.None);
await task;
});
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key)
{
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary>
/// <param name="key">The input sent.</param>
/// <returns>void</returns>
public override void noticeInput(EnumInput key, Touch[] inputs)
{
}
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary> /// <param name="key">The input sent.</param> /// <returns>void</returns> public abstract void noticeInput(EnumInput key);
/// <summary>Recieves all the necessary inputs (keyboard, gamepad and mouse).</summary> /// <param name="key">The input sent.</param> /// <returns>void</returns> public abstract void noticeInput(EnumInput key, Touch[] inputs);
