/// <summary>
/// Shake hands with the connecting socket
/// </summary>
/// <param name="socket">The socket to send the handshake to</param>
/// <param name="callback">a callback function that is called when the send has completed</param>
public void Shake(Socket socket)
{
try
{
// create the state object, and save the relavent information.
HandShakeState state = new HandShakeState();
state.socket = socket;
// receive the client handshake
state.socket.BeginReceive(state.buffer, 0, HandShakeState.BufferSize, 0, new AsyncCallback(DoShake), state);
}
catch (Exception e)
{
Log.Error("Exception thrown from method Receive:\n" + e.Message);
}
}
protected override bool HandleMessages(byte[] message)
{
try
{
HandShakeRequest msg = BsonUtilities.Deserialise <HandShakeRequest>(message);
Console.WriteLine("HandShakeRequest rec");
if (Config.Password.Equals(msg.AuthPassword))
{
State = HandShakeState.Authorised;
}
else
{
State = HandShakeState.NotAuthorised;
}
var waiter = new TaskCompletionSource <bool>();
this.SendMessage(new HandShakeOutcome()
{
MessageType = State == HandShakeState.Authorised ? MessageTypeEnum.AuthRequestOk : MessageTypeEnum.AuthRequestError,
ServerGuid = State == HandShakeState.Authorised ? this._server.ServerGuid : Guid.Empty
}, waiter);
waiter.Task.Wait();
if (waiter.Task.Result && State == HandShakeState.Authorised)
{
if (msg.MessageType == MessageTypeEnum.ClientAuthRequest)
{
_server.ClientConnected(msg.RegisteredGuid, TemporaryID);
}
else if (msg.MessageType == MessageTypeEnum.ServerAuthRequest)
{
_server.ServerConnected(msg.RegisteredGuid, TemporaryID);
}
}
else
{
_server.ConnectionFailed(this, TemporaryID);
}
}
catch (Exception ex)
{
this.State = HandShakeState.ProtocolError;
_server.ConnectionFailed(this, TemporaryID);
}
return(false);
}
public void Shake(ISocket socket)
{
var state = new HandShakeState {Socket = socket};
var segment = new ArraySegment<byte>(state.Buffer);
Task<int>.Factory.FromAsync(socket.BeginReceive, socket.EndReceive, new[] {segment}, SocketFlags.None, null)
.ContinueWith(t => DoShake(state, t.Result))
.ContinueWith(t => FleckLog.Error("Failed to recieve handshake", t.Exception),
TaskContinuationOptions.OnlyOnFaulted);
}
public void DoShake(HandShakeState state, int receivedByteCount)
{
ClientHandshake = ParseClientHandshake(new ArraySegment<byte>(state.Buffer, 0, receivedByteCount));
if (ClientHandshake.Validate(Origin, Location))
{
ServerHandshake serverShake = GenerateResponseHandshake();
BeginSendServerHandshake(serverShake, state.Socket);
}
else
{
state.Socket.Close();
return;
}
}
void ChangeState(HandShakeState _newState)
{
currentState = _newState;
switch (_newState)
{
case HandShakeState.Running:
Debug.Log("New hand shake started");
decreasePatience = true;
if (currentGestureSequenceIndex >= gestureSequence.Length)
{
ChangeState(HandShakeState.Done);
return;
}
playerHand.Disable();
otherHand.SetSprite(gestureSequence[currentGestureSequenceIndex], otherHandSprites[gestureSequence[currentGestureSequenceIndex]]);
break;
case HandShakeState.Success:
Debug.Log("Success!");
currentGestureSequenceIndex++;
StartCoroutine(RunSuccessAnimation());
break;
case HandShakeState.Fail:
Debug.Log("Fail!");
currentGestureSequenceIndex++;
failedShakes++;
ChangeState(HandShakeState.Running);
break;
case HandShakeState.Done:
Debug.Log("Done");
playerHand.gameObject.SetActive(false);
otherHand.gameObject.SetActive(false);
guestCounter++;
float failedShakeRatio = (float)failedShakes / gestureSequence.Length;
bool failed = false;
Debug.Log("FailedShakeRatio = " + failedShakeRatio);
if (failedShakeRatio == 1f || patienceTimer <= 0f)
{
disappointedGuests++;
ChangeState(HandShakeState.GameOver);
}
if (failedShakeRatio > .5f || patienceTimer <= 0f)
{
disappointedGuests++;
Debug.Log("Guest left disappointed");
failed = true;
}
if (onSequenceFinished != null)
onSequenceFinished(failed);
break;
case HandShakeState.GameOver:
gameOverSlider.value = (float)disappointedGuests / guestCounter;
gameOverComment.text = disappointedGuests + "/" + guestCounter + " vieraista olivat pettyneitä.";
gameOverCanvas.SetActive(true);
FindObjectOfType<GenerateLine>().enabled = false;
this.enabled = false;
break;
default:
break;
}
}
