private void AddConsoleMessage(string msg, Enums.MessageType type, Brush msgColour = null, FontWeight?msgWeight = null, double msgSize = 12)
{
if (msgColour == null)
{
msgColour = Brushes.White;
}
if (msgWeight == null)
{
msgWeight = FontWeights.Normal;
}
switch (type)
{
case Enums.MessageType.Network:
networkConsole.AddMessage(msg);
IncrementBadge(Enums.MessageType.Network);
break;
case Enums.MessageType.Debug:
debugConsole.AddMessage(msg);
IncrementBadge(Enums.MessageType.Debug);
break;
case Enums.MessageType.WorldGen:
worldConsole.AddMessage(msg);
IncrementBadge(Enums.MessageType.WorldGen);
break;
}
}
public static void WriteToOutputWindow(string message, Enums.MessageType messageType)
{
message = $"{messageType.ToString().ToUpper()} | {DateTime.Now:G}: {message}";
message = Environment.NewLine + message;
var guidPane = VSConstants.OutputWindowPaneGuid.GeneralPane_guid;
if (!(Package.GetGlobalService(typeof(SVsOutputWindow)) is IVsOutputWindow outputWindow))
{
Logger.Error(Resource.ErrorMessage_ErrorGettingOutputWindow);
return;
}
if (guidPane == VSConstants.OutputWindowPaneGuid.GeneralPane_guid)
{
outputWindow.CreatePane(guidPane, Resource.OutputLoggerWindowTitle, 1, 1);
}
outputWindow.GetPane(guidPane, out var outputWindowPane);
if (outputWindowPane == null)
{
return;
}
outputWindowPane.Activate();
outputWindowPane.OutputString(message);
//This would bring the output window into focus
//using EnvDTE;
//DTE dte = (DTE)Package.GetGlobalService(typeof(DTE));
//dte.ExecuteCommand("View.Output", string.Empty);
}
public void ShowMessage(string message, Enums.MessageType messageType)
{
string script = string.Empty;
switch (messageType)
{
case Enums.MessageType.Defualt:
script += $"ShowDefualtMessage('','{message}')";
break;
case Enums.MessageType.Error:
script += $"ShowErrorMessage('خطا!','{message}')";
break;
case Enums.MessageType.Info:
script += $"ShowInfoMessage('','{message}')";
break;
case Enums.MessageType.Primary:
script += $"ShowPrimaryMessage('','{message}')";
break;
case Enums.MessageType.Success:
script += $"ShowSuccessMessage('عملیات با موفقیت انجام شد','{message}')";
break;
case Enums.MessageType.Warning:
script += $"ShowWarningMessage('توجه!','{message}')";
break;
}
ViewBag.Message = script;
}
public static Color GetMessageColor(Enums.MessageType messageType)
{
switch (messageType)
{
case Enums.MessageType.Debug:
return(Colors.Gray);
case Enums.MessageType.Error:
return(Colors.Red);
case Enums.MessageType.PlayerConnect:
return(Colors.GreenYellow);
case Enums.MessageType.PlayerDisconnect:
return(Colors.GreenYellow);
case Enums.MessageType.ServerOnline:
return(Colors.Green);
case Enums.MessageType.ServerExit:
return(Colors.Red);
default:
return(Colors.White);
}
}
private void IncrementBadge(Enums.MessageType mType)
{
this.Dispatcher.Invoke(() =>
{
switch (mType)
{
case Enums.MessageType.Network:
if (LeTransit.Content != networkConsole)
{
NetworkBadge.Badge = (NetworkBadge.Badge == null ? 1 : ((int)NetworkBadge.Badge + 1));
}
return;
case Enums.MessageType.Debug:
if (LeTransit.Content != debugConsole)
{
DebugBadge.Badge = (DebugBadge.Badge == null ? 1 : ((int)DebugBadge.Badge + 1));
}
return;
case Enums.MessageType.WorldGen:
if (LeTransit.Content != worldConsole)
{
WorldGenBadge.Badge = (WorldGenBadge.Badge == null ? 1 : ((int)WorldGenBadge.Badge + 1));
}
return;
}
});
}
public static SolidColorBrush GetMessageBrush(Enums.MessageType messageType)
{
switch (messageType)
{
case Enums.MessageType.Debug:
return(Brushes.Gray);
case Enums.MessageType.Error:
return(Brushes.DarkRed);
case Enums.MessageType.PlayerConnect:
return(Brushes.Green);
case Enums.MessageType.PlayerDisconnect:
return(Brushes.Orange);
case Enums.MessageType.ServerOnline:
return(Brushes.GreenYellow);
case Enums.MessageType.ServerExit:
return(Brushes.Red);
default:
return(Brushes.White);
}
}
public static void WriteToOutputWindow(string message, Enums.MessageType messageType)
{
message = $"{messageType.ToString().ToUpper()} | {DateTime.Now:G}: {message}";
message = Environment.NewLine + message;
_customPane.OutputString(message);
_customPane.Activate();
}
public static MvcHtmlString ZN_Message(this HtmlHelper htmlHelper, Enums.MessageType messageType, string message)
{
TagBuilder tagResult = new TagBuilder("div");
tagResult.MergeAttribute("class", string.Format("alert alert-{0}", messageType.ToString().ToLower()));
tagResult.MergeAttribute("role", "alert");
tagResult.InnerHtml += message;
return(tagResult.ToHtml());
}
public ChatMessage createMessage(Chat targetChat, string chatMessage, Enums.MessageType messageType)
{
ChatMessage toReturn = new ChatMessage(parentSkype);
toReturn.Body = chatMessage;
toReturn.Chat = targetChat;
toReturn.Type = messageType;
toReturn.ID = Helpers.Misc.getTime().ToString();
toReturn.Sender = parentSkype.selfProfile;
sendChatmessage(toReturn);
return(toReturn);
}
public IMessageModel CreateNew(
Enums.Direction direction = Enums.Direction.Unknown,
Enums.MessageType type = Enums.MessageType.Unknown,
string idOverride = "",
string hostIdOverride = "",
long timestampOverride = 0)
{
IMessageModel output = _messageFactory();
output.AssaignID(string.IsNullOrWhiteSpace(idOverride) ? string.Empty : idOverride);
output.AssighHostID(string.IsNullOrWhiteSpace(hostIdOverride)? string.Empty : hostIdOverride);
output.Type = type;
output.Direction = direction;
output.Timestamp = timestampOverride < 0 ? Timestamp.TimestampNow : timestampOverride;
return(output);
}
/// <summary>
/// Creates a message packet.
/// </summary>
/// <param name="messageType">The type.</param>
/// <param name="sender">The sender.</param>
/// <param name="to">The receiver.</param>
/// <param name="message">The message.</param>
/// <param name="senderMesh">The senders mesh.</param>
/// <param name="toMesh">The receivers mesh.</param>
/// <param name="color">The color.</param>
/// <param name="timestamp">The timestamp.</param>
/// <returns>The message packet.</returns>
public static MessagePacket Create(Enums.MessageType messageType, string sender, string to, string message,
uint senderMesh = 0, uint toMesh = 0,
uint color = 0xffffffff, uint timestamp = 0)
{
return(new MessagePacket
{
Color = color,
MessageType = messageType,
Timestamp = timestamp,
FromMesh = senderMesh,
ToMesh = toMesh,
From = sender,
To = to,
Message = message
});
}
private void writeMessage(string text, string mSender, Enums.MessageType mType, bool verbose)
{
//Dealing with threads
if (this.txbMessage.InvokeRequired)
{
writeLogCallback d = new writeLogCallback(writeMessage);
this.Invoke(d, new object[] { text, mSender, mType });
}
else
{
if ((this.Visible) && (!verbose)) //don't show verbose
{
txbMessage.Text += text + "\n ";
}
}
}
public ConsoleMessage(string message, SolidColorBrush brush = null, FontWeight?weight = null, double size = 12)
{
// TODO: In case of Light theme, use other colour...
if (brush == null)
{
brush = Brushes.White;
}
if (!weight.HasValue)
{
weight = FontWeights.Normal;
}
OriginalMessage = message;
Message = OriginalMessage;
Type = MessageParser.CheckType(message);
Message = MessageParser.Parse(message, Type);
}
public static string Parse(string message, Enums.MessageType type)
{
string time = DateTime.Now.ToString("HH:mm:ss");
string date = DateTime.Now.ToString("MM/dd/yyyy");
if (type == Enums.MessageType.Network)
{
string newMessage = message;
foreach (KeyValuePair <string, string> entry in networkMessages)
{
if (message.Contains(entry.Key) && entry.Value != "")
{
newMessage = entry.Value;
// SteamID
if (newMessage.Contains("{steamID}"))
{
Match match = rxSteamID.Match(message);
if (!String.IsNullOrWhiteSpace(match.Value))
{
newMessage = newMessage.Replace("{steamID}", match.Value);
}
else
{
newMessage = "<<IGNORE>>";
}
return($"{date} {time}: " + newMessage);
}
// CharID
}
}
return(newMessage);
}
return(message);
}
static private void writeLogToFile(string message, string mSender, Enums.MessageType mType)
{
TextWriter logFile = new StreamWriter(Enums.LOGFILE, true);
string date = DateTime.Now.ToString();
string prefix = date + " - " + mSender.ToString() + " - ";
string msg = "";
if (mType == Enums.MessageType.Info)
{
msg = prefix + " - " + message;
}
else
if (mType == Enums.MessageType.Error)
{
msg = prefix + " - ## ERROR ## - " + message;
}
else
if (mType == Enums.MessageType.Warning)
{
msg = prefix + " - ## Warning ## - " + message;
}
logFile.WriteLine(msg);
logFile.Close();
}
static public void sendLogEvent(string message, string errorFile, string mSender, Enums.MessageType mType, bool verbose)
{
if (OnUpdateLog != null)
{
//set error file as link for dialog and regular for log file
string errorFileLink = "";
if (errorFile != "")
{
errorFileLink = "file:///" + errorFile.Replace(" ", "%20");
}
OnUpdateLog(message + errorFileLink, mSender, mType, verbose);
// Always write verbose message to log file
writeLogToFile(message + errorFile, mSender, mType);
}
}
protected MessageBase(Enums.MessageType messageType)
: this()
{
MessageType = messageType;
}
static public void sendLogEvent(string message, string mSender, Enums.MessageType mType, bool verbose)
{
sendLogEvent(message, "", mSender, mType, verbose);
}
static public void sendLogEvent(string message, string errorFile, string mSender, Enums.MessageType mType)
{
sendLogEvent(message, errorFile, mSender, mType, false);
}
/// <summary>
/// Shows the message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="messageType">The type.</param>
public void ShowMessage(string message, Enums.MessageType messageType = Enums.MessageType.Success)
{
this.TempData["Message"] = message;
this.TempData["MessageType"] = messageType.ToString().ToLower();
}
public static async Task <ChatMessage> SendMessage(this Chat targetChat, string newMessage, Enums.MessageType messageType = Enums.MessageType.Text)
{
return(await targetChat.parentSkype.SendMessage(targetChat, newMessage, messageType));
}
/// <summary> Message loop to check type of message and handle it accordingly </summary>
public void MessageLoop()
{
while ((_msg = _peer.ReadMessage()) != null)
{
s_bpsBytes += _msg.LengthBytes;
switch (_msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//Debug.WriteLine("ReceivePeersData DiscoveryRequest");
_peer.SendDiscoveryResponse(null, _msg.SenderEndPoint);
break;
case NetIncomingMessageType.DiscoveryResponse:
// just connect to first server discovered
//Debug.WriteLine("ReceivePeersData DiscoveryResponse CONNECT");
if (_peer.Connections.Any(x => x.RemoteEndPoint.Address.Equals(_msg.SenderEndPoint.Address)))
{
Debug.WriteLine("allreadyConnected");
}
else
{
_peer.Connect(_msg.SenderEndPoint);
}
break;
case NetIncomingMessageType.ConnectionApproval:
//Debug.WriteLine("ReceivePeersData ConnectionApproval");
_msg.SenderConnection.Approve();
//broadcast this to all connected clients
SendPeerInfo(_msg.SenderEndPoint.Address, _msg.SenderEndPoint.Port);
break;
case NetIncomingMessageType.Data:
//another client sent us data
//Read TypeData First
Enums.MessageType mType = (Enums.MessageType)_msg.ReadByte();
if (mType == Enums.MessageType.String)
{
var metadata = _msg.ReadString();
if (metadata == "StartEvent")
{
var map = _msg.ReadString();
_isMaster = false;
MasterNetConnection = _peer.Connections.FirstOrDefault(x => x.RemoteEndPoint.Address.ToString() == _msg.SenderEndPoint.Address.ToString());
Game1.Inst.Scene.Raise("startgame", map);
}
else if (metadata == "metadata")
{
Game1.Inst.Scene.Raise("network_data_text", _msg.ReadString());
}
}
else if (mType == Enums.MessageType.PeerInformation)
{
int byteLenth = _msg.ReadInt32();
byte[] addressBytes = _msg.ReadBytes(byteLenth);
IPAddress ip = new IPAddress(addressBytes);
int port = _msg.ReadInt32();
//connect
IPEndPoint endPoint = new IPEndPoint(ip, port);
Debug.WriteLine("Data::PeerInfo::Detecting if we're connected");
if (_peer.GetConnection(endPoint) == null)
{ //are we already connected?
//Don't try to connect to ourself!
if (_peer.Configuration.LocalAddress.GetHashCode() != endPoint.Address.GetHashCode() ||
_peer.Configuration.Port.GetHashCode() != endPoint.Port.GetHashCode())
{
Debug.WriteLine(string.Format("Data::PeerInfo::Initiate new connection to: {0}:{1}", endPoint.Address.ToString(), endPoint.Port.ToString()));
_peer.Connect(endPoint);
}
}
}
else if (mType == Enums.MessageType.Entity || mType == Enums.MessageType.EntityLight)
{
var cbody = new CBody();
var ctransform = new CTransform();
string modelname = "";
bool isPlayer = false;
int id = 0;
id = mType == Enums.MessageType.EntityLight ? _msg.ReadEntityLight(ref cbody, ref ctransform, ref modelname, ref isPlayer) : _msg.ReadEntity(ref cbody, ref ctransform, ref modelname, ref isPlayer);
Game1.Inst.Scene.Raise("entityupdate", new EntitySync {
ID = id, CBody = cbody, CTransform = ctransform, ModelFileName = modelname, IsPlayer = isPlayer
});
}
else if (mType == Enums.MessageType.CTransform)
{
var metadata = _msg.ReadString();
var data = _msg.ReadCTransform();
//Game1.Inst.Scene.Raise("network_data", data);
}
else if (mType == Enums.MessageType.Vector3)
{
var metadata = _msg.ReadString();
var data = _msg.ReadCTransform();
//Game1.Inst.Scene.Raise("network_data", data);
}
else if (mType == Enums.MessageType.CText)
{
var id = _msg.ReadInt32();
var data = _msg.ReadCText();
Game1.Inst.Scene.Raise("network_menu_data_received", new MenuItem {
CText = data, Id = id
});
}
else if (mType == Enums.MessageType.Int32)
{
var metadata = _msg.ReadString();
var data = _msg.ReadInt32();
if (metadata == "network_game_end")
{
Game1.Inst.Scene.Raise("game_end", data);
}
}
else if (mType == Enums.MessageType.PlayerInfo)
{
var date = _msg.ReadInt64();
if (!players.Any(x => x.IP == _msg.SenderEndPoint.Address.ToString() + " " + _msg.SenderEndPoint.Port.ToString()))
{
players.Add(new NetworkPlayer {
IP = _msg.SenderEndPoint.Address.ToString() + " " + _msg.SenderEndPoint.Port.ToString(), Time = new DateTime(date), You = false
});
Game1.Inst.Scene.Raise("update_peers", players.OrderBy(x => x.Time).ToList());
}
}
//Console.WriteLine("END ReceivePeersData Data");
break;
case NetIncomingMessageType.UnconnectedData:
Debug.WriteLine("UnconnectedData: " + _msg.ReadString());
break;
case NetIncomingMessageType.VerboseDebugMessage:
Debug.WriteLine(NetIncomingMessageType.VerboseDebugMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.DebugMessage:
Debug.WriteLine(NetIncomingMessageType.DebugMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Debug.WriteLine(NetIncomingMessageType.WarningMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Debug.WriteLine(NetIncomingMessageType.ErrorMessage + " " + _msg.ReadString());
break;
default:
Debug.WriteLine("ReceivePeersData Unknown type: " + _msg.MessageType.ToString());
try
{
Debug.WriteLine(_msg.SenderConnection);
if (_msg.SenderConnection.Status == NetConnectionStatus.Disconnected)
{
//Maybe try to reconnect
}
Debug.WriteLine(_msg.ReadString());
}
catch
{
Debug.WriteLine("Couldn't parse unknown to string.");
}
break;
}
}
}
/// <summary>
/// Send object thats cbody ctransform vector3 int32 string ctext to peers
/// Todo add SendEntity to this method.
/// </summary>
public void SendObject(object datatosend, object metadata)
{
if (!havePeers())
{
Debug.WriteLine("No connections to send to.");
return;
}
Enums.MessageType type = Enums.MessageType.Unknown;
Enum.TryParse(datatosend.GetType().Name, out type);
if (type == Enums.MessageType.Unknown)
{
return;
}
NetOutgoingMessage msg = _peer.CreateMessage();
switch (type)
{
case Enums.MessageType.CBody:
var dataCbody = (CBody)datatosend;
msg.Write((byte)type);
msg.Write((string)metadata);
msg.WriteCBody(dataCbody);
break;
case Enums.MessageType.CTransform:
var dataTransform = (CTransform)datatosend;
msg.Write((byte)type);
msg.Write((string)metadata);
msg.WriteCTransform(dataTransform);
break;
case Enums.MessageType.Vector3:
var datavector = (Vector3)datatosend;
msg.Write((byte)type);
msg.Write((string)metadata);
msg.WriteUnitVector3(datavector, 1);
break;
case Enums.MessageType.Int32:
int dataint = (int)datatosend;
msg.Write((byte)type);
msg.Write((string)metadata);
msg.Write(dataint);
break;
case Enums.MessageType.String:
var datastring = (string)datatosend;
msg.Write((byte)type);
msg.Write((string)metadata);
msg.Write(datastring);
break;
case Enums.MessageType.CText:
var ctext = (CText)datatosend;
msg.Write((byte)type);
msg.Write((int)metadata);
msg.WriteCText(ctext);
break;
default:
Debug.WriteLine("unknownType");
break;
}
if (MasterNetConnection == null)
{
_peer.SendMessage(msg, _peer.Connections, NetDeliveryMethod.Unreliable, 0);
}
else
{
_peer.SendMessage(msg, MasterNetConnection, NetDeliveryMethod.Unreliable, 0);
}
}
// This is a positional argument
public MetaAttribute(Enums.MessageType messageType, Enums.ActionCode actionCode)
{
MessageType = messageType;
ActionCode = actionCode;
}
public RequestMessage(Enums.MessageType messageType, Enums.ActionCode actionCode)
: base(messageType, actionCode)
{
}
public RequestMessage(Enums.MessageType messageType, Enums.ActionCode actionCode, ushort sequence)
: base(messageType, actionCode, sequence)
{
}
protected MessageBase(Enums.MessageType messageType, Enums.ActionCode actionCode, ushort sequence)
: this(messageType, actionCode)
{
Sequence = sequence;
}
/// <summary>
/// Log event message handeling
/// </summary>
void DrutNETBase_OnUpdateLog(string str, string mSender, Enums.MessageType mType, bool verbose)
{
// Write log messages on error window.
richTextBox_messages.Text = mType.ToString() + " - " + mSender + ": " + str + richTextBox_messages.Text;
}
private static extern IntPtr SHAppBarMessage(Enums.MessageType dwMessage, [In] ref Structs.Data pData);
protected MessageBase(Enums.MessageType messageType, Enums.ActionCode actionCode)
: this(messageType)
{
ActionCode = actionCode;
}
