public void TestClose()
{
var testResults = new TestResults(3, false);
var mailbox = new TestMailbox(testResults, World.DefaultLogger);
var actor = new CountTakerActor(testResults, World.DefaultLogger);
for (var count = 0; count < 3; ++count)
{
var countParam = count;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
dispatcher.Execute(mailbox);
}
dispatcher.Close();
Action <ICountTaker> consumer2 = consumerActor => consumerActor.Take(10);
var message2 = new LocalMessage <ICountTaker>(actor, consumer2, "Take(int)");
mailbox.Send(message2);
dispatcher.Execute(mailbox);
var counts = testResults.GetCounts();
Assert.Equal(3, counts.Count);
for (var idx = 0; idx < counts.Count; ++idx)
{
Assert.Contains(idx, counts);
}
}
private async Task SendReminderAsync(Reminder reminder)
{
var channel = Bot.GetChannel(reminder.GuildId, reminder.ChannelId);
var localMessage = new LocalMessage()
.WithContent(Mention.User(reminder.UserId))
.AddEmbed(reminder.CreateEmbed());
// Channel where reminder was created no longer exists and hence the reminder no longer exists
if (channel is not null)
{
await Bot.SendMessageAsync(reminder.ChannelId, localMessage);
}
else
{
try
{
localMessage.Embeds.First().WithFooter("Your are receiving a DM because the channel this reminder was scheduled in no longer exists");
var dmChannel = await Bot.CreateDirectChannelAsync(reminder.UserId);
await dmChannel.SendMessageAsync(localMessage);
}
catch (RestApiException e) when(e.ErrorModel.Code.GetValueOrDefault() == RestApiErrorCode.CannotSendMessagesToThisUser)
{
Logger.LogInformation("Could not notify user {0} about a reminder. Deleting reminder without notifying user.", reminder.UserId);
}
}
await RemoveReminderAsync(reminder);
}
private Dictionary <GameObject, ulong> ObjectContainer = new Dictionary <GameObject, ulong>(); //玩家物体——玩家编号
void OnEnable()
{
LocalMessage.SetHandler(MessageHandler);
InputField[] tempIF = { PlayerGoldInputField, TowerAttackInputField, TowerSpeedInputField, TowerBuildCostInputField, MonsterDefenseInputField, MonsterHipPointInputField, MonsterSpeedInputField };
Dropdown[] tempD = { PlayerGoldDropdown, TowerAttackDropdown, TowerSpeedDropdown, TowerBuildCostDropdown, MonsterDefenseDropdown, MonsterHipPointDropdown, MonsterSpeedDropdown, Difficult, CheckPoint };
if (LocalMessage.LocalIdentity != 0)
{
foreach (InputField field in tempIF)
{
field.enabled = false;
}
foreach (Dropdown d in tempD)
{
d.enabled = false;
}
}
else
{
foreach (InputField field in tempIF)
{
field.enabled = true;
}
foreach (Dropdown d in tempD)
{
d.enabled = true;
}
}
byte[] msg = new byte[8];
SmallTools.CopyArray(msg, SmallTools.ToByteArray(LocalMessage.LocalPlayerNumber));
LocalMessage.scom.SendMessage(MsgType.PlayerMsgInRoom, msg);
}
public void TestExecute()
{
var testResults = new TestResults();
testResults.Log.Set(true);
var mailbox = new TestMailbox(testResults);
var actor = new CountTakerActor(testResults);
testResults.Until = Until(Total);
for (var count = 0; count < Total; ++count)
{
var countParam = count;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
dispatcher.Execute(mailbox);
}
testResults.Until.Completes();
for (var idx = 0; idx < testResults.Counts.Count; ++idx)
{
Assert.Contains(idx, testResults.Counts);
}
}
public PagedView(PageProvider pageProvider, LocalMessage templateMessage = null)
: base(pageProvider, templateMessage)
{
FirstPageButton = new ButtonViewComponent(OnFirstPageButtonAsync)
{
Emoji = new LocalEmoji("⏮️"),
Style = LocalButtonComponentStyle.Secondary
};
PreviousPageButton = new ButtonViewComponent(OnPreviousPageButtonAsync)
{
Emoji = new LocalEmoji("◀️"),
Style = LocalButtonComponentStyle.Secondary
};
NextPageButton = new ButtonViewComponent(OnNextPageButtonAsync)
{
Emoji = new LocalEmoji("▶️"),
Style = LocalButtonComponentStyle.Secondary
};
LastPageButton = new ButtonViewComponent(OnLastPageButtonAsync)
{
Emoji = new LocalEmoji("⏭️"),
Style = LocalButtonComponentStyle.Secondary
};
StopButton = new ButtonViewComponent(OnStopButtonAsync)
{
Emoji = new LocalEmoji("⏹️"),
Style = LocalButtonComponentStyle.Secondary
};
AddComponent(FirstPageButton);
AddComponent(PreviousPageButton);
AddComponent(NextPageButton);
AddComponent(LastPageButton);
AddComponent(StopButton);
}
public void TestClose()
{
var dispatcher = new ManyToOneConcurrentArrayQueueDispatcher(MailboxSize, 2, 4, 10);
dispatcher.Start();
var mailbox = dispatcher.Mailbox;
var actor = new CountTakerActor();
actor.Until = Until(MailboxSize);
for (var i = 1; i <= MailboxSize; ++i)
{
var countParam = i;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
}
actor.Until.Completes();
dispatcher.Close();
const int neverReceived = MailboxSize * 2;
for (var count = MailboxSize + 1; count <= neverReceived; ++count)
{
var countParam = count;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
}
Assert.Equal(MailboxSize, actor.Highest.Get());
}
void OnDisable()
{
xml.Close();
TowerFileXml.Close();
UIFunction.ClearChild(MapPanel);
LocalMessage.SetHandler(null);
}
public void TestNotifyOnSendDispatch()
{
var mailboxSize = 64;
var testResults = new TestResults(mailboxSize);
var dispatcher = new ManyToOneConcurrentArrayQueueDispatcher(mailboxSize, 1000, true, 4, 10);
dispatcher.Start();
var mailbox = dispatcher.Mailbox;
var actor = new CountTakerActor(testResults);
for (var count = 1; count <= mailboxSize; ++count)
{
var countParam = count;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var localMessage = new LocalMessage <ICountTaker>(actor, consumer, "take(int)");
// notify if in back off
mailbox.Send(localMessage);
// every third message give time for dispatcher to back off
if (count % 3 == 0)
{
Thread.Sleep(50);
}
}
Assert.Equal(mailboxSize, testResults.GetHighest());
}
private void InitPreallocated()
{
for (int idx = 0; idx < _mailboxSize; ++idx)
{
_messages[idx] = new LocalMessage <object>();
}
}
public void TestClose()
{
var testResults = new TestResults();
const int mailboxSize = 64;
var dispatcher = new RingBufferDispatcher(mailboxSize, 2, 4);
dispatcher.Start();
var mailbox = dispatcher.Mailbox;
var actor = new CountTakerActor(testResults);
testResults.Until = Until(mailboxSize);
for (var count = 1; count <= mailboxSize; ++count)
{
var countParam = count;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
}
testResults.Until.Completes();
dispatcher.Close();
const int neverReceived = mailboxSize * 2;
for (var count = mailboxSize + 1; count <= neverReceived; ++count)
{
var countParam = count;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
}
Assert.Equal(mailboxSize, testResults.Highest.Get());
}
void OnDisable()
{
UIFunction.ClearChild(PlayerListPanel);
PlayerContainer.Clear();
ObjectContainer.Clear();
LocalMessage.SetHandler(null);
}
public static async Task <IUserMessage> SendMessageAsync(this IUser user,
LocalMessage message,
IRestRequestOptions options = null, CancellationToken cancellationToken = default)
{
var channel = await user.CreateDirectChannelAsync(options, cancellationToken).ConfigureAwait(false);
return(await channel.SendMessageAsync(message, options, cancellationToken).ConfigureAwait(false));
}
public static Task <IUserMessage> SendMessageAsync(this IMessageChannel channel,
LocalMessage message,
IRestRequestOptions options = null, CancellationToken cancellationToken = default)
{
var client = channel.GetRestClient();
return(client.SendMessageAsync(channel.Id, message, options, cancellationToken));
}
public void RequestToShowMessage(LocalMessage message)
{
if (userHandler.Receiver?.Name == message.Sender || userHandler.Receiver?.Name == message.Receiver)
{
NewMessages.Add(message);
MessagingCenter.Send(this, MessageKeys.MESSAGE_AVAILABLE, true);
MessagingCenter.Send(this, MessageKeys.UPDATE_USERS, true);
}
}
public static int GetNextLocalId()
{
LocalMessage lastMessage = savedMess.LastOrDefault();
if (lastMessage is null)
{
return(1);
}
return(lastMessage.LocalId + 1);
}
public void TestDeliverHappy()
{
var testResults = new SimpleTestResults(1);
var testActor = TestWorld.ActorFor <ISimple>(Definition.Has <SimpleActor>(Definition.Parameters(testResults), "test1-actor"));
Action <ISimple> consumer = x => x.Simple();
var message = new LocalMessage <ISimple>(testActor.ActorInside, consumer, "Simple()");
message.Deliver();
Assert.Equal(1, testResults.GetDeliveries());
}
public static void AddMessage(LocalMessage message)
{
if (message.LocalId == 0)
{
message.LocalId = GetNextLocalId();
}
if (message.Id == 0 || GetMessageById(message.Id) is null)
{
Connection.Insert(message);
}
}
/// <summary>
/// Handles simple Http-apis for "reaction" commands
///
/// The incoming argument 0 from context is a collection of IMember, but for later purposes
/// that type is not required, as we simply use IUser's Mention property, as such converting
/// down to the lower interface acceptable to allow for implicit targetting
/// </summary>
/// <param name="context"></param>
public static async Task DoReaction(DiscordCommandContext context)
{
var client = context.Services.GetRequiredService <HttpClient>();
List <IUser> users = ((IUser?[])context.Arguments[0]).Where(x => x != null).ToList() !;
var embed = (new LocalEmbed())
.WithColor(Program.Color);
var builder = new LocalMessage();
var apiCommand = Program.ApiCommands[context.Command.Name];
// if no members are specified allow for implicit targeting via the reply system
if (users.Count == 0 &&
context.Message.ReferencedMessage.HasValue &&
context.Message.ReferencedMessage.Value != null &&
context.Message.ReferencedMessage.Value.Author != null)
{
users.Add(context.Message.ReferencedMessage.Value.Author);
}
// prepare reaction text if needed
string?text = null;
if (apiCommand.Actions.Ranges.Count > 0)
{
text = apiCommand.Actions.GetValue(users.Count)?.Random();
}
// insert the author as the first "mention"
users = users.Prepend(context.Author).ToList();
// insert mentions
if (text != null)
{
// ReSharper disable once CoVariantArrayConversion
text = string.Format(text, users.Select(x => x.Mention).ToArray());
embed.WithDescription(text);
}
var response = await client.GetAsync(apiCommand.Url);
if (response.StatusCode != HttpStatusCode.OK)
{
await new DiscordResponseCommandResult(context, builder.WithEmbed(embed.WithDescription("An error occurred while fetching reaction!")));
return;
}
// decode the json response, nothing else is supported for the time being
// we also only care for one level of the response as of now.
var decoded = JsonConvert.DeserializeObject <Dictionary <string, string> >(await response.Content.ReadAsStringAsync());
embed.WithImageUrl(apiCommand.GetFixedImageUrl(decoded[apiCommand.Path]));
await new DiscordResponseCommandResult(context, (new LocalMessage()).WithEmbed(embed));
}
public void TestDeliverHappy()
{
var testResults = new SimpleTestResults();
TestWorld.ActorFor <ISimple>(Definition.Has <SimpleActor>(Definition.Parameters(testResults), "test1-actor"));
Action <ISimple> consumer = x => x.Simple();
var message = new LocalMessage <ISimple>(SimpleActor.Instance.Value, consumer, "Simple()");
message.Deliver();
testResults.UntilSimple.Completes();
Assert.Equal(1, testResults.Deliveries.Get());
}
private void LoadChat()
{
WebClient wc = new WebClient();
wc.DownloadStringCompleted += (a, b) => {
if (b.Error == null)
{
try {
this.Status = true;
List <LocalMessage> add = new List <LocalMessage>();
foreach (KeyValuePair <string, Newtonsoft.Json.Linq.JToken> item in Newtonsoft.Json.JsonConvert.DeserializeObject(b.Result) as Newtonsoft.Json.Linq.JObject)
{
int _toAdd = int.Parse(item.Key);
LocalMessage lm = getById(_toAdd);
if (lm == null)
{
lm = new LocalMessage(_toAdd, (string)item.Value);
if (lm._id > 0)
{
lm.Source = this;
lm.Id = this._label;
lm.ToMe = this.ContainKeywords(lm.Text);
add.Add(lm);
}
_cache.Add(lm);
}
else
{
}
}
if (add.Count > 0)
{
newMessagesArrived(add);
}
} catch (Exception er) {
App.Log('?', "Gipsyteam error: {0}", er);
}
}
else
{
//if( b.Error )
this.Status = false;
}
_timer.Start();
};
wc.DownloadStringAsync(new Uri(string.Format(_url, _chatId, DateTime.Now.ToBinary()), UriKind.Absolute));
}
public static void Remove(TEnum type, Action Listener)
{
LocalMessage target = null;
foreach (LocalMessage mb in dic_delegates[type])
{
if (mb.e_type == LocalMessage.enum_MessageType.Void && mb.ac_listener == Listener)
{
target = mb;
break;
}
}
if (target != null)
{
dic_delegates[type].Remove(target);
}
}
public void TestDeliverStopped()
{
var testResults = new SimpleTestResults();
TestWorld.ActorFor <ISimple>(Definition.Has <SimpleActor>(Definition.Parameters(testResults), "test1-actor"));
testResults.UntilSimple = TestUntil.Happenings(1);
SimpleActor.Instance.Value.Stop();
Action <ISimple> consumer = actor => actor.Simple();
var message = new LocalMessage <ISimple>(SimpleActor.Instance.Value, consumer, "Simple()");
message.Deliver();
Assert.Equal(1, testResults.UntilSimple.Remaining);
Assert.Equal(0, testResults.Deliveries.Get());
}
private void NewMessage(string msg)
{
LocalMessage lm = JsonConvert.DeserializeObject <LocalMessage>(msg);
TwoRatChat.Model.ChatMessage chatMessage = new TwoRatChat.Model.ChatMessage()
{
Date = DateTime.Now,
Name = lm.From,
Text = ReplaceSmiles(lm.Text.Replace(""", "\"")),
Source = this,
//Form = 0,
Id = _id,
ToMe = this.ContainKeywords(lm.Text)
};
newMessagesArrived(new TwoRatChat.Model.ChatMessage[] { chatMessage });
}
public PromptView(LocalMessage message)
: base(message)
{
ConfirmButton = new ButtonViewComponent(OnConfirmButtonAsync)
{
Label = "Confirm",
Style = LocalButtonComponentStyle.Success
};
DenyButton = new ButtonViewComponent(OnDenyButtonAsync)
{
Label = "Deny",
Style = LocalButtonComponentStyle.Danger
};
AddComponent(ConfirmButton);
AddComponent(DenyButton);
}
public void TestMailboxSendReceive()
{
var testResults = new TestResults(Total);
var actor = new CountTakerActor(testResults);
for (var i = 0; i < Total; ++i)
{
var countParam = i;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
}
for (var i = 0; i < Total; ++i)
{
Assert.Equal(i, actor.TestResults.GetCounts(i));
}
}
public async Task <DiscordCommandResult> SourceAsync(string path = null)
{
GitHubSource gitHubSource;
try
{
gitHubSource = await _sourceBrowser.GetPathAsync(path);
}
catch (HttpRequestException e) when(e.StatusCode == HttpStatusCode.NotFound)
{
return(Response("Requested file does not exist!"));
}
switch (gitHubSource)
{
case null:
return(Response("Something went wrong while fetching source."));
case GitHubSourceFile sourceFile when string.IsNullOrWhiteSpace(sourceFile.Content):
return(Response("The selected text is only whitespace."));
case GitHubSourceFile sourceFile when sourceFile.Content.Length > LocalMessageBase.MaxContentLength:
{
var stream = new MemoryStream(Encoding.Default.GetBytes(sourceFile.Content));
var msg = new LocalMessage().WithAttachments(new LocalAttachment(stream, gitHubSource.Filename));
return(Response(msg));
}
case GitHubSourceFile sourceFile:
return(Response(Markdown.CodeBlock(sourceFile.Filename.Split('.').Last(), sourceFile.Content)));
case GitHubSourceDirectory sourceDirectory:
{
var view = new SelectionPagedView(new SelectionPageProvider(Array.Empty <SelectionPage>()));
var pageProvider = new SelectionPageProvider(GetSourceCodePages(sourceDirectory, view));
view.SetPageProvider(pageProvider);
return(View(view));
}
default:
throw new ArgumentException($"The type of {nameof(gitHubSource)} was not expected!", nameof(gitHubSource));
}
}
public void TestBasicDispatch()
{
var testResult = new TestResults(MailboxSize);
var dispatcher = new ManyToOneConcurrentArrayQueueDispatcher(MailboxSize, 2, false, 4, 10);
dispatcher.Start();
var mailbox = dispatcher.Mailbox;
var actor = new CountTakerActor(testResult);
for (var count = 1; count <= MailboxSize; ++count)
{
var countParam = count;
Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
mailbox.Send(message);
}
Assert.Equal(MailboxSize, testResult.GetHighest());
}
private Dictionary <ushort, GameObject> RoomContainer2 = new Dictionary <ushort, GameObject>(); //房间号——组件
// Use this for initialization
void OnEnable()
{
if (LocalMessage.scom == null)
{
LocalMessage.scom = new SocketCom();
if (!LocalMessage.scom.Initialize())
{
EditorUtility.DisplayDialog("网络连接失败", "无法连接到服务器", "返回主菜单");
BackMainMenu();
return;
}
LocalMessage.SetHandler(MessageHandle);
}
else
{
LocalMessage.scom.SendMessage(MsgType.RoomMsgList);
}
//EditorUtility.DisplayDialog("打开", "进入大厅", "关闭");
}
public async Task RandomColorAsync(Color color)
{
var colorImagePath = _colorService.GetColorImage(color.ToString());
using (var colorImage = LocalAttachment.File(colorImagePath, "colorImage.png"))
{
var eb = new LocalEmbed()
.WithColor(color)
.WithDescription($"Hex: {color.ToString()}\nRGB: {color.R} {color.G} {color.B}")
.WithImageUrl("attachment://colorImage.png");
var mb = new LocalMessage()
.WithAttachments(colorImage)
.WithEmbeds(eb);
await Response(mb);
}
File.Delete(colorImagePath);
}
public void SyncMessage(MessageSyncInfo messageSyncInfo)
{
LocalMessage message = LocalMessageRepository
.GetMessageByLocalIdAndSenderName(messageSyncInfo.LocalId, messageSyncInfo.SenderName);
if (message is null)
{
return;
}
message.Id = messageSyncInfo.Id;
message.SendedTime = messageSyncInfo.NewDateTime;
SaveAndShowMessage(message);
RequestToHideMessage(
LocalMessageRepository.GetMessageByLocalIdAndSenderName(message.LocalId, message.Sender));
LocalMessageRepository.RemoveMessageByLocalIdIfWithoutId(message.LocalId);
ServerConnectionHandler.RequestsToSend.Add(
RequestConverter.ComposeMessageSynchronised(message.Id));
}
