public bool DeleteMessage(MessageEntry entry)
{
// Delete the file and remove the entry
if (!File.Exists(entry.File))
return false;
var attributes = File.GetAttributes(entry.File);
try
{
if (attributes.HasFlag(FileAttributes.ReadOnly))
{
// remove read only attribute
File.SetAttributes(entry.File, attributes ^ FileAttributes.ReadOnly);
}
}
catch (UnauthorizedAccessException ex)
{
throw new UnauthorizedAccessException(
string.Format("Unable to remove read-only attribute on file '{0}'", entry.File),
ex);
}
File.Delete(entry.File);
return true;
}
public static byte[] GetMessage(
this MessageRepository messageRepository,
MessageEntry entry)
{
if (messageRepository == null) throw new ArgumentNullException("messageRepository");
if (entry == null) throw new ArgumentNullException("entry");
return messageRepository.GetMessage(entry.File);
}
public MimeMessageEntry(MessageEntry entry, MimeMessageLoader loader)
: base(entry.File)
{
IsSelected = entry.IsSelected;
loader.Get(this).Subscribe(m => { Subject = m.Subject; },
e =>
{
Subject = "Failure loading message: " + e.Message;
});
}
public object AddMessage(Message message, User user, object textObject)
{
var entry = new MessageEntry(message, user);
var afterEntry = textObject as MessageEntry;
if (afterEntry != null)
{
var index = _messages.IndexOf(afterEntry);
_messages.Insert(index, entry);
}
else
{
_messages.Add(entry);
}
return entry;
}
public void Run([NotNull] IRule[] rules, [NotNull] MessageEntry messageEntry)
{
if (rules == null)
{
throw new ArgumentNullException(nameof(rules));
}
if (messageEntry == null)
{
throw new ArgumentNullException(nameof(messageEntry));
}
foreach (IRule rule in rules.Where(_ => _.IsEnabled))
{
_dispatchRuleMethod.MakeGenericMethod(rule.GetType())
.Invoke(this, new object[] { rule, messageEntry });
}
}
protected override void DispatchEvent(MessageEntry rr_m)
{
switch (rr_m.MemberName)
{
case "ev1":
{
if (ev1 != null)
{
ev1();
}
return;
}
default:
break;
}
}
private void AddMessage(MessageEntry msg)
{
try
{
if (Messages.Count >= 500)
{
ClearMessages();
}
lock (CheckLock)
{
Messages.Add(msg);
int firstDisplayed = DataGridView_PacketsList.FirstDisplayedScrollingRowIndex;
int displayed = DataGridView_PacketsList.DisplayedRowCount(true);
int lastVisible = (firstDisplayed + displayed) - 1;
int lastIndex = DataGridView_PacketsList.RowCount - 1;
DataGridView_PacketsList.Rows.Add(DateTime.Now.ToString("HH:mm:ss"), msg.Origin.ToString(), msg.Id.ToString(), msg.Name);
foreach (DataGridViewCell cell in DataGridView_PacketsList.Rows[DataGridView_PacketsList.Rows.Count - 1].Cells)
{
switch (msg.Origin)
{
case ConnectionDestination.Client:
cell.Style.BackColor = Color.DeepSkyBlue;
break;
case ConnectionDestination.Server:
cell.Style.BackColor = Color.Salmon;
break;
}
}
if (lastVisible == lastIndex)
{
DataGridView_PacketsList.FirstDisplayedScrollingRowIndex = firstDisplayed + 1;
}
}
}
catch (Exception ex)
{
WindowManager.MainWindow.Logger.Error("(Debug) Can't add message -> " + ex.Message);
}
}
public override void PipePacketReceived(MessageEntry m, Endpoint e = null)
{
if (m.EntryType == MessageEntryType.PipePacket)
{
List <MessageElement> ack = new List <MessageElement>();
foreach (MessageElement me in m.elements)
{
try
{
int index = Int32.Parse(me.ElementName);
uint pnum;
if (DispatchPacket(me, pipeendpoints[e.LocalEndpoint][index], out pnum))
{
ack.Add(new MessageElement(me.ElementName, new uint[] { pnum }));
}
}
catch (Exception)
{
}
}
try
{
if (ack.Count > 0)
{
MessageEntry mack = new MessageEntry(MessageEntryType.PipePacketRet, m.MemberName);
mack.elements = ack;
skel.SendPipeMessage(mack, e, default(CancellationToken)).IgnoreResult();
}
}
catch { }
}
else if (m.EntryType == MessageEntryType.PipePacketRet)
{
try
{
foreach (MessageElement me in m.elements)
{
int index = Int32.Parse(me.ElementName);
DispatchPacketAck(me, pipeendpoints[e.LocalEndpoint][index]);
}
}
catch { }
}
}
public void PeriodicCleanupTask()
{
if ((DateTime.UtcNow - LastMessageReceivedTime).TotalMilliseconds > node.EndpointInactivityTimeout)
{
Close().IgnoreResult();
}
if (m_RemoteEndpoint != 0)
{
if ((DateTime.UtcNow - LastMessageSentTime).TotalMilliseconds > 60000)
{
MessageEntry m = new MessageEntry(MessageEntryType.ClientKeepAliveReq, "");
m.ServicePath = m_ServiceName;
m.RequestID = 0;
SendMessage(m, default(CancellationToken)).IgnoreResult();
}
}
}
protected override async Task SendPipePacket(T data, int index, uint packetnumber, bool requestack, Endpoint e = null, CancellationToken cancel = default(CancellationToken))
{
if (!pipeendpoints.ContainsKey(e.LocalEndpoint))
{
throw new Exception("Pipe has been disconnect");
}
if (!pipeendpoints[e.LocalEndpoint].ContainsKey(index))
{
throw new Exception("Pipe has been disconnected");
}
MessageElement me = PackPacket(data, index, packetnumber, requestack);
MessageEntry m = new MessageEntry(MessageEntryType.PipePacket, MemberName);
m.AddElement(me);
await skel.SendPipeMessage(m, e, cancel);
}
public void SendMessageToSever(string msg, string stackTrace)
{
MessageEntry entry = new MessageEntry(msg, stackTrace);
int hashCode = entry.GetHashCode();
if (!this._sentMessageHashes.Contains(hashCode))
{
this._sentMessageHashes.Add(hashCode);
if ((this._mainThreadID == Thread.CurrentThread.ManagedThreadId) && (Singleton <ApplicationManager> .Instance.applicationBehaviour != null))
{
Singleton <ApplicationManager> .Instance.applicationBehaviour.StartCoroutine(this.SendMessageToSeverCoroutine(entry));
}
else
{
this._sendToServerMessages.Add(entry);
}
}
}
public async Task <string> LogoutUser(CancellationToken cancel = default(CancellationToken))
{
if (!UserAuthenticated)
{
throw new AuthenticationException("User is not authenticated");
}
m_UserAuthenticated = false;
m_AuthenticatedUsername = null;
MessageEntry m = new MessageEntry(MessageEntryType.ClientSessionOpReq, "LogoutUser");
m.ServicePath = ServiceName;
m.AddElement("username", AuthenticatedUsername);
MessageEntry ret = await ProcessRequest(m, cancel);
return(ret.FindElement("return").CastData <string>());
}
public void DisposePreventsRestart()
{
var innerLogWriter = new TestLogWriter <MessageEntry>(SetupLog, false);
BackgroundMultiLogWriter backgroundMultiLogWriter;
IQueueEntryWriter <MessageEntry> queueEntryWriter;
SetupBackgroundLogWriter(innerLogWriter, out backgroundMultiLogWriter, out queueEntryWriter);
backgroundMultiLogWriter.Dispose(); // Blocks until the background thread exits
// After a Dispose(), BackgroundMultiLogWriter can't be re-used
Assert.Throws <ObjectDisposedException>(() => backgroundMultiLogWriter.Start());
// Logging doesn't throw, though
var msg = new MessageEntry("Logged while Dispose()ed - never logged.");
queueEntryWriter.Write(ref msg);
}
public void LoadMessageEntry(MessageEntry messageEntry)
{
_loadingDisposable?.Dispose();
var handleLoading = !IsLoading;
if (messageEntry == null)
{
// show empty...
DisplayMimeMessage(null);
if (handleLoading)
{
IsLoading = false;
}
}
else
{
if (handleLoading)
{
IsLoading = true;
}
// load and show it...
_loadingDisposable = _mimeMessageLoader.Get(messageEntry).ObserveOnDispatcher().Subscribe(m =>
{
DisplayMimeMessage(m);
if (handleLoading)
{
IsLoading = false;
}
},
e =>
{
var failureMessage =
MimeMessage.CreateFromMailMessage(MailMessageHelper.CreateFailureMailMessage(e.Message));
DisplayMimeMessage(failureMessage);
if (handleLoading)
{
IsLoading = false;
}
});
}
}
protected virtual void CheckEndpointCapabilityMessage(Message m)
{
uint capability = 0;
MessageEntry e;
Message ret = new Message();
ret.header = new MessageHeader();
ret.header.ReceiverNodeName = m.header.SenderNodeName;
ret.header.SenderNodeName = node.NodeName;
ret.header.ReceiverNodeID = m.header.SenderNodeID;
ret.header.ReceiverEndpoint = m.header.SenderEndpoint;
ret.header.SenderEndpoint = m.header.ReceiverEndpoint;
ret.header.SenderNodeID = node.NodeID;
try
{
if (m.entries.Count == 0)
{
throw new InvalidOperationException();
}
e = m.entries[0];
MessageEntry eret = ret.AddEntry(MessageEntryType.EndpointCheckCapabilityRet, m.entries[0].MemberName);
eret.RequestID = e.RequestID;
eret.ServicePath = e.ServicePath;
if (e.EntryType != MessageEntryType.EndpointCheckCapability)
{
throw new InvalidOperationException();
}
string name = e.MemberName;
capability = EndpointCapability(name);
eret.AddElement("return", capability);
}
catch
{
}
SendMessage(ret, default(CancellationToken)).IgnoreResult();
}
public async Task SendMessage(MessageEntry m, CancellationToken cancel)
{
//m.ServiceName = ServiceName;
if (!Connected)
{
throw new ConnectionException("Client has been disconnected");
}
Message mm = new Message();
mm.header = new MessageHeader();
mm.entries.Add(m);
LastMessageSentTime = DateTime.UtcNow;
await SendMessage(mm, cancel);
}
public void CanRestartBackgroundMultiLogWriter()
{
var innerLogWriter = new TestLogWriter <MessageEntry>(SetupLog, false);
BackgroundMultiLogWriter backgroundMultiLogWriter;
IQueueEntryWriter <MessageEntry> queueEntryWriter;
SetupBackgroundLogWriter(innerLogWriter, out backgroundMultiLogWriter, out queueEntryWriter);
// Re-starting shouldn't hurt anything
Assert.True(backgroundMultiLogWriter.IsStarted);
backgroundMultiLogWriter.Start();
queueEntryWriter.Start();
// Log some, then Stop
ExampleHelper.LogTestMessagesInParallel(queueEntryWriter, 8, 8, _testOutputHelper);
backgroundMultiLogWriter.Stop(); // Blocks until the background thread exits
Assert.False(innerLogWriter.IsStarted);
Assert.False(backgroundMultiLogWriter.IsStarted);
Assert.Equal(8 * 8, innerLogWriter.Count);
// After a Stop(), logging does nothing
var msg = new MessageEntry("Logged while stopped - never logged.");
queueEntryWriter.Write(ref msg);
// After a Stop(), BackgroundMultiLogWriter and it's contained logwriters can be restarted
backgroundMultiLogWriter.Start();
// Log some, then Dispose
ExampleHelper.LogTestMessagesInParallel(queueEntryWriter, 8, 8, _testOutputHelper);
backgroundMultiLogWriter.Dispose(); // Blocks until the background thread exits
Assert.False(innerLogWriter.IsStarted);
Assert.False(backgroundMultiLogWriter.IsStarted);
Assert.Equal(2 * 8 * 8, innerLogWriter.Count);
// After a Dispose(), BackgroundMultiLogWriter can't be re-used
Assert.Throws <ObjectDisposedException>(() => backgroundMultiLogWriter.Start());
// Entries can still be written, though
queueEntryWriter.Write(ref msg);
}
private void Worker(MessageEntry msg)
{
Trace.TraceInformation($"Received query. Data: {msg.ReceivedMessage.GetMessageContentString()}");
// throw new Exception("test exception");
msg.ResponseOk("MyQueryHanlder - ok!");
if (!string.IsNullOrEmpty(msg.ReceivedMessage.GetVia().GetLast().responseHandlerName))
{
if (!querySet1.Task.IsCompleted)
{
querySet1.SetResult(true); //by handler
}
}
else
{
if (!querySet2.Task.IsCompleted)
{
querySet2.SetResult(true); //by callback
}
}
}
private void DataGridView_PacketsList_CellClick(object sender, DataGridViewCellEventArgs e)
{
if (this.DataGridView_PacketsList.SelectedRows.Count <= 0)
{
return;
}
try
{
this.TreeView_InfosPacket.Nodes.Clear();
lock (this.CheckLock)
{
MessageEntry message = this.Messages[this.DataGridView_PacketsList.SelectedRows[0].Index];
this.ShowProperties((object)message.Message, this.TreeView_InfosPacket.Nodes);
this.RichTextBox_Data.Text = UserForm.ByteArrayToString(message.Data.Data);
}
}
catch (Exception ex)
{
}
}
public MessageGump(MessageEntry entry, Map map, Point3D loc) : base((640 - entry.Width) / 2, (480 - entry.Height) / 2)
{
int xLong = 0, yLat = 0;
int xMins = 0, yMins = 0;
bool xEast = false, ySouth = false;
string fmt;
if (Sextant.Format(loc, map, ref xLong, ref yLat, ref xMins, ref yMins, ref xEast, ref ySouth))
{
fmt = String.Format("{0}°{1}'{2},{3}°{4}'{5}", yLat, yMins, ySouth ? "S" : "N", xLong, xMins, xEast ? "E" : "W");
}
else
{
fmt = "?????";
}
AddPage(0);
AddBackground(0, 0, entry.Width, entry.Height, 2520);
AddHtml(38, 38, entry.Width - 83, entry.Height - 86, String.Format(entry.Message, fmt), false, false);
}
public override object GetCallbackFunction(uint rr_endpoint, string rr_membername)
{
switch (rr_membername)
{
case "cb2": {
return(new Func <double, double, CancellationToken, Task>(async delegate(double d1, double d2, CancellationToken rr_cancel) {
MessageEntry rr_mm = new MessageEntry(MessageEntryType.CallbackCallReq, "cb2");
rr_mm.ServicePath = m_ServicePath;
MessageElementUtil.AddMessageElement(rr_mm, MessageElementUtil.PackScalar <double>("d1", d1));
MessageElementUtil.AddMessageElement(rr_mm, MessageElementUtil.PackScalar <double>("d2", d2));
MessageEntry rr_mr = await RRContext.ProcessCallbackRequest(rr_mm, rr_endpoint, rr_cancel);
MessageElement rr_me = rr_mr.FindElement("return");
}));
}
default:
break;
}
throw new MemberNotFoundException("Member not found");
}
public void LogFailure(string message)
{
for (int i = 0; i < m_Failures.Count; ++i)
{
MessageEntry entry = (MessageEntry)m_Failures[i];
if (entry.m_Message == message)
{
++entry.m_Count;
return;
}
}
if (m_Failures.Count == 10)
{
return;
}
m_Failures.Add(new MessageEntry(message));
}
public void AddResponse(string message)
{
for (int i = 0; i < m_Responses.Count; ++i)
{
MessageEntry entry = m_Responses[i];
if (entry.m_Message == message)
{
++entry.m_Count;
return;
}
}
if (m_Responses.Count == 10)
{
return;
}
m_Responses.Add(new MessageEntry(message));
}
private void SaveMessages(MessageEntry entry)
{
try
{
DateTime now = DateTime.Now;
Console.WriteLine(now.ToString((IFormatProvider)CultureInfo.GetCultureInfo("fr-CA")));
string debugPath = Configuration.DebugPath;
now = DateTime.Now;
string str1 = now.ToString((IFormatProvider)CultureInfo.GetCultureInfo("fr-CA")).Replace(":", "-");
StreamWriter text = File.CreateText(debugPath + str1 + "_Logs.txt");
text.WriteLine(string.Format("ID={0} Name={1} Origin={2}", (object)entry.Id.ToString(), (object)entry.Name, (object)entry.Origin.ToString()));
foreach (FieldInfo field in entry.Message.GetType().GetFields())
{
string str2 = field.GetValue((object)entry.Message).ToString();
if (field.Name != "Id")
{
text.WriteLine(string.Format(" {0} = {1}", (object)field.Name, (object)str2));
}
if (str2.Contains("[]"))
{
int num = 0;
foreach (object msg in (IEnumerable)field.GetValue((object)entry.Message))
{
this.SaveObject(msg, text, 2);
++num;
}
}
else if (!str2.Contains("AmaknaCore"))
{
;
}
text.WriteLine();
}
text.Close();
Process.Start(Configuration.DebugPath);
}
catch (Exception ex)
{
int num = (int)MessageBox.Show(ex.Message);
}
}
public async Task <IBusConsumer> Consume <T>(Func <IServiceProvider, IEnumerable <T>, Task <IEnumerable <T> > > handle)
where T : IIdentifiable <string>
{
var queue = _conventions.Get <T>().Queue;
int itemsToConsume = _options.ItemsToConsume;
if (itemsToConsume <= 0)
{
throw new Exception("Items to consume is invalid, please configure a valid number.");
}
var entryMessages = new List <MessageEntry <T> >(itemsToConsume);
IEnumerable <MessageEntry <T> > messages;
do
{
messages = await _amazonSQSClient.ReceiveMessageAsync <T>(queue, 10);
entryMessages.AddRange(messages);
} while (entryMessages.Count < itemsToConsume && messages.Any());
var incomingMessages = entryMessages.Select(x => x.Message);
var results = await handle(_serviceProvider, incomingMessages);
var successMessageIds = new HashSet <string>(results.Select(x => x.Id));
IDictionary <string, MessageEntry <T> > entryMessageDictionary = entryMessages.ToDictionary(x => x.UniqueKey);
var succeededMessages = new List <MessageEntry <T> >(successMessageIds.Count());
foreach (var id in successMessageIds)
{
MessageEntry <T> message = entryMessageDictionary[id];
succeededMessages.Add(message);
}
await _amazonSQSClient.DeleteMessagesAsync(succeededMessages, queue);
return(this);
}
public override async Task <MessageEntry> CallFunction(MessageEntry rr_m)
{
string rr_ename = rr_m.MemberName;
MessageEntry rr_mr = new MessageEntry(MessageEntryType.FunctionCallRes, rr_ename);
switch (rr_ename)
{
case "add_val":
{
double v = (MessageElementUtil.UnpackScalar <double>(MessageElementUtil.FindElement(rr_m, "v")));
double rr_ret = await this.obj.add_val(v, default(CancellationToken));
rr_mr.AddElement(MessageElementUtil.PackScalar <double>("return", rr_ret));
break;
}
default:
throw new MemberNotFoundException("Member not found");
}
return(rr_mr);
}
private void AddMessage(MessageEntry msg)
{
try
{
if (this.Messages.Count >= 500)
{
this.ClearMessages();
}
lock (this.CheckLock)
{
this.Messages.Add(msg);
int scrollingRowIndex = this.DataGridView_PacketsList.FirstDisplayedScrollingRowIndex;
int num1 = this.DataGridView_PacketsList.DisplayedRowCount(true);
int num2 = scrollingRowIndex + num1 - 1;
int num3 = this.DataGridView_PacketsList.RowCount - 1;
this.DataGridView_PacketsList.Rows.Add((object)DateTime.Now.ToString("HH:mm:ss"), (object)msg.Origin.ToString(), (object)msg.Id.ToString(), (object)msg.Name);
foreach (DataGridViewCell cell in (BaseCollection)this.DataGridView_PacketsList.Rows[this.DataGridView_PacketsList.Rows.Count - 1].Cells)
{
switch (msg.Origin)
{
case MessageOriginEnum.Server:
cell.Style.BackColor = Color.Salmon;
break;
case MessageOriginEnum.Client:
cell.Style.BackColor = Color.DeepSkyBlue;
break;
}
}
if (num2 != num3)
{
return;
}
this.DataGridView_PacketsList.FirstDisplayedScrollingRowIndex = scrollingRowIndex + 1;
}
}
catch (Exception ex)
{
}
}
public MessageGump(MessageEntry entry, Map map, Point3D loc) : base(150, 50)
{
int xLong = 0, yLat = 0;
int xMins = 0, yMins = 0;
bool xEast = false, ySouth = false;
string fmt;
if (Sextant.Format(loc, map, ref xLong, ref yLat, ref xMins, ref yMins, ref xEast, ref ySouth))
{
fmt = $"{yLat}°{yMins}'{(ySouth ? "S" : "N")},{xLong}°{xMins}'{(xEast ? "E" : "W")}";
}
else
{
fmt = "?????";
}
AddPage(0);
AddBackground(0, 40, 350, 300, 2520);
/* This is a message hastily scribbled by a passenger aboard a sinking ship.
* While it is probably too late to save the passengers and crew,
* perhaps some treasure went down with the ship!
* The message gives the ship's last known sextant co-ordinates.
*/
AddHtmlLocalized(
30,
80,
285,
160,
1018326,
true,
true
);
AddHtml(35, 240, 230, 20, fmt);
AddButton(35, 265, 4005, 4007, 0);
AddHtmlLocalized(70, 265, 100, 20, 1011036); // OKAY
}
public async Task <string> AuthenticateUser(string username, object credentials, CancellationToken cancel = default(CancellationToken))
{
MessageEntry m = new MessageEntry(MessageEntryType.ClientSessionOpReq, "AuthenticateUser");
m.ServicePath = ServiceName;
m.AddElement("username", username);
if (credentials is Dictionary <string, object> )
{
m.AddElement("credentials", PackMapType <string, object>(credentials));
}
else if (credentials is MessageElement)
{
MessageElement mcredentials = (MessageElement)credentials;
mcredentials.ElementName = "credentials";
m.AddElement(mcredentials);
}
MessageEntry ret = await ProcessRequest(m, cancel);
m_AuthenticatedUsername = username;
m_UserAuthenticated = true;
return(ret.FindElement("return").CastData <string>());
}
async Task DispatchRuleAsync <TRule>(TRule rule, MessageEntry messageEntry, CancellationToken token)
where TRule : IRule
{
this._logger.Information(
"Running Rule Dispatch for Rule {Rule} on Message {@MessageEntry}",
rule,
messageEntry);
try
{
var ruleDispatcher = this._lifetimeScope.Resolve <IRuleDispatcher <TRule> >();
await ruleDispatcher.DispatchAsync(rule, messageEntry, token);
}
catch (Exception ex)
{
this._logger.Warning(
ex,
"Failure Dispatching Rule {Rule} for Message {@MessageEntry}",
rule,
messageEntry);
}
}
public void Publish <T>(T message)
{
var initiatorMessage = _consumingContext.Message;
var id = _idStrategy.ConvertFromProvider(_idStrategy.NewId());
var correlationId = initiatorMessage == null
? _idStrategy.ConvertFromProvider(_idStrategy.NewId())
: initiatorMessage.CorrelationId;
var entry = new MessageEntry
{
Body = message,
Id = id,
SourceId = initiatorMessage?.Id,
CorrelationId = correlationId,
TopicType = typeof(T)
};
_session.Add(entry);
}
NotifyPropertyMessage Convert(MessageEntry item)
{
if (item.Path == NotifyTextMessage.MessagePath)
{
var message = new NotifyTextMessage(item.MessageId, item.DateTime, AsMessageReference(item.Reference));
message.SetObject(item.Object);
message.SetStatus(MessageStatus.Success);
return(message);
}
else if (item.Path == NotifyImageMessage.MessagePath)
{
var message = new NotifyImageMessage(item.MessageId, item.DateTime, AsMessageReference(item.Reference));
var imageHash = item.Object;
message.ImageHash = imageHash;
message.SetStatus(MessageStatus.Success);
if (this.cache.TryGetCache(imageHash, out var info))
{
message.SetObject(info.FullName);
}
return(message);
}
return(default);
private void DataGridView_PacketsList_CellClick(object sender, DataGridViewCellEventArgs e)
{
if (DataGridView_PacketsList.SelectedRows.Count <= 0)
{
return;
}
try
{
TreeView_InfosPacket.Nodes.Clear();
lock (CheckLock)
{
MessageEntry message = Messages[DataGridView_PacketsList.SelectedRows[0].Index];
ShowProperties(message.Message, TreeView_InfosPacket.Nodes);
}
}
catch (Exception)
{
return;
}
}
void DispatchRule <TRule>(TRule rule, MessageEntry messageEntry)
where TRule : IRule
{
_logger.Information(
"Running Rule Dispatch for Rule {Rule} on Message {@MessageEntry}",
rule,
messageEntry);
try
{
var ruleDispatcher = _lifetimeScope.Resolve <IRuleDispatcher <TRule> >();
ruleDispatcher.Dispatch(rule, messageEntry);
}
catch (Exception ex)
{
_logger.Warning(
ex,
"Failure Dispatching Rule {Rule} for Message {@MessageEntry}",
rule,
messageEntry);
}
}
/// <summary>
/// Moved this section to a private member function as processOrders is getting bloated.
/// </summary>
/// <param name="RNG">Random number generator needed for this function, usually the one from SimEntity.</param>
/// <returns>Missiles that either hit or missed the target ship. leftovers can survive to get another target if able.</returns>
private void ProcessImpact(Random RNG)
{
MissilesDestroyed = Missiles.Count;
for (int loop = 0; loop < Missiles.Count; loop++)
{
ushort ToHit = 0;
if (Missiles[loop].target.ship.ShipsTaskGroup.CurrentSpeed == 1 || Missiles[loop].target.ship.ShipsTaskGroup.CurrentSpeed == 0)
ToHit = 100;
else
ToHit = (ushort)((Missiles[loop].missileDef.maxSpeed / (float)Missiles[loop].target.ship.ShipsTaskGroup.CurrentSpeed) * Missiles[loop].missileDef.manuever);
ushort HitChance = (ushort)RNG.Next(1, 100);
if (ToHit > HitChance)
{
/// <summary>
/// First test the ship itself for its ability to shoot down the missile.
/// </summary>
bool Intercept = Missiles[loop].target.ship.InterceptMissile(RNG, Missiles[loop]);
#warning Make order of interception a configuration option?
if (Intercept == false)
{
/// <summary>
/// Then test other nearby FCs.
/// </summary>
Intercept = PointDefense.FinalDefensiveFire(GameState.Instance.Factions, Missiles[loop], RNG);
}
/// <summary>
/// if the missile was intercepted then it obviously did not go on to hit the ship.
/// </summary>
if (Intercept == true)
{
String Entry = String.Format("Missile {0} #{1} in Missile Group {2} shot down by point blank defensive fire", Missiles[loop].Name, loop, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileMissed, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
}
else
{
String Entry = String.Format("Missile {0} #{1} in Missile Group {2} Hit {3} for {4} damage.", Missiles[loop].Name, loop, Name, Missiles[loop].target.ship.Name, Missiles[loop].missileDef.warhead);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileMissed, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
ushort Columns = Missiles[loop].target.ship.ShipArmor.armorDef.cNum;
ushort location = (ushort)RNG.Next(0, Columns);
///<summary>
///Missile damage type always? laser damage type if implemented will need to change this.
///</summary>
#warning Implement Missile Laser damage here
bool ShipDest = Missiles[loop].target.ship.OnDamaged(DamageTypeTN.Missile, (ushort)Missiles[loop].missileDef.warhead, location, Missiles[loop].firingShip);
/// <summary>
/// Handle ship destruction at the ship level, to inform all incoming missiles that they need a new target.
/// </summary>
if (ShipDest == true)
{
MissilesDestroyed = loop;
break;
}
}
}
else
{
String Entry = String.Format("Missile {0} #{1} in Missile Group {2} Missed.", Missiles[loop].Name, loop, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileMissed, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
}
}
}
/// <summary>
/// Do all the missiles in this group still have MFC tracking?
/// </summary>
public void CheckTracking()
{
/// <summary>
/// Tracking has already been lost, and all survivors here are on their own already.
/// Update, all missiles in an ordnance group are the same. so if 0 is here and fine all are.
/// </summary>
if (Missiles[0].onOwnSensors == true)
{
return;
}
if (Missiles[0].HasMFCTracking() == false)
{
if (!Missiles[0].SetOwnSensors())
{
String Entry = "N/A";
if (Missiles.Count > 1)
Entry = String.Format("{0}x {1} Missiles in Missile Group {2} lost tracking,have no onboard sensors and will self destruct.", Missiles.Count, Missiles[0].Name, Name);
else
Entry = String.Format("1x {0} Missile in Missile Group {1} lost tracking,has no onboard sensor and will self destruct.", Missiles[0].Name, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileLostTracking, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
MissilesDestroyed = Missiles.Count;
}
else
{
String Entry = "N/A";
if (Missiles.Count > 1)
Entry = String.Format("{0}x {1} Missiles in Missile Group {2} lost tracking and will switch to onboard sensors.", Missiles.Count, Missiles[0].Name, Name);
else
Entry = String.Format("1x {0} Missile in Missile Group {1} lost tracking and will switch to onboard sensors.", Missiles[0].Name, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileLostTracking, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
}
if (MissilesDestroyed != Missiles.Count)
{
CreateWaypointTarget();
}
}
}
/// <summary>
/// Missiles which have used up their fuel should be destroyed if they run out under the right circumstances.
/// All missiles are the same, so no need to loop through them.
/// </summary>
/// <param name="TimeSlice">Time advancement to check for missile fuel usage.</param>
public void CheckFuel(uint TimeSlice)
{
float hourPer = TimeSlice / 3600.0f;
Missiles[0].fuel = Missiles[0].fuel - (Missiles[0].missileDef.totalFuelConsumption * hourPer);
if (Missiles[0].fuel <= 0.0f)
{
String Entry = "N/A";
if (Missiles.Count > 1)
Entry = String.Format("{0}x {1} Missiles in Missile Group {2} have run out of fuel.", Missiles.Count, Missiles[0].Name, Name);
else
Entry = String.Format("1x {0} Missile in Missile Group {1} has run out of fuel.", Missiles[0].Name, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileOutOfFuel, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
/// <summary>
/// Mark all missiles for destruction, as they have all run out of fuel.
/// </summary>
MissilesDestroyed = Missiles.Count;
}
}
/// <summary>
/// Fire this MFC in point defense mode.
/// </summary>
/// <param name="TG">Taskgroup the MFC is in</param>
/// <param name="FiredFrom">Ship the MFC is on</param>
/// <param name="Target">Target of point defense fire.</param>
/// <param name="MissilesToFire">Number of missiles to fire at it</param>
/// <returns></returns>
public int FireWeaponsPD(TaskGroupTN TG, ShipTN FiredFrom, OrdnanceGroupTN Target, int MissilesToFire)
{
/// <summary>
/// simple stupid sanity check.
/// </summary>
if (MissilesToFire == 0)
{
return 0;
}
int LaunchCount = 0;
/// <summary>
/// Just a temporary variable for this function.
/// </summary>
BindingList<OrdnanceGroupTN> LocalMissileGroups = new BindingList<OrdnanceGroupTN>();
foreach (MissileLauncherTN LaunchTube in m_lLinkedWeapons) //int loop = 0; loop < LinkedWeapons.Count; loop++)
{
if (LaunchTube.isDestroyed == false && LaunchTube.loadTime == 0 && LaunchTube.loadedOrdnance != null)
{
if (FiredFrom.ShipOrdnance.ContainsKey(LaunchTube.loadedOrdnance) == true)
{
OrdnanceTN newMissile = new OrdnanceTN(this, LaunchTube.loadedOrdnance, FiredFrom);
/// <summary>
/// Point defense does not go by MFC targetting. have to add target here.
/// </summary>
newMissile.target = new TargetTN(Target);
LaunchCount++;
/// <summary>
/// Create a new missile group
/// </summary>
if (LocalMissileGroups.Count == 0)
{
OrdnanceGroupTN newMissileGroup = new OrdnanceGroupTN(TG, newMissile);
LocalMissileGroups.Add(newMissileGroup);
TG.TaskGroupFaction.MissileGroups.Add(newMissileGroup);
/// <summary>
/// Add this ordnance group to the ord groups targetting list for the intended target missile group.
/// This is only necessary here as Manually fired MFC missiles are connected to their MFC.
/// </summary>
Target.ordGroupsTargetting.Add(newMissileGroup);
}
/// <summary>
/// An existing missile group may be useable.
/// </summary>
else
{
bool foundGroup = false;
foreach (OrdnanceGroupTN OrdGroup in LocalMissileGroups)
{
/// <summary>
/// All Missile groups should be composed of just 1 type of missile for convienence.
if (OrdGroup.missiles[0].missileDef.Id == LaunchTube.loadedOrdnance.Id)
{
OrdGroup.AddMissile(newMissile);
foundGroup = true;
break;
}
}
/// <summary>
/// Have to create a new missile group after all.
/// </summary>
if (foundGroup == false)
{
OrdnanceGroupTN newMissileGroup = new OrdnanceGroupTN(TG, newMissile);
LocalMissileGroups.Add(newMissileGroup);
TG.TaskGroupFaction.MissileGroups.Add(newMissileGroup);
/// <summary>
/// Add this ordnance group to the ord groups targetting list for the intended target missile group.
/// This is only necessary here as Manually fired MFC missiles are connected to their MFC.
/// </summary>
Target.ordGroupsTargetting.Add(newMissileGroup);
}
}
/// <summary>
/// Decrement the loaded ordnance count, and remove the type entirely if this was the last one.
/// </summary>
FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] = FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] - 1;
if (FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] == 0)
{
FiredFrom.ShipOrdnance.Remove(LaunchTube.loadedOrdnance);
}
/// <summary>
/// Set the launch tube cooldown time as a missile was just fired from it.
/// </summary>
LaunchTube.loadTime = LaunchTube.missileLauncherDef.rateOfFire;
if (LaunchCount == MissilesToFire)
break;
}
else
{
String Msg = String.Format("No ordnance {0} on ship {1} is available for Launch Tube {2} in PD Mode", LaunchTube.Name, FiredFrom.Name, LaunchTube.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.FiringNoAvailableOrdnance, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
}
else if (LaunchTube.isDestroyed == true)
{
String Msg = String.Format("Destroyed launch tube {0} is still attached to {1}'s MFC in PD Mode", LaunchTube.Name, FiredFrom.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.Error, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
else if (LaunchTube.loadedOrdnance == null)
{
String Msg = String.Format("No loaded ordnance for launch tube {0} on ship {1} in PD Mode", LaunchTube.Name, FiredFrom.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.FiringNoLoadedOrdnance, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
}
return LaunchCount;
}
int? GetIndexOfMessage(MessageEntry entry)
{
if (entry == null)
throw new ArgumentNullException(nameof(entry));
int index = MessagesSorted.OfType<MessageEntry>().FindIndex(m => Equals(entry, m));
return index == -1 ? null : (int?)index;
}
public IObservable<MimeMessage> Get(MessageEntry messageEntry)
{
_logger.Verbose("Loading Message Entry {@MessageEntry}", messageEntry);
return Observable.Create<MimeMessage>(
o =>
{
// in case of multiple subscriptions...
var observer = Observer.Synchronize(o, true);
var disposable = new CancellationDisposable();
MimeMessage message = null;
try
{
message = MimeMessageCache.GetOrSet(
messageEntry.File,
() =>
{
_logger.Verbose(
"Getting Message Data from Cached Message Repository",
messageEntry);
var messageData = _messageRepository.GetMessage(messageEntry);
MimeMessage mimeMessage;
// wrap in a memorystream...
using (var ms = new MemoryStream(messageData))
{
_logger.Verbose(
"MimeMessage Load for {@MessageEntry}",
messageEntry);
mimeMessage = MimeMessage.Load(
ParserOptions.Default,
ms,
disposable.Token);
}
return mimeMessage;
},
m =>
{
var policy = new CacheItemPolicy
{
SlidingExpiration = TimeSpan.FromSeconds(10)
};
MimeMessageCache.Add(messageEntry.File, m, policy);
});
}
catch (OperationCanceledException)
{
// no need to respond...
}
catch (Exception ex)
{
_logger.Error(ex, "Exception Loading {@MessageEntry}", messageEntry);
observer.OnError(ex);
}
if (message != null)
{
observer.OnNext(message);
observer.OnCompleted();
}
return disposable;
}).SubscribeOn(TaskPoolScheduler.Default);
}
public CartGump( TreasureMap tmap, MessageEntry entry, Map map, Point2D loc ) : base( (640 - entry.Width) / 2, (480 - entry.Height) / 2 )
{
string fmtx;
string fmty;
Tmap = tmap;
fmtx = String.Format( xc.ToString() );
fmty = String.Format( yc.ToString() );
AddPage( 0 );
AddBackground( 0, 0, entry.Width, entry.Height, 2520 );
AddHtml( 38, 38, entry.Width - 83, entry.Height - 86, String.Format( "From what you can tell, the location of the treasure is at these coordinates." ), false, false );
AddHtml( 30, 120, 120, 30, fmtx, false, false );
AddHtml( 90, 120, 120, 90, fmty, false, false );
}
public MessageGump( MessageEntry entry, Map map, Point3D loc )
: base(150, 50)
{
int xLong = 0, yLat = 0;
int xMins = 0, yMins = 0;
bool xEast = false, ySouth = false;
string fmt;
if ( Sextant.Format( loc, map, ref xLong, ref yLat, ref xMins, ref yMins, ref xEast, ref ySouth ) )
fmt = String.Format( "{0}°{1}'{2},{3}°{4}'{5}", yLat, yMins, ySouth ? "S" : "N", xLong, xMins, xEast ? "E" : "W" );
else
fmt = "?????";
AddPage( 0 );
AddBackground( 0, 40, 350, 300, 2520 );
AddHtmlLocalized( 30, 80, 285, 160, 1018326, true, true ); /* This is a message hastily scribbled by a passenger aboard a sinking ship.
* While it is probably too late to save the passengers and crew,
* perhaps some treasure went down with the ship!
* The message gives the ship's last known sextant co-ordinates.
*/
AddHtml( 35, 240, 230, 20, fmt, false, false );
AddButton( 35, 265, 4005, 4007, 0, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 70, 265, 100, 20, 1011036, false, false ); // OKAY
}
private void TimerElapsed(object state)
{
try
{
Console.WriteLine("okbbb");
Logger.Debug("time Elapsed");
_timer.Change(999999, 999999);
var db = new Database("sms");
using (var conn = db.OpenConnection())
{
var sql = "select * from sms where RetryCount > 0 and (ReservateTime is null or ReservateTime < getdate()) and ExpiredTime > getdate() and state = 1";
var cmd = db.CreateCommand(sql, conn);
List<MessageEntry> msgs = new List<MessageEntry>();
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
MessageEntry msg = new MessageEntry();
msg.Mobile = reader.GetValue("Mobile", msg.Mobile);
msg.Message = reader.GetValue("Message", msg.Message);
msg.SmsId = reader.GetValue("SmsId", msg.SmsId);
if (string.IsNullOrWhiteSpace(msg.Message) || string.IsNullOrWhiteSpace(msg.Mobile))
continue;
msgs.Add(msg);
}
}
if (msgs.Count > 0)
try
{
BeginSend();
foreach (var msg in msgs)
{
try
{
OnSend(msg.Mobile, msg.Message);
var cmd2 = conn.CreateCommand();
cmd2.CommandText = "update sms set RetryCount =RetryCount -1, state = 10 where smsid = " + msg.SmsId;
cmd2.ExecuteNonQuery();
}
catch
{
var cmd2 = conn.CreateCommand();
cmd2.CommandText = "update sms set RetryCount =RetryCount -1 where smsid = " + msg.SmsId;
cmd2.ExecuteNonQuery();
throw;
}
}
}
finally
{
EndSend();
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
finally
{
Logger.Debug("time started");
_timer.Change(5000, 5000);
}
}
/// <summary>
/// Load existing messages from the file system
/// </summary>
private void LoadMessages()
{
string[] files = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.eml");
foreach (string file in files)
{
MessageEntry entry = new MessageEntry(file);
messagesList.Items.Add(entry);
}
}
private void deleteButton_Click(object sender, RoutedEventArgs e)
{
// Lock to prevent rapid clicking issues
lock (deleteLockObject)
{
Array messages = new MessageEntry[messagesList.SelectedItems.Count];
messagesList.SelectedItems.CopyTo(messages, 0);
// Capture index position first
int index = messagesList.SelectedIndex;
foreach (MessageEntry entry in messages)
{
// Delete the file and remove the entry
if (File.Exists(entry.File))
File.Delete(entry.File);
messagesList.Items.Remove(entry);
}
// If there are more than the index location, keep the same position in the list
if (messagesList.Items.Count > index)
messagesList.SelectedIndex = index;
// If there are fewer, move to the last one
else if (messagesList.Items.Count > 0)
messagesList.SelectedIndex = messagesList.Items.Count - 1;
}
}
/// <summary>
/// Add a newly received message and show the balloon notification
/// </summary>
private void AddNewMessage(MessageEntry entry)
{
// Add it to the list box
messagesList.Items.Add(entry);
// Show the notification
notification.ShowBalloonTip(5000, "", "New message received!", ToolTipIcon.Info);
}
/// <summary>
/// Process missile impact determines what happens when an AMM hits any other missile.
/// Hits destroy the target missile on a one for one basis, unless armor is present.
/// Misses consume the amm.
/// left over amms can survive to acquire another target if so able.
/// </summary>
/// <param name="RNG">the random number generator, typically the one in SimEntity</param>
/// <returns>missiles to destroy</returns>
private void ProcessMissileImpact(Random RNG)
{
MissilesDestroyed = Missiles.Count;
for (int loop = 0; loop < Missiles.Count; loop++)
{
ushort ToHit = 0;
if (Missiles[loop].target.missileGroup.missiles[0].missileDef.maxSpeed == 1 || Missiles[loop].target.missileGroup.missiles[0].missileDef.maxSpeed == 0)
ToHit = 100;
else
ToHit = (ushort)((Missiles[loop].missileDef.maxSpeed / (float)Missiles[loop].target.missileGroup.missiles[0].missileDef.maxSpeed) * Missiles[loop].missileDef.manuever);
ushort HitChance = (ushort)RNG.Next(1, 100);
if (ToHit >= HitChance)
{
/// <summary>
/// Check armour, it could be zero, in which case destruction will always occur.
/// Chance to Hit vs Armour = (Weapon Damage / (Missile Armour + Weapon Damage)) * 100%
/// </summary>
ushort ToDestroy;
if (Missiles[loop].target.missileGroup.missiles[0].missileDef.armor == 0)
ToDestroy = 100;
else
ToDestroy = (ushort)(Math.Round((Missiles[loop].missileDef.warhead / (Missiles[loop].target.missileGroup.missiles[0].missileDef.armor + Missiles[loop].missileDef.warhead))) * 100.0f);
ushort DestChance = (ushort)RNG.Next(1, 100);
if (ToDestroy >= DestChance)
{
String Entry = String.Format("Missile {0} #{1} in Missile Group {2} Intercepted an enemy missile and destroyed it.", Missiles[loop].Name, loop, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileHit, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
/// <summary>
/// Destroy a missile.
/// </summary>
Missiles[loop].target.missileGroup.missilesDestroyed = Missiles[loop].target.missileGroup.missilesDestroyed + 1;
}
else
{
String Entry = String.Format("Missile {0} #{1} in Missile Group {2} Intercepted an enemy missile and failed to destroyed it.", Missiles[loop].Name, loop, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileHit, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
}
/// <summary>
/// Handle ordnance group destruction somewhere.
/// </summary>
if (Missiles[loop].target.missileGroup.missilesDestroyed == Missiles[0].target.missileGroup.missiles.Count)
{
MissilesDestroyed = loop;
break;
}
}
else
{
String Entry = String.Format("Missile {0} #{1} in Missile Group {2} Missed.", Missiles[loop].Name, loop, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileMissed, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
}
}
}
public NewMessageEvent(MessageEntry newMessage)
{
NewMessage = newMessage;
}
/// <summary>
/// Handle the case of a missile group hitting a planet.
/// </summary>
/// <param name="RNG"></param>
private void ProcessPopulationImpact(Random RNG)
{
MissilesDestroyed = Missiles.Count;
for (int loop = 0; loop < Missiles.Count; loop++)
{
/// <summary>
/// Is this planet defended by any point defense?
/// </summary>
bool Intercept = PointDefense.FinalDefensiveFire(GameState.Instance.Factions, Missiles[loop], RNG);
/// <summary>
/// Either the missiles will be intercepted or they will strike the planet.
/// </summary>
if (Intercept == true)
{
String Entry = String.Format("Missile {0} #{1} in Missile Group {2} shot down by point blank defensive fire", Missiles[loop].Name, loop, Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileMissed, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
}
else
{
String Entry = String.Format("Missile {0} #{1} in Missile Group {2} Hit {3}", Missiles[loop].Name, loop, Name, Missiles[loop].target.pop.Name);
MessageEntry Msg = new MessageEntry(MessageEntry.MessageType.MissileMissed, Contact.Position.System, Contact, GameState.Instance.GameDateTime,
GameState.Instance.LastTimestep, Entry);
OrdnanceGroupFaction.MessageLog.Add(Msg);
///<summary>
///Missile damage type always? laser damage type if implemented will need to change this.
///PopDamaged is also currently unused.
///</summary>
#warning Implement Missile Laser damage here
bool PopDamaged = Missiles[loop].target.pop.OnDamaged(DamageTypeTN.Missile, (ushort)Missiles[loop].missileDef.warhead, Missiles[loop].firingShip, Missiles[loop].missileDef.radValue);
}
}
}
public override void ViewDidLoad()
{
base.ViewDidLoad( );
// setup the table view and general background view colors
SeriesTable = new UITableView( );
SeriesTable.Layer.AnchorPoint = CGPoint.Empty;
SeriesTable.BackgroundColor = Rock.Mobile.UI.Util.GetUIColor( ControlStylingConfig.BackgroundColor );
SeriesTable.SeparatorStyle = UITableViewCellSeparatorStyle.None;
View.AddSubview( SeriesTable );
// setup the messages list
Messages = new List<MessageEntry>();
TableSource source = new TableSource( this, Messages, Series );
SeriesTable.Source = source;
SeriesTable.Delegate = new TableViewDelegate( source, Task.NavToolbar );
// log the series they tapped on.
MessageAnalytic.Instance.Trigger( MessageAnalytic.BrowseSeries, Series.Name );
IsVisible = true;
for ( int i = 0; i < Series.Messages.Count; i++ )
{
MessageEntry messageEntry = new MessageEntry();
Messages.Add( messageEntry );
messageEntry.Message = Series.Messages[ i ];
}
// do we have the real image?
if( TryLoadImage( NotesTask.FormatBillboardImageName( Series.Name ) ) == false )
{
// no, so use a placeholder and request the actual image
SeriesBillboard = new UIImage( NSBundle.MainBundle.BundlePath + "/" + PrivateGeneralConfig.NewsDetailsPlaceholder );
// request!
FileCache.Instance.DownloadFileToCache( Series.BillboardUrl, NotesTask.FormatBillboardImageName( Series.Name ),
delegate
{
Rock.Mobile.Threading.Util.PerformOnUIThread(
delegate
{
if( IsVisible == true )
{
TryLoadImage( NotesTask.FormatBillboardImageName( Series.Name ) );
}
});
} );
}
}
void AddNewMessage(MessageEntry entry)
{
var observable = _mimeMessageLoader.Get(entry);
observable.ObserveOnDispatcher().Subscribe(
message =>
{
_publishEvent.Publish(
new ShowBallonTip(
3500,
"New Message Received",
$"From: {message.From.ToString().Truncate(50)}\r\nSubject: {message.Subject.Truncate(50)}",
ToolTipIcon.Info));
// Add it to the list box
ClearSelected();
entry.IsSelected = true;
Messages.Add(new MimeMessageEntry(entry, _mimeMessageLoader));
},
e =>
{
// NOOP
});
}
public TreasureMessageGump(TreasureMessage tmessage, MessageEntry entry, Map map, Point2D loc)
: base((640 - entry.Width) / 2, (480 - entry.Height) / 2)
{
string fmtx;
string fmty;
Tmessage = tmessage;
fmtx = String.Format(xc.ToString());
fmty = String.Format(yc.ToString());
AddPage(0);
AddBackground(0, 0, entry.Width, entry.Height, 2520);
switch (Utility.Random(4))
{
case 0: AddHtml(38, 38, entry.Width - 83, entry.Height - 86, String.Format("I cannot find a way home, my friend. I am sending you this message in hopes you will come to my aid. Here are my coordinates."), false, false); break;
case 1: AddHtml(38, 38, entry.Width - 83, entry.Height - 86, String.Format("My love, I've been set upon by evil creatures and I do not think I will survive. I am sorry... I've sent my coordinates in hope..."), false, false); break;
case 2: AddHtml(38, 38, entry.Width - 83, entry.Height - 86, String.Format("I have found it! It was difficult, but I was victorious. Now, I must sleep in the forest at these coordinates."), false, false); break;
case 3: AddHtml(38, 38, entry.Width - 83, entry.Height - 86, String.Format("Mother, I am coming home and I've made a friend. He's a winged monkey named Durt. He said we need to take a detour along these coordinates."), false, false); break;
}
AddHtml(50, 150, 150, 50, fmtx, false, false);
AddHtml(100, 150, 150, 100, fmty, false, false);
}
public MessageGump( MessageEntry entry, Map map, Point3D loc ) : base( (640 - entry.Width) / 2, (480 - entry.Height) / 2 )
{
int xLong = 0, yLat = 0;
int xMins = 0, yMins = 0;
bool xEast = false, ySouth = false;
string fmt;
if ( Sextant.Format( loc, map, ref xLong, ref yLat, ref xMins, ref yMins, ref xEast, ref ySouth ) )
fmt = String.Format( "{0}°{1}'{2},{3}°{4}'{5}", yLat, yMins, ySouth ? "S" : "N", xLong, xMins, xEast ? "E" : "W" );
else
fmt = "?????";
AddPage( 0 );
AddBackground( 0, 0, entry.Width, entry.Height, 2520 );
AddHtml( 38, 38, entry.Width - 83, entry.Height - 86, String.Format( entry.Message, fmt ), false, false );
}
/// <summary>
/// Fire Weapons spawns new missiles groups or adds missiles to existing ones.
/// </summary>
/// <param name="TG">Taskgroup this MFC is in.</param>
/// <param name="FiredFrom">Ship these missiles were fired from.</param>
/// <returns>If missiles were fired at all from this MFC. true = atleast 1 missile(and therefore missile group, false = no missiles.</returns>
public bool FireWeapons(TaskGroupTN TG, ShipTN FiredFrom)
{
bool retv = false;
if (m_oTarget != null)
{
/// <summary>
/// Just a temporary variable for this function.
/// </summary>
BindingList<OrdnanceGroupTN> LocalMissileGroups = new BindingList<OrdnanceGroupTN>();
foreach (MissileLauncherTN LaunchTube in m_lLinkedWeapons)
{
if (LaunchTube.isDestroyed == false && LaunchTube.loadTime == 0 && LaunchTube.loadedOrdnance != null)
{
if (FiredFrom.ShipOrdnance.ContainsKey(LaunchTube.loadedOrdnance) == true)
{
OrdnanceTN newMissile = new OrdnanceTN(this, LaunchTube.loadedOrdnance, FiredFrom);
/// <summary>
/// Create a new missile group
/// </summary>
if (LocalMissileGroups.Count == 0)
{
OrdnanceGroupTN newMissileGroup = new OrdnanceGroupTN(TG, newMissile);
LocalMissileGroups.Add(newMissileGroup);
TG.TaskGroupFaction.MissileGroups.Add(newMissileGroup);
}
/// <summary>
/// An existing missile group may be useable.
/// </summary>
else
{
bool foundGroup = false;
foreach (OrdnanceGroupTN OrdGroup in LocalMissileGroups)
{
/// <summary>
/// All Missile groups should be composed of just 1 type of missile for convienence.
if (OrdGroup.missiles[0].missileDef.Id == LaunchTube.loadedOrdnance.Id)
{
OrdGroup.AddMissile(newMissile);
foundGroup = true;
break;
}
}
/// <summary>
/// Have to create a new missile group after all.
/// </summary>
if (foundGroup == false)
{
OrdnanceGroupTN newMissileGroup = new OrdnanceGroupTN(TG, newMissile);
LocalMissileGroups.Add(newMissileGroup);
TG.TaskGroupFaction.MissileGroups.Add(newMissileGroup);
}
}
/// <summary>
/// Decrement the loaded ordnance count, and remove the type entirely if this was the last one.
/// </summary>
FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] = FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] - 1;
if (FiredFrom.ShipOrdnance[LaunchTube.loadedOrdnance] == 0)
{
FiredFrom.ShipOrdnance.Remove(LaunchTube.loadedOrdnance);
}
/// <summary>
/// Set the launch tube cooldown time as a missile was just fired from it.
/// </summary>
LaunchTube.loadTime = LaunchTube.missileLauncherDef.rateOfFire;
/// <summary>
/// return that a missile was launched.
/// </summary>
retv = true;
}
else
{
String Msg = String.Format("No ordnance {0} on ship {1} is available for Launch Tube {2}", LaunchTube.Name, FiredFrom.Name, LaunchTube.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.FiringNoAvailableOrdnance, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
}
else if (LaunchTube.isDestroyed == true)
{
String Msg = String.Format("Destroyed launch tube {0} is still attached to {1}'s MFC", LaunchTube.Name, FiredFrom.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.Error, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
else if (LaunchTube.loadedOrdnance == null)
{
String Msg = String.Format("No loaded ordnance for launch tube {0} on ship {1}", LaunchTube.Name, FiredFrom.Name);
MessageEntry newMessage = new MessageEntry(MessageEntry.MessageType.FiringNoLoadedOrdnance, TG.Contact.Position.System, TG.Contact,
GameState.Instance.GameDateTime, GameState.Instance.LastTimestep, Msg);
TG.TaskGroupFaction.MessageLog.Add(newMessage);
}
}
return retv;
}
else
{
return false;
}
}
