public void JoinParty(PartyInfo party)
{
JoinCommand cmd = new JoinCommand();
cmd.type = (int)CommandType.JOIN;
cmd.partyName = party.partyName;
cmd.player = curPlayer;
string jsonCmd = JsonUtility.ToJson(cmd);
currentSocket.Send(jsonCmd);
}
public async Task <GameState> Handle(Guid tableId, JoinCommand command)
{
Task <GameState> loadStateTask = _reader.LoadTableState(tableId);
await loadStateTask;
GameState currentState = loadStateTask.Result;
GameState newState = CommandsHandler.Handle(currentState, command);
await _writer.WriteGameState(newState);
return(newState);
}
private void OnClick(object sender, RoutedEventArgs e)
{
if (With is TLChannel channel)
{
if (channel.IsLeft)
{
JoinCommand?.Execute(null);
}
else if (channel.HasBannedRights && channel.BannedRights.IsViewMessages)
{
DeleteAndExitCommand?.Execute(null);
}
else
{
if (channel.IsBroadcast)
{
if (channel.IsCreator || (channel.HasAdminRights && channel.AdminRights.IsPostMessages))
{
}
else
{
ToggleMuteCommand?.Execute(null);
}
}
}
}
if (With is TLChatForbidden forbiddenChat)
{
DeleteAndExitCommand?.Execute(null);
}
if (With is TLUser user)
{
var full = InMemoryCacheService.Current.GetFullUser(user.Id);
if (full != null && full.IsBlocked)
{
UnblockCommand?.Execute(null);
}
if (user.IsBot && HasAccessToken)
{
StartCommand?.Execute(null);
}
if (user.IsDeleted)
{
DeleteAndExitCommand?.Execute(null);
}
}
}
public void JoinRoomClick()
{
Debug.Log("User Display Name: " + ClientContext.Instance.GetUserSession().GetUserInfo().GetDisplayName());
Debug.Log("User Id : " + ClientContext.Instance.GetUserSession().GetUserInfo().GetUserId());
Debug.Log("Auth token Id : " + ClientContext.Instance.GetUserSession().GetAuthToken());
// TODO: Build Command from builder
IRoomService roomService = new RoomService();
ICommand command = new JoinCommand(roomService.findRoom(), ClientContext.Instance.GetUserSession().GetAuthToken());
EventDispatcher dispatcher = new EventDispatcher();
dispatcher.addListener(EventType.JOINED_ROOM_SUCCESS, new JoinRoomHandler(ClientContext.Instance.GetUserSession()));
command.perform(dispatcher);
}
private async Task When(JoinCommand cmd)
{
_group = await Group.AddAsync(cmd.RoomName);
var application = _applications.GetOrAdd(cmd.RoomName,
newRoomName => new ARWorldApplication(newRoomName, new EventStore(), new DomainEventPublisher()));
_roomName = cmd.RoomName;
application.DomainEventPublisher.EventStream
.Subscribe(e =>
{
switch (e)
{
case PlayerJoined joined:
BroadcastToSelf(_group).OnEvent(joined);
Console.WriteLine($"joined: {joined.PlayerId} as {joined.PlayerName} to {joined.RoomName}");
break;
case PlayerLeft left:
BroadcastToSelf(_group).OnEvent(left);
Console.WriteLine($"left: {left.PlayerId}");
break;
case PlayerSpoke playerSpoke:
BroadcastToSelf(_group).OnEvent(playerSpoke);
Console.WriteLine($"spoke: {playerSpoke.PlayerId} like {playerSpoke.Message}");
break;
case PlayerMoved playerMoved:
BroadcastToSelf(_group).OnEvent(playerMoved);
// Console.WriteLine($"spoke: {playerSpoke.PlayerId} like {playerSpoke.Message}");
break;
}
}).AddTo(_disposables);
application.Execute(cmd);
BroadcastToSelf(_group).OnEvent(
new ARWorldEventStream()
{
RoomName = _roomName,
EventStream = application.EventStore.LoadEventStream()
});
}
private void connectButton_Click(object sender, EventArgs e)
{
JoinCommand join = new JoinCommand();
join.UserName = "******";
join.PasswordHash = Communication.Tools.HashString("dani");
try
{
requestID = serviceProxy.HandleDarPoolingMobileRequest(join);
//MessageBox.Show(response);
if (requestID != null)
connectionLabel.Text = "Request sent";
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void connectButton_Click(object sender, EventArgs e)
{
JoinCommand join = new JoinCommand();
join.UserName = "******";
join.PasswordHash = Communication.Tools.HashString("dani");
try
{
requestID = serviceProxy.HandleDarPoolingMobileRequest(join);
//MessageBox.Show(response);
if (requestID != null)
{
connectionLabel.Text = "Request sent";
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public override bool Join(UserNodeCore context, string username, string password,
string serviceNodeAddress, string callbackAddress)
{
try
{
ClientCallback callback = new ClientCallback(context);
// First of all, set up the connection
EndpointAddress endPointAddress = new EndpointAddress(serviceNodeAddress);
WSDualHttpBinding binding = new WSDualHttpBinding();
binding.ClientBaseAddress = new Uri(callbackAddress);
DuplexChannelFactory <IDarPooling> factory = new DuplexChannelFactory <IDarPooling>(
callback, binding, endPointAddress);
context.ServiceProxy = factory.CreateChannel();
}
catch
{
context.ServiceProxy = null;
return(false);
}
// Now, hopefully you have a working ServiceProxy.
string passwordHash = Communication.Tools.HashString(password);
Command c = new JoinCommand(context.UserNode, username, passwordHash);
try
{
context.ServiceProxy.HandleDarPoolingRequest(c);
}
catch (TimeoutException e)
{
context.ServiceProxy = null;
throw e;
}
// Finally, if Join is NOT successfull, remove reference (UserNodeCore.onResultReceive)
return(true);
}
/// <summary>
/// Creates a new instance of an On Join command
/// </summary>
/// <param name="type">The type of join command</param>
/// <param name="value">The value for the command (download link, website url)</param>
public OnJoinCommand(JoinCommand type, object value)
{
this.Type = type;
this.Value = value;
}
public ActionResult <GameState> Join(string tableId, [FromBody] JoinCommand joinCommand)
{
return(_commandFacade.Handle(Guid.Parse(tableId), joinCommand).Result);
}
private void When(JoinCommand cmd)
{
Update(_roomName, world => world.AddPlayer(cmd.PlayerId, cmd.PlayerName));
}
/**
* <summary>
* Parses the <see cref="CommandList"/> with the specified file name to an object
* </summary>
*/
public static CommandList Parse(string name = "base")
{
Dictionary <string, object> jsonData;
// Check if the files Directory exists, if not, create it
string dataPath = Application.persistentDataPath + "/commandlists";
if (!Directory.Exists(dataPath))
{
Directory.CreateDirectory(dataPath);
}
// Read from the file, handle cases the specified file, or even the standard file doesnt exist
if (File.Exists(dataPath + "/" + name + ".json"))
{
using (StreamReader sr = new StreamReader(dataPath + "/" + name + ".json"))
{
jsonData = JsonConvert.DeserializeObject <Dictionary <string, object> >(sr.ReadLine());
}
}
else if (File.Exists(dataPath + "/base.json"))
{
using (StreamReader sr = new StreamReader(dataPath + "/base.json"))
{
jsonData = JsonConvert.DeserializeObject <Dictionary <string, object> >(sr.ReadLine());
}
PlayerPrefs.SetString("list", "base");
}
else
{
jsonData = new Dictionary <string, object>();
}
// Parse the string to an object
CommandList newCommandList;
if (jsonData.Count > 0)
{
// Try get the name of the list
if (jsonData.TryGetValue("name", out object dataName))
{
newCommandList = new CommandList(name, (string)dataName);
}
else
{
newCommandList = new CommandList(name, "Some List");
}
// Try get the content of the list
if (jsonData.TryGetValue("parts", out object partlistobj))
{
// Iterate over each PartCommandList in the JSON data
foreach (List <Dictionary <string, object> > part in ((Newtonsoft.Json.Linq.JArray)partlistobj).ToObject <List <List <Dictionary <string, object> > > >())
{
PartCommandList newPart = new PartCommandList();
// Iterate over each Command in that list in the JSON data
foreach (Dictionary <string, object> cmd in part)
{
if (cmd.TryGetValue("commandTitle", out object commandTitle))
{
// Incase there is a commandTitle specified in JSON, try and get meaning from it
Command newCmd = null;
switch (commandTitle)
{
// Incase the title means something, try and get the values for that specific Command
case "rainbow":
newCmd = new RainbowCommand();
if (cmd.TryGetValue("wait_ms", out object wait_ms))
{
((RainbowCommand)newCmd).wait_ms = Convert.ToInt32(wait_ms);
}
break;
case "rainbowStationary":
newCmd = new StatRainbowCommand();
if (cmd.TryGetValue("wait_ms", out wait_ms))
{
((StatRainbowCommand)newCmd).wait_ms = Convert.ToInt32(wait_ms);
}
break;
case "colorWipe":
newCmd = new ColorwipeCommand();
if (cmd.TryGetValue("color", out object color))
{
((ColorwipeCommand)newCmd).color = Helper.ToColor(Convert.ToInt32(color));
}
if (cmd.TryGetValue("wait_ms", out wait_ms))
{
((ColorwipeCommand)newCmd).wait_ms = Convert.ToInt32(wait_ms);
}
break;
case "setColor":
newCmd = new SetColorCommand();
if (cmd.TryGetValue("color", out color))
{
((SetColorCommand)newCmd).color = Helper.ToColor(Convert.ToInt32(color));
}
break;
case "theaterChase":
newCmd = new TheaterCommand();
if (cmd.TryGetValue("color", out color))
{
((TheaterCommand)newCmd).color = Helper.ToColor(Convert.ToInt32(color));
}
if (cmd.TryGetValue("wait_ms", out wait_ms))
{
((TheaterCommand)newCmd).wait_ms = Convert.ToInt32(wait_ms);
}
if (cmd.TryGetValue("iterations", out object iterations))
{
((TheaterCommand)newCmd).iterations = Convert.ToInt32(iterations);
}
break;
case "theaterChaseRainbow":
newCmd = new TheaterRainbowCommand();
if (cmd.TryGetValue("wait_ms", out wait_ms))
{
((TheaterRainbowCommand)newCmd).wait_ms = Convert.ToInt32(wait_ms);
}
break;
case "interpolate":
newCmd = new InterpolateCommand();
if (cmd.TryGetValue("color", out color))
{
((InterpolateCommand)newCmd).color = Helper.ToColor(Convert.ToInt32(color));
}
if (cmd.TryGetValue("color2", out object color2))
{
((InterpolateCommand)newCmd).color2 = Helper.ToColor(Convert.ToInt32(color2));
}
if (cmd.TryGetValue("duration_ms", out object duration_ms))
{
((InterpolateCommand)newCmd).duration_ms = Convert.ToInt32(duration_ms);
}
if (cmd.TryGetValue("goback", out object goback))
{
((InterpolateCommand)newCmd).goback = (bool)goback;
}
break;
case "wait":
newCmd = new WaitCommand();
if (cmd.TryGetValue("duration_ms", out duration_ms))
{
((WaitCommand)newCmd).duration_ms = Convert.ToInt32(duration_ms);
}
break;
case "split":
newCmd = new SplitCommand();
if (cmd.TryGetValue("newList", out object newList))
{
((SplitCommand)newCmd).newList = Convert.ToInt32(newList);
}
break;
case "join":
newCmd = new JoinCommand();
if (cmd.TryGetValue("listtojoin", out object listtojoin))
{
((JoinCommand)newCmd).listtojoin = Convert.ToInt32(listtojoin);
}
if (cmd.TryGetValue("waitlist", out object waitlist))
{
((JoinCommand)newCmd).waitlist = (bool)waitlist;
}
break;
}
// Only add to list if the title meant sth
if (newCmd != null)
{
if (cmd.TryGetValue("title", out object title))
{
newCmd.title = (string)title;
}
if (cmd.TryGetValue("lamps", out object lamps))
{
newCmd.lamps = ((Newtonsoft.Json.Linq.JArray)lamps).ToObject <List <int> >();
}
newPart.AddHidden(newCmd);
}
}
}
newCommandList.lists.Add(newPart);
}
}
return(newCommandList);
}
return(new CommandList());
}
/**
* <summary>
* Changes the <see cref="Command"/> object to the new dynamic type specified by newSetting
* </summary>
*/
public void ChangeCommand(Command cmd, string newSetting)
{
// Initializing the subtype
Command newCommand;
if (newSetting == "rainbow")
{
newCommand = new RainbowCommand();
}
else if (newSetting == "rainbowStationary")
{
newCommand = new StatRainbowCommand();
}
else if (newSetting == "theaterChaseRainbow")
{
newCommand = new TheaterRainbowCommand();
}
else if (newSetting == "theaterChase")
{
newCommand = new TheaterCommand();
}
else if (newSetting == "colorWipe")
{
newCommand = new ColorwipeCommand();
}
else if (newSetting == "interpolate")
{
newCommand = new InterpolateCommand();
}
else if (newSetting == "setColor")
{
newCommand = new SetColorCommand();
}
else if (newSetting == "wait")
{
newCommand = new WaitCommand();
}
else if (newSetting == "split")
{
newCommand = new SplitCommand();
}
else if (newSetting == "join")
{
newCommand = new JoinCommand();
}
else
{
newCommand = new RainbowCommand();
}
// Saves all settings from the old command that the new Command has
newCommand.SaveSettings(cmd.GetSettings());
// Replaces the old Gameobject with a fresh one and initializes it
int idx = 0;
int i = 0;
foreach (PartCommandList list in commands.lists)
{
if (list.list.Contains(cmd))
{
idx = list.Remove(cmd);
list.list.Insert(idx, newCommand);
i = commands.lists.IndexOf(list);
}
}
GameObject obj = Instantiate(commandPrefab, commands.lists[i].listObject.transform);
newCommand.commandObject = obj;
newCommand.Init();
obj.transform.SetSiblingIndex(idx);
// Deletes the old Gameobject to be picked up by garbage collector
GameObject.Destroy(cmd.commandObject);
}
private void Join(ApplicationContext applicationContext, JoinCommand join)
{
applicationContext.TeamContext = new TeamContext(join.Text);
applicationContext.Application.Server.Write(Components.LogType.Info, "joining team " + join.Text);
}
private void RelayJoinCommand(object sender, JoinCommand e)
{
string msg = string.Format("[{0}] * {1} has joined.", e.Channel, Bot.IRC.Nickname);
ProcessRelay(e.Channel, RelayType.Join, msg);
}
// Update is called once per frame
void Update()
{
List <NetworkCommand> cmds = Network.getPendingCommands();
if (cmds != null)
{
foreach (NetworkCommand cmd in cmds)
{
/*** IN-GAME ACTIONS ***/
if (cmd is MoveCommand)
{
MoveCommand move = (MoveCommand)cmd;
Pos start = Network.getPlayer(move.clientID).grid_pos;
Pos end = move.end;
Debug.Log("Move received! From " + start + " to " + end);
mapManager.move(start, end);
}
if (cmd is AttackCommand)
{
AttackCommand attack = (AttackCommand)cmd;
Pos start = Network.getPlayer(attack.clientID).grid_pos;
Pos end = attack.end;
Debug.Log("Attack received! From " + start + " to " + end + " action No: " + attack.actionNo);
mapManager.attack(start, end, attack.actionNo);
}
if (cmd is WaitCommand)
{
WaitCommand wait = (WaitCommand)cmd;
Debug.Log("Wait received! From client#" + wait.clientID);
Client waitingClient = Network.getPeer(wait.clientID);
waitingClient.playerObject.wait();
}
if (cmd is InteractCommand)
{
InteractCommand interact = (InteractCommand)cmd;
Pos start = Network.getPlayer(interact.clientID).grid_pos;
Pos end = interact.end;
Debug.Log("Interact received! From " + start + " to " + end);
mapManager.interact(start, end);
}
if (cmd is UseItemCommand)
{
UseItemCommand item = (UseItemCommand)cmd;
Player player = Network.getPlayer(item.clientID);
Item itemToUse = player.inventory.GetItemFromSlot(item.slotIndex);
player.inventory.DecrementItemAtSlot(item.slotIndex);
InventoryManager.UseItem(itemToUse, player);
Debug.Log("Use Item received! From client#" + item.clientID + " for item in slot #" + item.slotIndex);
}
/*** LOBBY ACTIONS ***/
if (cmd is ReadyCommand)
{
ReadyCommand ready = (ReadyCommand)cmd;
Debug.Log("Received READY");
Client client = Network.getPeer(ready.clientID);
if (client == null)
{
Network.setPeer(ready.clientID);
client = Network.getPeer(ready.clientID);
}
client.ready = !client.ready;
}
if (cmd is NicknameCommand)
{
NicknameCommand nickname = (NicknameCommand)cmd;
Debug.Log("Received nickname: " + nickname.nickname);
Client client = Network.getPeer(nickname.clientID);
if (client == null)
{
Network.setPeer(nickname.clientID);
client = Network.getPeer(nickname.clientID);
}
client.nickname = nickname.nickname;
}
if (cmd is ClassnameCommand)
{
ClassnameCommand classname = (ClassnameCommand)cmd;
Debug.Log("Received classname: " + classname.classname);
Client client = Network.getPeer(classname.clientID);
if (client == null)
{
Network.setPeer(classname.clientID);
client = Network.getPeer(classname.clientID);
}
client.classname = classname.classname;
}
if (cmd is UpdateClientInfoCommand) // called when a new player joins and needs to be synchronized
{
UpdateClientInfoCommand update = (UpdateClientInfoCommand)cmd;
Debug.Log("Received update from client#" + update.clientID);
Client client = Network.getPeer(update.clientID);
if (client == null)
{
Network.setPeer(update.clientID);
client = Network.getPeer(update.clientID);
}
client.nickname = update.nickname;
client.classname = update.classname;
client.ready = update.ready;
}
if (cmd is SetSeedCommand)
{
SetSeedCommand seed = (SetSeedCommand)cmd;
Debug.Log("Received seed!");
Settings.MasterSeed = seed.seed;
}
/*** NETWORK ACTIONS ***/
if (cmd is JoinCommand)
{
JoinCommand _join = (JoinCommand)cmd; // to avoid conflict with 'join' keyword
if (clientID == 0)
{
clientID = _join.clientID;
Debug.Log("Joined game! Client ID #" + clientID + " assigned!");
}
else
{
Debug.Log("New player with client ID #" + _join.clientID + " joined!");
Network.submitCommand(new UpdateClientInfoCommand(Network.getPeer(clientID)));
if (clientID == 1)
{
Network.submitCommand(new SetSeedCommand(Settings.MasterSeed));
}
}
Network.setPeer(_join.clientID);
}
if (cmd is StartCommand)
{
StartCommand start = (StartCommand)cmd;
Debug.Log("Received START");
if (SceneManager.GetActiveScene().name == "NewMenu") // only loads new scene if we're in the lobby
{
SceneManager.LoadScene("Procedural");
foreach (Client client in Network.getPeers())
{
client.ready = false;
}
}
else
{
GameManager.NextLevel();
}
}
if (cmd is EndCommand)
{
EndCommand end = (EndCommand)cmd;
Debug.Log("Received END");
}
if (cmd is DisconnectCommand)
{
DisconnectCommand disconnect = (DisconnectCommand)cmd;
Debug.Log("Received DISCONNECT from client #" + disconnect.clientID);
Network.removePeer(disconnect.clientID);
if (clientID >= disconnect.clientID)
{
clientID--;
Debug.Log("Changed client ID to " + clientID);
}
}
}
}
if (!Network.connected())
{
clientID = 0;
}
}
