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; } }