private bool ValidateFirstConnectionToChat(IClientModel clientSneder, ChatModule chat, InsertToChatMessageModel data)
{
if (clientSneder.CurrentConnectChat == null)
{
if (chat == null)
{
var errorBody = new ErrorMessage
{
RequestType = MessageType.ErrorResponse,
Error = $"There is not chat with id {data.ChatId}"
};
_containerInterfaces.RequestHandler.SendData(clientSneder.Client, Utils.SerlizeObject(errorBody));
return(false);
}
else
{
var successBody = new OkResponseMessage
{
RequestType = MessageType.SuccessResponse,
Message = $"user {data.From} in chat with {data.ChatId}"
};
_containerInterfaces.RequestHandler.SendData(clientSneder.Client, Utils.SerlizeObject(successBody));
return(true);
}
}
return(true);
}
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.SetRenderTarget(RenderTarget);
GraphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise;
GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp;
GraphicsDevice.SamplerStates[1] = SamplerState.PointClamp;
Mesh.ResetStats();
SkyModule.Draw(gameTime);
ChunkModule.Draw(gameTime);
HighlightModule.Draw(gameTime);
HudModule.Draw(gameTime);
ChatModule.Draw(gameTime);
WindowModule.Draw(gameTime);
DebugInfoModule.Draw(gameTime);
_imgui.BeforeLayout(gameTime);
ImGuiLayout();
_imgui.AfterLayout();
GraphicsDevice.SetRenderTarget(null);
SpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.Opaque);
SpriteBatch.Draw(RenderTarget, Vector2.Zero, Color.White);
SpriteBatch.End();
base.Draw(gameTime);
}
public void Operation(MainRequest request)
{
var data = request as InsertToChatMessageModel;
ChatModule foundChat = _allChatDetails.GetChatById(data.ChatId);
SendToAll(request, foundChat);
}
public void SendMessage(string to, string message)
{
if (LinphoneCore.IsNonZero())
{
IntPtr chat_room = ChatModule.linphone_core_get_chat_room_from_uri(LinphoneCore, to);
IntPtr chat_message = ChatModule.linphone_chat_room_create_message(chat_room, message);
ChatModule.linphone_chat_room_send_chat_message(chat_room, chat_message);
}
}
public void TakeScreenshot()
{
var path = Path.Combine(Paths.Screenshots, DateTime.Now.ToString("yyyy-MM-dd_H.mm.ss") + ".png");
if (!Directory.Exists(Path.GetDirectoryName(path)))
Directory.CreateDirectory(Path.GetDirectoryName(path));
using (var stream = File.OpenWrite(path))
new PngWriter().Write(RenderTarget, stream);
ChatModule.AddMessage("Screenshot saved to " + Path.GetFileName(path));
}
//SCRIPTINPUT (FS)
void AssignNext(ChatModule cm, int position, string requester)
{
if (cm.RemoveRequest(requester))
{
if (position + 1 < requests.Count)
{
cm.SetRequest(requests[position + 1].targetName, requests[position + 1].targetID);
}
}
}
protected override void OnLoad()
{
module = ModuleManager.Instance.GetModule <ChatModule>();
UIManager.SetButtonClick(btnSend.gameObject, OnSend);
chatLeftModel = Resources.Load <Transform>("Prefabs/UI/RotbotChatItem");
chatRightModel = Resources.Load <Transform>("Prefabs/UI/selfChatItem");
Messager.Instance.AddNotification(ChatModule.MSG_RESPOND, OnRespond);
base.OnLoad();
}
public IRCBridge(ChatModule module)
{
this.module = module;
module.OnMessageMOTD += new ChatModule.OnMessageDelegate(module_OnMessageMOTD);
module.OnMessageGuildChat += new ChatModule.OnMessageDelegate(module_OnMessageGuildChat);
module.OnMessageOfficerChat += new ChatModule.OnMessageDelegate(module_OnMessageOfficerChat);
module.OnMessageWhisper += new ChatModule.OnMessageDelegate(module_OnMessageWhisper);
module.OnPresenceChange += new ChatModule.OnPresenceDelegate(module_OnPresenceChange);
}
void module_OnPresenceChange(ChatModule module, Presence presence)
{
var arrow = "->";
if (presence.Offline)
{
arrow = "<-";
}
IrcSendMessage(String.Format("{0} {1} ({2})", arrow, presence.Name, presence.Type));
}
private void SendToAll(ChatModule chat, MainRequest request, string message)
{
var allUserToSend = GetAllConnectedToSend(chat, request);
foreach (var client in allUserToSend)
{
if (client.Client.Connected)
{
_requestHandler.SendData(client.Client, message);
}
}
}
void OnPresenceChange(ChatModule module, Presence presence)
{
var arrow = "->";
if (presence.Offline)
{
arrow = "<-";
}
AppendLine(String.Format("{0} {1} ({2})", arrow, presence.Name, presence.Type));
NotifyPropertyChanged("ChatLog");
}
private void SendAll(ChatModule foundChat, InsertToChatMessageModel request, string message)
{
var allUserToSend = GetAllConnectedToSend(foundChat, request);
foreach (var client in allUserToSend)
{
if (client.Client.Connected)
{
_requestHandler.SendData(client.Client, message);
}
}
}
private void SendToAllExit(ChatModule chat, MainRequest request, string message)
{
var allUserToSend = chat.Clients.Where(c => c.CurrentConnectChat != null).Where(g => g.Connected == true && g.CurrentConnectChat.ChatId == chat.ChatId);
foreach (var client in allUserToSend)
{
if (client.Client.Connected)
{
_requestHandler.SendData(client.Client, message);
}
}
}
public void TakeScreenShot()
{
var path = Path.Combine(Paths.Screenshots, DateTime.Now.ToString("yyyy-MM-dd_H.mm.ss") + ".png");
var directoryName = Path.GetDirectoryName(path);
Directory.CreateDirectory(directoryName ?? throw new InvalidOperationException());
using (var stream = File.OpenWrite(path))
RenderTarget.SaveAsPng(stream, RenderTarget.Width, RenderTarget.Height);
ChatModule.AddMessage($"screen shot saved to {Path.GetFileName(path)}");
}
public void OnSubmit()
{
mInput.RemoveFocus();
string text = NGUIText.StripSymbols(mInput.value);
if (!string.IsNullOrEmpty(text))
{
ChatModule module = ModuleManager.Instance.FindModule <ChatModule>();
module.SendText(mCurChannel, text);
mInput.value = "";
}
}
protected override void Update(GameTime gameTime)
{
GameTime = gameTime;
if (PendingMainThreadActions.TryTake(out var action))
{
action();
}
var adjusted = Client.World.World.FindBlockPosition(
new Coordinates3D((int)Client.Position.X, 0, (int)Client.Position.Z), out var chunk);
if (chunk != null && Client.LoggedIn)
{
if (chunk.GetHeight((byte)adjusted.X, (byte)adjusted.Z) != 0)
{
Client.Physics.Update(gameTime.ElapsedGameTime);
}
}
if (NextPhysicsUpdate < DateTime.UtcNow && Client.LoggedIn)
{
// NOTE: This is to make the vanilla server send us chunk packets
// We should eventually make some means of detecting that we're on a vanilla server to enable this
// It's a waste of bandwidth to do it on a TrueCraft server
Client.QueuePacket(new PlayerGroundedPacket {
OnGround = true
});
NextPhysicsUpdate = DateTime.UtcNow.AddMilliseconds(50);
}
if (IsActive)
{
foreach (var module in InputModules)
{
module.Update(gameTime);
}
}
SkyModule.Update(gameTime);
ChunkModule.Update(gameTime);
HighlightModule.Update(gameTime);
HudModule.Update(gameTime);
ChatModule.Update(gameTime);
WindowModule.Update(gameTime);
DebugInfoModule.Update(gameTime);
UpdateCamera();
base.Update(gameTime);
}
public override void Initialize(IServer server)
{
base.Initialize(server);
_module = server.GetModule <ChatModule>();
server.SetHandler(777, message =>
{
var username = message.AsString();
Logs.Debug("Changing username to: " + username);
_module.ChangeUsername(message.Peer, username);
});
}
public void OnMessageReceived(IntPtr lc, IntPtr room, IntPtr message)
{
var peer_address = ChatModule.linphone_chat_room_get_peer_address(room);
if (peer_address.IsNonZero())
{
var addressStringPtr = CallModule.linphone_address_as_string(peer_address);
var chatMessagePtr = ChatModule.linphone_chat_message_get_text(message);
string addressString, chatMessage;
if (MarshalingExtensions.TryConvert(addressStringPtr, out addressString) && MarshalingExtensions.TryConvert(chatMessagePtr, out chatMessage))
{
MessageReceivedEvent?.Invoke(addressString, chatMessage);
}
}
}
public void UpdateCurrentChat(IClientModel clientModel, ChatModule chat)
{
var clientFromClients = GetClientByName(clientModel.Name);
var clientFromChat = GetClientByNameFromChat(clientModel.Name);
if (chat != null)
{
var clientFromChat2 = chat.GetClient(clientModel.Name);
if (clientFromChat2 != null)
{
clientFromChat2.CurrentConnectChat = chat;
}
}
clientFromClients.CurrentConnectChat = chat;
clientFromChat.CurrentConnectChat = chat;
}
void OnMessage(ChatModule module, Message m)
{
if (m.Type == Message.CHAT_MSG_TYPE_GUILD_CHAT || m.Type == Message.CHAT_MSG_TYPE_OFFICER_CHAT)
{
AppendLine(String.Format("<{0}> {1}", m.CharacterName, m.Body));
}
else if (m.Type == Message.CHAT_MSG_TYPE_GUILD_MOTD)
{
AppendLine("MOTD: " + m.Body);
}
else if (m.Type == Message.CHAT_MSG_TYPE_WHISPER)
{
AppendLine(String.Format("whisper <{0}> {1}", m.CharacterName, m.Body));
}
NotifyPropertyChanged("ChatLog");
}
static void Main(string[] args)
{
if (args.Length < 7)
{
var exename = Path.GetFileName(Process.GetCurrentProcess().MainModule.FileName);
Console.WriteLine("Usage: {0} account password characterName realmName ircHost ircChannel ircNick", exename);
return;
}
session = new Session();
var chat = new ChatModule(session, args[2], args[3]);
var irc = new IRCBridge(chat);
irc.Start(args[4], args[5], args[6], "", 6667);
session.Start(args[0], args[1]);
}
private void SendToAll(MainRequest request, ChatModule chat)
{
var data = request as InsertToChatMessageModel;
var clientSneder = _allChatDetails.GetClientByName(data.From);
if (!ValidateFirstConnectionToChat(clientSneder, chat, data))
{
return;
}
try
{
lock (locker)
{
_allChatDetails.UpdateCurrentChat(clientSneder, chat);
}
var model = new NewChatMessage
{
RequestType = MessageType.NewChatMessage,
From = request.From,
Message = data.MessageChat
};
string message = Utils.SerlizeObject(model);
if (data.MessageChat == "exit")
{
ExitFromChat(clientSneder, chat, request);
return;
}
SendToAll(chat, request, message);
chat.AddMessage(new MessageModel(ChatMessageType.TextMessage, data.MessageChat, clientSneder, DateTime.Now));
}
catch (Exception e)
{
ExitFromChat(clientSneder, chat, request);
}
}
private void ExitFromChat(IClientModel clientSneder, ChatModule chat, MainRequest request)
{
lock (locker)
{
_allChatDetails.UpdateCurrentChat(clientSneder, null);
}
var model = new NewChatMessage
{
RequestType = MessageType.NewChatMessage,
From = request.From
};
model.Message = $"The user {clientSneder.Name} disconnect from server";
chat.AddMessage(new MessageModel(ChatMessageType.TextMessage, model.Message, clientSneder, DateTime.Now));
SendToAll(chat, request, Utils.SerlizeObject(model));
model.Message = $"exit";
chat.AddMessage(new MessageModel(ChatMessageType.TextMessage, model.Message, clientSneder, DateTime.Now));
_containerInterfaces.RequestHandler.SendData(clientSneder.Client, Utils.SerlizeObject(model));
}
private void ConnectedToChat(string requestData)
{
string response = requestData;
InsertToChatMessageModel request = Utils.DeSerlizeObject <InsertToChatMessageModel>(response);
var clientSneder = _allChatDetails.GetClientByName(Name);
ChatModule foundChat = _allChatDetails.GetChatById(request.ChatId);
lock (locker)
{
_allChatDetails.UpdateCurrentChat(clientSneder, foundChat);
}
Console.WriteLine(clientSneder.CurrentConnectChat);
while (true)
{
request = Utils.DeSerlizeObject <InsertToChatMessageModel>(response);
var model = new NewChatMessage
{
RequestType = "NewChatMessage",
From = request.From,
Message = request.MessageChat
};
string message = Utils.SerlizeObject(model);
if (request.MessageChat == "exit")
{
lock (locker)
{
_allChatDetails.UpdateCurrentChat(clientSneder, null);
//clientSneder.CurrentConnectChat = null;
}
model.Message = $"The user {model.From} disconnect from this chat";
SendAll(foundChat, request, $"User");
return;
}
SendAll(foundChat, request, message);
foundChat.AddMessage(new MessageModel(MessageType.TextMessage, message, clientSneder, DateTime.Now));
response = _responseHandler.GetResponse(_allChatDetails.GetClientByName(Name).Client);
}
}
static void Main(string[] args)
{
var client = new Client();
var websocketHandler = new WebsocketHandler();
var chatModule = new ChatModule();
client
.SetServerAddress("127.0.0.1")
.SetPort(800)
.WithReconnectPolicy(ReconnectPolicy.Forever)
.AddHandler(websocketHandler.AddModule(chatModule))
//.AddHandler(new EncryptionHandler())
//.AddHandler(new BroadcastHandler())
.Connect();
while (true)
{
var message = Console.ReadLine();
chatModule.SendMessage(websocketHandler, message);
}
}
private void Start()
{
QualitySettings.currentLevel = (QualityLevel)(3 + GameData.mGameSettings.mGraphicsLevel);
StartCoroutine(UpdateScreenSpace());
DynamicOptions.bDrawCursor = true;
if (GameObject.Find("GameMusic(Clone)") != null)
{
Object.Destroy(GameObject.Find("GameMusic(Clone)"));
}
if (GameData.MyFactionId == 1)
{
if (GameObject.Find("BanzaiMusic(Clone)") == null)
{
BanzaiMusic = (Object.Instantiate(BanzaiMusic) as GameObject);
BanzaiMusic.GetComponent <AudioSource>().volume = GameData.mGameSettings.mMusicVolume;
}
else
{
BanzaiMusic = GameObject.Find("BanzaiMusic(Clone)");
BanzaiMusic.GetComponent <AudioSource>().volume = GameData.mGameSettings.mMusicVolume;
}
}
else if (GameData.MyFactionId == 2)
{
if (GameObject.Find("AtlasMusic(Clone)") == null)
{
AtlasMusic = (Object.Instantiate(AtlasMusic) as GameObject);
AtlasMusic.GetComponent <AudioSource>().volume = GameData.mGameSettings.mMusicVolume;
}
else
{
AtlasMusic = GameObject.Find("AtlasMusic(Clone)");
AtlasMusic.GetComponent <AudioSource>().volume = GameData.mGameSettings.mMusicVolume;
}
}
gameSummary.Start(this);
chat = new ChatModule(this);
queueState = initMyQueue;
Camera.main.backgroundColor = Color.black;
StartCoroutine(HolidayEvent.OnQueueStart());
}
private List <IClientModel> GetAllConnectedToSend(ChatModule chat, MainRequest requestData)
{
var request = requestData as InsertToChatMessageModel;
List <IClientModel> ls = new List <IClientModel>();
foreach (var client in chat.Clients)
{
if ((client.Name != request.From) && (client.Connected == true))
{
if (client.CurrentConnectChat != null)
{
if (client.CurrentConnectChat.ChatId == chat.ChatId)
{
ls.Add(client);
}
}
}
}
return(ls);
}
private void SendToAll(MainRequest request, ChatModule chat)
{
var data = request as InsertToChatMessageModel;
var clientSneder = _allChatDetails.GetClientByName(data.From);
lock (locker)
{
_allChatDetails.UpdateCurrentChat(clientSneder, chat);
}
var model = new NewChatMessage
{
RequestType = "NewChatMessage",
From = request.From,
Message = data.MessageChat
};
string message = Utils.SerlizeObject(model);
if (data.MessageChat == "exit")
{
model.Message = $"The user {data.From} disconnect from server";
SendToAll(chat, request, Utils.SerlizeObject(model));
model.Message = $"exit";
SendToAllExit(chat, request, Utils.SerlizeObject(model));
lock (locker)
{
_allChatDetails.UpdateCurrentChat(clientSneder, null);
}
return;
}
SendToAll(chat, request, message);
chat.AddMessage(new MessageModel(MessageType.TextMessage, message, clientSneder, DateTime.Now));
}
private void UpdateViews()
{
mAreaLabel.text = "";
ChatModule module = ModuleManager.Instance.FindModule <ChatModule>();
ChatCacheData[] msgs = module.GetMessageCache(mCurChannel);
if (msgs == null)
{
return;
}
for (int i = 0; i < msgs.Length; ++i)
{
ChatCacheData data = msgs[i];
if (i != msgs.Length - 1)
{
data.msg += "\n";
}
AddMessage(mCurChannel, data.name, data.msg);
}
mScrollBar.value = 1.0f;
}
public MainWindow(string accountName, string password, string characterName, string realmName)
{
InitializeComponent();
session = new Session();
this.Closed += new EventHandler(MainWindow_Closed);
DataContext = this;
if (chat == null)
{
chat = new ChatModule(session, characterName, realmName);
var msgDele = new ChatModule.OnMessageDelegate(OnMessage);
chat.OnMessageGuildChat += msgDele;
chat.OnMessageOfficerChat += msgDele;
chat.OnMessageWhisper += msgDele;
chat.OnMessageMOTD += msgDele;
chat.OnPresenceChange += new ChatModule.OnPresenceDelegate(OnPresenceChange);
chat.OnChatLoggedOut += new ChatModule.OnChatLoggedInOutDelegate(OnChatLoggedOut);
chat.OnChatLoggedIn += new ChatModule.OnChatLoggedInOutDelegate(OnChatLoggedIn);
chat.OnLoginFailed += new ChatModule.OnLoginFailedDelegate(OnLoginFailed);
}
session.Start(accountName, password);
session.OnSessionClosed += new Session.OnSessionClosedDelegate(OnSessionClosed);
var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var version = assembly.GetName().Version.ToString();
Title = String.Format("Guild Chat ({0}/{1}) {2}", characterName, realmName, version);
AppendLine("Logging into chat..");
}