public void SetState(TerminalState new_state)
{
input_fix = true;
cached_command_text = command_text;
command_text = "";
switch (new_state)
{
case TerminalState.Close:
open_target = 0;
break;
case TerminalState.OpenSmall:
open_target = Screen.height * MaxHeight * SmallTerminalRatio;
if (current_open_t > open_target)
{
// Prevent resizing from OpenFull to OpenSmall if window y position
// is greater than OpenSmall's target
open_target = 0;
state = TerminalState.Close;
return;
}
real_window_size = open_target;
scroll_position.y = int.MaxValue;
break;
case TerminalState.OpenFull:
default:
real_window_size = Screen.height * MaxHeight;
open_target = real_window_size;
break;
}
state = new_state;
}
public void Disconnect()
{
if (State != TerminalState.Disabled)
{
_state = TerminalState.Available;
}
}
/// <summary>
/// Places the operator Terminal in mock mode
/// This does not take any input from the user
/// </summary>
public static void DisableMock()
{
MockMode = false;
MockState = TerminalState.LOGIN;
MockPacket = null;
return;
}
public void SetCurrentInputAsNullTest()
{
var terminalState = new TerminalState();
var isInputSet = terminalState.TrySetCurrentInput(null);
Assert.IsFalse(isInputSet);
}
/// <summary>
/// Places the operator Terminal in mock mode
/// This does not take any input from the user
/// </summary>
public static void EnableMock()
{
MockMode = true;
MockState = TerminalState.LOGIN;
MockPacket = null;
return;
}
public void GetDefaultCurrentInputTest()
{
var terminalState = new TerminalState();
var actual = terminalState.GetCurrentInput();
Assert.IsNull(actual);
}
public void SetCurrentInputAsEmptyTest()
{
var terminalState = new TerminalState();
var isInputSet = terminalState.TrySetCurrentInput(string.Empty);
Assert.IsFalse(isInputSet);
}
private void SetTerminalsStateTo(PhoneNumber source, PhoneNumber target, TerminalState state)
{
var sourceTerminal = GetTerminalByPhoneNumber(source) as TestTerminal;
var targetTerminal = GetTerminalByPhoneNumber(target) as TestTerminal;
if (sourceTerminal != null) sourceTerminal.State = state;
if (targetTerminal != null) targetTerminal.State = state;
}
/// <summary>
/// Uses or Unlocks a power-up.
/// </summary>
/// <param name="powerUpID">The ID of the power-up being used.</param>
public void usePowerUp(int powerUpID)
{
//UNLOCK ABILITY
//check for enough charge and that another ability isnt currently being unlocked
if (charge >= powerUps[powerUpID].getChargeRequired() && terminalState == TerminalState.Idle && powerUps[powerUpID].isLocked())
{
//tooltip
tipManager.DismissTip(3); // unlock button
tipManager.ShowTip(9); //cannot charge
//set unlocking to true
terminalState = TerminalState.Unlocking;
unlockID = powerUpID;
}
//USE ABILITY
else if (powerUps[powerUpID].isLocked() == false && terminalState == TerminalState.Idle && powerUps[powerUpID].OnCoolDown() == false)
{
//dismiss tool tip
tipManager.DismissTip(4);
tipManager.DismissTip(5);
//show cooldowntip
tipManager.ShowTip(8);
terminalState = TerminalState.UsingPowerUp;
useID = powerUpID;
}
}
public Terminal(string model)
{
Model = model;
Random rand = new Random();
Number = "+375 " + rand.Next(100000, 999999).ToString(); //Generate random number
IsConnected = TerminalState.off;
}
public void GetDefaultHistoricalCommandsTest()
{
var terminalState = new TerminalState();
var previousCommands = terminalState.GetPreviousTerminalCommands();
Assert.IsNotNull(previousCommands);
Assert.IsEmpty(previousCommands);
}
public void GetDefaultInputHistoryLimitTest()
{
var terminalState = new TerminalState();
var actual = terminalState.GetCommandHistoryLimit();
Assert.IsNotNull(actual);
Assert.AreEqual(actual, 0);
}
/// <summary>
/// check for terminal ready on pin change
/// </summary>
/// <param name="sender">Serial port</param>
/// <param name="e">Pin arguments</param>
private void Terminal_PinChanged(object sender, SerialPinChangedEventArgs e)
{
if (State != lastState)
{
lastState = State;
TerminalStateChanged(State);
}
}
bool SetupTTY(int stdin)
{
// Ensure that we are using a real terminal,
// rather than some short of file redirection.thing.
if (!Terminal.IsTerminal(stdin))
{
Debug.Print("[Linux] Terminal.IsTerminal({0}) returned false.", stdin);
return(false);
}
//original_stdin = Libc.dup(stdin);
int ret = Terminal.GetAttributes(stdin, out original_state);
if (ret < 0)
{
Debug.Print("[Linux] Terminal.GetAttributes({0}) failed. Error: {1}",
stdin, ret);
return(false);
}
// Retrieve current keyboard mode
ret = Libc.ioctl(stdin, KeyboardIoctlCode.GetMode, ref original_mode);
if (ret != 0)
{
Debug.Print("[Linux] Libc.ioctl({0}, KeyboardIoctlCode.GetMode) failed. Error: {1}",
stdin, ret);
return(false);
}
// Update terminal state
current_state = original_state;
current_state.LocalMode &= ~(/*LocalFlags.ECHO |*/ LocalFlags.ICANON | LocalFlags.ISIG);
current_state.InputMode &= ~(
InputFlags.ISTRIP | InputFlags.IGNCR | InputFlags.ICRNL |
InputFlags.INLCR | InputFlags.IXOFF | InputFlags.IXON);
current_state.ControlCharacters.VMIN = 0;
current_state.ControlCharacters.VTIME = 0;
Terminal.SetAttributes(stdin, OptionalActions.FLUSH, ref current_state);
// Request keycodes
int mode = 0x02; // K_MEDIUMRAW
ret = Libc.ioctl(stdin, KeyboardIoctlCode.SetMode, mode);
if (ret != 0)
{
Debug.Print("[Linux] Libc.ioctl({0}, KeyboardIoctlCode.SetMode, {1}) failed. Error: {2}",
stdin, mode, ret);
ExitTTY(this, EventArgs.Empty);
return(false);
}
// Ensure we reset the original keyboard/terminal state on exit,
// even if we crash.
HookEvents();
return(true);
}
public void AddHistoricalCommandAsNullTest()
{
var terminalState = new TerminalState();
var isHistoryLimitSet = terminalState.TrySetCommandHistoryLimit(10);
var isAddHistoricalCommandSuccess = terminalState.TryAddHistoricalCommand(null);
Assert.IsTrue(isHistoryLimitSet);
Assert.IsFalse(isAddHistoricalCommandSuccess);
}
public void Connect(IPort port)
{
Port = port;
State = TerminalState.On;
Port = port;
Port.State = PortState.Connected;
Port.OnInComingCall += Port_InComingCall;
Port.OnCallResponce += Port_OnCallResponce;
}
public void SetInputLengthLimitTest()
{
var terminalState = new TerminalState();
var expected = 20;
var isLimitSet = terminalState.TrySetTerminalInputLengthLimit(expected);
var actual = terminalState.GetInputLengthLimit();
Assert.IsTrue(isLimitSet);
Assert.AreEqual(expected, actual);
}
public void NonTruncatedEmptyInputTest()
{
var terminalState = new TerminalState();
var isInputLengthSet = terminalState.TrySetTerminalInputLengthLimit(1);
var isInputTruncated = terminalState.TryTruncateInput(string.Empty, out var truncatedInput);
Assert.IsTrue(isInputLengthSet);
Assert.IsFalse(isInputTruncated);
Assert.IsNull(truncatedInput);
}
public void SetTerminalState(TerminalType type, TerminalState state)
{
for (int i = 0; i < m_terminalList.Count; i++)
{
if (m_terminalList[i].m_type == type)
{
m_terminalList[i].m_state = state;
}
}
}
public void InvalidInputEmptyTest()
{
var terminalState = new TerminalState();
var isInputLengthSet = terminalState.TrySetTerminalInputLengthLimit(1);
var isInputValid = terminalState.TryValidateInput(string.Empty, out var validInput);
Assert.IsTrue(isInputLengthSet);
Assert.IsFalse(isInputValid);
Assert.IsNull(validInput);
}
public void SetCurrentInputOverLengthLimitTest()
{
var terminalState = new TerminalState();
var stringOverLengthLimit = "this is a really long test";
var isLengthLimitSet = terminalState.TrySetTerminalInputLengthLimit(10);
var isInputSet = terminalState.TrySetCurrentInput(stringOverLengthLimit);
Assert.IsTrue(isLengthLimitSet);
Assert.IsFalse(isInputSet);
}
/// <summary>
/// For testing the update delegates without risking infinite loop of conventional means.
/// ONLY USE FOR UNIT TESTS
/// </summary>
/// <param name="terminalState"></param>
/// <returns>Whether or not the console will continue to run</returns>
public bool _RunUpdateDelegateOnce(TerminalState terminalState)
{
currentState = terminalState;
userID = "123456789";
if (updateDelegates[(int)terminalState] != null)
{
return(updateDelegates[(int)terminalState]());
}
return(false);
}
public void ToggleState(TerminalState new_state)
{
if (state == new_state)
{
SetState(TerminalState.Close);
}
else
{
SetState(new_state);
}
}
public void InitializeTerminalState(TerminalState terminalState, int inputLengthCharacterLimit, int inputHistoryLimit)
{
Debug.Assert(inputLengthCharacterLimit > 0, "Input length character limit is invalid.");
Debug.Assert(inputHistoryLimit > 0, "Input history limit is invalid.");
var isInputLengthSetSuccess = terminalState.TrySetTerminalInputLengthLimit(inputLengthCharacterLimit);
var isInputHistorySetSuccess = terminalState.TrySetCommandHistoryLimit(inputHistoryLimit);
Debug.Assert(isInputLengthSetSuccess, "Failed to set maximum input length.");
Debug.Assert(isInputHistorySetSuccess, "Failed to set maximum input history limit.");
}
public void ValidInputTest()
{
var terminalState = new TerminalState();
var expected = "test";
var isInputLengthSet = terminalState.TrySetTerminalInputLengthLimit(10);
var isInputValid = terminalState.TryValidateInput(expected, out var validInput);
Assert.IsTrue(isInputLengthSet);
Assert.IsTrue(isInputValid);
Assert.AreEqual(expected, validInput);
}
public void AddHistoricalCommandWithEmptyOutputTest()
{
var terminalState = new TerminalState();
var terminalCommand = new TerminalCommand {
TerminalCommandInput = "testInput", TerminalCommandOutput = string.Empty
};
var isHistoryLimitSet = terminalState.TrySetCommandHistoryLimit(10);
var isAddHistoricalCommandSuccess = terminalState.TryAddHistoricalCommand(terminalCommand);
Assert.IsTrue(isHistoryLimitSet);
Assert.IsFalse(isAddHistoricalCommandSuccess);
}
public void SetCurrentInputTest()
{
var terminalState = new TerminalState();
var expected = "test";
var isLengthLimitSet = terminalState.TrySetTerminalInputLengthLimit(10);
var isInputSet = terminalState.TrySetCurrentInput(expected);
var actual = terminalState.GetCurrentInput();
Assert.IsTrue(isLengthLimitSet);
Assert.IsTrue(isInputSet);
Assert.AreEqual(actual, expected);
}
/// <summary>
/// Start the game with terminal state in idle and all powerups being initialised
/// Show Gaze and Communication terminal ToolTips
/// </summary>
void Start()
{
terminalState = TerminalState.Idle;
if (audioSource == null)
{
audioSource = GetComponent <AudioSource> ();
}
tipManager.ShowTip(0);
tipManager.ShowTip(6);
}
public void Answer()
{
if (State == TerminalState.Ring)
{
TerminalDefaultEventArg terminalDefaultEventArg = new TerminalDefaultEventArg();
terminalDefaultEventArg.TerminalStateArg = _state;
OnAnswered(terminalDefaultEventArg);
_state = terminalDefaultEventArg.TerminalStateArg;
}
}
public void TruncatedInputTest()
{
var terminalState = new TerminalState();
var input = "test";
var lengthLimit = 1;
var isInputLengthSet = terminalState.TrySetTerminalInputLengthLimit(lengthLimit);
var isInputTruncated = terminalState.TryTruncateInput(input, out var truncatedInput);
Assert.IsTrue(isInputLengthSet);
Assert.IsTrue(isInputTruncated);
Assert.AreNotEqual(input, truncatedInput);
Assert.AreEqual(truncatedInput.Length, lengthLimit);
}
/// <summary>
/// Initializes a new VT100 terminal with the given Serial Port
/// </summary>
/// <param name="InOut">Serial Port. Automatically opened if closed</param>
public VTconsole(SerialPort InOut)
{
Terminal = InOut;
lastState = State;
TerminalStateChanged += new TerminalStateChangedHandler(VTconsole_TerminalStateChanged);
Terminal.DtrEnable = true;
Terminal.RtsEnable = true;
Terminal.PinChanged += new SerialPinChangedEventHandler(Terminal_PinChanged);
if (!Terminal.IsOpen)
{
Terminal.Open();
}
}
public CallList MakeCall(string senderName, string recieverName, int duration)
{
TermianlMessageEvent?.Invoke("\nBeep beep..");
IsConnected = TerminalState.calling; //Terminal switches to 'calling' state during the call
TermianlMessageEvent?.Invoke("\nCall Started");
CallList CallInfo = new CallList();
Thread.Sleep(duration * 1000); //Sleep imitates process of calling
TermianlMessageEvent?.Invoke("\nCall Finished\n");
IsConnected = TerminalState.connected; //Terminal switches back after call
return(CallInfo);
}
public bool CallTo(PhoneNumberStruct number)
{
if (State == TerminalState.Available)
{
CallingEventArgs callingEventArgs = new CallingEventArgs();
callingEventArgs.PhoneNumberArg = number;
callingEventArgs.TerminalStateArg = TerminalState.Available;
OnCallingTo(callingEventArgs);
_state = callingEventArgs.TerminalStateArg;
}
return false;
}
public void ClearCurrentInputTest()
{
var terminalState = new TerminalState();
var previousInput = "exists";
var isLengthLimitSet = terminalState.TrySetTerminalInputLengthLimit(10);
var isInputSet = terminalState.TrySetCurrentInput(previousInput);
terminalState.ClearCurrentInput();
var actual = terminalState.GetCurrentInput();
Assert.IsTrue(isLengthLimitSet);
Assert.IsTrue(isInputSet);
Assert.IsNotNull(actual);
Assert.IsEmpty(actual);
}
private void TerminalOnStateChangedEvent(object sender, TerminalState oldState, TerminalState newState)
{
IsRegisteredTerminalPluged = newState != TerminalState.Unplagged;
}
private void WriteXml(TerminalState state)
{
this.WriteXmlBase((State)state);
}
public void SetTerminalState(TerminalState state)
{
terminalState = state;
}
public void InsertIntoPort()
{
State = TerminalState.Online;
if (InsertedIntoPort != null)
InsertedIntoPort(this, EventArgs.Empty);
}
protected virtual void OnStateChanged(TerminalState state)
{
if (StateChanged != null)
StateChanged(this, state);
}
public bool Ring()
{
if (State == TerminalState.Available)
{
_state = TerminalState.Ring;
OnRinging(new TerminalDefaultEventArg());
return true;
}
else
{
return false;
}
}
public void Connect(PhoneNumber phoneNumber)
{
if (State == TerminalState.Unplagged)
throw new StateException($"{this} unplagged");
if (State == TerminalState.Online)
throw new StateException($"{this} already online");
State = TerminalState.Online;
var r = new ConnectRequest(ConnectRequest.UnprotectedConnection, PhoneNumber, phoneNumber);
OnConnectingEvent(r);
SendRequest(r);
}
protected void Validate(TerminalState terminalState)
{
this.ValidateBase((State)terminalState);
}
public void UnPlug()
{
if (_state == TerminalState.Available)
{
_state = TerminalState.Disabled;
}
}
// Constructor
public PBXTerminal()
{
_state = TerminalState.Available;
}
public void EndCall()
{
if (State != TerminalState.Disabled)
{
TerminalDefaultEventArg terminalDefaultEventArg = new TerminalDefaultEventArg();
terminalDefaultEventArg.TerminalStateArg = _state;
OnEndedCall(terminalDefaultEventArg);
_state = TerminalState.Available;
}
}
private void OnStateChangingEvent(TerminalState terminalState)
{
StateChangingEvent?.Invoke(MACAddress, terminalState);
}
private void PortOnUnbindPortEvent(object sender, IPort port)
{
if (State != TerminalState.Unplagged)
State = TerminalState.Offline;
}
public void Disconnect()
{
if (State == TerminalState.Unplagged)
throw new StateException($"{this} unplagged");
if (State != TerminalState.Online) return;
State = TerminalState.Offline;
OnDisconnectEvent();
}
public CallInfo(PhoneNumber target, PhoneNumber source, TerminalState state)
{
Target = target;
Source = source;
State = state;
}
public void Plug()
{
if (State != TerminalState.Unplagged) return;
State = TerminalState.Offline;
}
public void RemoveFromPort()
{
State = TerminalState.Offline;
if (RemovedFromPort != null)
RemovedFromPort(this, EventArgs.Empty);
}
public void ProcessRequest(object sender, IRequest request)
{
if (sender == null) throw new ArgumentNullException(nameof(sender));
if (request == null) throw new ArgumentNullException(nameof(request));
if (State == TerminalState.Unplagged)
throw new StateException($"{this} unplagged");
var senderMac = sender as string;
if (senderMac == null || senderMac != _registeredPortMAC) return;
if (request is ConnectRequest)
{
if (State == TerminalState.Online)
{
var r = new ConnectResponse((ConnectRequest)request, ConnectResponse.TerminalBusy);
OnSendResponseEvent(r);
}
else
{
State = TerminalState.Online;
var r = new ConnectResponse((ConnectRequest)request, ConnectResponse.TerminalOk);
OnSendResponseEvent(r);
}
return;
}
if (State == TerminalState.Offline) return;
ProcessRequestWhenConnect(request);
}
private void SetTerminalStateTo(PhoneNumber source, TerminalState state)
{
var sourceTerminal = GetTerminalByPhoneNumber(source) as TestTerminal;
if (sourceTerminal != null) sourceTerminal.State = state;
}
public void ProcessResponse(object sender, IResponse response)
{
if (sender == null) throw new ArgumentNullException(nameof(sender));
if (response == null) throw new ArgumentNullException(nameof(response));
if (State == TerminalState.Unplagged)
throw new StateException($"{this} unplagged");
if (State == TerminalState.Offline) return;
var senderMac = sender as string;
if (senderMac == null || (senderMac != _registeredPortMAC && senderMac != MACAddress))
return;
if (response is ConnectResponse)
{
if (response.Code == ConnectResponse.TerminalOk)
OnConnectSucceededEvent((ConnectResponse)response);
else
{
State = TerminalState.Offline;
OnConnectFailedEvent((ConnectResponse)response);
}
return;
}
if (response is DropedResponse)
{
State = TerminalState.Offline;
OnDropedEvent((DropedResponse)response);
return;
}
ProcessResponseWhenConnect(response);
}
internal static State State(string typeName)
{
DesignByContract.Check.Require(!string.IsNullOrEmpty(typeName), string.Format(CommonStrings.XMustNotBeNullOrEmpty, "typeName"));
State state = null;
switch (typeName)
{
case "NON_TERMINAL_STATE":
state = new NonTerminalState();
break;
case "TERMINAL_STATE":
state = new TerminalState();
break;
default:
throw new NotSupportedException("type not supported: " + typeName);
}
DesignByContract.Check.Ensure(state != null, "state must not be null.");
return state;
}
public virtual void RemovePort(IPort port)
{
if (port == null) throw new ArgumentNullException(nameof(port));
if (port.MACAddress != _registeredPortMAC)
throw new RegistrationException($"{this} did'n register {port}");
if (!IsPortRegistered) return;
port.StateChangedEvent -= PortOnStateChangedEvent;
port.ProcessRequestEvent -= ProcessRequest;
port.ProcessResponseEvent -= ProcessResponse;
port.UnbindPortEvent -= PortOnUnbindPortEvent;
_registeredPortMAC = null;
IsRegisteredPortNotClosed = false;
if (State != TerminalState.Unplagged)
State = TerminalState.Offline;
OnRemovePort(port);
}
private void ReadXml(TerminalState state)
{
Check.Require(state != null, "terminalState must not be null.");
reader.ReadStartElement();
reader.MoveToContent();
this.ReadXmlBase((State)state);
reader.ReadEndElement();
reader.MoveToContent();
}
public void Unplug()
{
if (State == TerminalState.Unplagged) return;
State = TerminalState.Unplagged;
}
private void OnStateChangedEvent(TerminalState oldstate)
{
StateChangedEvent?.Invoke(MACAddress, oldstate, _state);
}
public void Plug()
{
if (_state == TerminalState.Disabled)
{
_state = TerminalState.Available;
}
}
