private Task handle_events(EventBase ev)
{
switch (ev.EventCase)
{
case EventBase.EventOneofCase.SubscriptionSuccessful:
var session_id_str = ev.SubscriptionSuccessful.SessionToken;
if (!Guid.TryParse(session_id_str, out session_token))
{
throw new Exception("Could not parse the session token received from server!");
}
MainThreadEventQueue.Enqueue(() => OnSuccessfulSubscription(session_token));
if (metadata != null)
{
Debug.LogError("Subscriptionsuccessful is received multiple times!");
}
var local_metadata = new Metadata(); //Local first because of thread concurrency
GrpcHeaders.AddSessionToken(local_metadata, session_token);
metadata = local_metadata;
break;
case EventBase.EventOneofCase.None:
Debug.Log("Got none event.");
break;
}
return(null);
}
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 on_log(string msg)
{
MainThreadEventQueue.Enqueue(() =>
{
OnLog.Invoke(msg);
});
}
private void make_rpc <T>(AsyncUnaryCall <T> response, Action <T> handler)
{
Task.Run(async() =>
{
var result = await response;
MainThreadEventQueue.Enqueue(() => handler(result));
});
}
private void handle_result(QueueStateMsg res)
{
if (!res.Authenticated)
{
MainThreadEventQueue.Enqueue(() => OnNotAuthenticated());
}
else
{
MainThreadEventQueue.Enqueue(() => OnStateChanged(res.CurrentState));
}
}
private Task handle_events(Event ev)
{
switch (ev.EventCase)
{
case Event.EventOneofCase.None:
UnityEngine.Debug.Log("Got a none event from server.");
break;
case Event.EventOneofCase.FriendAcceptedRequest:
MainThreadEventQueue.Enqueue(() => OnFriendAcceptedRequest(ev.FriendAcceptedRequest)); break;
case Event.EventOneofCase.FriendOnlineStateChanged:
MainThreadEventQueue.Enqueue(() => OnFriendOnlineStateChanged(ev.FriendOnlineStateChanged)); break;
case Event.EventOneofCase.FriendRemovedYou:
MainThreadEventQueue.Enqueue(() => OnFriendRemovedYou(ev.FriendRemovedYou)); break;
case Event.EventOneofCase.FriendRequest:
MainThreadEventQueue.Enqueue(() => OnFriendRequest(ev.FriendRequest)); break;
case Event.EventOneofCase.GotGroupInvite:
MainThreadEventQueue.Enqueue(() => OnGroupInvite(ev.GotGroupInvite)); break;
case Event.EventOneofCase.GroupDequeued:
MainThreadEventQueue.Enqueue(() => OnGroupDequeued(ev.GroupDequeued)); break;
case Event.EventOneofCase.GroupInviteTimedOut:
MainThreadEventQueue.Enqueue(() => OnGroupInviteTimedOut(ev.GroupInviteTimedOut)); break;
case Event.EventOneofCase.GroupQueueStateChanged:
MainThreadEventQueue.Enqueue(() => OnGroupQueueStateChanged(ev.GroupQueueStateChanged)); break;
case Event.EventOneofCase.LoginResult:
MainThreadEventQueue.Enqueue(() => OnLoginResult(ev.LoginResult)); break;
case Event.EventOneofCase.PlayerAnsweredGroupInvite:
MainThreadEventQueue.Enqueue(() => OnPlayerAnsweredGroupInvite(ev.PlayerAnsweredGroupInvite)); break;
case Event.EventOneofCase.PlayerLeftGroup:
MainThreadEventQueue.Enqueue(() => OnPlayerLeftGroup(ev.PlayerLeftGroup)); break;
case Event.EventOneofCase.QueuePopped:
MainThreadEventQueue.Enqueue(() => OnQueuePopped(ev.QueuePopped)); break;
case Event.EventOneofCase.ReceivedMessage:
MainThreadEventQueue.Enqueue(() => OnReceivedMessage(ev.ReceivedMessage)); break;
default:
throw new Exception("Unhandled enum value " + ev.EventCase);
}
return(null);
}
private void code_editor_watcher()
{
string tmp_file = null;
try
{
var cancel_token = cancel_source.Token;
tmp_file = create_tmp_code_file();
string brane_path;
switch (os)
{
case OperatingSystemFamily.Linux:
brane_path = LinuxZeroBranePath;
break;
case OperatingSystemFamily.MacOSX:
brane_path = MacOSZeroBranePath;
break;
case OperatingSystemFamily.Windows:
brane_path = WindowsZeroBranePath;
break;
default:
throw new Exception("Unhandled enum value " + SystemInfo.operatingSystemFamily);
}
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = Path.Combine(base_dir, brane_path),
Arguments = '"' + tmp_file + '"'
}
};
process.Start();
var fs = new FileSystemWatcher
{
Path = Path.GetDirectoryName(tmp_file),
Filter = Path.GetFileName(tmp_file)
};
fs.EnableRaisingEvents = true;
for (; ;)
{
if (cancel_token.IsCancellationRequested)
{
break;
}
var change = fs.WaitForChanged(WatcherChangeTypes.All, 100);
if (!change.TimedOut)
{
switch (change.ChangeType)
{
case WatcherChangeTypes.Created:
case WatcherChangeTypes.Deleted:
case WatcherChangeTypes.Renamed:
tmp_file = create_tmp_code_file();
goto case WatcherChangeTypes.Changed;
case WatcherChangeTypes.Changed:
Code = File.ReadAllText(tmp_file);
NewCodeHasBeenSubmitted = 1;
MainThreadEventQueue.Enqueue(() => OnCodeChanged.Invoke());
break;
default:
throw new Exception("Unhandled enum value " + change.ChangeType);
}
}
}
}
catch (Exception e)
{
UnityEngine.Debug.LogError(e);
} finally
{
UnityEngine.Debug.Log("Stopped looking for code changes.");
MainThreadEventQueue.Enqueue(() => OnEditorClose.Invoke());
try
{
if (!string.IsNullOrEmpty(tmp_file))
{
File.Delete(tmp_file);
}
} catch { }
}
}
void run_env()
{
Script.DefaultOptions.DebugPrint = (s) => MainThreadEventQueue.Enqueue(() => LogController.Instance?.Log(s));
var engine = new Script();
var cancel_token = cancel_source.Token;
var ud_v3 = UserData.RegisterType(typeof(Vector3));
var ud_q = UserData.RegisterType(typeof(Quaternion));
UserData.RegisterType(typeof(PlayerState));
UserData.RegisterType(typeof(EnvState));
UserData.RegisterType(typeof(Weapon));
var ud_weapon_type = UserData.RegisterType(typeof(WeaponType));
UserData.RegisterType(typeof(Bullet));
UserData.RegisterType(typeof(OtherPlayer));
UserData.RegisterType(typeof(Elevation));
for (; ;)
{
var timer = new CyclicTimer(1f / 10f);
try
{
if (cancel_token.IsCancellationRequested)
{
break;
}
var local_snapshot = current_snapshot; //Really important local_* is used instead of snapshot here. Basicly the state is viewed as consumed from here on.
var local_ps = local_snapshot.player_state;
var local_env = local_snapshot.env_state;
//Set up state
engine.Globals["vector3"] = UserData.CreateStatic(ud_v3);
engine.Globals["quaternion"] = UserData.CreateStatic(ud_q);
engine.Globals["WEAPON_TYPE"] = UserData.CreateStatic(ud_weapon_type);
engine.Globals["player"] = local_ps;
engine.Globals["environment"] = local_env;
//Run script
engine.DoString(Code, codeFriendlyName: "Script");
//Run commands from script
if (local_ps.new_dest.HasValue) //SetDestination
{
var v = local_ps.new_dest.Value;
local_ps.new_dest = null;
MainThreadEventQueue.Enqueue(() => local_navmesh_network.SetDestination(v));
}
if (local_ps.use_weapon) //UseWeapon
{
if (local_ps.equipped_weapon != null)
{
local_ps.use_weapon = false;
MainThreadEventQueue.Enqueue(() => equipment_controller?.CmdUseWeapon());
}
}
if (local_ps.weapon_to_pick_up != null) //PickUpWeapon
{
var weapon = local_ps.weapon_to_pick_up;
local_ps.weapon_to_pick_up = null;
MainThreadEventQueue.Enqueue(() => bag?.PickUp(weapon.controller)); //TODO: Error message: weapon already picked up or owned by other
}
if (local_ps.weapon_to_drop != null) //DropWeapon
{
var weapon = local_ps.weapon_to_drop;
local_ps.weapon_to_drop = null;
MainThreadEventQueue.Enqueue(() => bag?.Drop(weapon.controller)); //TODO: Error message: weapon not ours
}
if (local_ps.weapon_to_equip != null) //EquipWeapon
{
var weapon = local_ps.weapon_to_equip;
local_ps.weapon_to_equip = null;
MainThreadEventQueue.Enqueue(() => equipment_controller?.EquipWeapon(weapon.controller)); //TODO: Error message: weapon not picked up
}
if (local_ps.new_rotation.HasValue) //Aim
{
var rot = local_ps.new_rotation.Value;
local_ps.new_rotation = null;
MainThreadEventQueue.Enqueue(() => rotator?.CmdSetRotation(rot));
}
timer.WaitUntilNextFrame();
} catch (SyntaxErrorException e)
{
MainThreadEventQueue.Enqueue(() => LogController.Instance?.Log(e.DecoratedMessage));
wait_until_new_code_has_been_submitted(timer, cancel_token);
} catch (ScriptRuntimeException e)
{
MainThreadEventQueue.Enqueue(() => LogController.Instance?.Log(e.DecoratedMessage));
wait_until_new_code_has_been_submitted(timer, cancel_token);
} catch (Exception e)
{
UnityEngine.Debug.LogError(e);
MainThreadEventQueue.Enqueue(() => LogController.Instance?.Log(e.Message));
wait_until_new_code_has_been_submitted(timer, cancel_token);
}
}
UnityEngine.Debug.Log("Ended running scripts");
}
protected void OnMainThread(Action a)
{
MainThreadEventQueue.Enqueue(a);
}
