public void Discharge(GameObject _receiver, Telegram _msg)
{
if (_receiver.HandleMessage(_msg) == false)
{
Debug.Log("Message cannot be send due to error !");
}
}
public override bool HandleMessage(Telegram message)
{
if (base.HandleMessage(message))
return true;
if (message.TelegramType == TelegramType.QuestTrade)
{
RemoveAllSubgoals();
CharacterDetails traderDetails = AgentManager.Instance.GetAgent(message.Sender);
AgentInventory traderInventory = (traderDetails.IsPlayer ? traderDetails.PlayerAgent.Inventory : traderDetails.CognitiveAgent.Inventory);
//Get equipped item from trader's inventory.
//See if cues of equipped item match the cue needed to satisfy the quest.
//If so, remove from one inventory and pass to the other.
ItemCue traderItem = traderInventory.GetEquippedItem();
if (traderItem != null)
{
for (int i = 0; i < traderItem.CueMarkers.Length; i++)
{
if(traderItem.CueMarkers[i] == Owner.QuestInfo.QuestUID)
{
Owner.Inventory.PickupItem(traderDetails.PlayerAgent.Inventory.LoseEquippedItem(), true);
Owner.CompleteQuest();
CurrentStatus = GoalStatus.Completed;
return true;
}
}
}
}
return false; //The message is unhandled by this goal.
}
public void DispatchMessage(double delay,
int sender,
int receiver,
int msg,
Object ExtraInfo = default(Object))
{
try
{
Agent Sender = AgentManager.Instance.GetAgent(sender);
Agent Receiver = AgentManager.Instance.GetAgent(receiver);
Telegram telegram = new Telegram(0, sender, receiver,
msg, ExtraInfo);
if(delay <= 0.0)
{
Discharge(Receiver, telegram);
}
else
{
telegram.mDispatchTime = DateTime.Now.Second + delay;
priorityQueue.insert(telegram);
}
}
catch(ArgumentException argEx)
{
Console.WriteLine(argEx.Message);
return;
}
}
public void DispatchMessage(float delay, /*fa song zhe */int sender, /*jie shou zhe */int receiver, int msg,MonoBehaviour _be)
{
//jie shou zhe de zhi zhen
BaseGameEntity pReceiver = EntityManager.Instance ().GetEntityFromID (receiver);
//chuang jian yi ge xiao xi
Telegram telegram = new Telegram (0, sender, receiver, msg,_be);
if (delay <= 0.0f) {
//li ji fa song xiao xi
Discharge (pReceiver, telegram);
} else {
//yan chi fa song xiao xi
float CurrentTime = Time.realtimeSinceStartup;
telegram.DispatchTime = CurrentTime + delay;
foreach(Telegram val in PriorityQ)
{
if(val.Sender == sender && val.Receiver == receiver && val.Msg ==msg)
{
return ;
}
}
PriorityQ.Add (telegram);
}
}
public static void SendMessage(CognitiveAgent agent, Telegram telegram)
{
agent.HandleMessage(telegram);
//if(agent.HandleMessage(telegram))
// Debug.Log("A message " + (telegram.IsResponse ? "response" : "") + " ( " + telegram.TelegramType + " ) was handled by " + agent.name);
//else
// Debug.Log("A message " + (telegram.IsResponse ? "response" : "") + " ( " + telegram.TelegramType + " ) was left unhandled by " + agent.name);
}
public TelegramUtil(Client client, Telegram.Bot.TelegramBotClient telegram, ISettings settings, Inventory inv)
{
_client = client;
_telegram = telegram;
_clientSettings = settings;
_inventory = inv;
DoLiveStats(settings);
DoInformation();
}
public override void HandleMessage(Telegram telegram)
{
if (telegram.TargetList != null)
{
if (telegram.TargetList.Contains(this))
{
callCoroutine();
}
}
}
public void TestFixtureSetUp()
{
_actualTelegram = null;
var recipientController = new Clerk(this, this);
recipientController.Run();
_expectedTelegram = new Telegram("Hello, world!");
OnTelegramReceived(new TelegramReceivedEventArgs(_expectedTelegram));
}
void Start()
{
wallButtons.AddRange(gameObject.GetComponentsInChildren<WallButton>());
arrowButtonContainer = gameObject.GetComponentInChildren<ArrowButtonContainer>();
walls = gameObject.GetComponentInChildren<Walls>();
//lastWall = walls.PuzzleWalls.Last<DimensionWall>().GetComponent<DimensionWall>().CameraSpace;
wallButtonsTelegram = new Telegram(wallButtons.Cast<ButtonBase>().ToList());
arrowButtonContainerTelegram = new Telegram(arrowButtonContainer);
}
public void TestFixtureSetUp()
{
_rabbitManager = new RabbitManager();
_rabbitManager.PurgeQueue().Wait();
_telegraphist = new Telegraphist();
_telegraphist.TelegramReceived += (sender, e) => _actualTelegram = e.Telegram;
_telegraphist.Start();
_rabbitManager.PublishMessage(ExpectedValue).Wait();
Thread.Sleep(1000);
}
public static void DispatchMessage(int sender, int receiver, TelegramType telegramType, bool isResponse = false, Vector3? location = null, float delay = 0.0f)
{
Telegram telegram = new Telegram (sender, receiver, telegramType, isResponse, location, delay);
if (delay <= 0.0f)
{
CognitiveAgent rAgent = AgentManager.Instance.GetAgent(receiver).CognitiveAgent;
SendMessage(rAgent, telegram);
}
else
{
telegram.DispatchTime = Time.time + delay;
telegramQueue.Add(telegram);
}
}
//---------------------------- DispatchMsg ---------------------------
//
// given a message, a receiver, a sender and any time delay, this function
// routes the message to the correct agent (if no delay) or stores
// in the message queue to be dispatched at the correct time
//------------------------------------------------------------------------
public void DispatchMsg(TimeSpan delay, int sender, int receiver, int messagecode, object additionalInfo)
{
//get a pointer to the receiver
BaseGameEntity receiverEntity = EntityManager.Instance.FindEntity(receiver);
//make sure the receiver is valid
if (receiverEntity == null)
{
//#ifdef SHOW_MESSAGING_INFO
//debug_con << "\nWarning! No Receiver with ID of " << receiver << " found" << "";
//#endif
}
else
{
//create the telegram
Telegram telegram = new Telegram(sender, receiver, messagecode, DateTime.Now, additionalInfo);
//if there is no delay, route telegram immediately
if (delay.TotalMilliseconds <= Telegram.SmallestDelay)
{
//#ifdef SHOW_MESSAGING_INFO
//debug_con << "\nTelegram dispatched at time: " << TickCounter->GetCurrentFrame()
// << " by " << sender << " for " << receiver
// << ". Msg is " << msg << "";
//#endif
//send the telegram to the recipient
discharge(receiverEntity, telegram);
}
//else calculate the time when the telegram should be dispatched
else
{
telegram.DispatchTime = DateTime.Now + delay;
_priorityQueue.Enqueue(telegram, -delay.TotalMilliseconds);
//#ifdef SHOW_MESSAGING_INFO
//debug_con << "\nDelayed telegram from " << sender << " recorded at time "
// << TickCounter->GetCurrentFrame() << " for " << receiver
// << ". Msg is " << msg << "";
//#endif
}
}
}
public PluginManager(Telegram.Bot.Api _Api, string plugin_directory)
{
try
{
PluginFolder = plugin_directory;
client.OnTaskDone += OnTaskDone;
client.Api = _Api;
client.Id = 9914;
pluginadapter = new PluginAdaptor(client);
pluginadapter.Onerror += (sender, error) => { OnError(sender, error); };
pluginadapter.Onmessage += (sender, message) => { OnMessage(sender, message); };
}
catch (Exception ex)
{
OnError(this, ex);
}
}
public void DispatchMessage(GameObject _Sender, GameObject _Receiver, MessageType _Msg, double _Delay)
{
Telegram telegram = new Telegram();
telegram.Sender = _Sender;
telegram.Receiver = _Receiver;
telegram.Msg = _Msg;
telegram.dDispatchTime = _Delay;
if (_Delay <= 0.0)
{
Discharge(_Receiver, telegram);
}
else
{
double dCurrentTime = Time.time;
telegram.dDispatchTime = dCurrentTime + _Delay;
m_PriorityList.Add(telegram);
SortListByDelay();
}
}
public static bool HandleMessage(this GameObject _GO, Telegram _Telegram)
{
//_GO being the reciever of the message and _Telegram being the message to be delivered to the reciever
//If the sender and reciever of the message is not given, return false in the handling of message
if (_Telegram.Sender == null && _Telegram.Receiver == null || _GO == null)
{
return false;
}
//Add additional "if" statements if other FSM require the usage of Telegram. However,
//you will need to add a Telegram variable into that FSM script so this function can assign
//sent messages to that FSM for them to process the message
if (_GO.tag == "EnemyChild")
{
_GO.GetComponent<EnemyChildFSM>().Command = _Telegram.Msg;
}
return true;
}
/// <summary>
/// 全局方法，提供消息发送的功能
/// </summary>
/// <param name="delay">延迟时间(目前不用)</param>
/// <param name="sender"></param>
/// <param name="receiver"></param>
/// <param name="msg"></param>
/// <param name="ExtraInfo"></param>
public void DispatchMessage(double delay,
int sender,
int receiver,
int msg,
TelegramInfo ExtraInfo)
{
// 发送消息的Entity
BaseGameEntity pSender = EntityManager.Instance().GetEntityFromID(sender);
// 接收消息的Entity
BaseGameEntity pReceiver = EntityManager.Instance().GetEntityFromID(receiver);
//
if (pReceiver == null)
return;
// 消息体
Telegram telegram = new Telegram(0, sender, receiver, msg, ExtraInfo);
// 发送
Discharge(pReceiver, telegram);
}
private void senduVorton(Telegram.Bot.Types.Update update)
{
var item = this.GetSingleWord();
if (item == null)
{
botApi.SendTextMessage(update.Message.Chat.Id, "Pardonu, mi ne povas sendi la vorton nun. Mi pardonpetas pro la ĝeno.");
}
else
{
var vorto = String.Format("{0}\n\n{1}", item.Title, item.Description);
botApi.SendTextMessage(update.Message.Chat.Id, vorto);
}
}
public bool OnMessage(Miner owner, Telegram telegram)
{
return(false);
}
public bool HandleMessage(Telegram telegram)
{
return(CurrentState?.OnMessage(_owner, telegram) == true ||
GlobalState?.OnMessage(_owner, telegram) == true);
}
public void Shutdown()
{
_cancellationTokenSource.Cancel();
Telegram.Stop();
}
public List <FrameResponse> ReadAllTelegram(string portcom, string macadresseprt)
{
List <FrameResponse> myFrameList = new List <FrameResponse>();
HyScript hyScript = new HyScript();
int port = Convert.ToInt32(portcom);
string comPort = "com://" + port;
string response = "false";
string dataJSON = "";
string rawDataInterpretJSON = "";
string cmdClear = "if(dc~=nil) then dc:close(); cl=nil; pl=nil; dc=nil";
_logger.Info("Check Licence");
response = hyScript.call("setLogLevel(-1); setLogFileName('IzarCSI.log'); return License.check('EGEEEGEE','I1ARCQI0')");
_logger.Info("resultat Check Licence : " + response);
if (response == "true")
{
hyScript.call(cmdClear);
string cmd = "dc = DataConcentrator.new();" +
" ds = BtReceiverDataSource.new();" +
" ds:setDataConcentrator(ref(dc));" +
" pl = IPhysicalLayer.new('" + comPort + "');" +
" cl = ICommunicationLayer.new('hybtoh://', ref(pl));" +
" ds:setCommunicationLayer(ref(cl));" +
" local ri = RadioInterpreter.new();" +
" ri:setProcessLevel();" +
" dc:setRadioInterpreter(ri);" +
" ri:enableDecryption(false);" +
" tsf=ToStringFormater.new();" +
" tsf:setAddSPDEAddress(true);" +
" setFormater(tsf);" +
" ds:setSourceId('" + macadresseprt + "');" +
" ds:config('timeoutNoAnswer', 150);" +
" ds:config('timeoutNoDataFollows', 2);" +
" ds:config('timeoutAfterTelegram', 10); return true";
_logger.Info("Init: " + cmd);
response = hyScript.call(cmd);
_logger.Info("resultat Init : " + response);
if (response == "true")
{
//startASync
_logger.Info("ds:startASync()");
hyScript.call("ds:startASync()");
Thread.Sleep(2000);
//stopASync
_logger.Info("ds:stopASync()");
hyScript.call("ds:stopASync()");
string telegramProcessed = hyScript.call("return dc:getNumberOfProcessedTelegrams()");
_logger.Info("Nombre de télégrammes traités: " + telegramProcessed);
string telegramCollected = hyScript.call("return dc:getNumberOfCollectedTelegrams()");
_logger.Info("Nombre de télégrammes collectés: " + telegramCollected);
string falseTelegram = hyScript.call("return dc:getNumberOfFalseTelegrams()");
_logger.Info("Nombre de faux télégrammes : " + falseTelegram);
string foundedDevice = hyScript.call("return dc:getNumberOfFoundedDevices()");
_logger.Info("Nombre de modules trouvés : " + foundedDevice);
//device founded
if (Convert.ToInt32(foundedDevice) > 0)
{
_logger.Info("dc:getDeviceList()");
dataJSON = hyScript.call("return dc:getDeviceList():__tostring(dc:getDeviceList():getBeginDeviceDescriptionIterator(true))");
_logger.Info("resultat getDeviceList : " + dataJSON);
try
{
FrameResponse dataFrame;
SappelResponseContract sappelResponseContract = JsonConvert.DeserializeObject <SappelResponseContract>(dataJSON);
List <Entry> entries = sappelResponseContract.entries.ToList();
foreach (var entry in entries)
{
List <Telegram> telegrams = entry.value.meteringPoint.telegrams.ToList();
foreach (var telegram in telegrams)
{
dataFrame = new FrameResponse();
if (telegram.telegramTypeSpecifica.qualityIndicator.rssi > 25)
{
dataFrame.deviceId = telegram.mBusData.deviceId.spdeid.spde;
dataFrame.manuString = telegram.mBusData.deviceId.manuString;
dataFrame.ciField = telegram.mBusData.ciField;
dataFrame.structure = telegram.mBusData.deviceId.spdeid.format;
//Récupération des alarmes
if (telegram.mBusData.alarmField.data != "00" && telegram.mBusData.alarmField.data != "00 00")
{
dataFrame.alarmeCode = TelegramAlarmFormat(telegram.mBusData.alarmField.data);
}
string rawData = TelegramFormat(telegram.mBusData.rawData.data);
//On récupére la raw data
rawDataInterpretJSON = Interpreter(rawData);
Telegram telegramResponse = JsonConvert.DeserializeObject <Telegram>(rawDataInterpretJSON);
List <MBusValue> mBusValues = telegramResponse.mBusData.mBusValues.ToList();
foreach (var mBusValue in mBusValues)
{
if ((mBusValue.valid == true))
{
if (mBusValue.dimension.stringId == "VOLUME")
{
//volume
if (mBusValue.storageNumber == 0 && mBusValue.tariffNumber == 0 && mBusValue.subUnitNumber == 0)
{
dataFrame.volumeValue = Convert.ToInt32(mBusValue.formated);
dataFrame.volumeIndex = CalculIndex(Convert.ToInt32(mBusValue.formated), Convert.ToInt32(mBusValue.exponent));
dataFrame.volumeCode = mBusValue.dimension.stringId;
dataFrame.volumeUnite = mBusValue.unit.stringId;
dataFrame.volumeExponent = Convert.ToInt32(mBusValue.exponent);
dataFrame.volumeFormat = dataFrame.volumeCode + " " + dataFrame.volumeIndex + " m3";
}
}
if (mBusValue.dimension.stringId == "ENERGY")
{
//Energy
if (mBusValue.storageNumber == 0 && mBusValue.tariffNumber == 0 && mBusValue.subUnitNumber == 0)
{
dataFrame.energyValue = Convert.ToInt32(mBusValue.formated);
dataFrame.energyIndex = CalculIndex(Convert.ToInt32(mBusValue.formated), Convert.ToInt32(mBusValue.exponent));
dataFrame.energyCode = mBusValue.dimension.stringId;
dataFrame.energyUnite = mBusValue.unit.stringId;
dataFrame.energyExponent = Convert.ToInt32(mBusValue.exponent);
dataFrame.energyFormat = dataFrame.energyCode + " " + dataFrame.energyIndex + " " + dataFrame.energyUnite;
}
}
if (mBusValue.dimension.stringId == "OPERATIONTIMEBATTERY")
{
dataFrame.batteryCode = mBusValue.dimension.stringId;
dataFrame.batteryFormated = Convert.ToInt32(mBusValue.formated);
dataFrame.batteryUnite = mBusValue.unit.stringId;
}
if (mBusValue.dimension.stringId == "TIMEPOINT")
{
dataFrame.date = mBusValue.formated.ToString();
}
}
}
if (!myFrameList.Where(x => x.deviceId == dataFrame.deviceId).Any())
{
if ((dataFrame.volumeCode != null || dataFrame.energyCode != null) && dataFrame.ciField != 0)
{
myFrameList.Add(dataFrame);
}
}
}
}
}
}
catch (Exception ex)
{
_logger.Info("ERREUR : " + ex.Message);
}
}
hyScript.call("dc:getDeviceList():clear()");
}
else
{
dataJSON = hyScript.call("dc:clearLastException() val=dc:getValue(valueIdent) ret = {val, dc:getLastException()} return ret");
_logger.Info("Erreur Init and StartASync: " + dataJSON);
}
}
else
{
dataJSON = hyScript.call("dc:clearLastException() val=dc:getValue(valueIdent) ret = {val, dc:getLastException()} return ret");
_logger.Info("Erreur check licence: " + dataJSON);
}
_logger.Info("ResultMyFrameList : " + myFrameList.ToString());
return(myFrameList);
}
public void OnOtherTelegrams(Telegram t)
{
try
{
if (t is TelegramPalletRemoved)
{
using (MFCSEntities dc = new MFCSEntities())
{
string loc;
int idx = (t as TelegramPalletRemoved).Location;
// int idxp = ((int)((idx - 1) / 4) + 1) * 10 + (idx - 1) % 4 + 1;
int idxp = idx;
if (idx % 10 == 0) // button pressed at the end of ramp
{
using (WMSToMFCSClient client = new WMSToMFCSClient())
{
idx = idx / 10;
loc = $"W:32:{idx:D2}";
bool canDelete;
try
{
canDelete = false; // !client.OrderForRampActive(loc);
}
catch
{
canDelete = true;
}
if (canDelete && dc.Places.Any(p => p.Place1.StartsWith(loc))) // ramp is full, remove pallets
{
var pallets = (from p in dc.Places
where p.Place1.StartsWith(loc)
select p).ToList();
foreach (var pal in pallets)
{
DBService.MaterialDelete(pal.Place1, pal.Material);
OnMaterialMove?.Invoke(pal, EnumMovementTask.Delete);
//DBService.MaterialMove(pal.Material, pal.Place1, "W:out");
//Place pl = new Place { Material = pal.Material, Place1 = "W:out", Time = DateTime.Now };
//OnMaterialMove?.Invoke(pl, EnumMovementTask.Move);
}
}
// else // release ramp
// client.DestinationEmptied(loc);
}
}
else // sensor detected removal
{
loc = $"W:32:{idxp:D3}:1:1";
Place place = dc.Places.Where(p => p.Place1 == loc).OrderBy(pp => pp.Time).FirstOrDefault();
{
DBService.MaterialDelete(place.Place1, place.Material);
OnMaterialMove?.Invoke(place, EnumMovementTask.Delete);
//DBService.MaterialMove(place.Material, loc, "W:out");
//Place pl = new Place { Material = place.Material, Place1 = "W:out", Time = DateTime.Now };
//OnMaterialMove?.Invoke(pl, EnumMovementTask.Move);
}
}
}
}
}
catch (Exception ex)
{
AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, ex.Message);
AddEvent(Event.EnumSeverity.Error, Event.EnumType.Exception, String.Format("{0} BasicWarehouse.OnOtherTelegrams failed", Name));
}
}
public static int GetYear(this Telegram telegram)
{
return(int.Parse(telegram.RowKey[..4]));
public static int GetMonth(this Telegram telegram)
{
return(int.Parse(telegram.RowKey.Substring(4, 2)));
}
abstract public bool OnMessage(entity_type entity, Telegram telegram);
private Task <ActivationResult> Register(string code)
{
return(Task <ActivationResult> .Factory.StartNew(() =>
{
var result = Telegram.RegisterCode(_service, GetSettingsTelegramSettings(), CountryCode + NationalNumber,
GetSettingsCodeHash(), code, FirstName, LastName, GetSettingsRegistered());
if (result == null)
{
return new ActivationResult
{
Success = false,
ErrorMessage = Localize.GetString("TelegramCodeError")
};
}
if (result.Response != Telegram.CodeRegister.Type.Success)
{
string errorMessage = null;
switch (result.Response)
{
case Telegram.CodeRegister.Type.NumberInvalid:
errorMessage = Localize.GetString("TelegramCodeNumberInvalid");
break;
case Telegram.CodeRegister.Type.CodeEmpty:
errorMessage = Localize.GetString("TelegramCodeInvalidMessage");
break;
case Telegram.CodeRegister.Type.CodeExpired:
errorMessage = Localize.GetString("TelegramCodeCodeExpired");
break;
case Telegram.CodeRegister.Type.CodeInvalid:
errorMessage = Localize.GetString("TelegramCodeCodeInvalid");
break;
case Telegram.CodeRegister.Type.FirstNameInvalid:
errorMessage = Localize.GetString("TelegramCodeFirstNameInvalid");
break;
case Telegram.CodeRegister.Type.LastNameInvalid:
errorMessage = Localize.GetString("TelegramCodeLastNameInvalid");
break;
default:
errorMessage = Localize.GetString("TelegramCodeError");
break;
}
return new ActivationResult
{
Success = false,
ErrorMessage = errorMessage
};
}
return new ActivationResult
{
Success = true,
AccountId = result.AccountId,
};
}));
}
private Task <ActivationResult> DoVerify(VerificationOption option)
{
return(Task <ActivationResult> .Factory.StartNew(() =>
{
var settings = GetSettingsTelegramSettings();
var response = Telegram.RequestCode(_service, CountryCode + NationalNumber,
GetSettingsCodeHash(),
GetSettingsTelegramSettings(), option == VerificationOption.Voice);
if (response.Response == Telegram.CodeRequest.Type.Migrate)
{
TelegramSettings newSettings;
using (var migratedClient = Telegram.GetNewClient(response.MigrateId, GetSettingsTelegramSettings(), out newSettings))
{
TelegramUtils.RunSynchronously(migratedClient.Connect());
response = Telegram.RequestCode(_service, CountryCode + NationalNumber,
GetSettingsCodeHash(),
newSettings, option == VerificationOption.Voice);
Utils.DebugPrint(">>>>> Response from the server " + ObjectDumper.Dump(response));
if (option == VerificationOption.Sms)
{
SetSettingsSettings(newSettings, false);
SetSettingsCodeHash(response.CodeHash, false);
SetSettingsRegistered(response.Registered, false);
}
return new ActivationResult
{
Success = true,
};
}
}
if (response == null || response.Response != Telegram.CodeRequest.Type.Success)
{
var message = Localize.GetString("TelegramVerifyError");
if (response != null)
{
if (response.Response == Telegram.CodeRequest.Type.NumberInvalid)
{
message = Localize.GetString("TelegramVerifyInvalidNumber");
}
}
return new ActivationResult
{
Success = false,
ErrorMessage = message,
};
}
if (option == VerificationOption.Sms)
{
SetSettingsCodeHash(response.CodeHash, true);
SetSettingsRegistered(response.Registered, true);
}
return new ActivationResult
{
Success = true
};
}));
}
private void Discharge(Telegram message)
{
message.Receiver?.HandleMessage(message);
}
public override void HandleMassage(Telegram tele)
{
stateMachine.HandleMassage(tele);
}
public Info(Service service, TabbedPage tabs, Verify verify)
{
_phoneNumberContainer = new StackLayout();
_phoneNumberContainer.Orientation = StackOrientation.Horizontal;
_phoneNumberContainer.HorizontalOptions = LayoutOptions.FillAndExpand;
_phoneNumber = new PhoneEntry();
_phoneNumber.Placeholder = Localize.GetString("TelegramPhoneNumber");
_phoneNumber.HorizontalOptions = LayoutOptions.FillAndExpand;
_phoneNumberContainer.Children.Add(_phoneNumber);
var programmaticChange = false;
_firstName = new Entry();
_firstName.Placeholder = Localize.GetString("TelegramFirstName");
_lastName = new Entry();
_lastName.Placeholder = Localize.GetString("TelegramLastName");
_loadConversationsLayout = new StackLayout();
_loadConversationsLayout.Orientation = StackOrientation.Horizontal;
_loadConversationsLayout.HorizontalOptions = LayoutOptions.End;
_loadConversationsLayout.Padding = new Thickness(15, 0);
_loadConversationsLayout.Spacing = 10;
_loadConversationsTitle = new Label();
_loadConversationsTitle.Text = Localize.GetString("TelegramLoadConversations");
_loadConversationsSwitch = new Switch();
_loadConversationsSwitch.Toggled += (sender, e) =>
{
(service as Telegram).LoadConversations = e.Value;
};
_loadConversationsSwitch.IsToggled = true;
_loadConversationsLayout.Children.Add(_loadConversationsTitle);
_loadConversationsLayout.Children.Add(_loadConversationsSwitch);
_next = new Button();
_next.HorizontalOptions = LayoutOptions.FillAndExpand;
_next.Text = Localize.GetString("TelegramNext");
_next.TextColor = Color.White;
_next.BackgroundColor = Color.FromHex("77D065");
_next.Clicked += async(sender, e) =>
{
if (String.IsNullOrWhiteSpace(_firstName.Text))
{
await DisplayAlert(Localize.GetString("TelegramInvalidFirstNameTitle"), Localize.GetString("TelegramInvalidFirstNameMessage"), Localize.GetString("TelegramOkay"));
return;
}
if (String.IsNullOrWhiteSpace(_lastName.Text))
{
await DisplayAlert(Localize.GetString("TelegramInvalidLastNameTitle"), Localize.GetString("TelegramInvalidLastNameMessage"), Localize.GetString("TelegramOkay"));
return;
}
Func <Task> invalidNumber = () =>
{
return(DisplayAlert(Localize.GetString("TelegramInvalidNumberTitle"),
Localize.GetString("TelegramInvalidNumberMessage"), Localize.GetString("TelegramOkay")));
};
if (!PhoneBook.IsPossibleNumber(_phoneNumber.Text))
{
await invalidNumber();
return;
}
var number = PhoneBook.TryGetPhoneNumberLegible(_phoneNumber.Text);
var formattedNumber = PhoneBook.FormatPhoneNumber(number);
if (formattedNumber == null)
{
await invalidNumber();
return;
}
var nationalNumber = new string(formattedNumber.Item2.Where(Char.IsDigit).ToArray());
if (!await DisplayAlert(Localize.GetString("TelegramConfirmNumberTitle"),
Localize.GetString("TelegramConfirmNumberMessage").Replace("[number]", number),
Localize.GetString("TelegramYes"),
Localize.GetString("TelegramNo")))
{
return;
}
_progressBar.IsVisible = true;
_next.IsEnabled = false;
_firstName.IsEnabled = false;
_lastName.IsEnabled = false;
_phoneNumber.IsEnabled = false;
DependencyService.Get <IPluginPageControls>().BackPressEnabled = false;
TelegramSettings settings = null;
var skipSave = false;
var state = _settings.States.FirstOrDefault(x => x.NationalNumber == nationalNumber);
if (state != null && state.Settings != null)
{
skipSave = true;
settings = state.Settings;
}
else
{
settings = await Task <TelegramSettings> .Factory.StartNew(() => { return(Telegram.GenerateAuthentication(service)); });
}
var firstName = _firstName.Text.Trim();
var lastName = _lastName.Text.Trim();
DependencyService.Get <IPluginPageControls>().BackPressEnabled = true;
_firstName.IsEnabled = true;
_lastName.IsEnabled = true;
_phoneNumber.IsEnabled = true;
_next.IsEnabled = true;
_progressBar.IsVisible = false;
if (settings == null)
{
await DisplayAlert(Localize.GetString("TelegramAuthGenerationFailedTitle"),
Localize.GetString("TelegramAuthGenerationFailedMessage"), Localize.GetString("TelegramOkay"));
return;
}
if (!skipSave)
{
_settings.States.Add(new Setup.TelegramSetupSettings.State
{
Settings = settings,
NationalNumber = nationalNumber
});
SaveSettings();
}
verify.CountryCode = formattedNumber.Item1;
verify.NationalNumber = nationalNumber;
verify.FirstName = firstName;
verify.LastName = lastName;
tabs.Children.Add(verify);
tabs.CurrentPage = verify;
};
_image = new Image();
_image.Source = ImageSource.FromUri(
new Uri("https://lh4.ggpht.com/fuvTtxbZ1-dkEmzUMfKcgMJwW8PyY4fhJJ_NKT-NpIQJukszEY2GfCkJUF5ch6Co3w=w300"));
_image.WidthRequest = 100;
_image.HeightRequest = 100;
_progressBar = new ActivityIndicator();
_progressBar.VerticalOptions = LayoutOptions.EndAndExpand;
_progressBar.IsRunning = true;
_progressBar.IsVisible = false;
var stackLayout = new StackLayout();
stackLayout.Spacing = 20;
stackLayout.Padding = 25;
stackLayout.VerticalOptions = LayoutOptions.Start;
var children = stackLayout.Children;
children.Add(_image);
children.Add(_firstName);
children.Add(_lastName);
children.Add(_phoneNumberContainer);
children.Add(_loadConversationsLayout);
var nextLayout = new StackLayout();
nextLayout.Spacing = 20;
nextLayout.Orientation = StackOrientation.Horizontal;
nextLayout.Children.Add(_next);
nextLayout.Children.Add(_progressBar);
children.Add(nextLayout);
Content = new ScrollView {
Content = stackLayout
};
Title = Localize.GetString("TelegramInformationTitle");
}
private void SortListByDelay()
{
int size = m_PriorityList.Count;
List<Telegram> sortResult = new List<Telegram>();
while (sortResult.Count < size)
{
double shortestDelay = m_PriorityList[0].dDispatchTime;
Telegram closest = new Telegram();
for (int i = 0; i < m_PriorityList.Count; i++)
{
if (m_PriorityList[i].dDispatchTime < shortestDelay)
{
shortestDelay = m_PriorityList[i].dDispatchTime;
closest = m_PriorityList[i];
}
}
sortResult.Insert(0, closest);
}
m_PriorityList = sortResult;
}
// 这边和 Miner 类差不多，不过懒得再给妻子设定多一个地点枚举了
// public void ChangeLocation(LocationType loc)
// {
// m_Location = loc;
// }
public override bool HandleMessage(Telegram message)
{
return(m_pStateMachine.HandleMessage(message));
}
/// <summary>
/// This executes if the agent receives a message from the message dispatcher.
/// </summary>
/// <param name="miner">
/// The game object associated with this state.
/// </param>
/// <param name="msg">
/// The message.
/// </param>
/// <returns>
/// True if the message was handled. Otherwise, false.
/// </returns>
public override bool OnMessage(Miner miner, Telegram msg)
{
// send msg to global message handler
return(false);
}
public override bool OnMessage(Player entity, Telegram telegram)
{
return(false);
}
public override bool HandleMessage(Telegram msg)
{
Debug.Log("Miner HandleMessage");
return(m_StateMachine.HandleMessage(msg));
}
public override bool OnMessage(Miner miner, Telegram telegram)
{
return(false);
}
public override bool HandleMessage(Telegram msg)
{
return(false);
}
public override bool OnMessage(Player entity, Telegram telegram)
{
NewBuff(telegram.buff, entity);
if (entity.mymotor.IsTouchingGround)
{
if (entity.isPasive)
{
if (telegram.Msg == (int)MessagesType.player_MinisterFlash)
{
entity.GetFSM().ChangeState(Player_StateMinisterFlash.Instance);
return(true);
}
if (telegram.Msg == (int)MessagesType.player_WTeanaFlash)
{
entity.GetFSM().ChangeState(Player_StateTeanaFlash.Instance);
return(true);
}
}
else
{
if (entity.isskilling == false)
{
if (telegram.Msg == (int)MessagesType.Player_SkillQ)
{
entity.GetFSM().ChangeState(Player_StateSkillQ.Instance);
return(true);
}
if (telegram.Msg == (int)MessagesType.Player_SkillF)
{
entity.GetFSM().ChangeState(Player_StateSkillF.Instance);
return(true);
}
if (telegram.Msg == (int)MessagesType.Player_SkillM)
{
entity.GetFSM().ChangeState(Player_StateSkillM.Instance);
return(true);
}
if (telegram.Msg == (int)MessagesType.Player_SkillR)
{
entity.GetFSM().ChangeState(Player_StateSkillR.Instance);
return(true);
}
if (telegram.Msg == (int)MessagesType.Player_SkillS)
{
entity.GetFSM().ChangeState(Player_StateSkillS.Instance);
return(true);
}
if (telegram.Msg == (int)MessagesType.player_WEtherFlash)
{
entity.GetFSM().ChangeState(Player_StateWEtherFlash.Instance);
return(true);
}
if (telegram.Msg == (int)MessagesType.Player_Flash)
{
entity.GetFSM().ChangeState(Player_StateFlash.Instance);
return(true);
}
if (telegram.Msg == (int)MessagesType.player_MasterFlash)
{
entity.GetFSM().ChangeState(Player_StateMasterFlash.Instance);
return(true);
}
}
}
}
if (telegram.Msg == (int)MessagesType.Msg_BeingHurt)
{
if (!entity.SuperArmor)
{
entity.GetFSM().ChangeState(Player_StateHurt.Instance);
}
return(true);
}
if (telegram.Msg == (int)MessagesType.Msg_BeingUpFukongBig)
{
entity.flyhigh = 25f;
if (!entity.SuperArmor)
{
entity.GetFSM().ChangeState(Player_StateFloating.Instance);
}
return(true);
}
if (telegram.Msg == (int)MessagesType.Msg_BeingUpFukongSmall)
{
entity.flyhigh = 18f;
if (!entity.SuperArmor)
{
entity.GetFSM().ChangeState(Player_StateFloating.Instance);
}
return(true);
}
if (telegram.Msg == (int)MessagesType.Msg_BeingUpForced_Fall)
{
if (!entity.SuperArmor)
{
entity.GetFSM().ChangeState(Player_StateForce_Fall.Instance);
}
return(true);
}
return(false);
}
public void WriteData(string input, FrameType type)
{
byte[] Header = { STARTBYTE, (byte)type };
byte[] fileId = { 0 };
byte[] size;
byte[] NumOfFrames;
byte[] FrameNumber;
byte[] BufferToSend;
byte[] Telegram;
string Telegram_s;
string size_s;
byte[] ByteToEncode;
byte[] ByteEncoded;
switch (type)
{
case FrameType.MSG:
#region MSG
if (IsConnected())
{
// Telegram[] = Coding(input);
Telegram = Encoding.Default.GetBytes(input); //потом это кыш
BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
Header.CopyTo(BufferToSend, 0);
Telegram.CopyTo(BufferToSend, Header.Length);
Port.Write(BufferToSend, 0, BufferToSend.Length);
Log.AppendText("(" + Port.PortName + ") WriteData: sent message > " + Encoding.Default.GetString(Telegram) + "\n");
}
break;
#endregion
case FrameType.ACK:
#region ACK
if (IsConnected())
{
// Telegram[] = Coding(input);
Telegram = Encoding.Default.GetBytes(input); //потом это кыш
BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
Header.CopyTo(BufferToSend, 0);
Telegram.CopyTo(BufferToSend, Header.Length);
Port.Write(BufferToSend, 0, BufferToSend.Length);
Telegram_s = Encoding.Default.GetString(Telegram);
//Log.AppendText("[" + DateTime.Now + "] Отправлено ACK согласие на принятие файла: " + Telegram_s + "\n");
}
break;
#endregion
case FrameType.FILEOK:
if (IsConnected())
{
ByteToEncode = File.ReadAllBytes(input);
FilePath = input;
size = new byte[sizeLenght];
size = Encoding.Default.GetBytes(((double)ByteToEncode.Length).ToString()); //нужны байты
//Telegram = Encoding.Default.GetBytes(size); //потом это кыш
BufferToSend = new byte[Header.Length + size.Length]; //буфер для отправки = заголовок+сообщение
Header.CopyTo(BufferToSend, 0);
size.CopyTo(BufferToSend, Header.Length);
Port.Write(BufferToSend, 0, BufferToSend.Length);
size_s = Encoding.Default.GetString(size);
Log.AppendText("[" + DateTime.Now + "] Отправлена информация о размере файла: " + size_s + "\n");
//SuccessfulFrameNumber = int.Parse(Telegram_s);
}
break;
case FrameType.FRAME:
if (IsConnected())
{
// Telegram[] = Coding(input);
Telegram = Encoding.Default.GetBytes(input); //потом это кыш
BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
Header.CopyTo(BufferToSend, 0);
Telegram.CopyTo(BufferToSend, Header.Length);
Port.Write(BufferToSend, 0, BufferToSend.Length);
Telegram_s = Encoding.Default.GetString(Telegram);
//Log.AppendText("[" + DateTime.Now + "] получен Frame > " + Telegram_s + " .Отправлено подтверждение о получении.\n");
//SuccessfulFrameNumber = int.Parse(Telegram_s);
}
break;
case FrameType.FILE:
#region FILE
if (IsConnected())
{
ByteToEncode = File.ReadAllBytes(@FilePath);
size = new byte[sizeLenght];
size = Encoding.Default.GetBytes(((double)ByteToEncode.Length).ToString()); //нужны байты
//WriteData(Encoding.Default.GetString(size), FrameType.FILEOK);
NumOfFrames = new byte[NumOfFrameLenght];
FrameNumber = new byte[NumOfFrameLenght];
string typeFile = @input.Split('.')[1];
fileId[0] = TypeFile_to_IdFile(typeFile);
ByteEncoded = new byte[ByteToEncode.Length * 2];
for (int i = 0; i < ByteToEncode.Length; i++)
{
Hamming.HammingEncode74(ByteToEncode[i]).CopyTo(ByteEncoded, i * 2);
}
if (ByteEncoded.Length + InfoLen < Port.WriteBufferSize)
{
BufferToSend = new byte[InfoLen + ByteEncoded.Length];
Header.CopyTo(BufferToSend, 0);
fileId.CopyTo(BufferToSend, Header.Length);
size.CopyTo(BufferToSend, Header.Length + fileId.Length);
NumOfFrames = Encoding.Default.GetBytes(1.ToString());
NumOfFrames.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght);
FrameNumber = Encoding.Default.GetBytes(1.ToString());
FrameNumber.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght + NumOfFrameLenght);
ByteEncoded.CopyTo(BufferToSend, InfoLen);
bool flag = false;
while (!flag)
{
if (MessageBox.Show("Отправить?", "Файл", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
flag = true;
Port.Write(BufferToSend, 0, BufferToSend.Length);
//loading.Hide();
MessageBox.Show("Готово!");
//loading.progressBar1.Value = 0;
//loading.i = 1;
}
else
{
flag = true;
//loading.Hide();
//loading.progressBar1.Value = 0;
MessageBox.Show("Вы отменили передачу файла.");
// loading.i = 1;
}
}
}
else
{
int EncodedByteIndex;
int Part_ByteEncodedIndex;
int parts = (int)Math.Ceiling((double)ByteEncoded.Length / (double)(Port.WriteBufferSize - InfoLen));
NumOfFrames = Encoding.Default.GetBytes(parts.ToString());
for (int i = 0; i < parts; i++)
{
EncodedByteIndex = i * (Port.WriteBufferSize - InfoLen);
Part_ByteEncodedIndex = (Port.WriteBufferSize - InfoLen);
byte[] Part_ByteEncoded = new byte[Part_ByteEncodedIndex];
int Part_Len = 0;
if (((ByteEncoded.Length - EncodedByteIndex) >= Part_ByteEncodedIndex))
{
Part_Len = Part_ByteEncodedIndex;
}
else if (ByteEncoded.Length - EncodedByteIndex > 0)
{
Part_Len = ByteEncoded.Length - i * (Port.WriteBufferSize - InfoLen);
}
BufferToSend = new byte[Port.WriteBufferSize];
Header.CopyTo(BufferToSend, 0);
fileId.CopyTo(BufferToSend, Header.Length);
size.CopyTo(BufferToSend, Header.Length + fileId.Length);
NumOfFrames.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght);
FrameNumber = Encoding.Default.GetBytes((i + 1).ToString());
FrameNumber.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght + NumOfFrameLenght);
Array.ConstrainedCopy(ByteEncoded, EncodedByteIndex, BufferToSend, InfoLen, Part_Len);
//Log.AppendText("[" + DateTime.Now + "] : Отправляется фрейм: " + (SuccessfulFrameNumber + 1).ToString() + "\n");
Port.Write(BufferToSend, 0, BufferToSend.Length);
int ByteCheck;
if (i > 0)
{
int WaitTime = 0;
ByteCheck = Port.ReadByte();
while (ByteCheck != (int)STARTBYTE)
{
if (WaitTime <= 1000)
{
Thread.Sleep(100);
WaitTime += 100;
ByteCheck = Port.ReadByte();
}
}
ByteCheck = Port.ReadByte();
if (ByteCheck == (int)FrameType.FRAME)
{
int n = FrameNumber.Length;//Port.BytesToRead;
byte[] msgByteBuffer = new byte[n];
Port.Read(msgByteBuffer, 0, n); //считываем сообщение
string Message = Encoding.Default.GetString(msgByteBuffer);
Log.Invoke(new EventHandler(delegate
{
Log.AppendText("[" + DateTime.Now + "] : Получено подтверждение об успешной доставке Frame " + Message + "\n");
}));
SuccessfulFrameNumber = int.Parse(Message);
}
if (i == SuccessfulFrameNumber)
{
continue;
}
if (i != SuccessfulFrameNumber)
{
MessageBox.Show("Передача файла прервана");
break;
}
}
}
}
}
break;
#endregion
default:
if (IsConnected())
{
Port.Write(Header, 0, Header.Length);
}
break;
} //Зачем такая конструкция?
Log.Invoke(new EventHandler(delegate
{
Log.AppendText("sent frame " + type + "\n"); //всё записываем, мы же снобы
}));
}
public abstract bool OnMessage(T entity, Telegram telegram);
public override bool handelMassage(Elsa enity, Telegram tele)
{
return(false);
}
private void senduMalabonitaMesagxo(Telegram.Bot.Types.Update update)
{
var abonitaMesagxo = "Vi estas malabonita de ĉi tia servo.";
botApi.SendTextMessage(update.Message.From.Id, abonitaMesagxo);
}
public void TelegramSend(Telegram t)
{
Console.WriteLine(t.ToString());
}
public override bool HandleMessage(Telegram message)
{
if (base.HandleMessage(message))
return true;
if (Owner.IsAlert)
{
if (message.TelegramType == TelegramType.Greeting)
{
if (message.IsResponse)
{
//This is a response message to a greeting message we sent to the sender.
Message.DispatchMessage(message.Receiver, message.Sender, TelegramType.MeetingRequest, false, Owner.Transform.position);
AddSubgoal(new Goal_Conversation(Owner, (AgentManager.Instance.GetAgent(message.Sender).CognitiveAgent.Transform.position - Owner.Transform.position), new List<int>() { message.Receiver, message.Sender }, true, Owner.DesiredTopic));
return true;
}
else
{
//This is a message from the sender, inviting us to a conversation.
//We've got a greeting request. We must respond and let the other agent know we are ready to talk.
Owner.IsAlert = false; //We don't want to respond to any other greetings for the moment.
Message.DispatchMessage(message.Receiver, message.Sender, TelegramType.Greeting, true);
return true;
}
}
else if (message.TelegramType == TelegramType.QuestTrade)
{
RemoveAllSubgoals();
CharacterDetails traderDetails = AgentManager.Instance.GetAgent(message.Sender);
AgentInventory traderInventory = (traderDetails.IsPlayer ? traderDetails.PlayerAgent.Inventory : traderDetails.CognitiveAgent.Inventory);
//Get equipped item from trader's inventory.
//See if cues of equipped item match the cue needed to satisfy the quest.
//If so, remove from one inventory and pass to the other.
ItemCue traderItem = traderInventory.GetEquippedItem();
if (traderItem != null)
{
for (int i = 0; i < traderItem.CueMarkers.Length; i++)
{
if (traderItem.CueMarkers[i] == Owner.QuestInfo.QuestUID)
{
Owner.Inventory.PickupItem(traderDetails.PlayerAgent.Inventory.LoseEquippedItem(), false);
Owner.CompleteQuest();
return true;
}
}
}
}
else if (message.TelegramType == TelegramType.DiscussEvent)
{
AddSubgoal(new Goal_Event(Owner));
return true;
}
}
if (message.TelegramType == TelegramType.MeetingRequest)
{
//The other agent got our response and so we have no agreed to meet and talk.
AddSubgoal(new Goal_Conversation(Owner, message.Location.Value - Owner.Transform.position, new List<int>() { message.Receiver, message.Sender }));
return true;
}
return false; //The message is unhandled by this goal.
}
public override bool OnMessage(Goblin entity, Telegram telegram)
{
return(false);
}
public abstract bool HandleMessage(Telegram msg);
private void Discharge(Telegram telegram)
{
telegram.reciever.HandleMassage(telegram);
}
//this method is utilized by DispatchMsg or DispatchDelayedMessages.
//This method calls the message handling member function of the receiving
//entity, pReceiver, with the newly created telegram
private void discharge(BaseGameEntity receiver, Telegram telegram)
{
receiver.HandleMessage(telegram);
}
public void Delete(Telegram telegramToDelete)
{
var origTelegram = GetById(telegramToDelete.Id);
_telegrams.Remove(origTelegram);
}
public override bool HandleMessage(Telegram telegram)
{
return(StateMachine.HandleMessage(telegram));
}
public static bool autorem(TGMessage msg, TGUser usr)
{
var chat = msg.chat;
var enable = XenforceRoot.getGroupConfigurationValue(chat, "autoban", true);
if (!enable)
{
return(false);
} // Not enabled.
var qsc = "SELECT * FROM xenf_autokick WHERE `group`={0} AND `user`={1}";
var rqry = string.Format(qsc, chat.id, usr.id);
MySql.Data.MySqlClient.MySqlDataReader datar;
SQLQueryInstance QueryInst;
var queryok = SQL.Query(rqry, out QueryInst);
if (QueryInst != null && QueryInst.reader.HasRows) // They've already been kicked before.
{
QueryInst.Finish();
return(false);
}
if (QueryInst != null)
{
QueryInst.Finish();
}
var UserID = usr.id;
var GroupID = msg.chat.id;
var user_name_full = usr.first_name + " " + usr.last_name;
var userscore = 500;
for (int i = 0; i < user_name_full.Length; i++)
{
var wtf = user_name_full[i];
if (wtf > 0xAF)
{
userscore += 5;
}
else if (wtf < 0x80)
{
userscore -= 3;
}
}
var picons = Telegram.getNumProfilePhotos(usr);
userscore -= picons * 45;
if (picons == 0)
{
userscore += 30;
}
if (userscore > 488)
{
Telegram.kickChatMember(chat, usr, 120);
if (XenforceRoot.getGroupConfigurationValue(chat, "announcekicks", 1) > 0)
{
msg.delete();
var msgr = msg.replySendMessage(user_name_full + " was automatically removed from the chat -- I think they're a bot.");
XenforceRoot.AddCleanupMessage(chat.id, msgr.message_id, 30);
var statement =
string.Format("INSERT INTO xenf_autokick (`group`,`user`,`when`,`why`) VALUES ({0},{1},{2},'{3}')",
GroupID,
UserID,
Helpers.getUnixTime(),
"Bot Score too high"
);
int ra = 0;
SQL.NonQuery(statement, out ra);
if (ra < 1)
{
Console.WriteLine("Creating autorem incident failed failed. No SQL rows affected.");
var cmsg = msg.replySendMessage("AutoremAddIncident() FAILED:\n\n Info:\n\n" + SQL.getLastError());
XenforceRoot.AddCleanupMessage(chat.id, cmsg.message_id, 120);
}
}
return(true);
}
return(false);
}
public void discharge(AIEntity receiver, Telegram msg)
{
if(receiver.handlesMessage(msg) ==false) {
;//throw error. - FILL OUT
}
}
public bool HandleMessage(Telegram message) //Handles messages that are passed to this agent, passing them into the current goal (which can then pass it to any sub-goals, to try and handle it).
{
if (CurrentGoal != null && CurrentGoal.HandleMessage(message))
return true;
return false;
}
public bool equals(Telegram other)
{
return((Math.Abs(dispatchTime - other.dispatchTime) < 0.001) &&
(sender == other.sender) &&
(messageType == other.messageType) &&
(receiver == other.receiver));
}
public bool greaterThan(Telegram other)
{
if(this == other)return true;
else return (dispatchTime < other.dispatchTime);
}
//AIEntity getEntity(double rec){
//return;
//}
public void dispatchMessage(double delay, int sender, int rec, int msg, object extra)
{
AIEntity ent = EntityManager.globalInstance().getEntity(rec);
Telegram t = new Telegram(delay,sender,rec,msg,extra);
if(delay <= 0.0)discharge(ent, t);
else {
priorityQueue.Add(t);
}
}
public TelegramUtil(Client client, Telegram.Bot.TelegramBotClient telegram, ISettings settings, Inventory inv)
{
instance = this;
_client = client;
_telegram = telegram;
_clientSettings = settings;
_inventory = inv;
Array values = Enum.GetValues(typeof(TelegramUtilInformationTopics));
foreach (TelegramUtilInformationTopics topic in values)
{
_informationDescription[topic] = TranslationHandler.GetString(_informationDescriptionIDs[topic], _informationDescriptionDefault[topic]);
_information[topic] = false;
}
DoLiveStats(settings);
DoInformation();
}
// 所有的实体entities都通过此方法实现消息传送
// 使用MessageDispatcher类
public abstract bool HandleMessage(Telegram msg);// { Debug.LogException(new System.Exception("No Overwrite Method")); return false; }
public override void HandleMessage(Telegram telegram)
{
if (telegram.Target == this)
{
callCoroutine();
}
}
/// <summary>
/// 消息传递
/// </summary>
/// <param name="pReceiver"></param>
/// <param name="telegram"></param>
void Discharge(BaseGameEntity pReceiver, Telegram telegram)
{
if (!pReceiver.HandleMessage(telegram))
{
//telegram could not be handled
//cout << "Message not handled";
}
}
