public void Clear()
{
entitiesUpdated.Clear();
updateStorage.Clear();
authorityChanges.Clear();
componentsAdded.Clear();
componentsRemoved.Clear();
}
private void flush()
{
try
{
if (m_Count > 0)
{
Message msg = null;
if (m_List.Count == 1)
{
msg = m_List[0];
}
else
{
msg = new Message();
msg.Type = m_MessageType;
msg.Topic = m_MessageTopic;
msg.Source = m_MessageSource;
var txt = new StringBuilder();
foreach (var m in m_List)
{
txt.Append("-->");
txt.AppendLine(m.ToString());
if (m_MaxTextLength > 0)
{
if (txt.Length > m_MaxTextLength)
{
break;
}
}
}
var txtl = txt.ToString();
if (m_MaxTextLength > 0)
{
if (txtl.Length > m_MaxTextLength)
{
txtl = txtl.Substring(0, m_MaxTextLength) + "...";
}
}
msg.Text = string.Format("{0} entries received, {1} combined:\r\n{2}", m_Count, m_List.Count, txtl);
}
m_List.Clear();
m_Count = 0;
base.DoSend(msg);
}
}
finally
{
m_LastFlush = Service.Now;
}
}
private void resetParameterUpdate(object updateParameter)
{
Parameter parameter = (Parameter)updateParameter;
if (parameter.GetValueAsInt() == 1)
{
MessageList.Clear();
WarnLight = "Transparent";
}
}
public void AddInfoMessage(string message, bool clearOldMessage = false)
{
if (clearOldMessage)
{
MessageList.Clear();
}
MessageList.Add(new ReturnMessage {
Message = message, Type = MessageType.Info
});
LogMessage();
}
public void Clear()
{
entitiesUpdated.Clear();
updateStorage.Clear();
authorityChanges.Clear();
componentsAdded.Clear();
componentsRemoved.Clear();
healthModifiedEventStorage.Clear();
respawnEventStorage.Clear();
}
public void AddWaningMessage(string message, bool clearOldMessage = false, bool isFailure = false)
{
if (clearOldMessage)
{
MessageList.Clear();
}
Success = !isFailure;
MessageList.Add(new ReturnMessage {
Message = message, Type = MessageType.Warning
});
LogMessage();
}
/// <summary>
/// 更新消息列表
/// </summary>
private void UpdateMessageList()
{
if (SelectedFriend != null)
{
string name = SelectedFriend.UserName;
MessageList.Clear();
if (MessageRecord.ContainsKey(name))
{
foreach (MessageModel messageModel in MessageRecord[name])
{
MessageList.Add(messageModel);
}
}
}
}
public async Task <Error> DownloadMessages()
{
var jsonrpc = new JsonRpcClient();
if (await jsonrpc.SendRequest("message::all"))
{
MessageList.Clear();
var response = jsonrpc.GetRequestResponseDeserialized <Response <ObservableCollection <Message> > >();
if (response != null)
{
MessageList = response.result;
}
}
return(jsonrpc.Error);
}
public void Connect()
{
Debug.Log("Connect()");
config.SaveConfig();
message_list.Clear();
if (config.UseAuth)
{
mqtt.Connect(config.Host, config.Port, config.Username, config.Password);
}
else
{
mqtt.Connect(config.Host, config.Port);
}
config.Intaractable = false;
connect_button.interactable = false;
}
public async Task Init()
{
IsBusy = true;
IEnumerable <Model.Message> list;
if (APIService.Role == "Administrator")
{
list = await _serviceMessages.Get <IEnumerable <Model.Message> >(null);
}
else
{
var request = new MessageSearchRequest()
{
UserId = APIService.UserId
};
list = await _serviceMessages.Get <IEnumerable <Model.Message> >(request);
}
MessageList.Clear();
UnreadList.Clear();
foreach (var message in list)
{
if (APIService.Role == "Administrator")
{
if (message.Response == null)
{
UnreadCount++;
UnreadList.Add(message);
}
}
else
{
if (!message.IsOpened)
{
UnreadCount++;
UnreadList.Add(message);
}
}
MessageList.Add(message);
}
;
IsBusy = false;
}
/// <summary>
/// Creates factory entities (mostly segment, arcs, cotations...) in <see cref="PicFactory"/> class instance passed as first argument
/// </summary>
/// <param name="factory">Instance of class <see cref="PicFactory"/> to be populated with entities</param>
/// <param name="stack">Array of <see cref="Paramerter"/> to apply while generating entities</param>
public void CreateFactoryEntities(PicFactory factory, ParameterStack stackIn)
{
ParameterStack stack = ConvertIn(stackIn);
var tempList = new List <string>(MessageList);
MessageList.Clear();
var handler = new ComponentLoader.FeedbackEmitted(OnFeedbackAdded);
ComponentLoader.OnFeedbackEmitted += handler;
Plugin.CreateFactoryEntities(factory, stack, Transform2D.Identity);
// --- US units ---
stackIn = ConvertOut(stack);
ConvertOutRef(factory);
// ---
ComponentLoader.OnFeedbackEmitted -= handler;
if (!MessageList.SequenceEqual(tempList))
{
FeedBack?.Invoke(this, MessageList);
}
}
public override void Clear()
{
base.Clear();
fooEventEventStorage.Clear();
}
public void Rest()
{
Success = true;
MessageList.Clear();
}
public void Clear()
{
lock (m_List)
m_List.Clear();
}
private void flush()
{
try
{
if (m_Count == 0)
{
return;
}
Message msg = null;
if (m_List.Count == 1)
{
msg = m_List[0];
}
else
{
msg = new Message();
msg.Type = m_MessageType;
msg.Topic = m_MessageTopic;
msg.From = m_MessageFrom;
msg.Source = m_MessageSource;
if (msg.Topic.IsNullOrWhiteSpace())
{
msg.Topic = CoreConsts.LOG_TOPIC;
}
if (msg.From.IsNullOrWhiteSpace())
{
msg.From = "FloodFilter";
}
var txt = new StringBuilder();
foreach (var m in m_List)
{
txt.Append("--> ");
txt.AppendLine(m.ToString());
txt.AppendLine();
txt.AppendLine();
if (m_MaxTextLength > 0 && txt.Length > m_MaxTextLength)
{
break;
}
}
var txtl = txt.ToString();
if (m_MaxTextLength > 0)
{
if (txtl.Length > m_MaxTextLength)
{
txtl = txtl.Substring(0, m_MaxTextLength) + " ...... " + "truncated at {0} chars".Args(m_MaxTextLength);
}
}
msg.Text = "{0} log msgs, {1} combined:\r\n\n{2}".Args(m_Count, m_List.Count, txtl);
}
m_List.Clear();
m_Count = 0;
base.DoSend(msg);
}
finally
{
m_LastFlush = Service.Now;
}
}
/// <summary>
/// 清除全部消息
/// </summary>
public void Clear()
{
MessageList.Clear();
}
private void flush()
{
if (!Running && !ComponentDirector.LogDaemon.Reliable)
{
return;
}
try
{
if (m_Count == 0)
{
return;
}
Message msg = null;
if (m_List.Count == 1)
{
msg = m_List[0];
}
else
{
msg = new Message();
msg.InitDefaultFields(App);
msg.Type = m_MessageType;
msg.Topic = m_MessageTopic;
msg.From = m_MessageFrom;
msg.Source = m_MessageSource;
if (msg.Topic.IsNullOrWhiteSpace())
{
msg.Topic = CoreConsts.LOG_TOPIC;
}
if (msg.From.IsNullOrWhiteSpace())
{
msg.From = "FloodFilter";
}
var txt = new StringBuilder();
foreach (var m in m_List)
{
if (!Running && !ComponentDirector.LogDaemon.Reliable)
{
return;
}
txt.Append("@");
txt.AppendLine(m.ToString());
txt.AppendLine(m.Parameters.TakeFirstChars(128, ".."));
txt.AppendLine();
if (m_MaxTextLength > 0 && txt.Length > m_MaxTextLength)
{
break;
}
}
var txtl = txt.ToString();
if (m_MaxTextLength > 0)
{
if (txtl.Length > m_MaxTextLength)
{
txtl = txtl.Substring(0, m_MaxTextLength) + " ...... " + "truncated at {0} chars".Args(m_MaxTextLength);
}
}
msg.Text = "{0} log msgs, {1} combined:\r\n\n{2}".Args(m_Count, m_List.Count, txtl);
}
m_List.Clear();
m_Count = 0;
base.DoSend(msg);
}
finally
{
m_LastFlush = DateTime.UtcNow;
}
}
public void Clear()
{
requestStorage.Clear();
responseStorage.Clear();
}
private void ClearMessageProc()
{
MessageList.Clear();
}
public Listeners(Socket socket, Client client)
{
socket.On("message", (Action <object>)((data) =>
{
Console.WriteLine("MESSAGE INCOMING");
Message message = new Message(data.ToString());
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Add(message);
});
Console.WriteLine((string)("+++++++++++ MESSAGE:" + message.Text + " " + message.Type + " +++++++++++"));
}));
socket.On("roomSwitched", (data) =>
{
RoomParameter roomParameter = new RoomParameter(data.ToString());
Client.RoomId = roomParameter.RoomId;
Console.WriteLine("+++++++++++ ROOM SWITCHED:" + roomParameter.RoomName + " +++++++++++");
OnChatroomSwitched(roomParameter.RoomName);
});
socket.On("isWaiting", () =>
{
OnIsWaiting();
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Clear();
MessageList.Add(new Message("Waiting for an Opponent...", MessageDisplayType.MessageInfo));
});
});
socket.On("gameover", () =>
{
Console.WriteLine("GAMEOVER");
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
Client.IsOnTurn = false;
Client.EmitEndSession();
MessageList.Clear();
OnMatchAbort();
});
});
socket.On("turnBroadcast", (data) =>
{
OnTurnBroadcast(new TurnBroadcast(data.ToString()));
});
socket.On("gameBegins", () =>
{
});
socket.On("cSharpSaveReset", () =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
OnMatchStart(true);
});
});
socket.On("matchParameter", (data) =>
{
MatchParameter mP = new MatchParameter(data.ToString());
Client.OpponentsName = mP.OpponentsName;
Client.OpponentsId = mP.OpponentsId;
Client.IsOnTurn = mP.FirstTurn;
var delayedTurnEmit = System.Threading.Tasks.Task.Run(() => OnSetOnTurn(mP.FirstTurn));
delayedTurnEmit.Wait(TimeSpan.FromMilliseconds(300));
OnSetOnTurn(mP.FirstTurn);
});
socket.On("winnerBroadcast", (data) =>
{
WinnerBroadcast wB = new WinnerBroadcast(data.ToString());
OnMatchResult(wB.animation);
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
if (wB.isWinner)
{
MessageList.Add(new Message("You Won!", MessageDisplayType.ResultWin));
}
else
{
MessageList.Add(new Message("You Lost!", MessageDisplayType.ResultLose));
}
});
});
socket.On("drawBroadcast", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Add(new Message("You both are too dumb to win", MessageDisplayType.ResultDraw));
});
});
socket.On("scoreBroadcast", (data) =>
{
ScoreBroadcast sb = new ScoreBroadcast(data.ToString());
OnScoreBroadcast("You " + sb.clientScore + " : " + sb.opponentsScore + " " + Client.OpponentsName);
});
socket.On("revancheRequest", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
//TODO
MessageList.Add(new Message(Client.OpponentsName + " wants a revanche... Take it or leave it.", MessageDisplayType.RevancheInvitation));
});
});
socket.On("playAgainRequest", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
//TODO
MessageList.Add(new Message(Client.OpponentsName + " wants to play again...", MessageDisplayType.PlayAgainInvitation));
});
});
socket.On("revancheAccepted", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Clear();
OnMatchStart(true);
MessageList.Add(new Message(Client.OpponentsName + " wants to kick your ass again!", MessageDisplayType.MessageInfo));
});
});
socket.On("playAgainAccepted", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Clear();
OnMatchStart(true);
MessageList.Add(new Message(Client.OpponentsName + " wants to play again!", MessageDisplayType.MessagePrimary));
});
});
socket.On("firstTurn", () =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
MessageList.Clear();
});
});
socket.On("setOnTurn", (data) =>
{
var delayedTurnEmit = System.Threading.Tasks.Task.Run(() => OnSetOnTurn((bool)data));
delayedTurnEmit.Wait(TimeSpan.FromMilliseconds(400));
OnSetOnTurn((bool)data);
Client.IsOnTurn = (bool)data;
});
socket.On("opponentFound", (data) =>
{
System.Windows.Application.Current.Dispatcher.Invoke(delegate
{
OnMatchStart(false);
MessageList.Clear();
MessageList.Add(new Message("Opponent found, you're playing against " + data, MessageDisplayType.MessageInfo));
System.Windows.Application.Current.MainWindow.DataContext = new GameViewModel();
});
});
socket.On("idCommit", (data) =>
{
Client.SocketId = data.ToString();
Console.WriteLine("+++++++++++ ID COMMIT:" + data + " +++++++++++");
});
socket.On("updateOnlineUsers", (data) =>
{
OnUpdateOnlineUsers((int)(long)data);
});
}
private void ClearMessages()
{
MessageList.Clear();
}
