private Task handle_event(QueueStateMsg state)
{
if (!state.Authenticated)
{
MainThreadEventQueue.Enqueue(() => OnNotAuthenticated());
return(null);
}
switch (state.CurrentState)
{
case QueueState.ArenaJoinable:
case QueueState.AwaitingOtherPlayers:
case QueueState.InArena:
case QueueState.NotQueued:
case QueueState.Queued:
case QueueState.QueuePopped:
MainThreadEventQueue.Enqueue(() => OnStateChanged(state.CurrentState));
break;
default:
throw new Exception("Unhandled enum value " + state.CurrentState);
}
return(null);
}
private void handle_result(QueueStateMsg res)
{
if (!res.Authenticated)
{
MainThreadEventQueue.Enqueue(() => OnNotAuthenticated());
}
else
{
MainThreadEventQueue.Enqueue(() => OnStateChanged(res.CurrentState));
}
}
protected bool PopQueueForPlayers(List <Player> left, List <Player> right)
{
var match_decl = new MatchDecl(left, right);
foreach (var player in left.Concat(right))
{
if (!player.online)
{
cancel_queue(left, right);
return(false);
}
var player_res = player.match_maker.AwaitingAccept(match_decl);
switch (player_res)
{
case MatchMaker.State.AwaitingAccept:
break; //Success
default:
cancel_queue(left, right);
return(false);
}
}
var ev = new QueueStateMsg
{
Authenticated = true,
CurrentState = QueueState.QueuePopped
};
foreach (var player in left.Concat(right))
{
player.stream_match_maker.Enqueue(ev);
}
return(true);
}
public override Task <QueueStateMsg> AnswerMatch(AnswerMatchAttempt request, ServerCallContext context)
{
var player = PlayerAuth.Instance.GetPlayer(context);
if (player == null)
{
return(not_authenticated());
}
var result = player.match_maker.AnswerPending(player, request.Accepted);
switch (result.player_state)
{
case MatchMaker.State.AwaitingOtherPlayers: //Success
{
if (result.all_is_ready)
{
//Create arena
var arena = match_constructors.GetArenaFactory(result.match_mode, result.arena, result.team_size).Construct();
foreach (var match_player in result.match_decl.Left)
{
arena.AddLeftPlayer(match_player);
}
foreach (var match_player in result.match_decl.Right)
{
arena.AddRightPlayer(match_player);
}
//Send arena joinable to everyone
var ev = new QueueStateMsg
{
Authenticated = true,
CurrentState = QueueState.ArenaJoinable
};
var players = result.match_decl.Left.Concat(result.match_decl.Right);
foreach (var match_player in players)
{
if (match_player != player)
{
match_player.stream_match_maker.Enqueue(ev);
}
match_player.match_maker.InArena(arena);
}
//And finally send to last player
return(Task.FromResult(ev));
}
else
{
return(Task.FromResult(new QueueStateMsg
{
Authenticated = true,
CurrentState = QueueState.AwaitingOtherPlayers
}));
}
}
case MatchMaker.State.AwaitingAccept:
case MatchMaker.State.InArena:
case MatchMaker.State.NotQueued:
case MatchMaker.State.Queued:
return(state_task(result.player_state));
default:
throw new Exception("Unhandled enum value " + result.player_state);
}
}
