public override void ExecuteMenuCommand()
{
GlobalInputController.LockInput();
switch (MenuAction)
{
case MenuCommand.EXIT_GAME:
Application.Quit();
break;
case MenuCommand.RESTART:
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex, LoadSceneMode.Single);
break;
case MenuCommand.CHANGE_SCENE:
if (c_itemActiveData.i_nextScene > -1 && c_itemActiveData.i_nextScene < SceneManager.sceneCountInBuildSettings)
{
MessageServer.OnSceneChange();
SceneManager.LoadScene(c_itemActiveData.i_nextScene, LoadSceneMode.Single);
}
break;
case MenuCommand.RESUME:
MessageServer.SendMessage(MessageID.PAUSE, new Message(0));
break;
case MenuCommand.CONFIRM:
break;
}
}
void FixedUpdate()
{
debugAccessor.DisplayFloat("Speed", c_playerData.f_currentSpeed);
debugAccessor.DisplayState("air state", c_airMachine.GetCurrentState());
if (!c_stateData.b_updateState)
{
return;
}
c_lastFrameData.v_lastFramePosition = c_playerData.v_currentPosition;
c_lastFrameData.q_lastFrameRotation = c_positionData.q_currentModelRotation;
c_lastFrameData.q_lastFrameCoGRotation = c_positionData.q_currentModelRotation * c_positionData.q_centerOfGravityRotation;
UpdateStateMachine();
c_airMachine.Act();
c_accelMachine.Act();
c_turnMachine.Act();
sm_tricking.Act();
sm_trickPhys.Act();
EngineUpdate();
LateEnginePull();
// send normal
MessageServer.SendMessage(MessageID.PLAYER_POSITION_UPDATED, new Message(c_playerData.v_currentPosition, c_playerData.q_currentRotation, c_playerData.f_currentSpeed)); // NOT the model rotation INCLUDE AIR STATE
}
/// <summary>
/// Sends a message to a client
/// </summary>
/// <param name="message"></param>
/// <param name="allClients"></param>
protected void MessageSend(Message message, bool allClients = false)
{
if (_messageServer.IsRunning())
{
_messageServer.SendMessage(message, allClients);
}
}
public bool RecieveMessage(MessageID id, Message message)
{
Message sentMessage = new Message(message.getInt());
MessageServer.SendMessage(MessageID.ERROR_MSG, sentMessage);
return(true);
}
public override void ExecuteMenuCommand()
{
GlobalInputController.LockInput();
switch (MenuAction)
{
case MenuCommand.EXIT_GAME:
Application.Quit();
break;
case MenuCommand.RESUME:
MessageServer.SendMessage(MessageID.PAUSE, new Message(0));
break;
case MenuCommand.CONFIRM:
break;
case MenuCommand.UPDATE_GAME_DATA:
GlobalGameData.playerOneCharacter = currentCharacter;
MessageServer.SendMessage(MessageID.CHARACTER_SELECTED, new Message((uint)PlayerID.PLAYER1));
break;
case MenuCommand.MENU_BACK:
MessageServer.SendMessage(MessageID.MENU_BACK, new Message());
break;
}
}
public override void ExecuteMenuCommand()
{
GlobalInputController.LockInput();
switch (MenuAction)
{
case MenuCommand.EXIT_GAME:
Application.Quit();
break;
case MenuCommand.RESTART:
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex, LoadSceneMode.Single);
break;
case MenuCommand.CHANGE_SCENE:
if (c_itemActiveData.i_nextScene > -1)
{
MessageServer.OnSceneChange();
SceneManager.LoadScene(c_itemActiveData.i_nextScene, LoadSceneMode.Single);
}
break;
case MenuCommand.RESUME:
MessageServer.SendMessage(MessageID.PAUSE, new Message(0));
break;
case MenuCommand.MENU_BACK:
MessageServer.SendMessage(MessageID.MENU_BACK, new Message());
break;
case MenuCommand.MENU_FORWARD:
if (ChildMenuController == null)
{
return;
}
MessageServer.SendMessage(MessageID.MENU_FORWARD, new Message(ChildMenuController.GetSuperMenuIndex()));
break;
case MenuCommand.CONFIRM:
break;
case MenuCommand.EDIT_DATA:
if (DataItem == DataTarget.ERROR_TARGET)
{
return;
}
if (ChildEditController == null)
{
return;
}
// open data editor, wait for return
ChildEditController.Activate(DataItem);
MessageServer.SendMessage(MessageID.EDIT_START, new Message());
break;
case MenuCommand.RESET_CONTROLS:
GlobalGameData.SetControlsToDefault(DataItem == DataTarget.CONTROLLER_CONTROLS ? InputType.CONTROLLER_GENERIC : InputType.KEYBOARD_GENERIC);
break;
}
}
public override void ConfirmDataEdit(DataTarget targetIn)
{
MessageServer.SendMessage(MessageID.EDIT_END, new Message());
GlobalInputController.UpdateAction(InputAction, c_controllerData.k, this.InputType);
GlobalGameData.SetActionSetting(InputAction, c_controllerData.k, this.InputType);
MessageServer.SendMessage(MessageID.EDIT_DISPLAY_UPDATE, new Message((int)c_controllerData.k, (uint)InputAction).withInputType(this.InputType));
Deactivate();
}
private void EnginePush()
{
if (c_countdownData.i_countdownTime == c_countdownData.i_targetTime)
{
MessageServer.SendMessage(MessageID.COUNTDOWN_OVER, new Message());
Destroy(gameObject);
}
}
// Update is called once per frame
void FixedUpdate()
{
if (GlobalInputController.GetInputAction(ControlAction.PAUSE, KeyValue.PRESSED))
{
Message pauseMessage = new Message((c_data.b_isPaused ? 0 : 1)); // if we want to pause, send 1, otherwise 0
//isPaused = !isPaused;
MessageServer.SendMessage(MessageID.PAUSE, pauseMessage);
}
}
private void ZoneAction()
{
if (c_positionData.u_zone == uint.MaxValue)
{
return;
}
if (ZoneController.GetZoneType(c_positionData.u_zone) == ZoneType.FINISH_LINE)
{
Message playerFinished = new Message(c_entityData.u_entityID);
MessageServer.SendMessage(MessageID.PLAYER_FINISHED, playerFinished);
}
}
// TODO: swapping a key with pause will not also update the "other mutex" buttons, allowing for a multiple mapping edge case
public void InputSwap(KeyCode keyIn)
{
c_controllerData.k = keyIn;
GlobalInputController.UpdateAction(InputAction, c_controllerData.k, this.InputType);
GlobalGameData.SetActionSetting(InputAction, c_controllerData.k, this.InputType);
if (InputSpriteController.getInputSprite(out spriteOut, c_controllerData.k, this.InputType))
{
SpriteDisplay.sprite = spriteOut;
}
MessageServer.SendMessage(MessageID.EDIT_DISPLAY_UPDATE, new Message((int)c_controllerData.k, (uint)InputAction).withInputType(this.InputType));
}
/* Checks if the key is in the mutex or not, as certain inputs cannot be overlapped
*
*/
private void VerifyAndUpdateMutex(KeyCode keyIn)
{
// if the current keycode is bound to an existing action
List <ControlAction> foundActions = GlobalInputController.GetActionForKey(keyIn);
foreach (ControlAction controlAction in foundActions)
{
if (this.InputMutex.MutuallyExclusiveActions.Contains(controlAction) &&
controlAction != InputAction) // verify that we are not infinitely swapping the current action
{
MessageServer.SendMessage(MessageID.EDIT_SWAP, new Message((int)c_controllerData.k, (uint)controlAction));
}
}
}
/// <summary>
/// Start this instance. Initializes all valid states for this object
/// then adds them to the state machine
/// </summary>
void Awake()
{
SetDefaultPlayerData();
cart_incr = new IncrementCartridge();
InitializeStateMachines();
InitializeAudioController();
InitializeMessageClient();
InitializeCachedLists();
InitializeCollisionController();
EnginePull();
MessageServer.SendMessage(MessageID.PLAYER_POSITION_UPDATED, new Message(c_playerData.v_currentPosition, c_playerData.q_currentRotation)); // NOT the model rotation
}
private void UpdateStateMachine()
{
if (GlobalInputController.GetInputAction(ControlAction.CONFIRM, KeyValue.PRESSED) &&
!CountdownDisplayImage.enabled)
{
InGameInterface.SetActive(true);
PreviewInterface.SetActive(false);
CountdownDisplayImage.enabled = true;
MessageServer.SendMessage(MessageID.COUNTDOWN_START, new Message());
sm_countdown.Execute(Command.START_COUNTDOWN);
}
// we want to continuously countdown, tick, then countdown again
if (c_countdownData.f_currentCountdownTime < c_countdownData.i_countdownTime)
{
sm_countdown.Execute(Command.TICK_TIMER);
sm_countdown.Execute(Command.START_TIMER_DOWN);
CountdownDisplayImage.sprite = CountdownSprites[c_countdownData.i_countdownTime];
}
}
private void SendConnectionInfoToUser()
{
if (readyOperators.Count != 0 && penddingUsers.Count != 0)
{
var user = penddingUsers.Dequeue();
var @operator = readyOperators.Dequeue();
var operatorEndPoint = @operator.ListeningEndPoint;
var userEndPoint = user.EndPoint;
P2PResponse p2PResponse = new P2PResponse
{
ListeningEndPoint = operatorEndPoint,
Status = Status.Ok
};
messageServer.SendMessage(p2PResponse, userEndPoint.ToIPEndPoint());
Console.WriteLine("P2P responde sent to user {0}, {1}",
user.UserName, user.EndPoint.ToIPEndPoint().ToString());
messageServer.CloseConnection(userEndPoint.ToIPEndPoint());
}
}
private void CompileAndSendScore()
{
if (c_scoringData.l_trickList.Count == 0 &&
c_scoringData.f_currentFlipTarget.Equals(Constants.ZERO_F) &&
c_scoringData.f_currentSpinTarget.Equals(Constants.ZERO_F))
{
ResetScoringData();
return;
}
TrickMessageData trickDataOut = new TrickMessageData();
trickDataOut.FlipDegrees = c_scoringData.f_currentFlipTarget;
trickDataOut.SpinDegrees = c_scoringData.f_currentSpinTarget;
trickDataOut.FlipAngle = 0.0f;
trickDataOut.grabs = c_scoringData.l_trickList;
trickDataOut.grabTimes = c_scoringData.l_timeList;
trickDataOut.Success = true; // TODO: implement bails
MessageServer.SendMessage(MessageID.TRICK_FINISHED, new Message(trickDataOut));
MessageServer.SendMessage(MessageID.SCORE_EDIT, new Message(0));
ResetScoringData();
}
public static void UpdateInput()
{
if (InputToFlush)
{
FlushInputs();
InputToFlush = false;
return;
}
InputType oldInputType = activeControllerType;
CheckAndSetKeyValue(ControlAction.JUMP);
CheckAndSetKeyValue(ControlAction.CROUCH);
CheckAndSetKeyValue(ControlAction.LEFT_GRAB);
CheckAndSetKeyValue(ControlAction.RIGHT_GRAB);
CheckAndSetKeyValue(ControlAction.DOWN_GRAB);
CheckAndSetKeyValue(ControlAction.UP_GRAB);
CheckAndSetKeyValue(ControlAction.PAUSE);
CheckAndSetKeyValue(ControlAction.CONFIRM);
CheckAndSetKeyValue(ControlAction.BACK);
CheckAndSetKeyValue(ControlAction.LEFT_BIN);
CheckAndSetKeyValue(ControlAction.RIGHT_BIN);
CheckAndSetKeyValue(ControlAction.DOWN_BIN);
CheckAndSetKeyValue(ControlAction.UP_BIN);
CheckAndSetAxisValue(ControlAction.TURN_AXIS);
CheckAndSetAxisValue(ControlAction.SPIN_AXIS);
CheckAndSetAxisValue(ControlAction.SLOW_AXIS);
CheckAndSetAxisValue(ControlAction.FLIP_AXIS);
if (oldInputType != activeControllerType)
{
MessageServer.SendMessage(MessageID.INPUT_TYPE_CHANGED, new Message().withInputType(activeControllerType));
}
}
public void SendMessage(Message message)
{
messageServer.SendMessage(message);
}
public override void CancelDataEdit()
{
c_controllerData.i = i_lastStoredValue;
EnginePush();
MessageServer.SendMessage(MessageID.EDIT_END, new Message(MappedValues[c_controllerData.i]));
}
public void OnItemActive(int thisId = -1)
{
MessageServer.SendMessage(MessageID.MENU_ITEM_CHANGED, new Message(this.HelpText, thisId));
}
public virtual void MenuCommandBack()
{
MessageServer.SendMessage(MessageID.MENU_BACK, new Message());
}
public override void ConfirmDataEdit(DataTarget targetIn)
{
MessageServer.SendMessage(MessageID.EDIT_END, new Message(MappedValues[c_controllerData.i]));
GlobalGameData.SetSettingsValue(targetIn, MappedValues[c_controllerData.i]);
}
public override void CancelDataEdit()
{
MessageServer.SendMessage(MessageID.EDIT_END, new Message());
c_controllerData.k = GlobalInputController.GetInputKey(InputAction, this.InputType);
Deactivate();
}
