Merge branch 'master' into relay-valve

Author: cesarBLG

.github/release.yml

@@ -0,0 +1,22 @@
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+    authors:
+      - appveyor
+      - dependabot
+      - github-actions
+  categories:
+    - title: New Features
+      labels:
+        - enhancement
+    - title: Documentation and Localization
+      labels:
+        - documentation
+        - locales
+    - title: Bug Fixes
+      labels:
+        - bug
+    - title: Other Changes
+      labels:
+        - "*"

Docs/Policies.md

@@ -0,0 +1,41 @@
+# Project Policies
+
+This document records the policies currently in place under which the Project Team operates.
+
+## License
+
+The [GNU Public License](http://www.gnu.org/licenses/licenses.html) allows a user to use Open Rails in any way, except that you may not distribute software containing part of Open Rails without respecting the license terms. 
+
+## Liability
+
+Open Rails is intended for entertainment purposes only and, to avoid liability, is not suitable for professional applications.
+
+## Code Submissions
+
+[Code contributions](https://github.com/openrails/openrails/blob/master/Docs/Contributing.md) to our repository must be in Microsoft's C# language. An authorised developer may not change content in the official version of Open Rails without approval from another authorised developer.
+
+## Content Compatibility
+
+Open Rails will continue to maintain compatibility with content from previous official versions of Open Rails.
+
+## File Formats
+
+New types of content will use the JavaScript Object Notation (JSON).
+Existing types of content from previous official versions of Open Rails will continue to be loaded without change. 
+
+## Keyboard Assignments
+
+New key assignments should obey the following rules where that is possible.
+
+* Reserve digit keys for camera operations.
+* Reserve Fn keys for pop-up windows.
+* Reserve the Alt modifier for debug operations.
+* Reserve modifier+space (e.g. Ctrl+space) for future expansion using sequences of keys.
+
+Existing key assignments may not be changed without community discussion and approval of the Open Rails Management Team.
+
+## Crashes and Derailments
+
+Open Rails simulates emergency events which bring a train to a standstill, such as a derailment, and provides both a visual indication and a notification of the problem.
+
+Open Rails does not show rolling stock leaving the track due to crashes or derailments. We have many members from the rail industry who have spent their working lives preventing incidents that cause injuries and loss of life and we respect that point of view. 

Docs/Readme.md

@@ -19,9 +19,10 @@ Open Rails is a free train simulator supporting the world's largest range of dig
 * [Join the community](http://www.openrails.org/share/community/?utm_campaign=documentation&utm_source=readme&utm_medium=referral)
 * [Report bugs or offer suggestions](http://www.openrails.org/contribute/reporting-bugs/?utm_campaign=documentation&utm_source=readme&utm_medium=referral)
 * [Create content](http://www.openrails.org/contribute/building-models/?utm_campaign=documentation&utm_source=readme&utm_medium=referral)
+* [How to propose and submit work](Contributing.md)
 * [Write code](http://www.openrails.org/contribute/developing-code/?utm_campaign=documentation&utm_source=readme&utm_medium=referral)
 * [Join the team](http://www.openrails.org/contribute/joining-the-team/?utm_campaign=documentation&utm_source=readme&utm_medium=referral)
-* [More details](Contributing.md)
+
 
 ## Build status
 

Source/Contrib/TrackViewer/Drawing/DrawColors.cs

@@ -46,6 +46,7 @@ static class DrawColors
         public static ColorScheme colorsRoadsHotlight = new ColorScheme(HighlightType.Hotlight);
         public static ColorScheme colorsPathMain = new ColorScheme();
         public static ColorScheme colorsPathSiding = new ColorScheme();
+        public static ColorScheme colorsEvent = new ColorScheme();
 
         static ColorsGroupTrack trackGroupFlat = new ColorsGroupTrack();
         static ColorsGroupTrack roadTrackGroupFlat = new ColorsGroupTrack();
@@ -212,6 +213,11 @@ private static void SetItemColors(IPreferenceChanger preferenceChanger)
                 TrackViewer.catalog.GetString("Select speedpost color"));
             itemColors.Speedpost = itemColor;
 
+            itemColor = new ColorWithHighlights(Color.DarkGray, 40);
+            itemColor.MakeIntoUserPreference(preferenceChanger, "event",
+                TrackViewer.catalog.GetString("Select event color"));
+            itemColors.Event = itemColor;
+
             itemColor = new ColorWithHighlights(Color.Blue, 40);
             itemColors.CandidateNode = itemColor;
 
@@ -321,6 +327,7 @@ class ColorsGroupBasic {
         public ColorWithHighlights RoadCrossing { get; set; }
         public ColorWithHighlights Speedpost { get; set; }
         public ColorWithHighlights Siding { get; set; }
+        public ColorWithHighlights Event { get; set; }
 
         public ColorWithHighlights Text { get; set; }
         public ColorWithHighlights ClearWindowInset { get; set; }
@@ -362,6 +369,7 @@ class ColorScheme
         public Color RoadCrossing { get { return TrackItemColors.RoadCrossing.Colors[highlightType]; } }
         public Color Speedpost { get { return TrackItemColors.Speedpost.Colors[highlightType]; } }
         public Color Siding { get { return TrackItemColors.Siding.Colors[highlightType]; } }
+        public Color Event { get { return TrackItemColors.Event.Colors[highlightType]; } }
 
         public Color ActiveNode { get { return TrackItemColors.ActiveNode.Colors[highlightType]; } }
         public Color CandidateNode { get { return TrackItemColors.CandidateNode.Colors[highlightType]; } }

Source/Contrib/TrackViewer/Drawing/DrawTrackDB.cs

@@ -45,6 +45,10 @@ public class RouteData
         public RoadTrackDB RoadTrackDB { get; set; }
         /// <summary>The signal config file containing, for instance, the information to distinguish normal and non-normal signals</summary>
         public SignalConfigurationFile SigcfgFile { get; set; }
+        /// <summary>
+        /// <summary>Activity names</summary>
+        /// </summary>
+        public List<string> ActivityNames = new List<string> { };
 
         private string storedRoutePath;
         private Dictionary<uint, string> signalFileNames;
@@ -87,7 +91,7 @@ public RouteData(string routePath, MessageDelegate messageDelegate)
             }
             catch
             {
-            } 
+            }
 
             string ORfilepath = System.IO.Path.Combine(routePath, "OpenRails");
             if (File.Exists(ORfilepath + @"\sigcfg.dat"))
@@ -102,6 +106,72 @@ public RouteData(string routePath, MessageDelegate messageDelegate)
             {
                 //sigcfgFile = null; // default initialization
             }
+
+            // read the activity location events and store them in the TrackDB.TrItemTable
+
+            ActivityNames.Clear();
+            var directory = System.IO.Path.Combine(routePath, "ACTIVITIES");
+            if (System.IO.Directory.Exists(directory))
+            {
+                // counting
+                int cnt = 0;
+
+                foreach (var file in Directory.GetFiles(directory, "*.act"))
+                {
+                    try
+                    {
+                        var activityFile = new ActivityFile(file);
+                        Events events = activityFile.Tr_Activity.Tr_Activity_File.Events;
+                        if (events != null)
+                        {
+                            for (int i = 0; i < events.EventList.Count; i++)
+                            {
+                                if (events.EventList[i].GetType() == typeof(EventCategoryLocation))
+                                {
+                                    cnt++;
+                                }
+                            }
+                        }
+                    }
+                    catch { }
+                }
+
+                // adding
+                uint index = 0;
+                foreach (var file in Directory.GetFiles(directory, "*.act"))
+                {
+                    try
+                    {
+                        var activityFile = new ActivityFile(file);
+                        Events events = activityFile.Tr_Activity.Tr_Activity_File.Events;
+                        bool found = false;
+                        if (events != null)
+                        {
+                            for (int i = 0; i < events.EventList.Count; i++)
+                            {
+                                if (events.EventList[i].GetType() == typeof(EventCategoryLocation))
+                                {
+                                    EventCategoryLocation eventCategoryLocation = (EventCategoryLocation)events.EventList[i];
+                                    EventItem eventItem = new EventItem(
+                                        activityFile.Tr_Activity.Tr_Activity_Header.Name + ":" + eventCategoryLocation.Name,
+                                        eventCategoryLocation.Outcomes.DisplayMessage,
+                                        eventCategoryLocation.TileX, eventCategoryLocation.TileZ,
+                                        eventCategoryLocation.X, 0, eventCategoryLocation.Z,
+                                        index);
+                                    TrackDB.TrItemTable[index] = eventItem;
+                                    index++;
+                                    found = true;
+                                }
+                            }
+                        }
+                        if (found) {
+                            ActivityNames.Add(activityFile.Tr_Activity.Tr_Activity_Header.Name);
+                        }
+                    }
+                    catch { }
+                }
+
+            }
         }
 
         /// <summary>
@@ -176,6 +246,32 @@ public string GetSignalFilename(uint signalIndex)
         }
     }
 
+    /// <summary>
+    /// represents an Activity Location EventItem
+    /// </summary>
+    /// defined in this trackviewer file because I want to keep changes localized to the TrackViewer
+    
+    public class EventItem : TrItem
+    {
+        /// <summary>
+        /// Default constructor, no file parsing used
+        /// </summary>
+        public EventItem(string itemName, string briefing, int tileX, int tileZ, float x, float y, float z, uint trItemId)
+        {
+            // ItemType is trEMPTY on purpose
+            // so that Orts.Formats.Msts.TrItem.trItemType does not need a change
+            ItemType = trItemType.trEMPTY;
+            ItemName = itemName;
+            TileX = tileX;
+            TileZ = tileZ;
+            X = x;
+            Y = y;
+            Z = z;
+            TrItemId = trItemId;
+            SData2 = briefing;
+        }
+    }
+
     /// <summary>
     /// This is a big class where the drawing of everything in the track data base is done. 
     /// This means tracks themselves (meaning so-called vector nodes that contain a number of sections,

Source/Contrib/TrackViewer/Drawing/DrawableTrackItem.cs

@@ -70,6 +70,7 @@ public static DrawableTrackItem CreateDrawableTrItem(TrItem originalTrItem)
             if (originalTrItem is RoadLevelCrItem){ return new DrawableRoadLevelCrItem(originalTrItem); }
             if (originalTrItem is CarSpawnerItem) { return new DrawableCarSpawnerItem(originalTrItem); }
             if (originalTrItem is CrossoverItem)  { return new DrawableCrossoverItem(originalTrItem); }
+            if (originalTrItem is EventItem)      { return new DrawableEvent(originalTrItem); }
             return new DrawableEmptyItem(originalTrItem);
         }
 
@@ -605,4 +606,51 @@ internal override bool Draw(DrawArea drawArea, ColorScheme colors, bool drawAlwa
         }
     }
     #endregion
+
+    #region DrawableEvent
+    /// <summary>
+    /// Represents a drawable event
+    /// </summary>
+    class DrawableEvent : DrawableTrackItem
+    {
+        private string ItemName;
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="originalTrItem">The original track item that we are representing for drawing</param>
+        public DrawableEvent(TrItem originalTrItem)
+            : base(originalTrItem)
+        {
+            Description = "event";
+            ItemName = originalTrItem.ItemName;
+        }
+
+        /// <summary>
+        /// Draw an event
+        /// </summary>
+        /// <param name="drawArea">The area to draw upon</param>
+        /// <param name="colors">The colorscheme to use</param>
+        /// <param name="drawAlways">Do we need to draw anyway, independent of settings?</param>
+        internal override bool Draw(DrawArea drawArea, ColorScheme colors, bool drawAlways)
+        {
+            bool returnValue = false;
+            if (String.IsNullOrEmpty(Properties.Settings.Default.CurrentActivityName) ||
+                (ItemName.StartsWith(Properties.Settings.Default.CurrentActivityName + ":")))
+            {
+                if (Properties.Settings.Default.showEvents || drawAlways)
+                {
+                    drawArea.DrawTexture(WorldLocation, "disc", 6f, 0, colors.Event);
+                    returnValue = true;
+                }
+                if (Properties.Settings.Default.showEventNames || drawAlways)
+                {
+                    drawArea.DrawExpandingString(this.WorldLocation, ItemName);
+                    returnValue = true;
+                }
+            }
+            return returnValue;
+        }
+    }
+    #endregion
 }

Source/Contrib/TrackViewer/Editing/Charts/DrawPathChart.cs

@@ -161,7 +161,6 @@ private void OnPathChanged()
             }
             pathData.Update(trainpath);
             chartWindow.Draw();
-            chartWindow.SetTitle(pathEditor.CurrentTrainPath.PathName);
         }
 
         /// <summary>

Source/Contrib/TrackViewer/Editing/Charts/PathChartWindow.xaml.cs

@@ -91,15 +91,6 @@ public void Draw()
             }
 
         }
-
-        /// <summary>
-        /// Set the title of the window
-        /// </summary>
-        /// <param name="newTitle"></param>
-        public void SetTitle(string newTitle)
-        {
-            this.Title = newTitle;
-        }
         #endregion
 
         #region Window events