├── LaMulana2Randomizer
    ├── Seed
    │   └── spoilers.json
    ├── LaMulana2.ico
    ├── Monomod
    │   ├── MonoMod.exe
    │   ├── Mono.Cecil.dll
    │   ├── Mono.Cecil.Mdb.dll
    │   ├── Mono.Cecil.Pdb.dll
    │   ├── MonoMod.Utils.dll
    │   └── Mono.Cecil.Rocks.dll
    ├── packages.config
    ├── App.xaml.cs
    ├── UI
    │   ├── MainWindow.xaml.cs
    │   ├── EnumBooleanConverter.cs
    │   ├── ProgressDialog.xaml.cs
    │   ├── IntRangRules.cs
    │   └── ProgressDialog.xaml
    ├── App.xaml
    ├── Utils
    │   ├── Shuffle.cs
    │   ├── Logger.cs
    │   └── FileUtils.cs
    ├── Extensions
    │   └── StringExtensions.cs
    ├── RandomiserException.cs
    ├── BindableBase.cs
    ├── Item.cs
    ├── RelayCommand.cs
    ├── SpoilerLog.cs
    ├── LogicParsing
    │   ├── Logic.cs
    │   ├── ShuntingYard.cs
    │   ├── LogicTree.cs
    │   └── Tokeniser.cs
    ├── Area.cs
    ├── App.config
    ├── ViewModels
    │   ├── ProgressDialogViewModel.cs
    │   └── MainViewModel.cs
    ├── Properties
    │   ├── AssemblyInfo.cs
    │   ├── Resources.Designer.cs
    │   └── Resources.resx
    ├── Location.cs
    ├── Exit.cs
    ├── ItemPool.cs
    └── LaMulana2Randomizer.csproj
├── LM2RandomiserShared
    ├── Version.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── ExitID.cs
    ├── AreaID.cs
    ├── LaMulana2RandomizerShared.csproj
    ├── ItemID.cs
    └── LocationID.cs
├── Assembly-CSharp
    ├── Patches
    │   ├── TrapFloor.cs
    │   ├── MenuSystem.cs
    │   ├── L2SystemCore.cs
    │   ├── HolyTabretScript.cs
    │   ├── TreasureBoxScript.cs
    │   ├── EventItemScript.cs
    │   ├── CostumeScript.cs
    │   ├── ItemPotScript.cs
    │   ├── Status.cs
    │   ├── SeihaiMenu.cs
    │   ├── L2FlagSystem.cs
    │   ├── ItemDialog.cs
    │   └── ShopScript.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── FakeItem.cs
    ├── HotSpring.cs
    ├── StartDB.cs
    ├── ItemTracker.cs
    ├── DevUI.cs
    ├── Assembly-CSharp.csproj
    └── ExitDB.cs
├── README.md
├── LaMulana2Randomizer.sln
└── .gitignore


/LaMulana2Randomizer/Seed/spoilers.json:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/LaMulana2.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Coookie93/LaMulana2Randomizer/HEAD/LaMulana2Randomizer/LaMulana2.ico


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Monomod/MonoMod.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Coookie93/LaMulana2Randomizer/HEAD/LaMulana2Randomizer/Monomod/MonoMod.exe


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Monomod/Mono.Cecil.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Coookie93/LaMulana2Randomizer/HEAD/LaMulana2Randomizer/Monomod/Mono.Cecil.dll


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Monomod/Mono.Cecil.Mdb.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Coookie93/LaMulana2Randomizer/HEAD/LaMulana2Randomizer/Monomod/Mono.Cecil.Mdb.dll


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Monomod/Mono.Cecil.Pdb.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Coookie93/LaMulana2Randomizer/HEAD/LaMulana2Randomizer/Monomod/Mono.Cecil.Pdb.dll


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Monomod/MonoMod.Utils.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Coookie93/LaMulana2Randomizer/HEAD/LaMulana2Randomizer/Monomod/MonoMod.Utils.dll


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Monomod/Mono.Cecil.Rocks.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Coookie93/LaMulana2Randomizer/HEAD/LaMulana2Randomizer/Monomod/Mono.Cecil.Rocks.dll


--------------------------------------------------------------------------------
/LaMulana2Randomizer/packages.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <packages>
3 |   <package id="Newtonsoft.Json" version="13.0.2" targetFramework="net472" />
4 | </packages>


--------------------------------------------------------------------------------
/LM2RandomiserShared/Version.cs:
--------------------------------------------------------------------------------
1 | namespace LaMulana2RandomizerShared
2 | {
3 |     public static class Version
4 |     {
5 |         public static string version = "2.2.4";
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows;
 2 | 
 3 | namespace LaMulana2Randomizer
 4 | {
 5 |     /// <summary>
 6 |     /// Interaction logic for App.xaml
 7 |     /// </summary>
 8 |     public partial class App : Application
 9 |     {
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/UI/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows;
 2 | 
 3 | namespace LaMulana2Randomizer.UI
 4 | {
 5 |     public partial class MainWindow : Window
 6 |     {
 7 |         public MainWindow()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/TrapFloor.cs:
--------------------------------------------------------------------------------
 1 | using MonoMod;
 2 | 
 3 | namespace LM2RandomiserMod.Patches
 4 | {
 5 |     [MonoModPatch("global::TrapFloor")]
 6 |     public class patched_TrapFloor : global::TrapFloor
 7 |     {
 8 |         public float whalf;
 9 |         public float width;
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/App.xaml:
--------------------------------------------------------------------------------
 1 | <Application x:Class="LaMulana2Randomizer.App"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |              xmlns:local="clr-namespace:LaMulana2Randomizer"
 5 |              StartupUri="UI/MainWindow.xaml">
 6 |     <Application.Resources>
 7 |          
 8 |     </Application.Resources>
 9 | </Application>
10 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Utils/Shuffle.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace LaMulana2Randomizer.Utils
 5 | {
 6 |     public abstract class Shuffle
 7 |     {
 8 |         public static List<T> FisherYates<T>(List<T> list, Random random)
 9 |         {
10 |             int max = list.Count;
11 |             for (int i = 0; i < max; i++)
12 |             {
13 |                 int r = i + random.Next(max - i);
14 |                 T temp = list[r];
15 |                 list[r] = list[i];
16 |                 list[i] = temp;
17 |             }
18 |             return list;
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Extensions/StringExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | 
 4 | namespace LaMulana2Randomizer.ExtensionMethods
 5 | {
 6 |     public static class StringExtensions
 7 |     {
 8 |         public static string RemoveWhitespace(this string str)
 9 |         {
10 |             return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
11 |         }
12 | 
13 |         public static IEnumerable<string> Chunk(this string str, int chunkSize)
14 |         {
15 |             for (int i = 0; i < str.Length; i += chunkSize)
16 |                 yield return str.Substring(i, Math.Min(chunkSize, str.Length - i));
17 |         }
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/RandomiserException.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace LaMulana2Randomizer
 4 | {
 5 |     public class RandomiserException : Exception
 6 |     {
 7 |         public RandomiserException(string message) : base(message) { }
 8 |     }
 9 | 
10 |     public class LogicParsingExcpetion : RandomiserException
11 |     {
12 |         public LogicParsingExcpetion(string message) : base(message) { }
13 |     }
14 | 
15 |     public class InvalidLocationException : RandomiserException
16 |     {
17 |         public InvalidLocationException(string message) : base(message) { }
18 |     }
19 | 
20 |     public class InvalidAreaException : RandomiserException
21 |     {
22 |         public InvalidAreaException(string message) : base(message) { }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/BindableBase.cs:
--------------------------------------------------------------------------------
 1 | using System.ComponentModel;
 2 | using System.Runtime.CompilerServices;
 3 | 
 4 | namespace LaMulana2Randomizer
 5 | {
 6 |     public abstract class BindableBase : INotifyPropertyChanged
 7 |     {
 8 |         public event PropertyChangedEventHandler PropertyChanged;
 9 | 
10 |         protected virtual void RaisePropertyChanged([CallerMemberName] string propertyName = null)
11 |         {
12 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
13 |         }
14 | 
15 |         protected virtual void Set<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
16 |         {
17 |             if (Equals(field, value)) return;
18 | 
19 |             field = value;
20 |             RaisePropertyChanged(propertyName);
21 |         }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/UI/EnumBooleanConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows.Data;
 3 | 
 4 | namespace LaMulana2Randomizer.UI
 5 | {
 6 |     [ValueConversion(typeof(Enum), typeof(bool))]
 7 |     public class EnumBooleanConverter : IValueConverter
 8 |     {
 9 |         public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
10 |         {
11 |             if (value == null)
12 |             {
13 |                 return false;
14 |             }
15 |             return value.Equals(parameter);
16 |         }
17 | 
18 |         public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
19 |         {
20 |             return value.Equals(true) ? parameter : Binding.DoNothing;
21 |         }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Item.cs:
--------------------------------------------------------------------------------
 1 | using Newtonsoft.Json;
 2 | using LaMulana2RandomizerShared;
 3 | 
 4 | namespace LaMulana2Randomizer
 5 | {
 6 |     public class Item
 7 |     {
 8 |         public string Name { get; private set; }
 9 |         public bool IsRequired { get; private set; }
10 | 
11 |         [JsonIgnore]
12 |         public ItemID ID { get; private set; }
13 | 
14 |         public int PriceMultiplier;
15 | 
16 |         [JsonConstructor]
17 |         public Item(string name, ItemID id, bool isRequired = false)
18 |         {
19 |             Name = name;
20 |             ID = id;
21 |             IsRequired = isRequired;
22 |             PriceMultiplier = 10;
23 |         }
24 | 
25 |         public Item DeepCopy()
26 |         {
27 |             Item result = (Item)MemberwiseClone();
28 |             result.Name = string.Copy(Name);
29 |             return result;
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/RelayCommand.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows.Input;
 3 | 
 4 | namespace LaMulana2Randomizer
 5 | {
 6 |     public class RelayCommand : ICommand
 7 |     {
 8 |         private readonly Predicate<object> _canExecute;
 9 |         private readonly Action<object> _execute;
10 | 
11 |         public RelayCommand(Predicate<object> canExecute, Action<object> execute)
12 |         {
13 |             _canExecute = canExecute;
14 |             _execute = execute;
15 |         }
16 | 
17 |         public event EventHandler CanExecuteChanged {
18 |             add { CommandManager.RequerySuggested += value; }
19 |             remove { CommandManager.RequerySuggested -= value; }
20 |         }
21 | 
22 |         public bool CanExecute(object parameter)
23 |         {
24 |             return _canExecute(parameter);
25 |         }
26 | 
27 |         public void Execute(object parameter)
28 |         {
29 |             _execute(parameter);
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Utils/Logger.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using System.Windows;
 4 | 
 5 | namespace LaMulana2Randomizer.Utils
 6 | {
 7 |     public static class Logger
 8 |     {
 9 |         private static StreamWriter sw;
10 | 
11 |         public static void Log(string message)
12 |         {
13 |             try
14 |             {
15 |                 if(sw == null)
16 |                     sw = new StreamWriter("log.txt", true);
17 | 
18 |                 sw.WriteLine(message);
19 |             }
20 |             catch(Exception ex)
21 |             {
22 |                 MessageBox.Show($"Error with logging, {ex.Message}");
23 |             }
24 |         }
25 | 
26 |         public static void Flush()
27 |         {
28 |             if (sw != null)
29 |                 sw.Flush();
30 |         }
31 | 
32 |         public static void LogAndFlush(string message)
33 |         {
34 |             Log(message);
35 |             Flush();
36 |         }
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/SpoilerLog.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using Newtonsoft.Json;
 3 | 
 4 | namespace LaMulana2Randomizer
 5 | {
 6 |     public class SpoilerLog
 7 |     {
 8 |         public int Seed;
 9 | 
10 |         [JsonProperty("Settings String")]
11 |         public string SettingsString;
12 | 
13 |         public Settings Settings;
14 | 
15 |         [JsonProperty("Starting Area")]
16 |         public string StartingArea;
17 | 
18 |         [JsonProperty("Starting Weapon")]
19 |         public string StartingWeapon;
20 | 
21 |         [JsonProperty("Starting Items")]
22 |         public List<string> StartingItems;
23 | 
24 |         [JsonProperty("Cursed Locations")]
25 |         public List<string> CursedLocations;
26 | 
27 |         public SortedList<string, string> Entrances;
28 | 
29 |         [JsonProperty("Soul Gates")]
30 |         public SortedList<int, SortedList<string, string>> SoulGates;
31 | 
32 |         public Dictionary<string, string> Locations;
33 |         public Dictionary<int, Dictionary<string, string>> Playthrough;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/UI/ProgressDialog.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Runtime.InteropServices;
 3 | using System.Windows;
 4 | using System.Windows.Interop;
 5 | 
 6 | namespace LaMulana2Randomizer.UI
 7 | {
 8 |     public partial class ProgressDialog : Window
 9 |     {
10 |         public ProgressDialog()
11 |         {
12 |             InitializeComponent();
13 |         }
14 | 
15 |         #region Why can't this just be done in the xaml
16 |         private const int GWL_STYLE = -16;
17 |         private const int WS_SYSMENU = 0x80000;
18 | 
19 |         [DllImport("user32.dll", SetLastError = true)]
20 |         private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
21 | 
22 |         [DllImport("user32.dll")]
23 |         private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
24 | 
25 |         private void Window_Loaded(object sender, RoutedEventArgs e)
26 |         {
27 |             var hwnd = new WindowInteropHelper(this).Handle;
28 |             SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);
29 |         }
30 |         #endregion
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/UI/IntRangRules.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows.Controls;
 4 | 
 5 | namespace LaMulana2Randomizer.UI
 6 | {
 7 |     public class IntRangeRule : ValidationRule
 8 |     {
 9 |         public int Min { get; set; }
10 | 
11 |         public int Max { get; set; }
12 | 
13 |         public override ValidationResult Validate(object value, CultureInfo cultureInfo)
14 |         {
15 |             int parameter = 0;
16 |             try
17 |             {
18 |                 if (((string)value).Length > 0)
19 |                 {
20 |                     parameter = int.Parse((string)value);
21 |                 }
22 |             }
23 |             catch (Exception e)
24 |             {
25 |                 return new ValidationResult(false, "Illegal characters or " + e.Message);
26 |             }
27 | 
28 |             if ((parameter < Min) || (parameter > Max))
29 |             {
30 |                 return new ValidationResult(false, "Please enter value in the range: " + Min + " - " + Max + ".");
31 |             }
32 |             return new ValidationResult(true, null);
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/LogicParsing/Logic.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace LaMulana2Randomizer.LogicParsing
 4 | {
 5 |     public class Logic
 6 |     {
 7 |         public LogicType logicType;
 8 |         public string value;
 9 | 
10 |         public Logic(string logic, string value = null)
11 |         {
12 |             if(!Enum.TryParse(logic, out logicType))
13 |                 throw new InvalidLogicTypeException($"Failed to parse logic type, type of logic \"{logic}\" does not exist.");
14 | 
15 |             this.value = value;
16 |         }
17 |     }
18 | 
19 |     public enum LogicType
20 |     {
21 |         CanReach,
22 |         CanChant,
23 |         CanWarp,
24 |         CanSpinCorridor,
25 |         CanStopTime,
26 |         CanSealCorridor,
27 |         Has,
28 |         CanUse,
29 |         MeleeAttack,
30 |         HorizontalAttack,
31 |         IsDead,
32 |         CanKill,
33 |         OrbCount,
34 |         GuardianKills,
35 |         PuzzleFinished,
36 |         AnkhCount,
37 |         Dissonance,
38 |         SkullCount,
39 |         Setting,
40 |         Glitch,
41 |         Start,
42 |         True,
43 |         False
44 |     }
45 | 
46 |     public class InvalidLogicTypeException : Exception
47 |     {
48 |         public InvalidLogicTypeException(string message) : base(message) { }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/UI/ProgressDialog.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="LaMulana2Randomizer.UI.ProgressDialog"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 5 |         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 6 |         xmlns:local="clr-namespace:LaMulana2Randomizer.UI"
 7 |         mc:Ignorable="d" Name="DialogWindow" Title="Generating Seed" SizeToContent="WidthAndHeight" ResizeMode="NoResize" WindowStartupLocation="CenterOwner" Loaded="Window_Loaded">
 8 |     <Window.Resources>
 9 |         <BooleanToVisibilityConverter x:Key="BoolToVisibility"/>
10 |     </Window.Resources>
11 |     <Grid Width="300">
12 |         <StackPanel Margin="10">
13 |             <TextBlock Name="Label" Margin="0,0,0,5" Text="{Binding Label}" TextAlignment="Center" TextWrapping="Wrap"/>
14 |             <ProgressBar x:Name="ProgressBar" Margin="0,0,0,5" Height="20" IsIndeterminate="{Binding IsIndeterminate}" Value="{Binding ProgressValue}"/>
15 |             <Button Content="OK" Width="40" Visibility="{Binding TaskComplete, Converter={StaticResource BoolToVisibility}}" Command="{Binding CloseCommand}" CommandParameter="{Binding ElementName=DialogWindow}" Margin="120,0"/>
16 |         </StackPanel>
17 |     </Grid>
18 | </Window>
19 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("Assembly-CSharp")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("Assembly-CSharp")]
13 | [assembly: AssemblyCopyright("Copyright ©  2019")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible
18 | // to COM components.  If you need to access a type in this assembly from
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("34400cb6-0827-46b4-801d-ca281ffacd2e")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("2.2.0.4")]
37 | 


--------------------------------------------------------------------------------
/LM2RandomiserShared/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("LM2RandomiserShared")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("LM2RandomiserShared")]
13 | [assembly: AssemblyCopyright("Copyright ©  2019")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible
18 | // to COM components.  If you need to access a type in this assembly from
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("9f97eb8e-6dce-4f97-a1a6-5d0f354f581b")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/FakeItem.cs:
--------------------------------------------------------------------------------
 1 | using L2Base;
 2 | using L2Flag;
 3 | using UnityEngine;
 4 | 
 5 | namespace LM2RandomiserMod
 6 | {
 7 |     public class FakeItem : MonoBehaviour
 8 |     {
 9 |         private Rect bounds;
10 |         private Rect playerRect;
11 |         private L2System sys;
12 |         private int flagNo;
13 |         private L2FlagBoxParent[] activeFlags;
14 | 
15 |         public void Init(L2System system, L2FlagBoxParent[] flags, int flag)
16 |         {
17 |             sys = system;
18 |             bounds.size = new Vector2(20, 20);
19 |             playerRect.size = new Vector2(16, 20);
20 |             activeFlags = flags;
21 |             flagNo = flag;
22 |         }
23 | 
24 |         public void Update()
25 |         {
26 |             if (sys.checkStartFlag(activeFlags))
27 |             {
28 |                 var sprite = GetComponent<SpriteRenderer>();
29 |                 sprite.enabled = true;
30 | 
31 |                 var player = sys.getPlayer();
32 |                 if (player != null)
33 |                 {
34 |                     Vector3 pPos = player.getPlayerPositon();
35 |                     pPos.y += 15f;
36 |                     playerRect.center = pPos;
37 |                     bounds.center = transform.position;
38 |                     if (playerRect.Overlaps(bounds))
39 |                     {
40 |                         sys.setFlagData(31, flagNo, 1);
41 |                         sys.setFlagData(1, 12, 1);
42 |                         gameObject.SetActive(false);
43 |                     }
44 |                 }
45 |             }
46 |         }
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Area.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using LaMulana2RandomizerShared;
 3 | 
 4 | namespace LaMulana2Randomizer
 5 | {
 6 |     public class JsonArea
 7 |     {
 8 |         public AreaID ID;
 9 |         public string Name;
10 |         public bool IsBackside;
11 |         public List<JsonLocation> Locations;
12 |         public List<JsonExit> Exits;
13 |     }
14 | 
15 |     public class Area
16 |     {
17 |         public AreaID ID { get; private set; }
18 |         public string Name { get; private set; }
19 |         public bool IsBackside { get; private set; }
20 |         public List<Location> Locations { get; private set; }
21 |         public List<Exit> Exits { get; private set; }
22 |         public List<Exit> Entrances { get; private set; }
23 | 
24 |         public bool Checking = false;
25 | 
26 |         public Area(JsonArea area)
27 |         {
28 |             ID = area.ID;
29 |             Name = area.Name;
30 |             IsBackside = area.IsBackside;
31 |             Locations = new List<Location>();
32 |             Entrances = new List<Exit>();
33 |             Exits = new List<Exit>();
34 |         }
35 | 
36 |         public bool CanReach(PlayerState state)
37 |         {
38 |             foreach (Exit entrance in Entrances)
39 |             {
40 |                 if (state.EscapeCheck && (entrance.ExitType == ExitType.PrisonExit || entrance.ExitType == ExitType.PrisonGate))
41 |                     continue;
42 | 
43 |                 if (state.CanReach(entrance))
44 |                     return true;
45 |             }
46 |             return false;
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/MenuSystem.cs:
--------------------------------------------------------------------------------
 1 | using L2Base;
 2 | using L2Menu;
 3 | using MonoMod;
 4 | using MonoMod.ModInterop;
 5 | 
 6 | #pragma warning disable 0626, 0649, 0414, 0108
 7 | namespace LM2RandomiserMod.Patches
 8 | {
 9 |     [MonoModPatch("L2Menu.MenuSystem")]
10 |     public class patched_MenuSystem : L2Menu.MenuSystem
11 | 	{
12 |         public patched_MenuSystem(L2System l2sys) : base(l2sys)
13 |         {
14 |             typeof(patched_MenuSystem).ModInterop();
15 |         }
16 | 
17 | 		[MonoModIgnore]
18 | 		private L2System sys;
19 | 
20 | 		[MonoModIgnore]
21 | 		private int flagq_count;
22 | 
23 | 		[MonoModIgnore]
24 | 		private MojiScFlagQ[] flagq;
25 | 
26 | 		[MonoModReplace]
27 | 		public void setMojiFlagQue(int sheet, int id, short vale)
28 | 		{
29 | 			if (flagq_count >= flagq.Length)
30 | 			{
31 | 				sys.L2Print("もじもじ君スクリプト用のフラグキューが一杯で入らないですよ");
32 | 				return;
33 | 			}
34 | 			for (int i = 0; i < flagq_count; i++)
35 | 			{
36 | 				if (flagq[i].flag_sheet == sheet && flagq[i].flag_name == id)
37 | 				{
38 | 					if(sheet == 3 && id == 30)
39 | 					{
40 | 						flagq[i].flag_vale += 4;
41 | 					}
42 | 					else if(sheet == 0 && id == 2)
43 | 					{
44 | 						flagq[i].flag_vale++;
45 | 					}
46 | 					else if(sheet == 0 && id == 32)
47 | 					{
48 | 						flagq[i].flag_vale++;
49 | 					}
50 | 					else if (sheet == 5 && id == 47)
51 | 					{
52 | 						flagq[i].flag_vale++;
53 | 					}
54 | 					return;
55 | 				}
56 | 			}
57 | 			flagq[flagq_count].flag_sheet = sheet;
58 | 			flagq[flagq_count].flag_name = id;
59 | 			flagq[flagq_count].flag_vale = vale;
60 | 			flagq_count++;
61 | 		}
62 | 	}
63 | }
64 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/L2SystemCore.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using MonoMod;
 3 | using L2Base;
 4 | using UnityEngine;
 5 | 
 6 | #pragma warning disable 0649, 0414, 0108
 7 | namespace LM2RandomiserMod.Patches
 8 | {
 9 |     [MonoModPatch("global::L2SystemCore")]
10 |     public class patched_L2SystemCore: L2SystemCore
11 | 	{
12 | 		private bool fadeInFlag;
13 | 		private bool scrollSystemInited;
14 | 		private AsyncOperation asOpe;
15 | 		private FairyBaseScript activeFairy;
16 | 
17 | 		[MonoModReplace]
18 | 		public bool setAsyncScene(bool sysflgReset = true)
19 | 		{
20 | 			if (asOpe == null)
21 | 			{
22 | 				if (fadeInFlag)
23 | 				{
24 | 					gameScreenFadeIn(10);
25 | 				}
26 | 				jumpPlayerPositionToPresetPosition();
27 | 				if (cartenObj != null)
28 | 					Destroy(cartenObj);
29 | 
30 | 				return true;
31 | 			}
32 | 			if (asOpe.progress < 0.9f)
33 | 			{
34 | 				return false;
35 | 			}
36 | 			sys.clearSceneTasks();
37 | 			if (sys.getPlayer() != null)
38 | 			{
39 | 				sys.getPlayer().transform.SetParent(base.transform);
40 | 			}
41 | 			if (activeFairy != null)
42 | 			{
43 | 				activeFairy.transform.SetParent(base.transform);
44 | 			}
45 | 			scrollSys = null;
46 | 			if (sysflgReset)
47 | 			{
48 | 				sys.delSysFlag(SYSTEMFLAG.DRAMATEJI);
49 | 			}
50 | 			GC.Collect();
51 | 			sys.setTaskRuningMode(false);
52 | 			if (cartenFirstFrame)
53 | 			{
54 | 				cartenFirstFrame = false;
55 | 				if (cartenObj != null)
56 | 				{
57 | 					MapCartain component = cartenObj.GetComponent<MapCartain>();
58 | 					component.initCartain();
59 | 				}
60 | 			}
61 | 			setMenuCameraActive(false);
62 | 			scrollSystemInited = false;
63 | 			asOpe.allowSceneActivation = true;
64 | 			return true;
65 | 		}
66 | 	}
67 | }
68 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/HolyTabretScript.cs:
--------------------------------------------------------------------------------
 1 | using L2Base;
 2 | using MonoMod;
 3 | using UnityEngine;
 4 | 
 5 | #pragma warning disable 0626, 0649, 0414, 0108
 6 | namespace LM2RandomiserMod.Patches
 7 | {
 8 |     [MonoModPatch("global::HolyTabretScript")]
 9 |     public class patched_HolyTabretScript : global::HolyTabretScript
10 |     {
11 |         [MonoModIgnore]
12 |         private L2System sys;
13 | 
14 |         [MonoModIgnore]
15 |         private L2SystemCore sysCore;
16 | 
17 |         [MonoModIgnore]
18 |         public ParticleSystem memsaveParticle;
19 | 
20 |         [MonoModReplace]
21 |         public bool memorySave()
22 |         {
23 |             short num = 0;
24 |             if (!this.sys.getFlag(this.sheetNo, this.flagNo, ref num))
25 |             {
26 |                 return false;
27 |             }
28 |             if (num < 1)
29 |             {
30 |                 L2Rando rando = GameObject.FindObjectOfType<L2Rando>();
31 |                 if (rando != null)
32 |                 {
33 |                     if (rando.AutoScanTablets)
34 |                     {
35 |                         this.sys.setFlagData(this.sheetNo, this.flagNo, 1);
36 |                     }
37 |                 }
38 |                 else
39 |                 {
40 |                     return false;
41 |                 }
42 |             }
43 |             if (this.sys.getItemNum("Holy Grail") <= 0)
44 |             {
45 |                 return false;
46 |             }
47 |             this.sysCore.seManager.playSE(base.gameObject, 143);
48 |             this.sys.memSave(base.transform.position.x, base.transform.position.y, this.warpPointNo);
49 |             this.clearSaveParticle();
50 |             this.memsaveParticle.Play();
51 |             return true;
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/LM2RandomiserShared/ExitID.cs:
--------------------------------------------------------------------------------
 1 | namespace LaMulana2RandomizerShared
 2 | {
 3 |     public enum ExitID
 4 |     {
 5 |         None = 0,
 6 | 
 7 |         fLLeft,
 8 |         fL02Left,
 9 |         fP00Left,
10 |         fP02Left,
11 | 
12 |         f01Right,
13 |         f03Right,
14 |         fL08Right,
15 |         fP00Right,
16 | 
17 |         f00Down,
18 |         f01Down,
19 |         f02Down,
20 |         f03Down1,
21 |         f03Down2,
22 |         f03Down3,
23 |         fLDown,
24 | 
25 |         f02Up,
26 |         f03Up,
27 |         f04Up,
28 |         f04Up2,
29 |         f04Up3,
30 |         fL02Up,
31 |         fL05Up,
32 | 
33 |         f00GateY0,
34 |         f00GateYA,
35 |         f00GateYB,
36 |         f00GateYC,
37 |         f02GateYA,
38 |         f03GateYC,
39 |         f04GateYB,
40 |         f05GateP1,
41 |         f06GateP0,
42 |         f06_2GateP0,
43 |         f07GateP0,
44 |         f08GateP0,
45 |         f09GateP0,
46 |         f10GateP0,
47 |         f11GateP0,
48 |         f12GateP0,
49 |         f13GateP0,
50 |         fLGate,
51 |         fL11GateY0,
52 |         fL11GateN,
53 | 
54 |         f00GateN1,
55 |         f02GateN2,
56 |         f03GateN3,
57 |         f03GateN4,
58 |         f03GateN9,
59 |         f04GateN5,
60 |         f04GateN6,
61 |         f05GateN1,
62 |         f06GateN2,
63 |         f06GateN7,
64 |         f07GateN3,
65 |         f08GateN4,
66 |         f08GateN8,
67 |         f09GateN5,
68 |         f10GateN7,
69 |         f12GateN8,
70 |         f13GateN9,
71 |         f14GateN6,
72 | 
73 |         fStart,
74 |         f01Start,
75 |         f02Bifrost,
76 |         f03In,
77 |         f03GateP0,
78 |         f03GateP1,
79 |         f08Neck,
80 |         f09In,
81 |         f11Pyramid,
82 |         fNibiru,
83 |         fP01Left,
84 |         fP01Right
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/HotSpring.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using L2Base;
 3 | 
 4 | namespace LM2RandomiserMod
 5 | {
 6 |     class HotSpring : MonoBehaviour
 7 |     {
 8 |         private Rect bounds;
 9 |         private Rect playerRect;
10 |         private L2System sys;
11 |         private int hpFrames = 0;
12 | 
13 |         private const float hpModifier = 0.0004f;
14 | 
15 |         public void Init(L2System sys)
16 |         {
17 |             this.sys = sys;
18 |             bounds.width = 50;
19 |             bounds.height = 50;
20 |             bounds.center = transform.position;
21 |             playerRect.width = 16;
22 |             playerRect.height = 20;
23 |         }
24 | 
25 |         public void Update()
26 |         {
27 |             var player = sys.getPlayer();
28 |             if (player != null)
29 |             {
30 |                 playerRect.center = player.getPlayerPositon();
31 | 
32 |                 if (playerRect.Overlaps(bounds))
33 |                 {
34 |                     hpFrames++;
35 |                     if (hpFrames > 10)
36 |                     {
37 |                         hpFrames = 0;
38 |                         int currentHP = sys.getPlayerHP();
39 |                         int maxHP = Mathf.RoundToInt(sys.getPlayerMaxHP() * 0.01f);
40 |                         if (currentHP < maxHP)
41 |                         {
42 |                             int hpToAdd = Mathf.RoundToInt(sys.getPlayerMaxHP() * hpModifier);
43 | 
44 |                             if (currentHP + hpToAdd > maxHP)
45 |                                 hpToAdd = maxHP - currentHP;
46 | 
47 |                             sys.setPLayerHP(hpToAdd);
48 |                             sys.getL2SystemCore().seManager.playSE(player.gameObject, 152);
49 |                         }
50 |                     }
51 |                 }
52 |             }
53 |         }
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/App.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8" ?>
 2 | <configuration>
 3 |     <configSections>
 4 |         <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
 5 |             <section name="LaMulana2Randomizer.Properties.AppSettings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
 6 |             <section name="LaMulana2Randomizer.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
 7 |             <section name="LaMulana2Randomizer.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
 8 |         </sectionGroup>
 9 |     </configSections>
10 |     <startup> 
11 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
12 |     </startup>
13 |     <userSettings>
14 |         <LaMulana2Randomizer.Properties.AppSettings>
15 |             <setting name="SettingsString" serializeAs="String">
16 |                 <value>0000A00000056020000000010000020000014190</value>
17 |             </setting>
18 |         </LaMulana2Randomizer.Properties.AppSettings>
19 |         <LaMulana2Randomizer.Properties.Settings>
20 |             <setting name="SettingString" serializeAs="String">
21 |                 <value>
22 |                 </value>
23 |             </setting>
24 |         </LaMulana2Randomizer.Properties.Settings>
25 |         <LaMulana2Randomizer.Settings>
26 |             <setting name="SettingsString" serializeAs="String">
27 |                 <value />
28 |             </setting>
29 |         </LaMulana2Randomizer.Settings>
30 |     </userSettings>
31 | </configuration>


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/TreasureBoxScript.cs:
--------------------------------------------------------------------------------
 1 | using MonoMod;
 2 | using UnityEngine;
 3 | 
 4 | #pragma warning disable 0649
 5 | namespace LM2RandomiserMod.Patches
 6 | {
 7 |     [MonoModPatch("global::TreasureBoxScript")]
 8 |     public class patched_TreasureBoxScript : global::TreasureBoxScript
 9 |     {
10 | 		[MonoModIgnore]
11 | 		private Animator myAnime;
12 | 
13 | 		[MonoModIgnore]
14 | 		private bool boxOpenFlag;
15 | 
16 | 		[MonoModReplace]
17 | 		private void openBox()
18 | 		{
19 | 			this.sta = 7;
20 | 			if (!this.openState.Equals(string.Empty))
21 | 			{
22 | 				this.myAnime.enabled = true;
23 | 				this.myAnime.Play(this.openState);
24 | 			}
25 | 			else
26 | 			{
27 | 				this.myAnime.enabled = false;
28 | 			}
29 | 			this.sys.setEffectFlag(this.openActionFlags);
30 | 			if (this.sys.checkStartFlag(this.itemFlags))
31 | 			{
32 | 				if (this.itemObj != null)
33 | 				{
34 | 					AbstractItemBase component = this.itemObj.GetComponent<AbstractItemBase>();
35 | 					if (component.itemLabel == "Coin")
36 | 					{
37 | 						Vector3 actionPosition = this.actionPosition;
38 | 						actionPosition.z -= 5f;
39 | 						base.getL2Core().dropItemGenerator.dropCoins(ref actionPosition, component.itemValue);
40 | 					}
41 | 					else if (component.itemLabel == "Weight")
42 | 					{
43 | 						Vector3 actionPosition = this.actionPosition;
44 | 						actionPosition.z -= 5f;
45 | 						base.getL2Core().dropItemGenerator.dropWeight(ref actionPosition, 1);
46 | 						sys.setFlagData(31, component.itemValue, 1);
47 | 					}
48 | 					else if (!this.boxOpenFlag)
49 | 					{
50 | 						GameObject gameObject = UnityEngine.Object.Instantiate<GameObject>(this.itemObj, this.actionPosition, Quaternion.identity);
51 | 						component = gameObject.GetComponent<AbstractItemBase>();
52 | 						if (this.closetMode)
53 | 						{
54 | 							component.itemValue = this.costumeId;
55 | 						}
56 | 						component.initTask();
57 | 						component.setTreasureBoxOut();
58 | 						this.boxOpenFlag = true;
59 | 					}
60 | 				}
61 | 				else if (this.dropitem != null)
62 | 				{
63 | 					this.dropitem.popDropItem();
64 | 				}
65 | 			}
66 | 		}
67 | 	}
68 | }
69 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/ViewModels/ProgressDialogViewModel.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows;
 3 | using System.Windows.Input;
 4 | 
 5 | namespace LaMulana2Randomizer.ViewModels
 6 | {
 7 |     public struct ProgressInfo
 8 |     {
 9 |         public string Label;
10 |         public bool IsIndeterminate;
11 |         public int ProgressValue;
12 |     }
13 | 
14 |     public class ProgressDialogViewModel : BindableBase
15 |     {
16 |         private string _label;
17 |         public string Label {
18 |             get => _label;
19 |             set => Set(ref _label, value);
20 |         }
21 | 
22 |         private bool _isIndeterminate;
23 |         public bool IsIndeterminate {
24 |             get => _isIndeterminate;
25 |             set => Set(ref _isIndeterminate, value);
26 |         }
27 | 
28 |         private int _progressValue;
29 |         public int ProgressValue {
30 |             get => _progressValue;
31 |             set => Set(ref _progressValue, value);
32 |         }
33 | 
34 |         private bool _taskComplete;
35 |         public bool TaskComplete {
36 |             get => _taskComplete;
37 |             set => Set(ref _taskComplete, value);
38 |         }
39 | 
40 |         public IProgress<ProgressInfo> progress;
41 | 
42 |         public ProgressDialogViewModel()
43 |         {
44 |             TaskComplete = false;
45 |             progress = new Progress<ProgressInfo>(Update);
46 |         }
47 | 
48 |         private void Update(ProgressInfo info)
49 |         {
50 |             Label = info.Label;
51 |             IsIndeterminate = info.IsIndeterminate;
52 |             ProgressValue = info.ProgressValue;
53 |         }
54 | 
55 |         private ICommand _closeCommand;
56 |         public ICommand CloseCommand {
57 |             get {
58 |                 if (_closeCommand == null)
59 |                 {
60 |                     _closeCommand = new RelayCommand((x) => true, (x) => CloseWindow((Window)x));
61 |                 }
62 |                 return _closeCommand;
63 |             }
64 |         }
65 | 
66 |         private void CloseWindow(Window window)
67 |         {
68 |             if (window != null)
69 |             {
70 |                 window.Close();
71 |             }
72 |         }
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/StartDB.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using UnityEngine;
 3 | using LaMulana2RandomizerShared;
 4 | 
 5 | namespace LM2RandomiserMod
 6 | {
 7 |     public abstract class StartDB
 8 |     {
 9 |         public static StartInfo GetStartInfo(AreaID areaID)
10 |         {
11 |             startData.TryGetValue(areaID, out StartInfo startInfo);
12 |             return startInfo;
13 |         }
14 | 
15 |         private static readonly Dictionary<AreaID, StartInfo> startData = new Dictionary<AreaID, StartInfo>()
16 |         {
17 |             { AreaID.RoY,           new StartInfo(0,  "PlayerStart f00Holy",  new Vector3( 30, -10, 0))},
18 |             { AreaID.VoD,           new StartInfo(1,  "PlayerStart f01Holy",  new Vector3(  0,   0, 0))},
19 |             { AreaID.AnnwfnMain,    new StartInfo(2,  "PlayerStart f02Holy",  new Vector3(-20, -10, 0))},
20 |             { AreaID.IBMain,        new StartInfo(3,  "PlayerStart f03Holy",  new Vector3( 30, -10, 0))},
21 |             { AreaID.ITLeft,        new StartInfo(4,  "PlayerStart f04Holy",  new Vector3(-30, -10, 0))},
22 |             { AreaID.DFMain,        new StartInfo(5,  "PlayerStart f05Holy",  new Vector3( 30, -10, 0))},
23 |             { AreaID.SotFGGrail,    new StartInfo(6,  "PlayerStart f06Holy",  new Vector3( 30, -10, 0))},
24 |             { AreaID.TSLeft,        new StartInfo(8,  "PlayerStart f08Holy",  new Vector3( 30, -10, 0))},
25 |             { AreaID.ValhallaMain,  new StartInfo(10, "PlayerStart f10RHoly", new Vector3( 30, -10, 0))},
26 |             { AreaID.DSLMMain,      new StartInfo(11, "PlayerStart f11RHoly", new Vector3( 90, -10, 0))},
27 |             { AreaID.ACTablet,      new StartInfo(12, "PlayerStart f12RHoly", new Vector3(-80, -10, 0))},
28 |             { AreaID.HoMTop,        new StartInfo(13, "PlayerStart f13RHoly", new Vector3( 30, -10, 0))},
29 |         };
30 |     }
31 | 
32 |     public class StartInfo
33 |     {
34 |         public int FieldNo;
35 |         public string AnchorName;
36 |         public Vector3 ShopOffset;
37 | 
38 |         public StartInfo(int fieldNo, string anchorName, Vector2 shopOffset)
39 |         {
40 |             FieldNo = fieldNo;
41 |             AnchorName = anchorName;
42 |             ShopOffset = shopOffset;
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/EventItemScript.cs:
--------------------------------------------------------------------------------
 1 | using MonoMod;
 2 | using L2Base;
 3 | 
 4 | namespace LM2RandomiserMod.Patches
 5 | {
 6 |     [MonoModPatch("global::EventItemScript")]
 7 |     public class patched_EventItemScript : global::EventItemScript
 8 |     {
 9 |         [MonoModReplace]
10 |         protected override void itemGetAction()
11 |         {
12 |             int slotNo = getL2Core().seManager.playSE(null, 39);
13 |             getL2Core().seManager.releaseGameObjectFromPlayer(slotNo);
14 |             pl.setActionOder(PLAYERACTIONODER.getitem);
15 |             if (itemLabel.Contains("Whip"))
16 |             {
17 |                 short data = 0;
18 |                 string trueItemName = string.Empty;
19 |                 sys.getFlag(2, "Whip", ref data);
20 |                 if (data == 0) trueItemName = "Whip";
21 |                 else if (data == 1) trueItemName = "Whip2";
22 |                 else if (data >= 2) trueItemName = "Whip3";
23 | 
24 |                 pl.setGetItem(ref trueItemName);
25 |                 pl.setGetItemIcon(L2SystemCore.getItemData(trueItemName));
26 |             }
27 |             else if (itemLabel.Contains("Shield"))
28 |             {
29 |                 short data = 0;
30 |                 string trueItemName = string.Empty;
31 |                 sys.getFlag(2, 196, ref data);
32 |                 if (data == 0) trueItemName = "Shield";
33 |                 else if (data == 1) trueItemName = "Shield2";
34 |                 else if (data >= 2) trueItemName = "Shield3";
35 | 
36 |                 pl.setGetItem(ref trueItemName);
37 |                 pl.setGetItemIcon(L2SystemCore.getItemData(trueItemName));
38 |             }
39 |             else
40 |             {
41 |                 pl.setGetItem(ref itemLabel);
42 |                 if (itemLabel.Contains("Mantra"))
43 |                     pl.setGetItemIcon(L2SystemCore.getItemData("Mantra"));
44 |                 else if(itemLabel.Contains("Research"))
45 |                     pl.setGetItemIcon(L2SystemCore.getItemData("Research"));
46 |                 else if (itemLabel.Contains("Beherit"))
47 |                     pl.setGetItemIcon(L2SystemCore.getItemData("Beherit"));
48 |                 else
49 |                     pl.setGetItemIcon(L2SystemCore.getItemData(itemLabel));
50 |             }
51 |         }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/LM2RandomiserShared/AreaID.cs:
--------------------------------------------------------------------------------
  1 | namespace LaMulana2RandomizerShared
  2 | {
  3 |     public enum AreaID
  4 |     {
  5 |         None,
  6 | 
  7 |         VoD,
  8 |         VoDLadder,
  9 |         Start,
 10 |         InfernoCavern,
 11 |         GateofGuidance,
 12 |         GateofGuidanceLeft,
 13 |         MausoleumofGiants,
 14 |         MausoleumofGiantsRubble,
 15 |         EndlessCorridor,
 16 |         GateofIllusion,
 17 |         RoY,
 18 |         RoYTopLeft,
 19 |         RoYTopRight,
 20 |         RoYTopMiddle,
 21 |         RoYMiddle,
 22 |         RoYBottom,
 23 |         RoYBottomLeft,
 24 |         AnnwfnMain,
 25 |         AnnwfnOneWay,
 26 |         AnnwfnSG,
 27 |         AnnwfnPoison,
 28 |         AnnwfnRight,
 29 |         IBBifrost,
 30 |         IBTop,
 31 |         IBTopLeft,
 32 |         IBCetusLadder,
 33 |         IBMain,
 34 |         IBRight,
 35 |         IBBottom,
 36 |         IBLeft,
 37 |         IBLeftSG,
 38 |         IBBattery,
 39 |         IBDinosaur,
 40 |         IBMoon,
 41 |         IBLadder,
 42 |         IBBoat,
 43 |         Cavern,
 44 |         Cliff,
 45 |         AltarLeft,
 46 |         AltarRight,
 47 |         ITEntrance,
 48 |         ITBottom,
 49 |         ITSinmara,
 50 |         ITLeft,
 51 |         ITRight,
 52 |         ITRightLeftLadder,
 53 |         ITVidofnir,
 54 |         DFEntrance,
 55 |         DFRight,
 56 |         DFMain,
 57 |         DFTop,
 58 |         SotFGMain,
 59 |         SotFGGrail,
 60 |         SotFGTop,
 61 |         SotFGBalor,
 62 |         SotFGBlood,
 63 |         SotFGBloodTez,
 64 |         SotFGLeft,
 65 |         GotD,
 66 |         GotDWedjet,
 67 |         TSEntrance,
 68 |         TSMain,
 69 |         TSLeft,
 70 |         TSNeck,
 71 |         TSNeckEntrance,
 72 |         TSBottom,
 73 |         TSBlood,
 74 |         HL,
 75 |         HLGate,
 76 |         HLSpun,
 77 |         HLCog,
 78 |         ValhallaMain,
 79 |         ValhallaTop,
 80 |         ValhallaTopRight,
 81 |         DSLMMain,
 82 |         DSLMTop,
 83 |         DSLMPyramid,
 84 |         Nibiru,
 85 |         ACBottom,
 86 |         ACWind,
 87 |         ACTablet,
 88 |         ACMain,
 89 |         ACBlood,
 90 |         HoMTop,
 91 |         HoM,
 92 |         HoMAwoken,
 93 |         EPDEntrance,
 94 |         EPDMain,
 95 |         EPDTop,
 96 |         EPDHel,
 97 |         EPG,
 98 |         SpiralHell
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/CostumeScript.cs:
--------------------------------------------------------------------------------
 1 | using MonoMod;
 2 | using L2Base;
 3 | 
 4 | namespace LM2RandomiserMod.Patches
 5 | {
 6 |     [MonoModPatch("global::CostumeSetScript")]
 7 |     public class patched_CostumeScript : global::CostumeSetScript
 8 |     {
 9 |         [MonoModReplace]
10 |         protected override void itemGetAction()
11 |         {
12 |             int slotNo = getL2Core().seManager.playSE(null, 39);
13 |             getL2Core().seManager.releaseGameObjectFromPlayer(slotNo);
14 |             pl.setActionOder(PLAYERACTIONODER.getitem);
15 |             if (itemLabel.Contains("Whip"))
16 |             {
17 |                 short data = 0;
18 |                 string trueItemName = string.Empty;
19 |                 sys.getFlag(2, "Whip", ref data);
20 |                 if (data == 0) trueItemName = "Whip";
21 |                 else if (data == 1) trueItemName = "Whip2";
22 |                 else if (data >= 2) trueItemName = "Whip3";
23 | 
24 |                 pl.setGetItem(ref trueItemName);
25 |                 pl.setGetItemIcon(L2SystemCore.getItemData(trueItemName));
26 |             }
27 |             else if (itemLabel.Contains("Shield"))
28 |             {
29 |                 short data = 0;
30 |                 string trueItemName = string.Empty;
31 |                 sys.getFlag(2, 196, ref data);
32 |                 if (data == 0) trueItemName = "Shield";
33 |                 else if (data == 1) trueItemName = "Shield2";
34 |                 else if (data >= 2) trueItemName = "Shield3";
35 | 
36 |                 pl.setGetItem(ref trueItemName);
37 |                 pl.setGetItemIcon(L2SystemCore.getItemData(trueItemName));
38 |             }
39 |             else
40 |             {
41 |                 pl.setGetItem(ref itemLabel);
42 |                 //Mantras don't have an icon so just use the mantra software icon
43 |                 if (itemLabel.Contains("Mantra"))
44 |                     pl.setGetItemIcon(L2SystemCore.getItemData("Mantra"));
45 |                 else if (itemLabel.Contains("Research"))
46 |                     pl.setGetItemIcon(L2SystemCore.getItemData("Research"));
47 |                 else if (itemLabel.Contains("Beherit"))
48 |                     pl.setGetItemIcon(L2SystemCore.getItemData("Beherit"));
49 |                 else
50 |                     pl.setGetItemIcon(L2SystemCore.getItemData(itemLabel));
51 |             }
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # La Mulana 2 Randomizer
 2 | Before playing a run it is best to head over to https://github.com/Coookie93/LaMulana2Randomizer/wiki for more information about the randomizer.
 3 | 
 4 | ## Installing:
 5 | 1. Get the lastest version from https://github.com/Coookie93/LaMulana2Randomizer/releases
 6 | 2. Place the `LaMulana2Randomizer` folder in the La-Mulana 2 root directory, the one with `lamaulana2.exe`
 7 | 3. Copy all the files from the `LaMulana2Randomizer/Monomod` folder to the `LaMulana2_Data/Managed` folder
 8 | 4. Now in the `LaMulana2_Data/Managed` folder, drag the `Assembly-CSharp.dll` onto `monomod.exe`
 9 | 5. Make a backup of `Assembly-CSharp.dll` eg. create an `Original` folder inside `LaMulana2_Data/Managed` and place the file in there.
10 | 6. Rename the `MONOMODDED_Assembly-CSharp.dll `file to `Assembly-CSharp.dll`
11 | 7. Now open the `LaMulana2Randomizer.exe` program, create a seed and you're good to go
12 | 
13 | ## Updating:
14 | 1. Get the lastest version from https://github.com/Coookie93/LaMulana2Randomizer/releases
15 | 2. If new version supports older seeds copy current seed if you want it.
16 | 3. Delete the `Assembly-CSharp.dll` in the `LaMulana2_Data/Managed` folder
17 | 4. Copy `LaMulana2_Data/Managed/Original/Assembly-CSharp.dll` back to `LaMulana2_Data/Managed/Assembly-CSharp.dll`.
18 | 5. Replace current `LaMulana2Randomizer` folder with the newer version.
19 | 6. Refer to steps 3-6 on the [Installing](#installing) section.
20 | 7. Copy old seeds into the seed folder if that is applicable.
21 | 
22 | ## Unistall:
23 | 1. Delete the `Assembly-CSharp.dll` in the `LaMulana2_Data/Managed` folder
24 | 2. Choose ONE of the following:
25 |     * Copy `LaMulana2_Data/Managed/Original/Assembly-CSharp.dll` back to `LaMulana2_Data/Managed/Assembly-CSharp.dll`.
26 |     * Use Steam's file verification and it will redownload the original `Assembly-CSharp.dll`
27 | 3. Remove `Assembley-CSharp.mm.dll` and all monomod related files from the `LaMulana2_Data/Managed` folder
28 | 
29 | ## Compiling:
30 | The randomisation application should compile fine.
31 | 
32 | The patch library will require both installing La-Mulana 2 and setting the system environment variable `LAMULANA2PATH` before building. Set the variable to where La-Mulana 2 is installed. Refer to [How to change Environment Variables on Windows 10](https://www.architectryan.com/2018/08/31/how-to-change-environment-variables-on-windows-10/) for additional information. Make sure the environment variable is set before launching Visual Studio.
33 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.CompilerServices;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // General Information about an assembly is controlled through the following
 8 | // set of attributes. Change these attribute values to modify the information
 9 | // associated with an assembly.
10 | [assembly: AssemblyTitle("LaMulana2Randomizer")]
11 | [assembly: AssemblyDescription("")]
12 | [assembly: AssemblyConfiguration("")]
13 | [assembly: AssemblyCompany("")]
14 | [assembly: AssemblyProduct("LaMulana2Randomizer")]
15 | [assembly: AssemblyCopyright("Copyright ©  2019")]
16 | [assembly: AssemblyTrademark("")]
17 | [assembly: AssemblyCulture("")]
18 | 
19 | // Setting ComVisible to false makes the types in this assembly not visible
20 | // to COM components.  If you need to access a type in this assembly from
21 | // COM, set the ComVisible attribute to true on that type.
22 | [assembly: ComVisible(false)]
23 | 
24 | //In order to begin building localizable applications, set
25 | //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
26 | //inside a <PropertyGroup>.  For example, if you are using US english
27 | //in your source files, set the <UICulture> to en-US.  Then uncomment
28 | //the NeutralResourceLanguage attribute below.  Update the "en-US" in
29 | //the line below to match the UICulture setting in the project file.
30 | 
31 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
32 | 
33 | 
34 | [assembly: ThemeInfo(
35 |     ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
36 |                                      //(used if a resource is not found in the page,
37 |                                      // or application resource dictionaries)
38 |     ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
39 |                                               //(used if a resource is not found in the page,
40 |                                               // app, or any theme specific resource dictionaries)
41 | )]
42 | 
43 | 
44 | // Version information for an assembly consists of the following four values:
45 | //
46 | //      Major Version
47 | //      Minor Version
48 | //      Build Number
49 | //      Revision
50 | //
51 | // You can specify all the values or you can default the Build and Revision Numbers
52 | // by using the '*' as shown below:
53 | // [assembly: AssemblyVersion("1.0.*")]
54 | [assembly: AssemblyVersion("1.0.0.0")]
55 | [assembly: AssemblyFileVersion("2.2.0.4")]
56 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/LogicParsing/ShuntingYard.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Linq;
 3 | using System.Collections.Generic;
 4 | 
 5 | namespace LaMulana2Randomizer.LogicParsing
 6 | {
 7 |     public abstract class ShuntingYard
 8 |     {
 9 |         public static IList<Token> Sort(IList<Token> tokens)
10 |         {
11 |             Queue<Token> outputQueue = new Queue<Token>();
12 |             Stack<Token> stack = new Stack<Token>();
13 | 
14 |             for (int index = 0; index < tokens.Count; index++)
15 |             {
16 |                 Token token = tokens[index];
17 |                 switch (token.Type)
18 |                 {
19 |                     case TokenType.RuleToken:
20 |                     {
21 |                         outputQueue.Enqueue(token);
22 |                         break;
23 |                     }
24 |                     case TokenType.AndOperator:
25 |                     {
26 |                         while (stack.Count > 0 && stack.Peek().Type == TokenType.AndOperator)
27 |                             outputQueue.Enqueue(stack.Pop());
28 | 
29 |                         stack.Push(token);
30 |                         break;
31 |                     }
32 |                     case TokenType.OrOperator:
33 |                     { 
34 |                         while (stack.Count > 0 && (stack.Peek().Type == TokenType.AndOperator || stack.Peek().Type == TokenType.OrOperator))
35 |                             outputQueue.Enqueue(stack.Pop());
36 | 
37 |                         stack.Push(token);
38 |                         break;
39 |                     }
40 |                     case TokenType.OpenParentheses:
41 |                     {
42 |                         stack.Push(token);
43 |                         break;
44 |                     }
45 |                     case TokenType.ClosedParentheses:
46 |                     {
47 |                         while (stack.Count > 0 && stack.Peek().Type != TokenType.OpenParentheses)
48 |                             outputQueue.Enqueue(stack.Pop());
49 | 
50 |                         if (stack.Count == 0 || stack.Peek().Type != TokenType.OpenParentheses)
51 |                             throw new Exception("Mismatched parentheses.");
52 |                         else
53 |                             stack.Pop();
54 |                         break;
55 |                     }
56 | 
57 |                     default:
58 |                         break;
59 |                 }
60 |             }
61 | 
62 |             while (stack.Count > 0)
63 |                 outputQueue.Enqueue(stack.Pop());
64 | 
65 |             return outputQueue.Reverse().ToList();
66 |         }
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/ItemPotScript.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using MonoMod;
 3 | using UnityEngine;
 4 | 
 5 | #if DEV
 6 | 
 7 | namespace LM2RandomiserMod.Patches
 8 | {
 9 |     [MonoModPatch("global::ItemPotScript")]
10 |     public class patched_ItemPotScript : global::ItemPotScript
11 |     {
12 |         [NonSerialized] public Camera[] cams;
13 |         [NonSerialized] public int camIndex;
14 |         [NonSerialized] public Vector3 worldPos;
15 | 
16 |         [NonSerialized] public Font currentFont = null;
17 |         [NonSerialized] public bool showText = true;
18 | 
19 |         public void Update()
20 |         {
21 |             if (Input.GetKeyDown(KeyCode.F8))
22 |                 showText = !showText;
23 |         }
24 | 
25 |         public void OnGUI()
26 |         {
27 |             if (showText)
28 |             {
29 |                 if (cams == null || cams.Length == 0)
30 |                 {
31 |                     cams = FindObjectsOfType<Camera>();
32 |                     return;
33 |                 }
34 | 
35 |                 Camera camera = null;
36 |                 foreach (var cam in cams)
37 |                 {
38 |                     if (cam.gameObject.name == "ExtCamera")
39 |                         camera = cam;
40 |                 }
41 | 
42 |                 if (camera == null || exItemPrefab == null)
43 |                     return;
44 | 
45 |                 var centerY = Screen.height / 2;
46 |                 worldPos = camera.WorldToScreenPoint(transform.position);
47 | 
48 |                 if (worldPos.y <= centerY)
49 |                 {
50 |                     var distToCenter = centerY - worldPos.y;
51 |                     worldPos.Set(worldPos.x, distToCenter + centerY, worldPos.z);
52 |                 }
53 |                 else
54 |                 {
55 |                     var distToCenter = worldPos.y - centerY;
56 |                     worldPos.Set(worldPos.x, centerY - distToCenter, worldPos.z);
57 |                 }
58 | 
59 |                 AbstractItemBase component = exItemPrefab.GetComponent<AbstractItemBase>();
60 | 
61 |                 if (component == null)
62 |                     return;
63 | 
64 |                 if (currentFont == null)
65 |                     currentFont = Font.CreateDynamicFontFromOSFont("Consolas", 14);
66 | 
67 |                 var guistyle = new GUIStyle(GUI.skin.label)
68 |                 {
69 |                     fontStyle = FontStyle.Bold
70 |                 };
71 |                 guistyle.normal.textColor = Color.white;
72 |                 guistyle.font = currentFont;
73 | 
74 |                 GUI.Label(new Rect(worldPos, new Vector3(100f, 100f)),
75 |                     $"{component.itemLabel ?? "unknown"} ({component.itemValue})",
76 |                     guistyle);
77 |             }
78 |         }
79 |     }
80 | }
81 | #endif


--------------------------------------------------------------------------------
/LM2RandomiserShared/LaMulana2RandomizerShared.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
 4 |   <PropertyGroup>
 5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 7 |     <ProjectGuid>{9F97EB8E-6DCE-4F97-A1A6-5D0F354F581B}</ProjectGuid>
 8 |     <OutputType>Library</OutputType>
 9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
10 |     <RootNamespace>LaMulana2RandomizerShared</RootNamespace>
11 |     <AssemblyName>LaMulana2RandomizerShared</AssemblyName>
12 |     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
13 |     <FileAlignment>512</FileAlignment>
14 |     <Deterministic>true</Deterministic>
15 |   </PropertyGroup>
16 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
17 |     <DebugSymbols>true</DebugSymbols>
18 |     <DebugType>full</DebugType>
19 |     <Optimize>false</Optimize>
20 |     <OutputPath>bin\Debug\</OutputPath>
21 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
22 |     <ErrorReport>prompt</ErrorReport>
23 |     <WarningLevel>4</WarningLevel>
24 |   </PropertyGroup>
25 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
26 |     <DebugType>pdbonly</DebugType>
27 |     <Optimize>true</Optimize>
28 |     <OutputPath>bin\Release\</OutputPath>
29 |     <DefineConstants>TRACE</DefineConstants>
30 |     <ErrorReport>prompt</ErrorReport>
31 |     <WarningLevel>4</WarningLevel>
32 |   </PropertyGroup>
33 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == '1.0|AnyCPU'">
34 |     <OutputPath>bin\1.0\</OutputPath>
35 |     <DefineConstants>TRACE</DefineConstants>
36 |     <Optimize>true</Optimize>
37 |     <DebugType>pdbonly</DebugType>
38 |     <PlatformTarget>AnyCPU</PlatformTarget>
39 |     <LangVersion>7.3</LangVersion>
40 |     <ErrorReport>prompt</ErrorReport>
41 |     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
42 |   </PropertyGroup>
43 |   <ItemGroup>
44 |     <Reference Include="System" />
45 |     <Reference Include="System.Core" />
46 |     <Reference Include="System.Xml.Linq" />
47 |     <Reference Include="System.Data.DataSetExtensions" />
48 |     <Reference Include="System.Data" />
49 |     <Reference Include="System.Xml" />
50 |   </ItemGroup>
51 |   <ItemGroup>
52 |     <Compile Include="AreaID.cs" />
53 |     <Compile Include="ExitID.cs" />
54 |     <Compile Include="Version.cs" />
55 |     <Compile Include="ItemID.cs" />
56 |     <Compile Include="LocationID.cs" />
57 |     <Compile Include="Properties\AssemblyInfo.cs" />
58 |   </ItemGroup>
59 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
60 | </Project>


--------------------------------------------------------------------------------
/LaMulana2Randomizer.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 16
 4 | VisualStudioVersion = 16.0.29403.142
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LaMulana2Randomizer", "LaMulana2Randomizer\LaMulana2Randomizer.csproj", "{40078A86-30B5-410D-9691-EC207662AE2D}"
 7 | 	ProjectSection(ProjectDependencies) = postProject
 8 | 		{34400CB6-0827-46B4-801D-CA281FFACD2E} = {34400CB6-0827-46B4-801D-CA281FFACD2E}
 9 | 	EndProjectSection
10 | EndProject
11 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Assembly-CSharp", "Assembly-CSharp\Assembly-CSharp.csproj", "{34400CB6-0827-46B4-801D-CA281FFACD2E}"
12 | EndProject
13 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LaMulana2RandomizerShared", "LM2RandomiserShared\LaMulana2RandomizerShared.csproj", "{9F97EB8E-6DCE-4F97-A1A6-5D0F354F581B}"
14 | EndProject
15 | Global
16 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
17 | 		Debug|Any CPU = Debug|Any CPU
18 | 		Dev|Any CPU = Dev|Any CPU
19 | 		Release|Any CPU = Release|Any CPU
20 | 	EndGlobalSection
21 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
22 | 		{40078A86-30B5-410D-9691-EC207662AE2D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
23 | 		{40078A86-30B5-410D-9691-EC207662AE2D}.Debug|Any CPU.Build.0 = Debug|Any CPU
24 | 		{40078A86-30B5-410D-9691-EC207662AE2D}.Dev|Any CPU.ActiveCfg = Debug|Any CPU
25 | 		{40078A86-30B5-410D-9691-EC207662AE2D}.Dev|Any CPU.Build.0 = Debug|Any CPU
26 | 		{40078A86-30B5-410D-9691-EC207662AE2D}.Release|Any CPU.ActiveCfg = Release|Any CPU
27 | 		{40078A86-30B5-410D-9691-EC207662AE2D}.Release|Any CPU.Build.0 = Release|Any CPU
28 | 		{34400CB6-0827-46B4-801D-CA281FFACD2E}.Debug|Any CPU.ActiveCfg = Dev|Any CPU
29 | 		{34400CB6-0827-46B4-801D-CA281FFACD2E}.Debug|Any CPU.Build.0 = Dev|Any CPU
30 | 		{34400CB6-0827-46B4-801D-CA281FFACD2E}.Dev|Any CPU.ActiveCfg = Dev|Any CPU
31 | 		{34400CB6-0827-46B4-801D-CA281FFACD2E}.Dev|Any CPU.Build.0 = Dev|Any CPU
32 | 		{34400CB6-0827-46B4-801D-CA281FFACD2E}.Release|Any CPU.ActiveCfg = Release|Any CPU
33 | 		{34400CB6-0827-46B4-801D-CA281FFACD2E}.Release|Any CPU.Build.0 = Release|Any CPU
34 | 		{9F97EB8E-6DCE-4F97-A1A6-5D0F354F581B}.Debug|Any CPU.ActiveCfg = Release|Any CPU
35 | 		{9F97EB8E-6DCE-4F97-A1A6-5D0F354F581B}.Debug|Any CPU.Build.0 = Release|Any CPU
36 | 		{9F97EB8E-6DCE-4F97-A1A6-5D0F354F581B}.Dev|Any CPU.ActiveCfg = Release|Any CPU
37 | 		{9F97EB8E-6DCE-4F97-A1A6-5D0F354F581B}.Dev|Any CPU.Build.0 = Release|Any CPU
38 | 		{9F97EB8E-6DCE-4F97-A1A6-5D0F354F581B}.Release|Any CPU.ActiveCfg = Release|Any CPU
39 | 		{9F97EB8E-6DCE-4F97-A1A6-5D0F354F581B}.Release|Any CPU.Build.0 = Release|Any CPU
40 | 	EndGlobalSection
41 | 	GlobalSection(SolutionProperties) = preSolution
42 | 		HideSolutionNode = FALSE
43 | 	EndGlobalSection
44 | 	GlobalSection(ExtensibilityGlobals) = postSolution
45 | 		SolutionGuid = {60DC95DA-BA9D-482A-A02E-7674921D3CCD}
46 | 	EndGlobalSection
47 | EndGlobal
48 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace LaMulana2Randomizer.Properties
12 | {
13 | 
14 | 
15 |     /// <summary>
16 |     ///   A strongly-typed resource class, for looking up localized strings, etc.
17 |     /// </summary>
18 |     // This class was auto-generated by the StronglyTypedResourceBuilder
19 |     // class via a tool like ResGen or Visual Studio.
20 |     // To add or remove a member, edit your .ResX file then rerun ResGen
21 |     // with the /str option, or rebuild your VS project.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     internal class Resources
26 |     {
27 | 
28 |         private static global::System.Resources.ResourceManager resourceMan;
29 | 
30 |         private static global::System.Globalization.CultureInfo resourceCulture;
31 | 
32 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
33 |         internal Resources()
34 |         {
35 |         }
36 | 
37 |         /// <summary>
38 |         ///   Returns the cached ResourceManager instance used by this class.
39 |         /// </summary>
40 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
41 |         internal static global::System.Resources.ResourceManager ResourceManager {
42 |             get {
43 |                 if ((resourceMan == null))
44 |                 {
45 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("LaMulana2Randomizer.Properties.Resources", typeof(Resources).Assembly);
46 |                     resourceMan = temp;
47 |                 }
48 |                 return resourceMan;
49 |             }
50 |         }
51 | 
52 |         /// <summary>
53 |         ///   Overrides the current thread's CurrentUICulture property for all
54 |         ///   resource lookups using this strongly typed resource class.
55 |         /// </summary>
56 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
57 |         internal static global::System.Globalization.CultureInfo Culture {
58 |             get {
59 |                 return resourceCulture;
60 |             }
61 |             set {
62 |                 resourceCulture = value;
63 |             }
64 |         }
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Location.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using Newtonsoft.Json;
  3 | using Newtonsoft.Json.Converters;
  4 | using LaMulana2Randomizer.LogicParsing;
  5 | using LaMulana2Randomizer.ExtensionMethods;
  6 | using LaMulana2RandomizerShared;
  7 | 
  8 | namespace LaMulana2Randomizer
  9 | {
 10 |     public enum LocationType
 11 |     {
 12 |         Chest,
 13 |         FreeStanding,
 14 |         Shop,
 15 |         Dialogue,
 16 |         Mural,
 17 |         Miniboss,
 18 |         Guardian,
 19 |         FinalBoss,
 20 |         Puzzle,
 21 |         Dissonance,
 22 |         Fairy
 23 |     }
 24 | 
 25 |     public class JsonLocation
 26 |     {
 27 |         public string Name;
 28 | 
 29 |         [JsonConverter(typeof(StringEnumConverter))]
 30 |         public LocationType LocationType;
 31 | 
 32 |         public string Logic;
 33 |         public string HardLogic;
 34 |         public Item Item;
 35 |     }
 36 | 
 37 |     public class Location
 38 |     {
 39 |         public bool IsLocked = false;
 40 |         public bool RandomPlacement = false;
 41 | 
 42 |         private string logicString;
 43 |         private string hardLogicString;
 44 |         private BinaryNode logicTree;
 45 | 
 46 |         public string Name { get; private set; }
 47 |         public LocationType LocationType { get; private set; }
 48 |         public Item Item { get; private set; }
 49 |         public LocationID ID { get; private set; }
 50 |         public AreaID ParentAreaID { get; private set; }
 51 | 
 52 |         public Location(string name, LocationID id, LocationType locationType, string logic, AreaID parentAreaID)
 53 |         {
 54 |             Name = name;
 55 |             ID = id;
 56 |             LocationType = locationType;
 57 |             logicString = logic;
 58 |             ParentAreaID = parentAreaID;
 59 |         }
 60 | 
 61 |         public Location(JsonLocation jsonLocation, AreaID parentAreaID)
 62 |         {
 63 |             Name = jsonLocation.Name;
 64 |             LocationType = jsonLocation.LocationType;
 65 |             logicString = jsonLocation.Logic;
 66 |             hardLogicString = jsonLocation.HardLogic;
 67 |             Item = jsonLocation.Item;
 68 |             Enum.TryParse(Name.RemoveWhitespace(), out LocationID temp);
 69 |             ID = temp;
 70 |             ParentAreaID = parentAreaID;
 71 |         }
 72 | 
 73 |         public bool CanReach(PlayerState state)
 74 |         {
 75 |             return logicTree.Evaluate(state) && state.CanReach(ParentAreaID);
 76 |         }
 77 | 
 78 |         public bool CanCollect(PlayerState state)
 79 |         {
 80 |             return logicTree.Evaluate(state);
 81 |         }
 82 | 
 83 |         public void UseHardLogic()
 84 |         {
 85 |             logicString = hardLogicString;
 86 |         }
 87 | 
 88 |         public void PlaceItem(Item item, bool randomPlacement)
 89 |         {
 90 |             Item = item;
 91 |             RandomPlacement = randomPlacement;
 92 |         }
 93 | 
 94 |         public void AppendLogicString(string str)
 95 |         {
 96 |             logicString = string.Format($"({logicString}) {str}");
 97 |             BuildLogicTree();
 98 |         }
 99 | 
100 |         public void BuildLogicTree()
101 |         {
102 |             logicTree = LogicTree.ParseAndBuildLogic(logicString);
103 |         }
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/LogicParsing/LogicTree.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using LaMulana2Randomizer.Utils;
  4 | 
  5 | namespace LaMulana2Randomizer.LogicParsing
  6 | {
  7 |     public abstract class LogicTree
  8 |     {
  9 |         public static BinaryNode ParseAndBuildLogic(string logicString)
 10 |         {
 11 |             try
 12 |             {
 13 |                 IList<Token> tokens = new Tokeniser(logicString).Tokenise();
 14 |                 IList<Token> polish = ShuntingYard.Sort(tokens);
 15 |                 var enumerator = polish.GetEnumerator();
 16 |                 enumerator.MoveNext();
 17 | 
 18 |                 return BuildLogicTree(enumerator);
 19 |             }
 20 |             catch(Exception ex)
 21 |             {
 22 |                 Logger.Log($"Failed to parse or build logic string, {logicString}.");
 23 |                 Logger.LogAndFlush(ex.Message);
 24 |                 throw new LogicParsingExcpetion("Failed to parse logic.");
 25 |             }
 26 |         }
 27 | 
 28 |         private static BinaryNode BuildLogicTree(IEnumerator<Token> tokens)
 29 |         {
 30 |             if (tokens.Current.Type == TokenType.RuleToken)
 31 |             {
 32 |                 LogicNode node = new LogicNode(tokens.Current.Logic, tokens.Current.Value);
 33 |                 tokens.MoveNext();
 34 |                 return node;
 35 |             }
 36 |             else if (tokens.Current.Type == TokenType.AndOperator)
 37 |             {
 38 |                 tokens.MoveNext();
 39 |                 AndNode node = new AndNode
 40 |                 {
 41 |                     left = BuildLogicTree(tokens),
 42 |                     right = BuildLogicTree(tokens)
 43 |                 };
 44 |                 return node;
 45 |             }
 46 |             else if (tokens.Current.Type == TokenType.OrOperator)
 47 |             {
 48 |                 tokens.MoveNext();
 49 |                 OrNode node = new OrNode
 50 |                 {
 51 |                     left = BuildLogicTree(tokens),
 52 |                     right = BuildLogicTree(tokens)
 53 |                 };
 54 |                 return node;
 55 |             }
 56 | 
 57 |             return null;
 58 |         }
 59 |     }
 60 | 
 61 |     public abstract class BinaryNode
 62 |     {
 63 |         public BinaryNode left;
 64 |         public BinaryNode right;
 65 | 
 66 |         public abstract bool Evaluate(PlayerState state);
 67 |     }
 68 | 
 69 |     public class AndNode : BinaryNode
 70 |     {
 71 |         public override bool Evaluate(PlayerState state)
 72 |         {
 73 |             return left.Evaluate(state) && right.Evaluate(state);
 74 |         }
 75 |     }
 76 | 
 77 |     public class OrNode : BinaryNode
 78 |     {
 79 |         public override bool Evaluate(PlayerState state)
 80 |         {
 81 |             return left.Evaluate(state) || right.Evaluate(state);
 82 |         }
 83 |     }
 84 | 
 85 |     public class LogicNode : BinaryNode
 86 |     {
 87 |         public Logic logic;
 88 | 
 89 |         public LogicNode(string logicType, string value = null)
 90 |         {
 91 |             logic = new Logic(logicType, value);
 92 |         }
 93 | 
 94 |         public override bool Evaluate(PlayerState state)
 95 |         {
 96 |             return state.Evaluate(logic);
 97 |         }
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Exit.cs:
--------------------------------------------------------------------------------
 1 | using LaMulana2Randomizer.LogicParsing;
 2 | using LaMulana2RandomizerShared;
 3 | 
 4 | namespace LaMulana2Randomizer
 5 | {
 6 |     public enum ExitType
 7 |     {
 8 |         LeftDoor,
 9 |         RightDoor,
10 |         DownLadder,
11 |         UpLadder,
12 |         Gate,
13 |         SoulGate,
14 |         OneWay,
15 |         Pyramid,
16 |         Corridor,
17 |         Internal,
18 |         PrisonExit,
19 |         PrisonGate,
20 |         Start,
21 |         Elevator,
22 |         Altar,
23 |         SpiralGate
24 |     }
25 | 
26 |     public class JsonExit
27 |     {
28 |         public string Name;
29 |         public ExitID ID;
30 |         public AreaID ConnectingAreaID;
31 |         public string Logic;
32 |         public ExitType ConnectionType;
33 |     }
34 | 
35 |     public class Exit
36 |     {
37 |         public AreaID ConnectingAreaID;
38 |         public bool Checking = false;
39 | 
40 |         private string logicString;
41 |         private BinaryNode logicTree;
42 | 
43 |         public string Name { get; private set; }
44 |         public AreaID ParentAreaID { get; private set; }
45 |         public ExitID ID { get; private set; }
46 |         public ExitType ExitType { get; private set; }
47 | 
48 |         public bool IsInaccessible {
49 |             get => ID == ExitID.fP02Left || ID == ExitID.fStart || ID == ExitID.fL05Up || ID == ExitID.fL08Right || ID == ExitID.f02GateYA || 
50 |                     ID == ExitID.f02Down || ID == ExitID.f03In || ID == ExitID.f03GateYC || ID == ExitID.f03Down2 || ID == ExitID.f06GateP0 || 
51 |                     ID == ExitID.f09In || ID == ExitID.f12GateP0 || ID == ExitID.f13GateP0 || ID == ExitID.fNibiru || ID == ExitID.fP01Left;
52 |         }
53 | 
54 |         public bool IsDeadEnd {
55 |             get => ID == ExitID.fStart || ID == ExitID.fL05Up || ID == ExitID.fL08Right || ID == ExitID.fLGate || ID == ExitID.f00Down || 
56 |                     ID == ExitID.f00GateYA || ID == ExitID.f01Down || ID == ExitID.f03Down1 || ID == ExitID.f03Down2 || ID == ExitID.f03Down3 || 
57 |                     ID == ExitID.f04Up3 || ID == ExitID.f06GateP0 || ID == ExitID.f06_2GateP0 || ID == ExitID.f09In || ID == ExitID.f09GateP0 || 
58 |                     ID == ExitID.f11Pyramid || ID == ExitID.f12GateP0 || ID == ExitID.f13GateP0 || ID == ExitID.fNibiru || ID == ExitID.fP01Right;
59 |         }
60 | 
61 |         public bool IsOneWay {
62 |             get => ID == ExitID.fL05Up || ID == ExitID.f02Down || ID == ExitID.f03Down2 || ID == ExitID.f03In || ID == ExitID.f09In;
63 |         }
64 | 
65 |         public Exit(JsonExit jsonConnection, AreaID parentAreaID) 
66 |         {
67 |             Name = jsonConnection.Name;
68 |             ID = jsonConnection.ID;
69 |             ConnectingAreaID = jsonConnection.ConnectingAreaID;
70 |             logicString = jsonConnection.Logic;
71 |             ExitType = jsonConnection.ConnectionType;
72 |             ParentAreaID = parentAreaID;
73 |             if (string.IsNullOrEmpty(Name))
74 |                 Name = $"{ParentAreaID} to {ConnectingAreaID}";
75 |         }
76 | 
77 |         public bool CanReach(PlayerState state)
78 |         {
79 |             return logicTree.Evaluate(state) && state.CanReach(ParentAreaID);
80 |         }
81 | 
82 |         public void AppendLogicString(string str)
83 |         {
84 |             logicString = string.Format($"({logicString}) {str}");
85 |             BuildLogicTree();
86 |         }
87 | 
88 |         public void BuildLogicTree()
89 |         {
90 |             logicTree = LogicTree.ParseAndBuildLogic(logicString);
91 |         }
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/ItemPool.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Linq;
  3 | using System.Collections;
  4 | using System.Collections.Generic;
  5 | using LaMulana2RandomizerShared;
  6 | 
  7 | namespace LaMulana2Randomizer
  8 | {
  9 |     public class ItemPool : IEnumerable
 10 |     {
 11 |         private readonly List<Item> items;
 12 | 
 13 |         public int ItemCount {
 14 |             get => items.Count;
 15 |         }
 16 | 
 17 |         public ItemPool() 
 18 |         {
 19 |             items = new List<Item>();
 20 |         }
 21 | 
 22 |         public ItemPool(List<Item> items)
 23 |         {
 24 |             this.items = items;
 25 |         }
 26 | 
 27 |         public void Add(Item item)
 28 |         {
 29 |             items.Add(item);
 30 |         }
 31 | 
 32 |         public void Remove(ItemID id)
 33 |         {
 34 |             items.Remove(Get(id));
 35 |         }
 36 | 
 37 |         public Item Get(ItemID id)
 38 |         {
 39 |             return items.Find(i => i.ID == id);
 40 |         }
 41 | 
 42 |         public Item GetAndRemove(ItemID id)
 43 |         {
 44 |             Item item = Get(id);
 45 |             items.Remove(item);
 46 |             return item;
 47 |         }
 48 | 
 49 |         public Item RandomGetAndRemove(Random random)
 50 |         {
 51 |             Item item = items[random.Next(items.Count)];
 52 |             items.Remove(item);
 53 |             return item;
 54 |         }
 55 | 
 56 |         public ItemPool GetandRemoveRequiredItems()
 57 |         {
 58 |             List<Item> required = items.Where(item => item.IsRequired).ToList();
 59 |             foreach (Item item in required)
 60 |                 items.Remove(item);
 61 | 
 62 |             return new ItemPool(required);
 63 |         }
 64 | 
 65 |         public ItemPool GetandRemoveNonRequiredItems()
 66 |         {
 67 |             List<Item> nonRequired = items.Where(item => !item.IsRequired).ToList();
 68 |             foreach (Item item in nonRequired)
 69 |                 items.Remove(item);
 70 | 
 71 |             return new ItemPool(nonRequired);
 72 |         }
 73 | 
 74 |         public List<Item> GetAndRemoveShopOnlyItems()
 75 |         {
 76 |             List<Item> shopItems = items.Where(item => item.ID >= ItemID.ShurikenAmmo && item.ID <= ItemID.Weights).ToList();
 77 |             foreach (Item item in shopItems)
 78 |                 items.Remove(item);
 79 | 
 80 |             return shopItems;
 81 |         }
 82 | 
 83 |         public List<Item> GetAndRemoveMantras()
 84 |         {
 85 |             var mantras = items.Where(item => item.ID >= ItemID.Heaven && item.ID <= ItemID.Night).ToList();
 86 |             foreach (Item mantra in mantras)
 87 |                 items.Remove(mantra);
 88 | 
 89 |             return mantras;
 90 |         }
 91 | 
 92 |         public ItemPool Copy()
 93 |         {
 94 |             List<Item> copies = new List<Item>();
 95 | 
 96 |             foreach (Item item in items)
 97 |                 copies.Add(item.DeepCopy());
 98 | 
 99 |             return new ItemPool(copies);
100 |         }
101 | 
102 |         public IEnumerator GetEnumerator()
103 |         {
104 |             foreach (Item item in items)
105 |                 yield return item;
106 |         }
107 | 
108 |         //
109 |         public ItemPool CreateRandomShopPool(int size, Random random)
110 |         {
111 |             if (size <= 0)
112 |                 throw new RandomiserException($"Can not create a random shop item pool with size {size}.");
113 | 
114 |             var shopItems = GetAndRemoveShopOnlyItems();
115 |             if (shopItems.Count <= 0)
116 |                 throw new RandomiserException($"Can not create a random shop item pool from {shopItems.Count} shop items.");
117 | 
118 |             ItemPool itemPool = new ItemPool(shopItems);
119 |             for (; size > 0; size--)
120 |                 itemPool.Add(shopItems[random.Next(shopItems.Count)]);
121 | 
122 |             return itemPool;
123 |         }
124 |     }
125 | }
126 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/Status.cs:
--------------------------------------------------------------------------------
  1 | using MonoMod;
  2 | using UnityEngine;
  3 | using L2Word;
  4 | using L2Menu;
  5 | using L2Hit;
  6 | 
  7 | #pragma warning disable 0649, 0414, 0108, 0626
  8 | namespace LM2RandomiserMod.Patches
  9 | {
 10 | 	[MonoModPatch("L2STATUS.Status")]
 11 | 	public class patched_Status : L2STATUS.Status
 12 | 	{
 13 | 		[MonoModIgnore]
 14 | 		private StatusBarIF statusbar;
 15 | 
 16 | 		[MonoModIgnore]
 17 | 		private int player_level;
 18 | 
 19 | 		[MonoModIgnore]
 20 | 		private int HPTANK;
 21 | 
 22 | 		[MonoModReplace]
 23 | 		public void resetPlayerStatus(int lv, int hp, int mcoin, int coin, int wait, int exp, MAINWEAPON now_wea, int now_wea_num, SUBWEAPON now_sub, int now_sub_num, USEITEM now_use, int now_use_num)
 24 | 		{
 25 | 			sys.setFlagData(2, 62, 0);
 26 | 			clearItemsNum();
 27 | 			string weaponName = string.Empty;
 28 | 			if (now_wea != MAINWEAPON.NON)
 29 | 			{
 30 | 				weaponName = sys.exchengeMainWeaponEnumToName(now_wea);
 31 | 			}
 32 | 			else if (now_sub != SUBWEAPON.NON)
 33 | 			{
 34 | 				weaponName = sys.exchengeSubWeaponEnumToName(now_sub);
 35 | 			}
 36 | 
 37 | 			if (!string.IsNullOrEmpty(weaponName))
 38 | 			{
 39 | 				sys.setItem(weaponName, 1, false, false, true);
 40 | 				sys.equipItem(weaponName, true);
 41 | 			}
 42 | 
 43 | 			player_level = lv;
 44 | 			if (player_level < 1)
 45 | 			{
 46 | 				player_level = 1;
 47 | 			}
 48 | 			if (hp < 1)
 49 | 			{
 50 | 				l2_hp = HPTANK * lv;
 51 | 			}
 52 | 			else
 53 | 			{
 54 | 				l2_hp = hp;
 55 | 			}
 56 | 			max_hp = HPTANK * lv;
 57 | 			max_coin = mcoin;
 58 | 			l2_coin = coin;
 59 | 			setMainWeapon(now_wea);
 60 | 			setSubWeapon(now_sub);
 61 | 			setUseItem(now_use);
 62 | 			statusbar.setInitHP(l2_hp / 100, (float)(max_hp / 100));
 63 | 			l2Exp = exp;
 64 | 			statusbar.setExp(exp);
 65 | 			if (max_coin < 1000)
 66 | 			{
 67 | 				statusbar.setCoin(l2_coin, 3);
 68 | 				statusbar.changeCoinMax(999);
 69 | 			}
 70 | 			else
 71 | 			{
 72 | 				statusbar.setCoin(l2_coin, 4);
 73 | 				statusbar.changeCoinMax(2000);
 74 | 			}
 75 | 			l2_wait = wait;
 76 | 			statusbar.setWait(wait);
 77 | 			statusbar.setMain(l2_eq_main, l2_main[(int)now_wea]);
 78 | 			statusbar.setSub(l2_eq_sub, l2_sub[(int)now_sub]);
 79 | 			statusbar.setUse(l2_eq_use, l2_use[(int)now_use]);
 80 | 		}
 81 | 
 82 | 		[MonoModReplace]
 83 | 		public MAINWEAPON changeMainWeapon(int slide_vector)
 84 | 		{
 85 | 			MAINWEAPON mainweapon = getMainWeapon();
 86 | 			for(int i = 0; i < 5; i++)
 87 | 			{
 88 | 				if (slide_vector == 1)
 89 | 				{
 90 | 					switch (mainweapon)
 91 | 					{
 92 | 						case MAINWEAPON.LWHIP:
 93 | 							mainweapon = MAINWEAPON.KNIFE;
 94 | 							break;
 95 | 						case MAINWEAPON.MWIHP:
 96 | 							mainweapon = MAINWEAPON.KNIFE;
 97 | 							break;
 98 | 						case MAINWEAPON.HWHIP:
 99 | 							mainweapon = MAINWEAPON.KNIFE;
100 | 							break;
101 | 						case MAINWEAPON.KNIFE:
102 | 							mainweapon = MAINWEAPON.RAPIER;
103 | 							break;
104 | 						case MAINWEAPON.RAPIER:
105 | 							mainweapon = MAINWEAPON.AXE;
106 | 							break;
107 | 						case MAINWEAPON.AXE:
108 | 							mainweapon = MAINWEAPON.SWORD;
109 | 							break;
110 | 						case MAINWEAPON.SWORD:
111 | 						case MAINWEAPON.NON:
112 | 							if (isMainWeapon(MAINWEAPON.HWHIP))
113 | 							{
114 | 								mainweapon = MAINWEAPON.HWHIP;
115 | 							}
116 | 							else if (isMainWeapon(MAINWEAPON.MWIHP))
117 | 							{
118 | 								mainweapon = MAINWEAPON.MWIHP;
119 | 							}
120 | 							else
121 | 							{
122 | 								mainweapon = MAINWEAPON.LWHIP;
123 | 							}
124 | 							break;
125 | 					}
126 | 				}
127 | 				else
128 | 				{
129 | 					switch (mainweapon)
130 | 					{
131 | 						case MAINWEAPON.LWHIP:
132 | 						case MAINWEAPON.MWIHP:
133 | 						case MAINWEAPON.HWHIP:
134 | 						case MAINWEAPON.NON:
135 | 							mainweapon = MAINWEAPON.SWORD;
136 | 							break;
137 | 						case MAINWEAPON.KNIFE:
138 | 							if (isMainWeapon(MAINWEAPON.HWHIP))
139 | 							{
140 | 								mainweapon = MAINWEAPON.HWHIP;
141 | 							}
142 | 							else if (isMainWeapon(MAINWEAPON.MWIHP))
143 | 							{
144 | 								mainweapon = MAINWEAPON.MWIHP;
145 | 							}
146 | 							else
147 | 							{
148 | 								mainweapon = MAINWEAPON.LWHIP;
149 | 							}
150 | 							break;
151 | 						case MAINWEAPON.RAPIER:
152 | 							mainweapon = MAINWEAPON.KNIFE;
153 | 							break;
154 | 						case MAINWEAPON.AXE:
155 | 							mainweapon = MAINWEAPON.RAPIER;
156 | 							break;
157 | 						case MAINWEAPON.SWORD:
158 | 							mainweapon = MAINWEAPON.AXE;
159 | 							break;
160 | 					}
161 | 				}
162 | 
163 | 				if (isMainWeapon(mainweapon))
164 | 					return mainweapon;
165 | 			}
166 | 
167 | 			return MAINWEAPON.NON;
168 | 		}
169 | 	}
170 | }
171 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/SeihaiMenu.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using MonoMod;
  6 | 
  7 | #pragma warning disable 0649, 0414, 0108
  8 | namespace LM2RandomiserMod.Patches
  9 | {
 10 |     [MonoModPatch("L2Menu.SeihaiMenu")]
 11 |     public class patched_SeihaiMenu : L2Menu.SeihaiMenu
 12 |     {
 13 |         [MonoModReplace]
 14 | 		private void getOnHolyNum(out int omote, out int ura)
 15 | 		{
 16 | 			uint fieldWarpFlag = this.sys.getFieldWarpFlag();
 17 | 			omote = 0;
 18 | 			ura = 0;
 19 | 			for (int i = 0; i < 10; i++)
 20 | 			{
 21 | 				if ((fieldWarpFlag >> i & 1u) == 1u)
 22 | 				{
 23 | 					omote++;
 24 | 				}
 25 | 			}
 26 | 			for (int j = 10; j < 20; j++)
 27 | 			{
 28 | 				if ((fieldWarpFlag >> j & 1u) == 1u)
 29 | 				{
 30 | 					ura++;
 31 | 				}
 32 | 			}
 33 | 
 34 | 			if (!sys.getPlayer()._uraWarp)
 35 | 				ura = 0;
 36 | 		}
 37 | 
 38 | 		[MonoModIgnore]
 39 | 		private int[] warppointbuffer_omote;
 40 | 
 41 | 		[MonoModIgnore]
 42 | 		private int[] warppointbuffer_ura;
 43 | 
 44 | 		[MonoModReplace]
 45 | 		private int getNowFieldPoint(int omotenum, int uranum, out int uraomote)
 46 | 		{
 47 | 			ViewProperty currentView = sys.getL2SystemCore().ScrollSystem.getCurrentView();
 48 | 			int sceaneNo = sys.getL2SystemCore().SceaneNo;
 49 | 			bool flag = sys.getPlayer()._uraWarp && uranum > 0;
 50 | 			int num;
 51 | 			switch (sceaneNo)
 52 | 			{
 53 | 				case 0:
 54 | 					uraomote = 0;
 55 | 					num = 1;
 56 | 					break;
 57 | 				case 1:
 58 | 					uraomote = 0;
 59 | 					num = 0;
 60 | 					break;
 61 | 				case 2:
 62 | 					uraomote = 0;
 63 | 					num = 2;
 64 | 					break;
 65 | 				case 3:
 66 | 					if (currentView.ViewY >= 5 && flag)
 67 | 					{
 68 | 						uraomote = 1;
 69 | 						num = 12;
 70 | 					}
 71 | 					else
 72 | 					{
 73 | 						uraomote = 0;
 74 | 						num = 3;
 75 | 					}
 76 | 					break;
 77 | 				case 4:
 78 | 					if (currentView.ViewX >= 4 && flag)
 79 | 					{
 80 | 						uraomote = 1;
 81 | 						num = 13;
 82 | 					}
 83 | 					else
 84 | 					{
 85 | 						uraomote = 0;
 86 | 						num = 4;
 87 | 					}
 88 | 					break;
 89 | 				case 5:
 90 | 					uraomote = 0;
 91 | 					num = 5;
 92 | 					break;
 93 | 				case 6:
 94 | 					uraomote = 0;
 95 | 					num = 6;
 96 | 					break;
 97 | 				case 7:
 98 | 					uraomote = 0;
 99 | 					num = 7;
100 | 					break;
101 | 				case 8:
102 | 					uraomote = 0;
103 | 					num = 8;
104 | 					break;
105 | 				case 9:
106 | 					uraomote = 0;
107 | 					num = 9;
108 | 					break;
109 | 				case 10:
110 | 					if (flag)
111 | 					{
112 | 						uraomote = 1;
113 | 						num = 14;
114 | 					}
115 | 					else
116 | 					{
117 | 						uraomote = 0;
118 | 						num = 0;
119 | 					}
120 | 					break;
121 | 				case 11:
122 | 					if (flag)
123 | 					{
124 | 						uraomote = 1;
125 | 						num = 16;
126 | 					}
127 | 					else
128 | 					{
129 | 						uraomote = 0;
130 | 						num = 0;
131 | 					}
132 | 					break;
133 | 				case 12:
134 | 					if (flag)
135 | 					{
136 | 						uraomote = 1;
137 | 						num = 17;
138 | 					}
139 | 					else
140 | 					{
141 | 						uraomote = 0;
142 | 						num = 0;
143 | 					}
144 | 					break;
145 | 				case 13:
146 | 					if (flag)
147 | 					{
148 | 						uraomote = 1;
149 | 						num = 18;
150 | 					}
151 | 					else
152 | 					{
153 | 						uraomote = 0;
154 | 						num = 0;
155 | 					}
156 | 					break;
157 | 				case 14:
158 | 					if (flag)
159 | 					{
160 | 						uraomote = 1;
161 | 						num = 10;
162 | 					}
163 | 					else
164 | 					{
165 | 						uraomote = 0;
166 | 						num = 0;
167 | 					}
168 | 					break;
169 | 				case 15:
170 | 					if (flag)
171 | 					{
172 | 						uraomote = 1;
173 | 						num = 11;
174 | 					}
175 | 					else
176 | 					{
177 | 						uraomote = 0;
178 | 						num = 0;
179 | 					}
180 | 					break;
181 | 				case 28:
182 | 					if (flag)
183 | 					{
184 | 						uraomote = 1;
185 | 						num = 15;
186 | 					}
187 | 					else
188 | 					{
189 | 						uraomote = 0;
190 | 						num = 0;
191 | 					}
192 | 					break;
193 | 				case 32:
194 | 					uraomote = 0;
195 | 					num = 0;
196 | 					break;
197 | 				default:
198 | 					uraomote = 0;
199 | 					num = -1;
200 | 					break;
201 | 			}
202 | 
203 | 			if (omotenum == 0 && uraomote == 0)
204 | 			{
205 | 				num = -1;
206 | 				uraomote = 1;
207 | 			}
208 | 
209 | 			if (num != -1)
210 | 			{
211 | 				if (uraomote == 0)
212 | 				{
213 | 					for (int i = 0; i < omotenum; i++)
214 | 					{
215 | 						if (this.warppointbuffer_omote[i] == num)
216 | 						{
217 | 							return i;
218 | 						}
219 | 					}
220 | 				}
221 | 				else if (uraomote == 1)
222 | 				{
223 | 					for (int i = 0; i < uranum; i++)
224 | 					{
225 | 						if (this.warppointbuffer_ura[i] == num)
226 | 						{
227 | 							return i;
228 | 						}
229 | 					}
230 | 				}
231 | 			}
232 | 			return 0;
233 | 		}
234 | 	}
235 | }
236 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/L2FlagSystem.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using L2Base;
  4 | using L2Flag;
  5 | using UnityEngine;
  6 | using MonoMod;
  7 | using MonoMod.ModInterop;
  8 | 
  9 | #pragma warning disable 0626, 0649, 0414, 0108
 10 | namespace LM2RandomiserMod.Patches
 11 | {
 12 |     [MonoModPatch("L2Flag.L2FlagSystem")]
 13 |     public class patched_L2FlagSystem : L2Flag.L2FlagSystem
 14 |     {
 15 |         [NonSerialized] public Queue<string> flagWatch = new Queue<string>();
 16 |         [NonSerialized] public Queue<L2FlagBoxEnd> flags = new Queue<L2FlagBoxEnd>();
 17 |         [NonSerialized] private ItemTracker ItemTracker;
 18 | 
 19 |         public patched_L2FlagSystem(L2System l2sys) : base(l2sys)
 20 |         {
 21 |             typeof(patched_L2FlagSystem).ModInterop();
 22 |         }
 23 | 
 24 |         public extern bool orig_setFlagData(int sheet_no, string name, short data);
 25 |         public extern bool orig_setFlagData(int sheet_no, int flag_no, short data);
 26 |         public extern void orig_addFlag(int seet_no1, int flag_no1, short value, CALCU cul);
 27 | 
 28 |         public bool setFlagData(int sheet_no, string name, short data)
 29 |         {
 30 | #if DEV
 31 |             AddFlagToWatch(sheet_no, name, data);
 32 | #endif
 33 |             bool result = orig_setFlagData(sheet_no, name, data);
 34 | 
 35 |             if (ItemTracker == null)
 36 |                 ItemTracker = GameObject.FindObjectOfType<ItemTracker>();
 37 | 
 38 |             if(ItemTracker != null)
 39 |                 ItemTracker.Add(sheet_no, getFlagNo(sheet_no, name));
 40 | 
 41 |             return result;
 42 |         }
 43 | 
 44 |         public bool setFlagData(int sheet_no, int flag_no, short data)
 45 |         {
 46 |             string name = flag.cellData[sheet_no][flag_no + 1][0][0];
 47 | #if DEV
 48 |             AddFlagToWatch(sheet_no, name, data);
 49 | #endif
 50 |             bool result = orig_setFlagData(sheet_no, flag_no, data);
 51 | 
 52 |             if (ItemTracker == null)
 53 |                 ItemTracker = GameObject.FindObjectOfType<ItemTracker>();
 54 | 
 55 |             if (ItemTracker != null)
 56 |                 ItemTracker.Add(sheet_no, flag_no);
 57 | 
 58 |             return result;
 59 |         }
 60 | 
 61 |         public void addFlag(int seet_no1, int flag_no1, short value, CALCU cul)
 62 |         {
 63 |             string name = flag.cellData[seet_no1][flag_no1 + 1][0][0];
 64 | #if DEV
 65 |             AddFlagToWatch(seet_no1, name, value, cul);
 66 | #endif
 67 |             orig_addFlag(seet_no1, flag_no1, value, cul);
 68 | 
 69 |             if (ItemTracker == null)
 70 |                 ItemTracker = GameObject.FindObjectOfType<ItemTracker>();
 71 | 
 72 |             if (ItemTracker != null)
 73 |                 ItemTracker.Add(seet_no1, flag_no1);
 74 |         }
 75 | 
 76 |         public void AddFlagToWatch(int sheet_no, string name, short data, CALCU cul)
 77 |         {
 78 |             if (name.StartsWith("playtime")) return;
 79 |             if (name.Contains("pDoor")) return;
 80 |             if (name == "Gold" || name == "weight" || name == "Playtime") return;
 81 | 
 82 |             if (flagWatch == null)
 83 |                 flagWatch = new Queue<string>();
 84 | 
 85 |             short oldData = 0;
 86 |             if (!getFlag(sheet_no, name, ref oldData)) return;
 87 | 
 88 |             short difference;
 89 |             switch (cul)
 90 |             {
 91 |                 case CALCU.EQR:
 92 |                     difference = (short)(data - oldData);
 93 |                     break;
 94 |                 case CALCU.ADD:
 95 |                     difference = data;
 96 |                     break;
 97 |                 case CALCU.SUB:
 98 |                     difference = (short)-data;
 99 |                     break;
100 |                 default:
101 |                     return;
102 |             }
103 | 
104 |             flagWatch.Enqueue($"[{sheet_no},{getFlagNo(sheet_no, name)}]{flag.seetName[sheet_no]}.{name} = {oldData + difference} (diff:{difference})");
105 | 
106 |             if (flagWatch.Count > 12)
107 |                 flagWatch.Dequeue();
108 |         }
109 | 
110 |         public void AddFlagToWatch(int sheet_no, string name, short data)
111 |         {
112 |             if (name.StartsWith("playtime")) return;
113 |             if (name.Contains("pDoor")) return;
114 |             if (name == "Gold" || name == "weight" || name == "Playtime") return;
115 | 
116 |             if (flagWatch == null)
117 |                 flagWatch = new Queue<string>();
118 | 
119 |             short oldData = 0;
120 |             if (!getFlag(sheet_no, name, ref oldData)) return;
121 | 
122 |             short difference = (short)(data - oldData);
123 | 
124 |             flagWatch.Enqueue($"[{sheet_no},{getFlagNo(sheet_no, name)}]{flag.seetName[sheet_no]}.{name} = {data} (diff:{difference})");
125 | 
126 |             if (flagWatch.Count > 12)
127 |                 flagWatch.Dequeue();
128 |         }
129 |         public Queue<string> GetFlagWatches()
130 |         {
131 |             return flagWatch;
132 |         }
133 | 
134 |         public Queue<L2FlagBoxEnd> GetFlags()
135 |         {
136 |             return flags;
137 |         }
138 |     }
139 | }
140 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:element name="root" msdata:IsDataSet="true">
 64 |       <xsd:complexType>
 65 |         <xsd:choice maxOccurs="unbounded">
 66 |           <xsd:element name="metadata">
 67 |             <xsd:complexType>
 68 |               <xsd:sequence>
 69 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 70 |               </xsd:sequence>
 71 |               <xsd:attribute name="name" type="xsd:string" />
 72 |               <xsd:attribute name="type" type="xsd:string" />
 73 |               <xsd:attribute name="mimetype" type="xsd:string" />
 74 |             </xsd:complexType>
 75 |           </xsd:element>
 76 |           <xsd:element name="assembly">
 77 |             <xsd:complexType>
 78 |               <xsd:attribute name="alias" type="xsd:string" />
 79 |               <xsd:attribute name="name" type="xsd:string" />
 80 |             </xsd:complexType>
 81 |           </xsd:element>
 82 |           <xsd:element name="data">
 83 |             <xsd:complexType>
 84 |               <xsd:sequence>
 85 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 86 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 87 |               </xsd:sequence>
 88 |               <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
 89 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 90 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 91 |             </xsd:complexType>
 92 |           </xsd:element>
 93 |           <xsd:element name="resheader">
 94 |             <xsd:complexType>
 95 |               <xsd:sequence>
 96 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 97 |               </xsd:sequence>
 98 |               <xsd:attribute name="name" type="xsd:string" use="required" />
 99 |             </xsd:complexType>
100 |           </xsd:element>
101 |         </xsd:choice>
102 |       </xsd:complexType>
103 |     </xsd:element>
104 |   </xsd:schema>
105 |   <resheader name="resmimetype">
106 |     <value>text/microsoft-resx</value>
107 |   </resheader>
108 |   <resheader name="version">
109 |     <value>2.0</value>
110 |   </resheader>
111 |   <resheader name="reader">
112 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
113 |   </resheader>
114 |   <resheader name="writer">
115 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 | </root>


--------------------------------------------------------------------------------
/LaMulana2Randomizer/LogicParsing/Tokeniser.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Collections.Generic;
  4 | 
  5 | namespace LaMulana2Randomizer.LogicParsing
  6 | {
  7 |     public enum TokenType
  8 |     {
  9 |         OpenParentheses,
 10 |         ClosedParentheses,
 11 |         OrOperator,
 12 |         AndOperator,
 13 |         RuleToken
 14 |     }
 15 | 
 16 |     public class Token
 17 |     {
 18 |         public TokenType Type;
 19 |         public string Logic;
 20 |         public string Value;
 21 | 
 22 |         public Token(TokenType type, string logic = null, string value = null)
 23 |         {
 24 |             Type = type;
 25 |             Logic = logic;
 26 |             Value = value;
 27 |         }
 28 |     }
 29 | 
 30 |     public class Tokeniser
 31 |     {
 32 |         private char next;
 33 |         private int parenthesCheck = 0;
 34 | 
 35 |         private readonly StringReader reader;
 36 |         private readonly IList<Token> tokens;
 37 | 
 38 |         public Tokeniser(string line)
 39 |         {
 40 |             reader = new StringReader(line);
 41 |             tokens = new List<Token>();
 42 |         }
 43 | 
 44 |         public IList<Token> Tokenise()
 45 |         {
 46 |             while (reader.Peek() != -1)
 47 |             {
 48 |                 next = (char)reader.Peek();
 49 |                 if (next.Equals('('))
 50 |                 {
 51 |                     if (tokens.Count != 0)
 52 |                     {
 53 |                         Token previousToken = tokens[tokens.Count - 1];
 54 |                         if (previousToken.Type == TokenType.ClosedParentheses || previousToken.Type == TokenType.RuleToken)
 55 |                             throw new TokeniserException("An open parentheses can only follow an \"and\" expression, an \"or\" expression or an parenthesis.");
 56 |                     }
 57 | 
 58 |                     tokens.Add(new Token(TokenType.OpenParentheses));
 59 |                     parenthesCheck++;
 60 |                     reader.Read();
 61 |                 }
 62 |                 else if (next.Equals(')'))
 63 |                 {
 64 |                     if (tokens.Count == 0)
 65 |                     {
 66 |                         throw new TokeniserException("Logic string can't start with a closed parentheses.");
 67 |                     }
 68 |                     else
 69 |                     {
 70 |                         Token previousToken = tokens[tokens.Count - 1];
 71 |                         if (previousToken.Type == TokenType.OpenParentheses || previousToken.Type == TokenType.AndOperator || previousToken.Type == TokenType.OrOperator)
 72 |                             throw new TokeniserException("A closed parentheses can only follow a logic expression or a closed parenthesis.");
 73 |                     }
 74 | 
 75 |                     tokens.Add(new Token(TokenType.ClosedParentheses));
 76 |                     parenthesCheck--;
 77 |                     reader.Read();
 78 |                 }
 79 |                 else if (char.IsLetter(next))
 80 |                 {
 81 |                     Expression();
 82 |                 }
 83 |                 else if (char.IsWhiteSpace(next))
 84 |                 {
 85 |                     reader.Read();
 86 |                 }
 87 |                 else
 88 |                 {
 89 |                     throw new TokeniserException($"Failed to parse character \"{next}\" when tokenising logic string.");
 90 |                 }
 91 |             }
 92 | 
 93 |             if(parenthesCheck != 0)
 94 |                 throw new TokeniserException("Mismatched amount of open and closed parentheses in logic string.");
 95 | 
 96 |             return tokens;
 97 |         }
 98 | 
 99 |         void Expression()
100 |         {
101 |             string s = GetString();
102 | 
103 |             if (s.Equals("or"))
104 |             {
105 |                 if (tokens.Count == 0)
106 |                     throw new TokeniserException("Logic string can't start with \"or\" expression.");
107 | 
108 |                 Token previousToken = tokens[tokens.Count - 1];
109 |                 if (previousToken.Type == TokenType.ClosedParentheses || previousToken.Type == TokenType.RuleToken)
110 |                     tokens.Add(new Token(TokenType.OrOperator));
111 |                 else
112 |                     throw new TokeniserException("An \"or\" expression can only follow a closed parentheses or logic expression in a logic string.");
113 |             }
114 |             else if (s.Equals("and"))
115 |             {
116 |                 if (tokens.Count == 0)
117 |                     throw new TokeniserException("Rule string can't start with \"and\" expression.");
118 | 
119 |                 Token previousToken = tokens[tokens.Count - 1];
120 |                 if (previousToken.Type == TokenType.ClosedParentheses || previousToken.Type == TokenType.RuleToken)
121 |                     tokens.Add(new Token(TokenType.AndOperator));
122 |                 else
123 |                     throw new TokeniserException("An \"and\" expression can only follow a closed parentheses or a logic expression in a logic string.");
124 |             }
125 |             else
126 |             {
127 |                 if (tokens.Count != 0)
128 |                 {
129 |                     Token previousToken = tokens[tokens.Count - 1];
130 |                     if (previousToken.Type == TokenType.ClosedParentheses || previousToken.Type == TokenType.RuleToken)
131 |                         throw new TokeniserException("A rule expression can only follow and open parentheses, an \"and\" expression or an \"or\" expression in a logic string.");
132 |                     
133 |                 }
134 | 
135 |                 if (next.Equals('('))
136 |                 {
137 |                     reader.Read();
138 |                     tokens.Add(new Token(TokenType.RuleToken, s, GetValueString()));
139 |                     reader.Read();
140 |                 }
141 |                 else
142 |                 {
143 |                     tokens.Add(new Token(TokenType.RuleToken, s));
144 |                 }
145 |             }
146 |         }
147 | 
148 |         string GetString()
149 |         {
150 |             next = (char)reader.Peek();
151 |             List<char> chars = new List<char>();
152 |             while (char.IsLetter(next))
153 |             {
154 |                 chars.Add(next);
155 |                 reader.Read();
156 |                 next = (char)reader.Peek();
157 |             }
158 | 
159 |             return new string(chars.ToArray());
160 |         }
161 | 
162 |         string GetValueString()
163 |         {
164 |             next = (char)reader.Peek();
165 |             List<char> chars = new List<char>();
166 |             while (!next.Equals(')'))
167 |             {
168 |                 chars.Add(next);
169 |                 reader.Read();
170 |                 next = (char)reader.Peek();
171 |             }
172 | 
173 |             return new string(chars.ToArray());
174 |         }
175 |     }
176 | 
177 |     public class TokeniserException : Exception
178 |     {
179 |         public TokeniserException(string message) : base(message) { }
180 |     }
181 | }
182 | 


--------------------------------------------------------------------------------
/LM2RandomiserShared/ItemID.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | 
  3 | namespace LaMulana2RandomizerShared
  4 | {
  5 |     [Serializable]
  6 |     public enum ItemID
  7 |     {
  8 |         None = 0,
  9 |         HandScanner,
 10 |         DjedPillar,
 11 |         Mjolnir,
 12 |         Beherit,
 13 |         AncientBattery,
 14 |         LampofTime,
 15 |         PochetteKey,
 16 |         PyramidCrystal,
 17 |         CrystalSkull,
 18 |         Vessel,
 19 |         Pepper,
 20 |         EggofCreation,
 21 |         GiantsFlute,
 22 |         CogofAntiquity,
 23 |         MulanaTalisman,
 24 |         MobileSuperx3P,
 25 |         ShellHorn,
 26 |         HolyGrail,
 27 |         FairyPass,
 28 |         Gloves,
 29 |         DinosaurFigure,
 30 |         GaleFibula,
 31 |         FlameTorc,
 32 |         Vajra,
 33 |         PowerBand,
 34 |         BronzeMirror,
 35 |         Perfume,
 36 |         IceCloak,
 37 |         NemeanFur,
 38 |         Gauntlet,
 39 |         Anchor,
 40 |         FreyasPendant,
 41 |         TotemPole,
 42 |         GrappleClaw,
 43 |         Spaulder,
 44 |         Scalesphere,
 45 |         Crucifix,
 46 |         GaneshaTalisman,
 47 |         MaatsFeather,
 48 |         Ring,
 49 |         Bracelet,
 50 |         Feather,
 51 |         Scriptures,
 52 |         FreysShip,
 53 |         Codices,
 54 |         SnowShoes,
 55 |         Harp,
 56 |         BookoftheDead,
 57 |         LightScythe,
 58 |         DestinyTablet,
 59 |         SecretTreasureofLife,
 60 |         OriginSigil,
 61 |         BirthSigil,
 62 |         LifeSigil,
 63 |         DeathSigil,
 64 |         ClaydollSuit,
 65 |         KimonoCowgirl,
 66 |         Valkyria,
 67 |         LittleDevil,
 68 |         EasternEurope,
 69 |         Whip1,
 70 |         Whip2,
 71 |         Whip3,
 72 |         Knife,
 73 |         Rapier,
 74 |         Axe,
 75 |         Katana,
 76 |         Shuriken,
 77 |         RollingShuriken,
 78 |         EarthSpear,
 79 |         Flare,
 80 |         Bomb,
 81 |         Chakram,
 82 |         Caltrops,
 83 |         Pistol,
 84 |         Shield1,
 85 |         Shield2,
 86 |         Shield3,
 87 |         AnkhJewel,
 88 |         Xelputter,
 89 |         YagooMapReader,
 90 |         YagooMapStreet,
 91 |         TextTrax,
 92 |         RuinsEncylopedia,
 93 |         Mantra,
 94 |         Guild,
 95 |         Research,
 96 |         EngaMusica,
 97 |         BeoEglana,
 98 |         Alert,
 99 |         Snapshot,
100 |         SkullReader,
101 |         RaceScanner,
102 |         DeathVillage,
103 |         RoseandCamelia,
104 |         SpaceCapstarII,
105 |         LonelyHouseMoving,
106 |         MekuriMaster,
107 |         BounceShot,
108 |         MiracleWitch,
109 |         FutureDevelopmentCompany,
110 |         LaMulana,
111 |         LaMulana2,
112 |         SacredOrb0,
113 |         SacredOrb1,
114 |         SacredOrb2,
115 |         SacredOrb3,
116 |         SacredOrb4,
117 |         SacredOrb5,
118 |         SacredOrb6,
119 |         SacredOrb7,
120 |         SacredOrb8,
121 |         SacredOrb9,
122 |         Map1,
123 |         Map2,
124 |         Map3,
125 |         Map4,
126 |         Map5,
127 |         Map6,
128 |         Map7,
129 |         Map8,
130 |         Map9,
131 |         Map10,
132 |         Map11,
133 |         Map12,
134 |         Map13,
135 |         Map14,
136 |         Map15,
137 |         Map16,
138 |         Map17,
139 |         Map18,
140 |         Map19,
141 |         Map20,
142 |         AnkhJewel1,
143 |         AnkhJewel2,
144 |         AnkhJewel3,
145 |         AnkhJewel4,
146 |         AnkhJewel5,
147 |         AnkhJewel6,
148 |         AnkhJewel7,
149 |         AnkhJewel8,
150 |         AnkhJewel9,
151 |         CrystalSkull1,
152 |         CrystalSkull2,
153 |         CrystalSkull3,
154 |         CrystalSkull4,
155 |         CrystalSkull5,
156 |         CrystalSkull6,
157 |         CrystalSkull7,
158 |         CrystalSkull8,
159 |         CrystalSkull9,
160 |         CrystalSkull10,
161 |         CrystalSkull11,
162 |         CrystalSkull12,
163 |         Heaven,
164 |         Earth,
165 |         Sun,
166 |         Moon,
167 |         Sea,
168 |         Fire,
169 |         Wind,
170 |         Mother,
171 |         Child,
172 |         Night,
173 |         Research1,
174 |         Research2,
175 |         Research3,
176 |         Research4,
177 |         Research5,
178 |         Research6,
179 |         Research7,
180 |         Research8,
181 |         Research9,
182 |         Research10,
183 | 
184 |         ProgressiveBeherit1,
185 |         ProgressiveBeherit2,
186 |         ProgressiveBeherit3,
187 |         ProgressiveBeherit4,
188 |         ProgressiveBeherit5,
189 |         ProgressiveBeherit6,
190 |         ProgressiveBeherit7,
191 | 
192 |         ShurikenAmmo,
193 |         RollingShurikenAmmo,
194 |         EarthSpearAmmo,
195 |         FlareAmmo,
196 |         BombAmmo,
197 |         ChakramAmmo,
198 |         CaltropsAmmo,
199 |         PistolAmmo,
200 |         Weights,
201 | 
202 |         ChestWeight01,
203 |         ChestWeight02,
204 |         ChestWeight03,
205 |         ChestWeight04,
206 |         ChestWeight05,
207 |         ChestWeight06,
208 |         ChestWeight07,
209 |         ChestWeight08,
210 |         ChestWeight09,
211 |         ChestWeight10,
212 |         ChestWeight11,
213 |         ChestWeight12,
214 |         ChestWeight13,
215 |         ChestWeight14,
216 |         ChestWeight15,
217 |         ChestWeight16,
218 |         ChestWeight17,
219 |         ChestWeight18,
220 |         ChestWeight19,
221 |         ChestWeight20,
222 |         ChestWeight21,
223 |         ChestWeight22,
224 |         ChestWeight23,
225 |         ChestWeight24,
226 |         ChestWeight25,
227 |         ChestWeight26,
228 |         ChestWeight27,
229 |         ChestWeight28,
230 |         ChestWeight29,
231 |         ChestWeight30,
232 |         ChestWeight31,
233 |         ChestWeight32,
234 |         ChestWeight33,
235 |         ChestWeight34,
236 |         ChestWeight35,
237 |         ChestWeight36,
238 |         ChestWeight37,
239 |         ChestWeight38,
240 |         ChestWeight39,
241 |         ChestWeight40,
242 | 
243 |         FakeItem01,
244 |         FakeItem02,
245 |         FakeItem03,
246 |         FakeItem04,
247 |         FakeItem05,
248 |         FakeItem06,
249 |         FakeItem07,
250 |         FakeItem08,
251 |         FakeItem09,
252 |         FakeItem10,
253 |         FakeItem11,
254 |         FakeItem12,
255 |         FakeItem13,
256 |         FakeItem14,
257 |         FakeItem15,
258 |         FakeItem16,
259 |         FakeItem17,
260 |         FakeItem18,
261 |         FakeItem19,
262 |         FakeItem20,
263 |         FakeItem21,
264 |         FakeItem22,
265 |         FakeItem23,
266 |         FakeItem24,
267 |         FakeItem25,
268 |         FakeItem26,
269 |         FakeItem27,
270 |         FakeItem28,
271 |         FakeItem29,
272 |         FakeItem30,
273 |         FakeItem31,
274 |         FakeItem32,
275 |         FakeItem33,
276 |         FakeItem34,
277 |         FakeItem35,
278 |         FakeItem36,
279 |         FakeItem37,
280 |         FakeItem38,
281 |         FakeItem39,
282 |         FakeItem40,
283 | 
284 |         NPCMoney01,
285 |         NPCMoney02,
286 |         NPCMoney03,
287 |         NPCMoney04,
288 |         NPCMoney05,
289 |         NPCMoney06,
290 |         NPCMoney07,
291 |         NPCMoney08,
292 |         NPCMoney09,
293 |         NPCMoney10,
294 | 
295 |         FakeScan01,
296 |         FakeScan02,
297 |         FakeScan03,
298 |         FakeScan04,
299 |         FakeScan05,
300 |         FakeScan06,
301 |         FakeScan07,
302 |         FakeScan08,
303 |         FakeScan09,
304 |         FakeScan10,
305 |         FakeScan11,
306 |         FakeScan12,
307 |         FakeScan13,
308 |         FakeScan14,
309 |         FakeScan15
310 |     }
311 | }
312 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.rsuser
  8 | *.suo
  9 | *.user
 10 | *.userosscache
 11 | *.sln.docstates
 12 | 
 13 | # User-specific files (MonoDevelop/Xamarin Studio)
 14 | *.userprefs
 15 | 
 16 | # Mono auto generated files
 17 | mono_crash.*
 18 | 
 19 | # Build results
 20 | [Dd]ebug/
 21 | [Dd]ebugPublic/
 22 | [Rr]elease/
 23 | [Rr]eleases/
 24 | x64/
 25 | x86/
 26 | [Aa][Rr][Mm]/
 27 | [Aa][Rr][Mm]64/
 28 | bld/
 29 | [Bb]in/
 30 | [Oo]bj/
 31 | [Ll]og/
 32 | 
 33 | # Visual Studio 2015/2017 cache/options directory
 34 | .vs/
 35 | # Uncomment if you have tasks that create the project's static files in wwwroot
 36 | #wwwroot/
 37 | 
 38 | # Visual Studio 2017 auto generated files
 39 | Generated\ Files/
 40 | 
 41 | # MSTest test Results
 42 | [Tt]est[Rr]esult*/
 43 | [Bb]uild[Ll]og.*
 44 | 
 45 | # NUNIT
 46 | *.VisualState.xml
 47 | TestResult.xml
 48 | 
 49 | # Build Results of an ATL Project
 50 | [Dd]ebugPS/
 51 | [Rr]eleasePS/
 52 | dlldata.c
 53 | 
 54 | # Benchmark Results
 55 | BenchmarkDotNet.Artifacts/
 56 | 
 57 | # .NET Core
 58 | project.lock.json
 59 | project.fragment.lock.json
 60 | artifacts/
 61 | 
 62 | # StyleCop
 63 | StyleCopReport.xml
 64 | 
 65 | # Files built by Visual Studio
 66 | *_i.c
 67 | *_p.c
 68 | *_h.h
 69 | *.ilk
 70 | *.meta
 71 | *.obj
 72 | *.iobj
 73 | *.pch
 74 | *.pdb
 75 | *.ipdb
 76 | *.pgc
 77 | *.pgd
 78 | *.rsp
 79 | *.sbr
 80 | *.tlb
 81 | *.tli
 82 | *.tlh
 83 | *.tmp
 84 | *.tmp_proj
 85 | *_wpftmp.csproj
 86 | *.log
 87 | *.vspscc
 88 | *.vssscc
 89 | .builds
 90 | *.pidb
 91 | *.svclog
 92 | *.scc
 93 | 
 94 | # Chutzpah Test files
 95 | _Chutzpah*
 96 | 
 97 | # Visual C++ cache files
 98 | ipch/
 99 | *.aps
100 | *.ncb
101 | *.opendb
102 | *.opensdf
103 | *.sdf
104 | *.cachefile
105 | *.VC.db
106 | *.VC.VC.opendb
107 | 
108 | # Visual Studio profiler
109 | *.psess
110 | *.vsp
111 | *.vspx
112 | *.sap
113 | 
114 | # Visual Studio Trace Files
115 | *.e2e
116 | 
117 | # TFS 2012 Local Workspace
118 | $tf/
119 | 
120 | # Guidance Automation Toolkit
121 | *.gpState
122 | 
123 | # ReSharper is a .NET coding add-in
124 | _ReSharper*/
125 | *.[Rr]e[Ss]harper
126 | *.DotSettings.user
127 | 
128 | # JustCode is a .NET coding add-in
129 | .JustCode
130 | 
131 | # TeamCity is a build add-in
132 | _TeamCity*
133 | 
134 | # DotCover is a Code Coverage Tool
135 | *.dotCover
136 | 
137 | # AxoCover is a Code Coverage Tool
138 | .axoCover/*
139 | !.axoCover/settings.json
140 | 
141 | # Visual Studio code coverage results
142 | *.coverage
143 | *.coveragexml
144 | 
145 | # NCrunch
146 | _NCrunch_*
147 | .*crunch*.local.xml
148 | nCrunchTemp_*
149 | 
150 | # MightyMoose
151 | *.mm.*
152 | AutoTest.Net/
153 | 
154 | # Web workbench (sass)
155 | .sass-cache/
156 | 
157 | # Installshield output folder
158 | [Ee]xpress/
159 | 
160 | # DocProject is a documentation generator add-in
161 | DocProject/buildhelp/
162 | DocProject/Help/*.HxT
163 | DocProject/Help/*.HxC
164 | DocProject/Help/*.hhc
165 | DocProject/Help/*.hhk
166 | DocProject/Help/*.hhp
167 | DocProject/Help/Html2
168 | DocProject/Help/html
169 | 
170 | # Click-Once directory
171 | publish/
172 | 
173 | # Publish Web Output
174 | *.[Pp]ublish.xml
175 | *.azurePubxml
176 | # Note: Comment the next line if you want to checkin your web deploy settings,
177 | # but database connection strings (with potential passwords) will be unencrypted
178 | *.pubxml
179 | *.publishproj
180 | 
181 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
182 | # checkin your Azure Web App publish settings, but sensitive information contained
183 | # in these scripts will be unencrypted
184 | PublishScripts/
185 | 
186 | # NuGet Packages
187 | *.nupkg
188 | # The packages folder can be ignored because of Package Restore
189 | **/[Pp]ackages/*
190 | # except build/, which is used as an MSBuild target.
191 | !**/[Pp]ackages/build/
192 | # Uncomment if necessary however generally it will be regenerated when needed
193 | #!**/[Pp]ackages/repositories.config
194 | # NuGet v3's project.json files produces more ignorable files
195 | *.nuget.props
196 | *.nuget.targets
197 | 
198 | # Microsoft Azure Build Output
199 | csx/
200 | *.build.csdef
201 | 
202 | # Microsoft Azure Emulator
203 | ecf/
204 | rcf/
205 | 
206 | # Windows Store app package directories and files
207 | AppPackages/
208 | BundleArtifacts/
209 | Package.StoreAssociation.xml
210 | _pkginfo.txt
211 | *.appx
212 | *.appxbundle
213 | *.appxupload
214 | 
215 | # Visual Studio cache files
216 | # files ending in .cache can be ignored
217 | *.[Cc]ache
218 | # but keep track of directories ending in .cache
219 | !?*.[Cc]ache/
220 | 
221 | # Others
222 | ClientBin/
223 | ~$*
224 | *~
225 | *.dbmdl
226 | *.dbproj.schemaview
227 | *.jfm
228 | *.pfx
229 | *.publishsettings
230 | orleans.codegen.cs
231 | 
232 | # Including strong name files can present a security risk
233 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
234 | #*.snk
235 | 
236 | # Since there are multiple workflows, uncomment next line to ignore bower_components
237 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
238 | #bower_components/
239 | # ASP.NET Core default setup: bower directory is configured as wwwroot/lib/ and bower restore is true
240 | **/wwwroot/lib/
241 | 
242 | # RIA/Silverlight projects
243 | Generated_Code/
244 | 
245 | # Backup & report files from converting an old project file
246 | # to a newer Visual Studio version. Backup files are not needed,
247 | # because we have git ;-)
248 | _UpgradeReport_Files/
249 | Backup*/
250 | UpgradeLog*.XML
251 | UpgradeLog*.htm
252 | ServiceFabricBackup/
253 | *.rptproj.bak
254 | 
255 | # SQL Server files
256 | *.mdf
257 | *.ldf
258 | *.ndf
259 | 
260 | # Business Intelligence projects
261 | *.rdl.data
262 | *.bim.layout
263 | *.bim_*.settings
264 | *.rptproj.rsuser
265 | *- Backup*.rdl
266 | 
267 | # Microsoft Fakes
268 | FakesAssemblies/
269 | 
270 | # GhostDoc plugin setting file
271 | *.GhostDoc.xml
272 | 
273 | # Node.js Tools for Visual Studio
274 | .ntvs_analysis.dat
275 | node_modules/
276 | 
277 | # Visual Studio 6 build log
278 | *.plg
279 | 
280 | # Visual Studio 6 workspace options file
281 | *.opt
282 | 
283 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
284 | *.vbw
285 | 
286 | # Visual Studio LightSwitch build output
287 | **/*.HTMLClient/GeneratedArtifacts
288 | **/*.DesktopClient/GeneratedArtifacts
289 | **/*.DesktopClient/ModelManifest.xml
290 | **/*.Server/GeneratedArtifacts
291 | **/*.Server/ModelManifest.xml
292 | _Pvt_Extensions
293 | 
294 | # Paket dependency manager
295 | .paket/paket.exe
296 | paket-files/
297 | 
298 | # FAKE - F# Make
299 | .fake/
300 | 
301 | # CodeRush personal settings
302 | .cr/personal
303 | 
304 | # Python Tools for Visual Studio (PTVS)
305 | __pycache__/
306 | *.pyc
307 | 
308 | # Cake - Uncomment if you are using it
309 | # tools/**
310 | # !tools/packages.config
311 | 
312 | # Tabs Studio
313 | *.tss
314 | 
315 | # Telerik's JustMock configuration file
316 | *.jmconfig
317 | 
318 | # BizTalk build output
319 | *.btp.cs
320 | *.btm.cs
321 | *.odx.cs
322 | *.xsd.cs
323 | 
324 | # OpenCover UI analysis results
325 | OpenCover/
326 | 
327 | # Azure Stream Analytics local run output
328 | ASALocalRun/
329 | 
330 | # MSBuild Binary and Structured Log
331 | *.binlog
332 | 
333 | # NVidia Nsight GPU debugger configuration file
334 | *.nvuser
335 | 
336 | # MFractors (Xamarin productivity tool) working folder
337 | .mfractor/
338 | 
339 | # Local History for Visual Studio
340 | .localhistory/
341 | 
342 | # BeatPulse healthcheck temp database
343 | healthchecksdb
344 | 
345 | # Backup folder for Package Reference Convert tool in Visual Studio 2017
346 | MigrationBackup/


--------------------------------------------------------------------------------
/LM2RandomiserShared/LocationID.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | 
  3 | namespace LaMulana2RandomizerShared
  4 | {
  5 |     [Serializable]
  6 |     public enum LocationID
  7 |     {
  8 |         None = 0,
  9 | 
 10 |         DjedPillarChest = 1,
 11 |         MjolnirChest = 2,
 12 |         BatteryChest = 4,
 13 |         LampofTimeChest = 5,
 14 |         PochetteKeyChest = 6,
 15 |         PyramidCrystalChest = 7,
 16 |         VesselChest = 9,
 17 |         EggofCreationChest = 11,
 18 |         GiantsFluteChest = 12,
 19 |         CogofAntiquityChest = 13,
 20 | 
 21 |         MobileSuperX3Item = 15,
 22 |         ShellHornChest = 16,
 23 |         HolyGrailChest = 17,
 24 |         FairyGuildPassChest = 18,
 25 |         GloveChest = 19,
 26 |         DinosaurFigureChest = 20,
 27 |         GaleFibulaChest = 21,
 28 |         FlameTorcChest = 22,
 29 |         VajraChest = 23,
 30 |         PowerBandChest = 24,
 31 |         BronzeMirrorSpot = 25,
 32 |         PerfumeChest = 26,
 33 |         IceCloakChest = 27,
 34 |         NemeanFurChest = 28,
 35 |         GauntletChest = 29,
 36 |         AnchorChest = 30,
 37 |         TotemPoleChest = 32,
 38 |         GrappleClawChest = 33,
 39 |         SpaulderChest = 34,
 40 |         ScalesphereChest = 35,
 41 |         CrucifixChest = 36,
 42 |         MaatsFeatherChest = 38,
 43 |         RingChest = 39,
 44 |         FeatherChest = 41,
 45 |         ScripturesChest = 42,
 46 |         FreyShip = 43,
 47 |         BookoftheDeadChest = 47,
 48 |         DestinyTabletChest = 49,
 49 |         SecretTreasureofLifeItem = 50,
 50 | 
 51 |         OriginSealChest = 51,
 52 |         BirthSigilChest = 52,
 53 |         LifeSigilChest = 53,
 54 |         DeathSigilChest = 54,
 55 | 
 56 |         ClaydollChest = 56,
 57 | 
 58 |         KnifePuzzleReward = 63,
 59 |         RapierPuzzleReward = 64,
 60 |         AxePuzzleReward = 65,
 61 |         KatanaPuzzleReward = 66,
 62 |         ShurikenPuzzleReward = 67,
 63 |         RollingShurikenPuzzleReward = 68,
 64 |         EarthSpearPuzzleReward = 69,
 65 |         FlarePuzzleReward = 70,
 66 |         BombPuzzleReward = 71,
 67 |         ChakramPuzzleReward = 72,
 68 |         CaltropPuzzleReward = 73,
 69 | 
 70 |         YagooMapStreetChest = 79,
 71 |         MantraMural = 82,
 72 |         BeoEglanaMural = 86,
 73 |         DeathVillageChest = 91,
 74 |         MiracleWitchChest = 97,
 75 |         LaMulanaChest = 99,
 76 |         LaMulana2Chest = 100,
 77 | 
 78 |         SacredOrbVoD = 101,
 79 |         SacredOrbChestRoY = 102,
 80 |         SacredOrbChestAnnwfn = 103,
 81 |         SacredOrbChestIB = 104,
 82 |         SacredOrbChestIT = 105,
 83 |         SacredOrbChestDF = 106,
 84 |         SacredOrbChestSotFG = 107,
 85 |         SacredOrbChestGotD = 108,
 86 |         SacredOrbChestTS = 109,
 87 |         SacredOrbChestHL = 110,
 88 | 
 89 |         MapChestRoY = 111,
 90 |         MapChestAnnwfn = 112,
 91 |         MapChestIB = 113,
 92 |         MapChestIT = 114,
 93 |         MapChestDF = 115,
 94 |         MapChestSotFG = 116,
 95 |         MapChestGotD = 117,
 96 |         MapChestTS = 118,
 97 |         MapChestHL = 119,
 98 |         MapChestValhalla = 120,
 99 |         MapChestDLM = 121,
100 |         MapChestAC = 122,
101 |         MapChestHoM = 123,
102 |         MapChestEPG = 124,
103 |         MapChestEPD = 125,
104 | 
105 |         AnkhChestRoY = 132,
106 |         AnkhChestDF = 133,
107 |         AnkhChestIT = 134,
108 |         AnkhChestSotFG = 135,
109 |         AnkhChestDLM = 136,
110 |         AnkhChestAC = 137,
111 |         AnkhJewel = 139,
112 | 
113 |         CrystalSkullChestRoY = 140,
114 |         CrystalSkullChestAnnwfn = 141,
115 |         CrystalSkullIB = 142,
116 |         CrystalSkullChestIT = 143,
117 |         CrystalSkullChestValhalla = 144,
118 |         CrystalSkullChestGotD = 145,
119 |         CrystalSkullChestTS = 146,
120 |         CrystalSkullChestDLM = 147,
121 |         CrystalSkullChestAC = 148,
122 |         CrystalSkullChestHL = 149,
123 |         CrystalSkullChestHoM = 150,
124 |         CrystalSkullChestEPD = 151,
125 | 
126 |         ChainWhipPuzzleReward = 153,
127 |         FlailWhipPuzzleReward = 154,
128 |         SilverShieldPuzzleReward = 156,
129 | 
130 |         HeavenMantraMural,
131 |         EarthMantraMural,
132 |         SunMantraMural,
133 |         MoonMantraMural,
134 |         SeaMantraMural,
135 |         FireMantraMural,
136 |         WindMantraMural,
137 |         MotherMantraMural,
138 |         ChildMantraMural,
139 |         NightMantraMural,
140 | 
141 |         ResearchAnnwfn,
142 |         ResearchIT,
143 |         ResearchIBTopLeft,
144 |         ResearchIBTopRight,
145 |         ResearchIBLeft,
146 |         ResearchIBPit,
147 |         ResearchIBTent1,
148 |         ResearchIBTent2,
149 |         ResearchIBTent3,
150 |         ResearchDSLM,
151 | 
152 |         DissonanceValhalla,
153 |         DissonanceDSLM,
154 |         DissonanceHL,
155 |         DissonanceEPG,
156 |         DissonanceNibiru,
157 |         DissonanceMoG,
158 | 
159 |         AlsedanaItem,
160 |         GiltoriyoItem,
161 |         XelpudItem,
162 |         NeburItem,
163 |         FreyasItem,
164 |         FobosItem,
165 |         FobosItem2,
166 |         MulbrukItem,
167 |         OsirisItem,
168 | 
169 |         NeburShop1,
170 |         NeburShop2,
171 |         NeburShop3,
172 |         ModroShop1,
173 |         ModroShop2,
174 |         ModroShop3,
175 |         SidroShop1,
176 |         SidroShop2,
177 |         SidroShop3,
178 |         HinerShop1,
179 |         HinerShop2,
180 |         HinerShop3,
181 |         HinerShop4,
182 |         KorobockShop1,
183 |         KorobockShop2,
184 |         KorobockShop3,
185 |         ShuhokaShop1,
186 |         ShuhokaShop2,
187 |         ShuhokaShop3,
188 |         PymShop1,
189 |         PymShop2,
190 |         PymShop3,
191 |         BTKShop1,
192 |         BTKShop2,
193 |         BTKShop3,
194 |         MinoShop1,
195 |         MinoShop2,
196 |         MinoShop3,
197 |         BargainDuckShop1,
198 |         BargainDuckShop2,
199 |         BargainDuckShop3,
200 |         VenumShop1,
201 |         VenumShop2,
202 |         VenumShop3,
203 |         PeibalusaShop1,
204 |         PeibalusaShop2,
205 |         PeibalusaShop3,
206 |         HiroRoderickShop1,
207 |         HiroRoderickShop2,
208 |         HiroRoderickShop3,
209 |         HydlitShop1,
210 |         HydlitShop2,
211 |         HydlitShop3,
212 |         AytumShop1,
213 |         AytumShop2,
214 |         AytumShop3,
215 |         KeroShop1,
216 |         KeroShop2,
217 |         KeroShop3,
218 |         AshGeenShop1,
219 |         AshGeenShop2,
220 |         AshGeenShop3,
221 |         FairylanShop1,
222 |         FairylanShop2,
223 |         FairylanShop3,
224 |         MegarockShop1,
225 |         MegarockShop2,
226 |         MegarockShop3,
227 |         StartingShop1,
228 |         StartingShop2,
229 |         StartingShop3,
230 | 
231 |         Ratatoskr1,
232 |         Nidhogg,
233 |         Kaliya,
234 |         Ixtab,
235 |         Cetus,
236 |         Ratatoskr2,
237 |         Svipdagr,
238 |         Vedfolnir,
239 |         Ratatoskr3,
240 |         Vidofnir,
241 |         HuginandMunin,
242 |         BadhbhCath,
243 |         Fenrir,
244 |         Balor,
245 |         Tezcatlipoca,
246 |         Unicorn,
247 |         RaijinandFujin,
248 |         Daji,
249 |         Belial,
250 |         Arachne,
251 |         Scylla,
252 |         GlasyaLabolas,
253 |         Griffin,
254 |         VucubCaquiz,
255 |         Jalandhara,
256 |         Sekhmet,
257 |         AngraMainyu,
258 |         Ammit,
259 |         Kisikillillake,
260 |         Anzu,
261 |         HoMLeftPath,
262 |         HoMMiddlePath,
263 |         HoMRightPath,
264 |         Orthrus,
265 |         Hraesvelgr,
266 |         Ratatoskr4,
267 |         Heimdall,
268 | 
269 |         Fafnir,
270 |         Kujata,
271 |         Jormangund,
272 |         Surtr,
273 |         Vritra,
274 |         AtenRa,
275 |         Anu,
276 |         Echidna,
277 |         Hel,
278 |         NinthChild,
279 | 
280 |         WeaponFairy,
281 |         MoneyFairy,
282 |         KeyFairy,
283 | 
284 |         AnnwfnRightShortcut,
285 |         IBLeftShortcut,
286 |         HoMLadder,
287 |         Bergelmir,
288 |         WhitePedestals,
289 |         GarmStatuePuzzle,
290 |         SakitPuzzle
291 |     }
292 | }
293 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/LaMulana2Randomizer.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{40078A86-30B5-410D-9691-EC207662AE2D}</ProjectGuid>
  8 |     <OutputType>WinExe</OutputType>
  9 |     <RootNamespace>LaMulana2Randomizer</RootNamespace>
 10 |     <AssemblyName>LaMulana2Randomizer</AssemblyName>
 11 |     <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
 12 |     <FileAlignment>512</FileAlignment>
 13 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 14 |     <WarningLevel>4</WarningLevel>
 15 |     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
 16 |     <Deterministic>true</Deterministic>
 17 |   </PropertyGroup>
 18 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 19 |     <PlatformTarget>AnyCPU</PlatformTarget>
 20 |     <DebugSymbols>true</DebugSymbols>
 21 |     <DebugType>full</DebugType>
 22 |     <Optimize>false</Optimize>
 23 |     <OutputPath>bin\Debug\</OutputPath>
 24 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 25 |     <ErrorReport>prompt</ErrorReport>
 26 |     <WarningLevel>4</WarningLevel>
 27 |   </PropertyGroup>
 28 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 29 |     <PlatformTarget>AnyCPU</PlatformTarget>
 30 |     <DebugType>pdbonly</DebugType>
 31 |     <Optimize>true</Optimize>
 32 |     <OutputPath>bin\Release\</OutputPath>
 33 |     <DefineConstants>TRACE</DefineConstants>
 34 |     <ErrorReport>prompt</ErrorReport>
 35 |     <WarningLevel>4</WarningLevel>
 36 |   </PropertyGroup>
 37 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == '1.0|AnyCPU'">
 38 |     <DebugSymbols>true</DebugSymbols>
 39 |     <OutputPath>bin\1.0\</OutputPath>
 40 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 41 |     <DebugType>full</DebugType>
 42 |     <PlatformTarget>AnyCPU</PlatformTarget>
 43 |     <LangVersion>7.3</LangVersion>
 44 |     <ErrorReport>prompt</ErrorReport>
 45 |     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
 46 |     <Prefer32Bit>true</Prefer32Bit>
 47 |   </PropertyGroup>
 48 |   <PropertyGroup>
 49 |     <ApplicationIcon>LaMulana2.ico</ApplicationIcon>
 50 |   </PropertyGroup>
 51 |   <ItemGroup>
 52 |     <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
 53 |       <HintPath>..\packages\Newtonsoft.Json.13.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
 54 |     </Reference>
 55 |     <Reference Include="System" />
 56 |     <Reference Include="System.Data" />
 57 |     <Reference Include="System.Drawing" />
 58 |     <Reference Include="System.Xml" />
 59 |     <Reference Include="Microsoft.CSharp" />
 60 |     <Reference Include="System.Core" />
 61 |     <Reference Include="System.Xml.Linq" />
 62 |     <Reference Include="System.Data.DataSetExtensions" />
 63 |     <Reference Include="System.Net.Http" />
 64 |     <Reference Include="System.Xaml">
 65 |       <RequiredTargetFramework>4.0</RequiredTargetFramework>
 66 |     </Reference>
 67 |     <Reference Include="WindowsBase" />
 68 |     <Reference Include="PresentationCore" />
 69 |     <Reference Include="PresentationFramework" />
 70 |   </ItemGroup>
 71 |   <ItemGroup>
 72 |     <ApplicationDefinition Include="App.xaml">
 73 |       <Generator>MSBuild:Compile</Generator>
 74 |       <SubType>Designer</SubType>
 75 |     </ApplicationDefinition>
 76 |     <Compile Include="Area.cs" />
 77 |     <Compile Include="Exit.cs" />
 78 |     <Compile Include="Extensions\StringExtensions.cs" />
 79 |     <Compile Include="Item.cs" />
 80 |     <Compile Include="Location.cs" />
 81 |     <Compile Include="SpoilerLog.cs" />
 82 |     <Compile Include="Utils\Logger.cs" />
 83 |     <Compile Include="PlayerState.cs" />
 84 |     <Compile Include="Randomiser.cs" />
 85 |     <Compile Include="RandomiserException.cs" />
 86 |     <Compile Include="RelayCommand.cs" />
 87 |     <Compile Include="LogicParsing\Logic.cs" />
 88 |     <Compile Include="LogicParsing\LogicTree.cs" />
 89 |     <Compile Include="LogicParsing\ShuntingYard.cs" />
 90 |     <Compile Include="LogicParsing\Tokeniser.cs" />
 91 |     <Compile Include="Settings.cs" />
 92 |     <Compile Include="UI\EnumBooleanConverter.cs" />
 93 |     <Compile Include="UI\IntRangRules.cs" />
 94 |     <Compile Include="UI\ProgressDialog.xaml.cs">
 95 |       <DependentUpon>ProgressDialog.xaml</DependentUpon>
 96 |     </Compile>
 97 |     <Compile Include="BindableBase.cs" />
 98 |     <Compile Include="Utils\FileUtils.cs" />
 99 |     <Compile Include="ItemPool.cs" />
100 |     <Compile Include="Utils\Shuffle.cs" />
101 |     <Compile Include="ViewModels\MainViewModel.cs" />
102 |     <Compile Include="ViewModels\ProgressDialogViewModel.cs" />
103 |     <Page Include="UI\MainWindow.xaml">
104 |       <Generator>MSBuild:Compile</Generator>
105 |       <SubType>Designer</SubType>
106 |     </Page>
107 |     <Compile Include="App.xaml.cs">
108 |       <DependentUpon>App.xaml</DependentUpon>
109 |       <SubType>Code</SubType>
110 |     </Compile>
111 |     <Compile Include="UI\MainWindow.xaml.cs">
112 |       <DependentUpon>MainWindow.xaml</DependentUpon>
113 |       <SubType>Code</SubType>
114 |     </Compile>
115 |     <Page Include="UI\ProgressDialog.xaml">
116 |       <SubType>Designer</SubType>
117 |       <Generator>MSBuild:Compile</Generator>
118 |     </Page>
119 |   </ItemGroup>
120 |   <ItemGroup>
121 |     <Compile Include="Properties\AssemblyInfo.cs">
122 |       <SubType>Code</SubType>
123 |     </Compile>
124 |     <Compile Include="Properties\Resources.Designer.cs">
125 |       <AutoGen>True</AutoGen>
126 |       <DesignTime>True</DesignTime>
127 |       <DependentUpon>Resources.resx</DependentUpon>
128 |     </Compile>
129 |     <EmbeddedResource Include="Properties\Resources.resx">
130 |       <Generator>ResXFileCodeGenerator</Generator>
131 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
132 |     </EmbeddedResource>
133 |     <None Include="Data\Items.json">
134 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
135 |     </None>
136 |     <None Include="Data\World.json">
137 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
138 |     </None>
139 |     <None Include="packages.config" />
140 |     <None Include="Seed\spoilers.json">
141 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
142 |     </None>
143 |   </ItemGroup>
144 |   <ItemGroup>
145 |     <None Include="App.config" />
146 |   </ItemGroup>
147 |   <ItemGroup>
148 |     <Resource Include="LaMulana2.ico" />
149 |     <Content Include="Monomod\Assembly-CSharp.mm.dll">
150 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
151 |     </Content>
152 |     <Content Include="Monomod\Mono.Cecil.dll">
153 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
154 |     </Content>
155 |     <Content Include="Monomod\Mono.Cecil.Mdb.dll">
156 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
157 |     </Content>
158 |     <Content Include="Monomod\Mono.Cecil.Pdb.dll">
159 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
160 |     </Content>
161 |     <Content Include="Monomod\Mono.Cecil.Rocks.dll">
162 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
163 |     </Content>
164 |     <Content Include="Monomod\MonoMod.exe">
165 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
166 |     </Content>
167 |     <Content Include="Monomod\MonoMod.Utils.dll">
168 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
169 |     </Content>
170 |   </ItemGroup>
171 |   <ItemGroup>
172 |     <ProjectReference Include="..\LM2RandomiserShared\LaMulana2RandomizerShared.csproj">
173 |       <Project>{9f97eb8e-6dce-4f97-a1a6-5d0f354f581b}</Project>
174 |       <Name>LaMulana2RandomizerShared</Name>
175 |     </ProjectReference>
176 |   </ItemGroup>
177 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
178 | </Project>


--------------------------------------------------------------------------------
/Assembly-CSharp/ItemTracker.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Text;
  3 | using System.Net;
  4 | using System.Net.Sockets;
  5 | using System.Collections.Generic;
  6 | using L2Base;
  7 | using L2Flag;
  8 | using UnityEngine;
  9 | using UnityEngine.SceneManagement;
 10 | 
 11 | namespace LM2RandomiserMod
 12 | {
 13 |     public class ItemTracker : MonoBehaviour
 14 |     {
 15 |         public static ItemTracker instance;
 16 | 
 17 |         private const int port = 56789;
 18 | 
 19 |         private TcpListener listener;
 20 |         private List<ConnectedClient> clients = new List<ConnectedClient>();
 21 |         private Queue<L2FlagBoxEnd> flags = new Queue<L2FlagBoxEnd>();
 22 | 
 23 |         private L2System sys;
 24 |         private bool onTitle;
 25 |         private Font currentFont;
 26 | 
 27 |         public void OnGUI()
 28 |         {
 29 |             if (onTitle)
 30 |             {
 31 |                 if (currentFont == null)
 32 |                     currentFont = Font.CreateDynamicFontFromOSFont("Consolas", 14);
 33 | 
 34 |                 GUIStyle guistyle = new GUIStyle(GUI.skin.label);
 35 |                 guistyle.normal.textColor = Color.white;
 36 |                 guistyle.font = currentFont;
 37 |                 guistyle.fontStyle = FontStyle.Bold;
 38 |                 guistyle.fontSize = 10;
 39 | 
 40 |                 GUIContent content = new GUIContent($"Item Tracker\nClients connected: {clients.Count}");
 41 |                 Vector2 size = guistyle.CalcSize(content);
 42 |                 GUI.Label(new Rect(Screen.width - size.x, 0, size.x, size.y), content, guistyle);
 43 |             }
 44 |         }
 45 | 
 46 |         public void Start()
 47 |         {
 48 |             sys = GameObject.Find("GameSystem").GetComponent<L2System>();
 49 |             instance = this;
 50 |             StartListener();
 51 |         }
 52 | 
 53 |         public void Update()
 54 |         {
 55 |             if(flags.Count > 0)
 56 |             {
 57 |                 byte[] data = new byte[3 * flags.Count];
 58 |                 int index = 0;
 59 |                 while (flags.Count > 0)
 60 |                 {
 61 |                     L2FlagBoxEnd l2Flag = flags.Dequeue();
 62 |                     data[index + 0] = (byte)l2Flag.seet_no1;
 63 |                     data[index + 1] = (byte)l2Flag.flag_no1;
 64 |                     data[index + 2] = (byte)l2Flag.data;
 65 |                     index += 3;
 66 |                 }
 67 |                 Send(data);
 68 |             }
 69 |         }
 70 | 
 71 |         public void OnEnable()
 72 |         {
 73 |             SceneManager.sceneLoaded += OnSceneLoaded;
 74 |         }
 75 | 
 76 |         public void OnDisable()
 77 |         {
 78 |             SceneManager.sceneLoaded -= OnSceneLoaded;
 79 |         }
 80 | 
 81 |         void OnSceneLoaded(Scene scene, LoadSceneMode mode)
 82 |         {
 83 |             onTitle = scene.name.Equals("title");
 84 |         }
 85 | 
 86 |         public void Add(int sheet, int flag)
 87 |         {
 88 |             if(sheet == 0)
 89 |             {
 90 |                 short data = 0;
 91 |                 if (sys.getFlag(sheet, flag, ref data))
 92 |                 {
 93 |                     if (data > 0)
 94 |                     {
 95 |                         if (flag == 32)
 96 |                         {
 97 |                             flags.Enqueue(new L2FlagBoxEnd()
 98 |                             {
 99 |                                 seet_no1 = 2,
100 |                                 flag_no1 = 8,
101 |                                 data = data
102 |                             });
103 |                         }
104 |                         else if (flag == 3)
105 |                         {
106 |                             flags.Enqueue(new L2FlagBoxEnd()
107 |                             {
108 |                                 seet_no1 = 2,
109 |                                 flag_no1 = 76,
110 |                                 data = data
111 |                             });
112 |                         }
113 |                     }
114 |                     else
115 |                     {
116 |                         if (flag == 3)
117 |                         {
118 |                             flags.Enqueue(new L2FlagBoxEnd()
119 |                             {
120 |                                 seet_no1 = 2,
121 |                                 flag_no1 = 76,
122 |                                 data = data
123 |                             });
124 |                         }
125 |                     }
126 |                 }
127 |             }
128 |             else if (sheet == 2)
129 |             {
130 |                 if (flag == 8)
131 |                     return;
132 | 
133 |                 short data = 0;
134 |                 if (sys.getFlag(sheet, flag, ref data))
135 |                 {
136 |                     if ((data > 0 && flag != 15) || (data > 1 && flag == 15))
137 |                     {
138 |                         flags.Enqueue(new L2FlagBoxEnd()
139 |                         {
140 |                             seet_no1 = sheet,
141 |                             flag_no1 = flag,
142 |                             data = data
143 |                         });
144 |                     }
145 |                 }
146 |             }
147 |             else if (sheet == 3 && (flag >= 10 || flag <= 18))
148 |             {
149 |                 short data = 0;
150 |                 if (sys.getFlag(sheet, flag, ref data))
151 |                 {
152 |                     if (data >= 4)
153 |                     {
154 |                         flags.Enqueue(new L2FlagBoxEnd()
155 |                         {
156 |                             seet_no1 = sheet,
157 |                             flag_no1 = flag,
158 |                             data = data
159 |                         });
160 |                     }
161 |                 }
162 |             }
163 |             else if(sheet > 99)
164 |             {
165 |                 flags.Enqueue(new L2FlagBoxEnd()
166 |                 {
167 |                     seet_no1 = sheet,
168 |                     flag_no1 = 0,
169 |                     data = 0
170 |                 });
171 |             }
172 |         }
173 | 
174 |         public void RemoveClient(ConnectedClient client)
175 |         {
176 |             lock (clients)
177 |             {
178 |                 clients.Remove(client);
179 |             }
180 |         }
181 | 
182 |         private void StartListener()
183 |         {
184 |             listener = new TcpListener(IPAddress.Loopback, port);
185 |             listener.Start();
186 |             listener.BeginAcceptTcpClient(OnClientConnected, null);
187 |         }
188 | 
189 |         private void OnClientConnected(IAsyncResult ar)
190 |         {
191 |             TcpClient client = listener.EndAcceptTcpClient(ar);
192 |             ConnectedClient cClient = new ConnectedClient(client);
193 |             clients.Add(cClient);
194 |             listener.BeginAcceptTcpClient(OnClientConnected, null);
195 |         }
196 | 
197 |         private void Send(byte[] data)
198 |         {
199 |             foreach (var client in clients)
200 |             {
201 |                 if (client.IsConnected)
202 |                     client.Send(data);
203 |             }
204 |         }
205 | 
206 |         private void Send(string message)
207 |         {
208 |             byte[] data = Encoding.UTF8.GetBytes(message);
209 |             foreach (var client in clients)
210 |             {
211 |                 if (client.IsConnected)
212 |                     client.Send(data);
213 |             }
214 |         }
215 |     }
216 | 
217 |     public class ConnectedClient
218 |     {
219 |         private const int BufferSize = 1024;
220 |         private byte[] Buffer = new byte[BufferSize];
221 |         private TcpClient Client;
222 | 
223 |         public bool IsConnected {
224 |             get => Client.Connected;
225 |         }
226 | 
227 |         public ConnectedClient(TcpClient client)
228 |         {
229 |             Client = client;
230 |             Client.GetStream().BeginRead(Buffer, 0, Buffer.Length, OnRead, null);
231 |         }
232 | 
233 |         public void Send(byte[] data)
234 |         {
235 |             Client.GetStream().Write(data, 0, data.Length);
236 |         }
237 | 
238 |         private void OnRead(IAsyncResult ar)
239 |         {
240 |             try
241 |             {
242 |                 int bytesRead = Client.GetStream().EndRead(ar);
243 |                 if (bytesRead <= 0)
244 |                 {
245 |                     ItemTracker.instance.RemoveClient(this);
246 |                     Client.Close();
247 |                     return;
248 |                 }
249 |                 Client.GetStream().BeginRead(Buffer, 0, Buffer.Length, OnRead, null);
250 |             }
251 |             catch (Exception)
252 |             {
253 |                 ItemTracker.instance.RemoveClient(this);
254 |             }
255 |         }
256 |     }
257 | }
258 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/DevUI.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using UnityEngine;
  3 | using L2Base;
  4 | using L2Flag;
  5 | using LM2RandomiserMod.Patches;
  6 | 
  7 | namespace LM2RandomiserMod
  8 | {
  9 |     public class DevUI : MonoBehaviour
 10 |     {
 11 |         private Font currentFont = null;
 12 | 
 13 |         private L2System sys;
 14 | 
 15 |         private bool showUI = false;
 16 |         private bool showFlagWatch = false;
 17 | 
 18 | 
 19 |         private string areaString;
 20 |         private string screenXString;
 21 |         private string screenYString;
 22 |         private string posXString;
 23 |         private string posYString;
 24 |         private bool sceneJump = true;
 25 |         private BGScrollSystem currentBGSys;
 26 | 
 27 |         private string sheetString;
 28 |         private string flagString;
 29 |         private string valueString;
 30 | 
 31 |         private string getSheetString;
 32 |         private string getFlagString;
 33 |         private string getValueString;
 34 | 
 35 |         public void Initialise(L2System l2System)
 36 |         {
 37 |             sys = l2System;
 38 |             Cursor.visible = true;
 39 |         }
 40 | 
 41 |         public void OnGUI() {
 42 | 
 43 |             if (showUI && sys.getPlayer() != null)
 44 |             {
 45 |                 areaString = GUI.TextArea(new Rect(0, 0, 100, 25), areaString);
 46 |                 screenXString = GUI.TextArea(new Rect(0, 25, 50, 25), screenXString);
 47 |                 screenYString = GUI.TextArea(new Rect(50, 25, 50, 25), screenYString);
 48 |                 posXString = GUI.TextArea(new Rect(0, 50, 50, 25), posXString);
 49 |                 posYString = GUI.TextArea(new Rect(50, 50, 50, 25), posYString);
 50 | 
 51 |                 if (GUI.Button(new Rect(0, 75, 100, 25), "Warp"))
 52 |                 {
 53 |                     DoDebugWarp();
 54 |                 }
 55 | 
 56 |                 sheetString = GUI.TextArea(new Rect(100, 0, 100, 25), sheetString);
 57 |                 flagString = GUI.TextArea(new Rect(100, 25, 100, 25), flagString);
 58 |                 valueString = GUI.TextArea(new Rect(100, 50, 100, 25), valueString);
 59 | 
 60 |                 if (GUI.Button(new Rect(100, 75, 100, 25), "Set Flag"))
 61 |                 {
 62 |                     SetFlag();
 63 |                 }
 64 | 
 65 |                 getSheetString = GUI.TextArea(new Rect(200, 0, 100, 25), getSheetString);
 66 |                 getFlagString = GUI.TextArea(new Rect(200, 25, 100, 25), getFlagString);
 67 |                 getValueString = GUI.TextArea(new Rect(200, 50, 100, 25), getValueString);
 68 | 
 69 |                 if (GUI.Button(new Rect(200, 75, 100, 25), "Get Flag"))
 70 |                 {
 71 |                     GetFlag();
 72 |                 }
 73 |                 
 74 |                 sys.setPandaModeHP(GUI.Toggle(new Rect(300, 0, 120, 25), sys.getPandaModeHP(), "Panda Mode"));
 75 |                 sys.setPandaModeHit(GUI.Toggle(new Rect(300, 25, 120, 25), sys.getPandaModeHit(), "Panda Hit Mode"));
 76 |             }
 77 | 
 78 |             if (showFlagWatch)
 79 |             {
 80 |                 if (currentFont == null)
 81 |                 {
 82 |                     currentFont = Font.CreateDynamicFontFromOSFont("Consolas", 14);
 83 |                 }
 84 | 
 85 |                 GUIStyle guistyle = new GUIStyle(GUI.skin.label);
 86 |                 guistyle.normal.textColor = Color.white;
 87 |                 guistyle.fontStyle = FontStyle.Bold;
 88 |                 guistyle.font = currentFont;
 89 |                 guistyle.fontSize = 14;
 90 | 
 91 |                 var flagWatch = ((patched_L2FlagSystem)sys.getFlagSys()).GetFlagWatches();
 92 | 
 93 |                 if (flagWatch == null)
 94 |                     return;
 95 | 
 96 |                 guistyle.fontSize = 10;
 97 | 
 98 |                 try
 99 |                 {
100 |                     string flags = string.Empty;
101 | 
102 |                     foreach(var flag in flagWatch)
103 |                     {
104 |                         flags = string.Format($"{flags}\n{flag}");
105 |                     }
106 |                     GUIContent flw1 = new GUIContent(flags);
107 |                     Vector2 flw1Size = guistyle.CalcSize(flw1);
108 |                     GUI.Label(new Rect(0, Screen.height - flw1Size.y, flw1Size.x, flw1Size.y), flw1, guistyle);
109 |                 }
110 |                 catch (Exception)
111 |                 {
112 |                     throw;
113 |                 }
114 |             }
115 |         }
116 | 
117 |         public void Update()
118 |         {
119 |             if(Input.GetKeyDown(KeyCode.F10))
120 |                 showUI = !showUI;
121 | 
122 |             if (Input.GetKeyDown(KeyCode.F9))
123 |                 showFlagWatch = !showFlagWatch;
124 | 
125 |             if (Input.GetKeyDown(KeyCode.F7))
126 |                 sys.drawHitBox(!sys.drawHitBoxFlag);
127 | 
128 |             UpdateBGSys();
129 |         }
130 | 
131 |         private void UpdateBGSys()
132 |         {
133 |             if (sceneJump)
134 |             {
135 |                 currentBGSys = sys.getL2SystemCore().ScrollSystem;
136 |                 if (currentBGSys != null)
137 |                 {
138 |                     sceneJump = false;
139 |                     UpdatePositionInfo();
140 |                 }
141 |             }
142 |         }
143 | 
144 |         private void UpdatePositionInfo()
145 |         {
146 |             L2SystemCore sysCore = sys.getL2SystemCore();
147 |             GameObject playerObj = sys.getPlayer().gameObject;
148 |             Vector3 position = playerObj.transform.position;
149 |             ViewProperty currentView = currentBGSys.roomSetter.getCurrentView(position.x, position.y);
150 |             int currentScene = sysCore.SceaneNo;
151 |             areaString = currentScene.ToString();
152 |             float num;
153 |             float num2;
154 |             if (currentView == null)
155 |             {
156 |                 screenXString = "-1";
157 |                 screenYString = "-1";
158 |                 num = 0f;
159 |                 num2 = 0f;
160 |             }
161 |             else
162 |             {
163 |                 screenXString = currentView.ViewX.ToString();
164 |                 screenYString = currentView.ViewY.ToString();
165 |                 num = position.x - currentView.ViewLeft;
166 |                 num2 = position.y - currentView.ViewBottom;
167 |             }
168 |             int num3 = (int)Mathf.Round(num * (float)BGAbstractScrollController.NumberCls);
169 |             int num4 = (int)Mathf.Round(num2 * (float)BGAbstractScrollController.NumberCls);
170 |             num3 /= 80;
171 |             num4 /= 80;
172 |             posXString = num3.ToString();
173 |             posYString = num4.ToString();
174 |         }
175 | 
176 |         private void SetFlag()
177 |         {
178 |             int sheet = int.Parse(sheetString);
179 |             int flag = int.Parse(flagString);
180 |             short value = short.Parse(valueString);
181 | 
182 |             sys.setFlagData(sheet, flag, value);
183 |         }
184 | 
185 |         private void GetFlag()
186 |         {
187 |             int sheet = int.Parse(getSheetString);
188 |             int flag = int.Parse(getFlagString);
189 |             sys.getFlagSys().getFlagBaseObject(sheet, flag, out L2FlagBase l2Flag);
190 |             getValueString = l2Flag.flagValue.ToString();
191 |         }
192 | 
193 |         private void DoDebugWarp()
194 |         {
195 |             try
196 |             {
197 |                 int area = int.Parse(areaString);
198 |                 int screenX = int.Parse(screenXString);
199 |                 int screenY = int.Parse(screenYString);
200 |                 int posX = int.Parse(posXString);
201 |                 int posY = int.Parse(posYString);
202 | 
203 |                 L2SystemCore sysCore = sys.getL2SystemCore();
204 | 
205 |                 sysCore.setJumpPosition(screenX, screenY, posX, posY, 0f);
206 |                 if (sysCore.SceaneNo != area)
207 |                 {
208 |                     sysCore.gameScreenFadeOut(10);
209 |                     sysCore.setFadeInFlag(true);
210 |                     sysCore.changeFieldSceane(area, true, false);
211 |                     sceneJump = true;
212 |                 }
213 |                 else
214 |                 {
215 |                     JumpPosition();
216 |                     UpdatePositionInfo();
217 |                 }
218 |             }
219 |             catch (Exception) { }
220 |         }
221 | 
222 |         private void JumpPosition()
223 |         {
224 |             if (sceneJump)
225 |                 return;
226 | 
227 |             L2SystemCore sysCore = sys.getL2SystemCore();
228 |             if (sysCore.getJumpPosition(out Vector3 vector))
229 |             {
230 |                 sysCore.L2Sys.movePlayer(vector);
231 |                 currentBGSys.setPlayerPosition(vector, false);
232 |                 sysCore.resetFairy();
233 |                 currentBGSys.forceResetCameraPosition();
234 |             }
235 |         }
236 |     }
237 | }
238 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/ItemDialog.cs:
--------------------------------------------------------------------------------
  1 | using UnityEngine;
  2 | using MonoMod;
  3 | using L2Base;
  4 | using L2Word;
  5 | 
  6 | #pragma warning disable 0626, 0649, 0414, 0108
  7 | namespace LM2RandomiserMod.Patches
  8 | {
  9 |     [MonoModPatch("global::ItemDialog")]
 10 |     public class patched_ItemDialog : global::ItemDialog
 11 |     {
 12 |         [MonoModIgnore]
 13 |         private Camera cam;
 14 | 
 15 |         [MonoModIgnore]
 16 |         private string[] MessString;
 17 | 
 18 |         [MonoModIgnore]
 19 |         private int[] MessInt;
 20 | 
 21 |         [MonoModIgnore]
 22 |         private float PositionD;
 23 | 
 24 |         [MonoModIgnore]
 25 |         private float PositionF;
 26 | 
 27 |         [MonoModIgnore]
 28 |         private CanvasGroup cgroup;
 29 | 
 30 |         [MonoModIgnore]
 31 |         private ItemDialogController con;
 32 | 
 33 |         [MonoModIgnore]
 34 |         private float move_count;
 35 | 
 36 |         [MonoModReplace]
 37 |         public override void StartSwitch()
 38 |         {
 39 |             if (!first)
 40 |             {
 41 |                 cam = GameObject.Find("BGScrollSystemBase").GetComponent<BGScrollSystem>().bgCamera.BaseCamera;
 42 |                 if (MessString[1] == "kataribe")
 43 |                 {
 44 |                     PositionF = 100f;
 45 |                     PositionD = 120f;
 46 |                 }
 47 |                 else
 48 |                 {
 49 |                     Vector3 position = sys.getPlayer().gameObject.transform.position;
 50 |                     if (cam.WorldToScreenPoint(position).y > 224f)
 51 |                     {
 52 |                         PositionF = -100f;
 53 |                         PositionD = -120f;
 54 |                     }
 55 |                     else
 56 |                     {
 57 |                         PositionF = 100f;
 58 |                         PositionD = 120f;
 59 |                     }
 60 |                     sys.setSysFlag(SYSTEMFLAG.MENUOPEN);
 61 |                 }
 62 |                 cgroup = con.DialogBase.GetComponent<CanvasGroup>();
 63 |                 cgroup.alpha = 0f;
 64 |                 if (MessString[0] == "Message")
 65 |                 {
 66 |                     con.Icon.gameObject.SetActive(false);
 67 |                 }
 68 |                 else
 69 |                 {
 70 |                     con.Icon.gameObject.SetActive(true);
 71 |                     if (MessString[0].Contains("Whip"))
 72 |                     {
 73 |                         short data = 0;
 74 |                         sys.getFlag(2, "Whip", ref data);
 75 |                         if (MessString[1] == "kataribe")
 76 |                         {
 77 |                             if (data == 0) MessString[0] = "Whip";
 78 |                             else if (data == 1) MessString[0] = "Whip2";
 79 |                             else if (data >= 2) MessString[0] = "Whip3";
 80 |                         }
 81 |                         else
 82 |                         {
 83 |                             if (data == 1) MessString[0] = "Whip";
 84 |                             else if (data == 2) MessString[0] = "Whip2";
 85 |                             else if (data >= 3) MessString[0] = "Whip3";
 86 |                         }
 87 |                     }
 88 |                     else if (MessString[0].Contains("Shield"))
 89 |                     {
 90 |                         short data = 0;
 91 |                         sys.getFlag(2, 196, ref data);
 92 |                         if (MessString[1] == "kataribe")
 93 |                         {
 94 |                             if (data == 0) MessString[0] = "Shield";
 95 |                             else if (data == 1) MessString[0] = "Shield2";
 96 |                             else if (data >= 2) MessString[0] = "Shield3";
 97 |                         }
 98 |                         else
 99 |                         {
100 |                             if (data == 1) MessString[0] = "Shield";
101 |                             else if (data == 2) MessString[0] = "Shield2";
102 |                             else if (data >= 3) MessString[0] = "Shield3";
103 |                         }
104 |                     }
105 |                     else if (MessString[0].Contains("Research"))
106 |                     {
107 |                         MessString[0] = "Research";
108 |                     }
109 |                     else if (MessString[0].Contains("Beherit"))
110 |                     {
111 |                         MessString[0] = "Beherit";
112 |                     }
113 |                     con.Icon.sprite = L2Math.Load("Textures/icons_itemmenu", MessString[0]);
114 |                 }
115 |                 string str;
116 |                 string str2;
117 |                 string str3;
118 |                 if (MessString[0] == "N Chip")
119 |                 {
120 |                     str = sys.getMojiText(true, "system", "itemDialog1", mojiScriptType.system);
121 |                     str2 = GetMonsterName(MessInt[0]);
122 |                     str3 = sys.getMojiText(true, "system", "itemDialog2", mojiScriptType.system);
123 |                 }
124 |                 else if (MessString[0] == "R Chip")
125 |                 {
126 |                     str = sys.getMojiText(true, "system", "itemDialog1", mojiScriptType.system);
127 |                     str2 = GetMonsterName(MessInt[0]);
128 |                     str3 = sys.getMojiText(true, "system", "itemDialog2", mojiScriptType.system);
129 |                 }
130 |                 else if (MessString[0] == "SR Chip")
131 |                 {
132 |                     str = sys.getMojiText(true, "system", "itemDialog1", mojiScriptType.system);
133 |                     str2 = GetMonsterName(MessInt[0]);
134 |                     str3 = sys.getMojiText(true, "system", "itemDialog2", mojiScriptType.system);
135 |                 }
136 |                 else if (MessString[0] == "UR Chip")
137 |                 {
138 |                     str = sys.getMojiText(true, "system", "itemDialog1", mojiScriptType.system);
139 |                     str2 = GetMonsterName(MessInt[0]);
140 |                     str3 = sys.getMojiText(true, "system", "itemDialog2", mojiScriptType.system);
141 |                 }
142 |                 else if (MessString[0] == "Message")
143 |                 {
144 |                     str = string.Empty;
145 |                     str2 = sys.getMojiText(true, MessString[1], MessString[2], mojiScriptType.system);
146 |                     str3 = string.Empty;
147 |                 }
148 |                 else if(MessString[0].Contains("Mantra") && !MessString[0].Equals("Mantra"))
149 |                 {
150 |                     con.Icon.gameObject.SetActive(false);
151 |                     str = sys.getMojiText(true, "system", "itemDialog1", mojiScriptType.system);
152 |                     string mojiName = "mantra1stM" + MessString[0].Substring(6);
153 |                     str2 = sys.getMojiText(false, "menu", mojiName, mojiScriptType.system);
154 |                     str3 = sys.getMojiText(true, "system", "itemDialog2", mojiScriptType.system);
155 |                 }
156 |                 else if (MessString[0].Equals("Nothing"))
157 |                 {
158 |                     con.Icon.gameObject.SetActive(false);
159 |                     str = sys.getMojiText(true, "system", "itemDialog1", mojiScriptType.system);
160 |                     str2 = "Nothing";
161 |                     str3 = sys.getMojiText(true, "system", "itemDialog2", mojiScriptType.system);
162 |                 }
163 |                 else if (MessString[0].Equals("Beherit"))
164 |                 {
165 |                     con.Icon.gameObject.SetActive(false);
166 |                     str = sys.getMojiText(true, "system", "itemDialog1", mojiScriptType.system);
167 |                     short data = 0;
168 |                     sys.getFlag(2, 3, ref data);
169 |                     if(data > 1)
170 |                     {
171 |                         str2 = "Dissonance " + (data - 1);
172 |                     }
173 |                     else
174 |                     {
175 |                         string itemSheetName = sys.getItemSheetName(MessString[0]);
176 |                         str2 = sys.getMojiText(false, itemSheetName, MessString[0], mojiScriptType.item);
177 |                     }
178 |                     str3 = sys.getMojiText(true, "system", "itemDialog2", mojiScriptType.system);
179 |                 }
180 |                 else
181 |                 {
182 |                     str = sys.getMojiText(true, "system", "itemDialog1", mojiScriptType.system);
183 |                     string itemSheetName = sys.getItemSheetName(MessString[0]);
184 |                     str2 = sys.getMojiText(false, itemSheetName, MessString[0], mojiScriptType.item);
185 |                     str3 = sys.getMojiText(true, "system", "itemDialog2", mojiScriptType.system);
186 |                 }
187 |                 con.DialogText.text = str + str2 + str3;
188 |                 sys.setSysFlag(SYSTEMFLAG.ITDLRBLOCK);
189 |                 sta = 1;
190 |                 con.DialogBase.transform.localPosition = new Vector3(0f, PositionD, 600f);
191 |                 move_count = 0f;
192 |                 m_obj.SetActive(true);
193 |             }
194 |         }
195 |     }
196 | }
197 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Assembly-CSharp.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{34400CB6-0827-46B4-801D-CA281FFACD2E}</ProjectGuid>
  8 |     <OutputType>Library</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>LM2RandomiserMod</RootNamespace>
 11 |     <AssemblyName>Assembly-CSharp.mm</AssemblyName>
 12 |     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
 13 |     <FileAlignment>512</FileAlignment>
 14 |     <Deterministic>true</Deterministic>
 15 |   </PropertyGroup>
 16 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 17 |     <DebugSymbols>true</DebugSymbols>
 18 |     <DebugType>full</DebugType>
 19 |     <Optimize>false</Optimize>
 20 |     <OutputPath>bin\Debug\</OutputPath>
 21 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 22 |     <ErrorReport>prompt</ErrorReport>
 23 |     <WarningLevel>4</WarningLevel>
 24 |   </PropertyGroup>
 25 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 26 |     <DebugType>pdbonly</DebugType>
 27 |     <Optimize>true</Optimize>
 28 |     <OutputPath>bin\Release\</OutputPath>
 29 |     <DefineConstants>TRACE</DefineConstants>
 30 |     <ErrorReport>prompt</ErrorReport>
 31 |     <WarningLevel>4</WarningLevel>
 32 |   </PropertyGroup>
 33 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Dev|AnyCPU'">
 34 |     <OutputPath>bin\Dev\</OutputPath>
 35 |     <DefineConstants>TRACE;TRACE, DEV</DefineConstants>
 36 |     <Optimize>true</Optimize>
 37 |     <DebugType>pdbonly</DebugType>
 38 |     <PlatformTarget>AnyCPU</PlatformTarget>
 39 |     <ErrorReport>prompt</ErrorReport>
 40 |     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
 41 |   </PropertyGroup>
 42 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == '1.0|AnyCPU'">
 43 |     <OutputPath>bin\1.0\</OutputPath>
 44 |     <DefineConstants>TRACE;DEV</DefineConstants>
 45 |     <Optimize>true</Optimize>
 46 |     <DebugType>pdbonly</DebugType>
 47 |     <PlatformTarget>AnyCPU</PlatformTarget>
 48 |     <LangVersion>7.3</LangVersion>
 49 |     <ErrorReport>prompt</ErrorReport>
 50 |     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
 51 |   </PropertyGroup>
 52 |   <ItemGroup>
 53 |     <Reference Include="Assembly-CSharp, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 54 |       <SpecificVersion>False</SpecificVersion>
 55 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\Original\Assembly-CSharp.dll</HintPath>
 56 |     </Reference>
 57 |     <Reference Include="Assembly-CSharp-firstpass">
 58 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\Assembly-CSharp-firstpass.dll</HintPath>
 59 |     </Reference>
 60 |     <Reference Include="Mono.Cecil, Version=0.10.0.0, Culture=neutral, PublicKeyToken=50cebf1cceb9d05e, processorArchitecture=MSIL">
 61 |       <SpecificVersion>False</SpecificVersion>
 62 |       <HintPath>..\LaMulana2Randomizer\Monomod\Mono.Cecil.dll</HintPath>
 63 |     </Reference>
 64 |     <Reference Include="Mono.Cecil.Mdb">
 65 |       <HintPath>..\LaMulana2Randomizer\Monomod\Mono.Cecil.Mdb.dll</HintPath>
 66 |     </Reference>
 67 |     <Reference Include="Mono.Cecil.Pdb">
 68 |       <HintPath>..\LaMulana2Randomizer\Monomod\Mono.Cecil.Pdb.dll</HintPath>
 69 |     </Reference>
 70 |     <Reference Include="Mono.Cecil.Rocks">
 71 |       <HintPath>..\LaMulana2Randomizer\Monomod\Mono.Cecil.Rocks.dll</HintPath>
 72 |     </Reference>
 73 |     <Reference Include="MonoMod">
 74 |       <HintPath>..\LaMulana2Randomizer\Monomod\MonoMod.exe</HintPath>
 75 |     </Reference>
 76 |     <Reference Include="MonoMod.Utils">
 77 |       <HintPath>..\LaMulana2Randomizer\Monomod\MonoMod.Utils.dll</HintPath>
 78 |     </Reference>
 79 |     <Reference Include="System" />
 80 |     <Reference Include="System.Core" />
 81 |     <Reference Include="System.Xml.Linq" />
 82 |     <Reference Include="System.Data.DataSetExtensions" />
 83 |     <Reference Include="System.Data" />
 84 |     <Reference Include="System.Xml" />
 85 |     <Reference Include="TextMeshPro">
 86 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\TextMeshPro.dll</HintPath>
 87 |     </Reference>
 88 |     <Reference Include="UnityEngine">
 89 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.dll</HintPath>
 90 |     </Reference>
 91 |     <Reference Include="UnityEngine.AnimationModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
 92 |       <SpecificVersion>False</SpecificVersion>
 93 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.AnimationModule.dll</HintPath>
 94 |     </Reference>
 95 |     <Reference Include="UnityEngine.AudioModule">
 96 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.AudioModule.dll</HintPath>
 97 |     </Reference>
 98 |     <Reference Include="UnityEngine.CoreModule">
 99 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.CoreModule.dll</HintPath>
100 |     </Reference>
101 |     <Reference Include="UnityEngine.ImageConversionModule">
102 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.ImageConversionModule.dll</HintPath>
103 |     </Reference>
104 |     <Reference Include="UnityEngine.IMGUIModule">
105 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.IMGUIModule.dll</HintPath>
106 |     </Reference>
107 |     <Reference Include="UnityEngine.ParticleSystemModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
108 |       <SpecificVersion>False</SpecificVersion>
109 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.ParticleSystemModule.dll</HintPath>
110 |     </Reference>
111 |     <Reference Include="UnityEngine.PhysicsModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
112 |       <SpecificVersion>False</SpecificVersion>
113 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.PhysicsModule.dll</HintPath>
114 |     </Reference>
115 |     <Reference Include="UnityEngine.TextRenderingModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
116 |       <SpecificVersion>False</SpecificVersion>
117 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.TextRenderingModule.dll</HintPath>
118 |     </Reference>
119 |     <Reference Include="UnityEngine.UI">
120 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.UI.dll</HintPath>
121 |     </Reference>
122 |     <Reference Include="UnityEngine.UIElementsModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
123 |       <SpecificVersion>False</SpecificVersion>
124 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.UIElementsModule.dll</HintPath>
125 |     </Reference>
126 |     <Reference Include="UnityEngine.UIModule, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">
127 |       <SpecificVersion>False</SpecificVersion>
128 |       <HintPath>$(LAMULANA2PATH)\LaMulana2_Data\Managed\UnityEngine.UIModule.dll</HintPath>
129 |     </Reference>
130 |   </ItemGroup>
131 |   <ItemGroup>
132 |     <Compile Include="ExitDB.cs" />
133 |     <Compile Include="DevUI.cs" />
134 |     <Compile Include="FakeItem.cs" />
135 |     <Compile Include="HotSpring.cs" />
136 |     <Compile Include="ItemDB.cs" />
137 |     <Compile Include="ItemTracker.cs" />
138 |     <Compile Include="L2Rando.cs" />
139 |     <Compile Include="Patches\CostumeScript.cs" />
140 |     <Compile Include="Patches\SeihaiMenu.cs" />
141 |     <Compile Include="Patches\TrapFloor.cs" />
142 |     <Compile Include="Patches\L2SystemCore.cs" />
143 |     <Compile Include="Patches\EventItemScript.cs" />
144 |     <Compile Include="Patches\HolyTabretScript.cs" />
145 |     <Compile Include="Patches\ItemDialog.cs" />
146 |     <Compile Include="Patches\ItemPotScript.cs" />
147 |     <Compile Include="Patches\L2FlagSystem.cs" />
148 |     <Compile Include="Patches\L2System.cs" />
149 |     <Compile Include="Patches\MenuSystem.cs" />
150 |     <Compile Include="Patches\SnapMenu.cs" />
151 |     <Compile Include="Patches\Status.cs" />
152 |     <Compile Include="Patches\TreasureBoxScript.cs" />
153 |     <Compile Include="Properties\AssemblyInfo.cs" />
154 |     <Compile Include="Patches\ShopScript.cs" />
155 |     <Compile Include="StartDB.cs" />
156 |   </ItemGroup>
157 |   <ItemGroup>
158 |     <ProjectReference Include="..\LM2RandomiserShared\LaMulana2RandomizerShared.csproj">
159 |       <Project>{9f97eb8e-6dce-4f97-a1a6-5d0f354f581b}</Project>
160 |       <Name>LaMulana2RandomizerShared</Name>
161 |     </ProjectReference>
162 |   </ItemGroup>
163 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
164 |   <PropertyGroup>
165 |     <PreBuildEvent>
166 |     </PreBuildEvent>
167 |   </PropertyGroup>
168 |   <PropertyGroup>
169 |     <PostBuildEvent>xcopy /f /y "$(TargetPath)" "$(SolutionDir)LaMulana2Randomizer\Monomod"</PostBuildEvent>
170 |   </PropertyGroup>
171 | </Project>


--------------------------------------------------------------------------------
/LaMulana2Randomizer/ViewModels/MainViewModel.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Threading.Tasks;
  3 | using System.Windows;
  4 | using System.Windows.Input;
  5 | using LaMulana2Randomizer.UI;
  6 | using LaMulana2Randomizer.Utils;
  7 | using Version = LaMulana2RandomizerShared.Version;
  8 | 
  9 | namespace LaMulana2Randomizer.ViewModels
 10 | {
 11 |     public class MainViewModel : BindableBase
 12 |     {
 13 |         private string title;
 14 |         public string Title {
 15 |             get => title;
 16 |             set => Set(ref title, value);
 17 |         }
 18 | 
 19 |         private Settings settings;
 20 |         public Settings Settings 
 21 |         {
 22 |             get => settings;
 23 |             set => Set(ref settings, value);
 24 |         }
 25 | 
 26 |         private int seed;
 27 |         public int Seed {
 28 |             get => seed;
 29 |             set => Set(ref seed, value);
 30 |         }
 31 | 
 32 |         private string settingsString;
 33 |         public string SettingsString {
 34 |             get => settingsString;
 35 |             set => Set(ref settingsString, value);
 36 |         }
 37 | 
 38 |         private ICommand rerollCommand;
 39 |         public ICommand RerollCommand {
 40 |             get {
 41 |                 if (rerollCommand == null)
 42 |                     rerollCommand = new RelayCommand((x) => true, (x) => Reroll());
 43 | 
 44 |                 return rerollCommand;
 45 |             }
 46 |         }
 47 | 
 48 |         private ICommand generateCommand;
 49 |         public ICommand GenerateCommand {
 50 |             get {
 51 |                 if (generateCommand == null)
 52 |                     generateCommand = new RelayCommand((x) => true, (x) => Generate());
 53 | 
 54 |                 return generateCommand;
 55 |             }
 56 |         }
 57 | 
 58 |         private ICommand generateSettingsStringCommand;
 59 |         public ICommand GenerateSettingsStringCommand {
 60 |             get {
 61 |                 if (generateSettingsStringCommand == null)
 62 |                     generateSettingsStringCommand = new RelayCommand((x) => true, (x) => SettingsString = Settings.GenerateSettingsString());
 63 | 
 64 |                 return generateSettingsStringCommand;
 65 |             }
 66 |         }
 67 | 
 68 |         private ICommand applySettingsStringCommand;
 69 |         public ICommand ApplySettingsStringCommand {
 70 |             get {
 71 |                 if (applySettingsStringCommand == null)
 72 |                     applySettingsStringCommand = new RelayCommand((x) => true, (x) => ApplySettingsString());
 73 | 
 74 |                 return applySettingsStringCommand;
 75 |             }
 76 |         }
 77 | 
 78 |         public MainViewModel()
 79 |         {
 80 |             Title = "La Mulana 2 Randomiser " + Version.version;
 81 |             Settings = FileUtils.LoadSettings();
 82 |             SettingsString = Settings.GenerateSettingsString();
 83 |             Reroll();
 84 |         }
 85 | 
 86 |         public void ApplySettingsString()
 87 |         {
 88 |             try
 89 |             {
 90 |                 Settings.ApplySettingsString(settingsString);
 91 |             }
 92 |             catch(Exception ex)
 93 |             {
 94 |                 Logger.Log($"Failed to apply settings string {ex.ToString()}");
 95 |                 MessageBox.Show("Failed to apply settings string.");
 96 |             }
 97 |         }
 98 | 
 99 |         public void Reroll()
100 |         {
101 |             Seed = new Random().Next(int.MinValue, int.MaxValue);
102 |         }
103 | 
104 |         public void Generate()
105 |         {
106 |             FileUtils.SaveSettings(settings);
107 |             SettingsString = Settings.GenerateSettingsString();
108 |             ProgressDialogViewModel dialogViewModel = new ProgressDialogViewModel();
109 |             ProgressDialog dialog = new ProgressDialog()
110 |             {
111 |                 DataContext = dialogViewModel,
112 |                 Owner = Application.Current.MainWindow
113 |             };
114 | 
115 |             var task = Task.Factory.StartNew(() => GenerateSeed(dialogViewModel.progress));
116 |             task.ContinueWith(_ => dialogViewModel.TaskComplete = true);
117 |             dialog.ShowDialog();
118 |         }
119 | 
120 |         public void GenerateSeed(IProgress<ProgressInfo> progress)
121 |         {
122 |             const int MaxEntranceAttempts = 1000;
123 |             const int MaxItemAttempts = 250;
124 | 
125 |             Randomiser randomiser = new Randomiser(settings, seed);
126 | 
127 |             progress.Report(new ProgressInfo 
128 |             { 
129 |                 Label = $"Generating Seed ", 
130 |                 ProgressValue = 0, 
131 |                 IsIndeterminate = true 
132 |             });
133 | 
134 |             int attemptCount = 0;
135 |             try
136 |             {
137 |                 randomiser.Setup();
138 |                 bool entranceCheck;
139 |                 do
140 |                 {
141 |                     attemptCount++;
142 |                     randomiser.PlaceEntrances();
143 |                     entranceCheck = randomiser.EntranceCheck();
144 |                     if (!entranceCheck)
145 |                     {
146 |                         randomiser.ClearEntrances();
147 |                         Logger.Log($"Failed to generate beatable entrance configuartion, retrying.");
148 |                         progress.Report(new ProgressInfo
149 |                         {
150 |                             Label = $"Failed to generate beatable entrance configuartion, retrying attempt {attemptCount}.",
151 |                             ProgressValue = 0,
152 |                             IsIndeterminate = true
153 |                         });
154 |                     }
155 | 
156 |                 } while (!entranceCheck && attemptCount < MaxEntranceAttempts);
157 | 
158 |                 if (attemptCount == MaxEntranceAttempts && !entranceCheck)
159 |                 {
160 |                     FileUtils.WriteSpoilerLog(randomiser);
161 |                     Logger.LogAndFlush($"Failed to generate beatable entrance configuration for seed {Seed}");
162 |                     progress.Report(new ProgressInfo
163 |                     {
164 |                         Label = $"Failed to generate beatable entrance configuration, stopping after {MaxEntranceAttempts} attempts.",
165 |                         ProgressValue = 100,
166 |                         IsIndeterminate = false
167 |                     });
168 |                     return;
169 |                 }
170 | 
171 |                 Logger.Log($"Generated beatable entrance configuartion after {attemptCount} attempts.");
172 | 
173 |                 randomiser.FixAnkhLogic();
174 |                 randomiser.FixFDCLogic();
175 | 
176 |                 attemptCount = 0;
177 |                 bool canBeatGame;
178 |                 do
179 |                 {
180 |                     attemptCount++;
181 |                     canBeatGame = false;
182 | 
183 |                     if(randomiser.PlaceItems())
184 |                         canBeatGame = randomiser.CanBeatGame();
185 | 
186 |                     if (!canBeatGame)
187 |                     {
188 |                         randomiser.ClearRandomlyPlacedItems();
189 |                         Logger.Log("Failed to generate beatable item placement, retrying.");
190 |                         progress.Report(new ProgressInfo
191 |                         {
192 |                             Label = $"Failed to generate beatable item placement, retrying attempt {attemptCount}.",
193 |                             ProgressValue = 0,
194 |                             IsIndeterminate = true
195 |                         });
196 |                     }
197 |                 } while (!canBeatGame && attemptCount < MaxItemAttempts);
198 | 
199 |                 if (attemptCount == MaxItemAttempts && !canBeatGame)
200 |                 {
201 |                     FileUtils.WriteSpoilerLog(randomiser);
202 |                     Logger.LogAndFlush($"Failed to generate beatable item placement for seed {Seed}");
203 |                     progress.Report(new ProgressInfo
204 |                     {
205 |                         Label = $"Failed to generate beatable item placement, stopping after {MaxItemAttempts} attempts.",
206 |                         ProgressValue = 100,
207 |                         IsIndeterminate = false
208 |                     });
209 |                     return;
210 |                 }
211 |                 randomiser.AdjustShopPrices();
212 |                 randomiser.FixEmptyLocations();
213 | 
214 |                 FileUtils.WriteSpoilerLog(randomiser);
215 |                 FileUtils.WriteSeedFile(randomiser);
216 |             }
217 |             catch (RandomiserException ex)
218 |             {
219 |                 Logger.Flush();
220 |                 progress.Report(new ProgressInfo
221 |                 {
222 |                     Label = ex.Message,
223 |                     ProgressValue = 100,
224 |                     IsIndeterminate = false
225 |                 });
226 |                 return;
227 |             }
228 |             catch (Exception ex)
229 |             {
230 |                 Logger.Log($"Error generating seed: {Seed}");
231 |                 Logger.LogAndFlush(ex.Message);
232 |                 progress.Report(new ProgressInfo
233 |                 {
234 |                     Label = "Something has gone very wrong!",
235 |                     ProgressValue = 100,
236 |                     IsIndeterminate = false
237 |                 });
238 |                 return;
239 |             }
240 | 
241 |             Logger.LogAndFlush($"Successfully generated for seed {Seed} after {attemptCount} attempts.");
242 |             progress.Report(new ProgressInfo
243 |             {
244 |                 Label = "Successfully generated seed.",
245 |                 ProgressValue = 100,
246 |                 IsIndeterminate = false
247 |             });
248 |         }
249 |     }
250 | }
251 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/Patches/ShopScript.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using MonoMod;
  3 | using L2Base;
  4 | using L2Word;
  5 | using TMPro;
  6 | using UnityEngine;
  7 | using UnityEngine.UI;
  8 | 
  9 | #pragma warning disable 0626, 0649, 0414, 0108
 10 | namespace LM2RandomiserMod.Patches
 11 | {
 12 |     [MonoModPatch("global::ShopScript")]
 13 |     public class patched_ShopScript : global::ShopScript
 14 |     {
 15 |         [MonoModIgnore]
 16 |         private Sprite[] icon;
 17 | 
 18 |         [MonoModIgnore]
 19 |         private string[] item_id;
 20 | 
 21 |         [MonoModIgnore]
 22 |         private int item_copunter;
 23 | 
 24 |         [MonoModIgnore]
 25 |         private int[] item_num;
 26 | 
 27 |         [MonoModIgnore]
 28 |         private int[] item_value;
 29 | 
 30 |         [MonoModIgnore]
 31 |         private Image[] shop_item;
 32 | 
 33 |         [MonoModIgnore]
 34 |         private Text[] item_valu;
 35 | 
 36 |         [MonoModIgnore]
 37 |         private TextMeshProUGUI[] item_name;
 38 |         
 39 |         //Change this so shops can handle having all the different item types in them
 40 |         [MonoModReplace]
 41 |         public override bool itemCallBack(string tab, string name, int vale, int num)
 42 |         {
 43 |             string[] weapons = { "Knife", "Rapier", "Axe", "Katana", "Shuriken", "R-Shuriken", "E-Spear", "Flare Gun", "Bomb",
 44 |                                     "Chakram", "Caltrops", "Clay Doll", "Origin Seal", "Birth Seal", "Life Seal", "Death Seal"};
 45 |             
 46 |             if (item_copunter > 2)
 47 |             {
 48 |                 return false;
 49 |             }
 50 |             true_name[item_copunter] = name;
 51 |             if (sys.isAnkJewel(name))
 52 |             {
 53 |                 name = "Ankh Jewel";
 54 |             }
 55 |             else if (sys.isMap(name))
 56 |             {
 57 |                 name = "Map";
 58 |             }
 59 |             else if (name.Contains("Research"))
 60 |             {
 61 |                 name = "Research";
 62 |             }
 63 |             item_id[item_copunter] = name;
 64 |             
 65 |             if (name.Contains("Mantra") && !name.Equals("Mantra"))
 66 |             {
 67 |                 icon[item_copunter] = L2SystemCore.getShopIconSprite(L2SystemCore.getItemData("Mantra"));
 68 |                 shop_item[item_copunter].sprite = icon[item_copunter];
 69 | 
 70 |                 string mojiName = name.Equals("Mantra10") ? "mantra1stM10" : "mantra1stM" + name.Substring(6, 1);
 71 |                 item_name[item_copunter].text = sys.getMojiText(true, sys.mojiSheetNameToNo(tab, sys.getMojiScript(mojiScriptType.system)),
 72 |                     sys.mojiIdToNo(tab, mojiName, sys.getMojiScript(mojiScriptType.system)), sys.getNowLangage(), sys.getMojiScript(mojiScriptType.system));
 73 |             }
 74 |             else if (name.Contains("Beherit"))
 75 |             {
 76 |                 name = "Beherit";
 77 |                 icon[item_copunter] = L2SystemCore.getShopIconSprite(L2SystemCore.getItemData("Beherit"));
 78 |                 shop_item[item_copunter].sprite = icon[item_copunter];
 79 | 
 80 |                 short data = 0;
 81 |                 sys.getFlag(2, 3, ref data);
 82 |                 if (data > 0)
 83 |                 {
 84 |                     item_name[item_copunter].text = "Dissonance " + data;
 85 |                 }
 86 |                 else
 87 |                 {
 88 |                     item_name[item_copunter].text = sys.getMojiText(true, sys.mojiSheetNameToNo(tab, sys.getMojiScript(mojiScriptType.item)),
 89 |                         sys.mojiIdToNo(tab, name, sys.getMojiScript(mojiScriptType.item)), sys.getNowLangage(), sys.getMojiScript(mojiScriptType.item));
 90 |                 }
 91 | 
 92 |             }
 93 |             else
 94 |             {
 95 |                 if (name.Equals("Map"))
 96 |                 {
 97 |                     icon[item_copunter] = L2SystemCore.getMapIconSprite(L2SystemCore.getItemData("Map"));
 98 |                 }
 99 |                 else if (name.Contains("Crystal S"))
100 |                 {
101 |                     name = "Crystal S";
102 |                     icon[item_copunter] = L2SystemCore.getShopIconSprite(L2SystemCore.getItemData(name));
103 |                 }
104 |                 else if (name.Contains("Sacred Orb"))
105 |                 {
106 |                     name = "Sacred Orb";
107 |                     icon[item_copunter] = L2SystemCore.getMenuIconSprite(L2SystemCore.getItemData(name));
108 |                 }
109 |                 else if (name.Contains("Whip"))
110 |                 {
111 |                     short data = 0;
112 |                     sys.getFlag(2, "Whip", ref data);
113 |                     if(data == 0)
114 |                     {
115 |                         name = "Whip";
116 |                     }
117 |                     else if (data == 1) 
118 |                     { 
119 |                         name = "Whip2";
120 |                         vale *= 2;
121 |                     }
122 |                     else if (data >= 2) 
123 |                     { 
124 |                         name = "Whip3";
125 |                         vale *= 4;
126 |                     }
127 |                     icon[item_copunter] = L2SystemCore.getMenuIconSprite(L2SystemCore.getItemData(name));
128 |                 }
129 |                 else if (name.Contains("Shield"))
130 |                 {
131 |                     short data = 0;
132 |                     sys.getFlag(2, 196, ref data);
133 |                     if(data == 0)
134 |                     {
135 |                         name = "Shield";
136 |                     }
137 |                     else if (data == 1) 
138 |                     { 
139 |                         name = "Shield2";
140 |                         vale *= 2;
141 |                     }
142 |                     else if (data >= 2) 
143 |                     { 
144 |                         name = "Shield3";
145 |                         vale *= 4;
146 |                     }
147 |                     icon[item_copunter] = Load("Textures/icons_shops", name);
148 |                 }
149 |                 else if (name.Equals("MSX"))
150 |                 {
151 |                     icon[item_copunter] = L2SystemCore.getShopIconSprite(L2SystemCore.getItemData("MSX3p"));
152 |                 }
153 |                 else if (Array.IndexOf(weapons, name) > -1)
154 |                 {
155 |                     icon[item_copunter] = L2SystemCore.getMenuIconSprite(L2SystemCore.getItemData(name));
156 |                 }
157 |                 else {
158 |                     icon[item_copunter] = Load("Textures/icons_shops", name);
159 |                 }
160 | 
161 |                 shop_item[item_copunter].sprite = icon[item_copunter];
162 |                 item_name[item_copunter].text = sys.getMojiText(true, sys.mojiSheetNameToNo(tab, sys.getMojiScript(mojiScriptType.item)),
163 |                         sys.mojiIdToNo(tab, name, sys.getMojiScript(mojiScriptType.item)), sys.getNowLangage(), sys.getMojiScript(mojiScriptType.item));
164 |             }
165 |             
166 |             item_value[item_copunter] = vale;
167 |             if (vale > 999)
168 |             {
169 |                 item_valu[item_copunter].text = L2Math.numToText(vale, 4);
170 |             }
171 |             else
172 |             {
173 |                 item_valu[item_copunter].text = L2Math.numToText(vale, 3);
174 |             }
175 |             item_num[item_copunter] = num;
176 |             item_copunter++;
177 |             return true;
178 |         }
179 | 
180 |         private extern string orig_exchangeItemName(string name);
181 |         public string exchangeItemName(string name)
182 |         {
183 |             return orig_exchangeItemName(name);
184 |         }
185 | 
186 |         [MonoModIgnore]
187 |         private bool[] isSouldOut;
188 | 
189 |         [MonoModReplace]
190 |         public void setSouldOut()
191 |         {
192 |             short num = 0;
193 |             for (int i = 0; i < 3; i++)
194 |             {
195 |                 string text = exchangeItemName(item_id[i]);
196 |                 if (text != item_id[i])
197 |                 {
198 |                     sys.getFlag(sys.SeetNametoNo("02Items"), text, ref num);
199 |                     if (num != 0)
200 |                     {
201 |                         if (item_id[i] == "Pistol-b")
202 |                         {
203 |                             if (sys.getItemNum("pistolBox") >= sys.getItemMax("pistolBox"))
204 |                             {
205 |                                 isSouldOut[i] = true;
206 |                             }
207 |                             else
208 |                             {
209 |                                 isSouldOut[i] = false;
210 |                             }
211 |                         }
212 |                         else if (sys.getItemNum(true_name[i]) >= sys.getItemMax(item_id[i]))
213 |                         {
214 |                             isSouldOut[i] = true;
215 |                         }
216 |                         else
217 |                         {
218 |                             isSouldOut[i] = false;
219 |                         }
220 |                     }
221 |                     else
222 |                     {
223 |                         isSouldOut[i] = true;
224 |                     }
225 |                 }
226 |                 else if (item_id[i] == "Pepper")
227 |                 {
228 |                     short num2 = 0;
229 |                     sys.getFlag(0, "Pepper-b", ref num2);
230 |                     if (num2 == 0)
231 |                     {
232 |                         isSouldOut[i] = false;
233 |                     }
234 |                     else
235 |                     {
236 |                         isSouldOut[i] = true;
237 |                     }
238 |                 }
239 |                 else if (sys.getItemNum(true_name[i]) >= sys.getItemMax(item_id[i]))
240 |                 {
241 |                     isSouldOut[i] = true;
242 |                 }
243 |                 else
244 |                 {
245 |                     isSouldOut[i] = false;
246 |                 }
247 |             }
248 |             isSouldOut[3] = false;
249 |             drawItems();
250 |         }
251 |     }
252 | }
253 | 


--------------------------------------------------------------------------------
/LaMulana2Randomizer/Utils/FileUtils.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Linq;
  4 | using System.Collections.Generic;
  5 | using Newtonsoft.Json;
  6 | using LaMulana2RandomizerShared;
  7 | 
  8 | namespace LaMulana2Randomizer.Utils
  9 | {
 10 |     public abstract class FileUtils
 11 |     {
 12 |         public static Settings LoadSettings()
 13 |         {
 14 |             try
 15 |             {
 16 |                 using (StreamReader sr = File.OpenText("Settings.json"))
 17 |                 {
 18 |                     JsonSerializer serializer = new JsonSerializer();
 19 |                     return (Settings)serializer.Deserialize(sr, typeof(Settings));
 20 |                 }
 21 |             }
 22 |             catch (Exception ex)
 23 |             {
 24 |                 Logger.Log($"Failed to deserialise Settings.json.\n{ex.ToString()}");
 25 |             }
 26 |             return new Settings();
 27 |         }
 28 | 
 29 |         public static void SaveSettings(Settings settings)
 30 |         {
 31 |             try
 32 |             {
 33 |                 using (StreamWriter sw = new StreamWriter("Settings.json"))
 34 |                 using (JsonWriter jw = new JsonTextWriter(sw))
 35 |                 {
 36 |                     JsonSerializer serializer = new JsonSerializer
 37 |                     {
 38 |                         NullValueHandling = NullValueHandling.Ignore,
 39 |                         Formatting = Formatting.Indented
 40 |                     };
 41 | 
 42 |                     serializer.Serialize(jw, settings);
 43 |                 }
 44 |             }
 45 |             catch (Exception ex)
 46 |             {
 47 |                 Logger.Log($"Failed to serialise Settings.json.\n{ex.ToString()}");
 48 |             }
 49 |         }
 50 | 
 51 |         public static List<JsonArea> LoadWorldData()
 52 |         {
 53 |             try
 54 |             {
 55 |                 using (StreamReader sr = File.OpenText("Data\\World.json"))
 56 |                 {
 57 |                     JsonSerializer serializer = new JsonSerializer();
 58 |                     return (List<JsonArea>)serializer.Deserialize(sr, typeof(List<JsonArea>));
 59 |                 }
 60 |             }
 61 |             catch (Exception ex)
 62 |             {
 63 |                 Logger.Log($"Failed to deserialise World.json.\n{ex.ToString()}");
 64 |                 throw new RandomiserException("Failed to parse World.json.");
 65 |             }
 66 |         }
 67 | 
 68 |         public static List<Item> LoadItemFile(string name)
 69 |         {
 70 |             try
 71 |             {
 72 |                 using (StreamReader sr = File.OpenText(Path.Combine("Data", name)))
 73 |                 {
 74 |                     JsonSerializer serializer = new JsonSerializer();
 75 |                     return (List<Item>)serializer.Deserialize(sr, typeof(List<Item>));
 76 |                 }
 77 |             }
 78 |             catch (Exception ex)
 79 |             {
 80 |                 Logger.Log($"Failed to deserialise Data\\items.json.\n{ex.ToString()}");
 81 |                 throw new RandomiserException($"Failed to parse Data\\items.json.");
 82 |             }
 83 |         }
 84 |         
 85 |         public static void WriteSpoilerLog(Randomiser randomiser)
 86 |         {
 87 |             SpoilerLog spoilerLog = new SpoilerLog
 88 |             {
 89 |                 Seed = randomiser.Seed,
 90 |                 SettingsString = randomiser.Settings.GenerateSettingsString(),
 91 |                 StartingArea = randomiser.StartingArea.Name,
 92 |                 StartingWeapon = randomiser.StartingWeapon?.Name,
 93 |                 StartingItems = randomiser.StartingItems.Select(item => item.Name).ToList(),
 94 |                 Settings = randomiser.Settings
 95 |             };
 96 | 
 97 |             SortedList<string, string> entrances = new SortedList<string, string>();
 98 |             foreach (var pair in randomiser.EntrancePairs)
 99 |             {
100 |                 entrances.Add(pair.Item1.Name, pair.Item2.Name);
101 |                 entrances.Add(pair.Item2.Name, pair.Item1.Name);
102 |             }
103 | 
104 |             spoilerLog.Entrances = entrances;
105 | 
106 |             SortedList<int, SortedList<string, string>> soulGates = new SortedList<int, SortedList<string, string>>();
107 |             foreach (var group in randomiser.SoulGatePairs.GroupBy(x => x.Item3))
108 |             {
109 |                 SortedList<string, string> pairs = new SortedList<string, string>();
110 |                 foreach(var item in group)
111 |                 {
112 |                     pairs.Add(item.Item1.Name, item.Item2.Name);
113 |                     pairs.Add(item.Item2.Name, item.Item1.Name);
114 |                 }
115 |                 soulGates.Add(group.Key, pairs);
116 |             }
117 |             spoilerLog.SoulGates = soulGates;
118 | 
119 |             Dictionary<string, string> locations = new Dictionary<string, string>();
120 |             foreach (Location location in randomiser.GetPlacedLocations().OrderBy(x => x.ID))
121 |             {
122 |                 if (location.ID < LocationID.Ratatoskr1 && location.ID != LocationID.None)
123 |                     locations.Add(location.Name, location.Item.Name);
124 |             }
125 |             spoilerLog.Locations = locations;
126 | 
127 |             PlayerState state = new PlayerState(randomiser)
128 |             {
129 |                 IgnoreFalseChecks = true
130 |             };
131 | 
132 |             List<Location> reachableLocations;
133 |             Dictionary<int, Dictionary<string, string>> playthrough = new Dictionary<int, Dictionary<string, string>>();
134 |             int sphere = 0;
135 |             do
136 |             {
137 |                 Dictionary<string, string> spoilerSphere = new Dictionary<string, string>();
138 |                 reachableLocations = state.GetReachableLocations(randomiser.GetPlacedRequiredItemLocations());
139 |                 foreach (Location location in reachableLocations.OrderBy(x => x.ID))
140 |                 {
141 |                     state.CollectItem(location.Item);
142 |                     state.CollectLocation(location);
143 |                     spoilerSphere.Add(location.Name,location.Item.Name);
144 |                 }
145 | 
146 |                 playthrough.Add(sphere++, spoilerSphere);
147 | 
148 |                 if (state.CanBeatGame())
149 |                     break;
150 | 
151 |                 state.RemoveFalseCheckedAreasAndEntrances();
152 | 
153 |             } while (reachableLocations.Count > 0);
154 | 
155 |             spoilerLog.Playthrough = playthrough;
156 | 
157 |             try
158 |             {
159 |                 using (StreamWriter sw = new StreamWriter("Seed\\Spoilers.json"))
160 |                 using (JsonWriter jw = new JsonTextWriter(sw))
161 |                 {
162 |                     JsonSerializer serializer = new JsonSerializer
163 |                     {
164 |                         NullValueHandling = NullValueHandling.Ignore,
165 |                         Formatting = Formatting.Indented
166 |                     };
167 | 
168 |                     serializer.Serialize(jw, spoilerLog);
169 |                 }
170 |             }
171 |             catch (Exception ex)
172 |             {
173 |                 Logger.Log($"Failed to write spoiler log.\n {ex.ToString()}");
174 |                 throw new RandomiserException("Failed to write spoiler log.");
175 |             }
176 |         }
177 | 
178 |         public static void WriteSeedFile(Randomiser randomiser)
179 |         {
180 |             List<(LocationID, ItemID)> items = new List<(LocationID, ItemID)>();
181 |             List<(LocationID, ItemID, int)> shopItems = new List<(LocationID, ItemID, int)>();
182 |             foreach (Location location in randomiser.GetPlacedLocations())
183 |             {
184 |                 if (location.ID < LocationID.Ratatoskr1 && location.ID != LocationID.None && location.Item.ID != ItemID.None)
185 |                 {
186 |                     if (location.LocationType == LocationType.Shop)
187 |                     {
188 |                         shopItems.Add((location.ID, location.Item.ID, location.Item.PriceMultiplier));
189 |                     }
190 |                     else
191 |                     {
192 |                         items.Add((location.ID, location.Item.ID));
193 |                     }
194 |                 }
195 |             }
196 | 
197 |             try
198 |             {   
199 |                 using (BinaryWriter br = new BinaryWriter(File.Open("Seed\\seed.lm2r", FileMode.Create)))
200 |                 {
201 |                     br.Write((int)randomiser.StartingWeapon.ID);
202 |                     br.Write((int)randomiser.StartingArea.ID);
203 |                     br.Write(randomiser.Settings.RandomDissonance);
204 |                     br.Write(randomiser.Settings.RequiredGuardians);
205 |                     br.Write(randomiser.Settings.RequiredSkulls);
206 |                     br.Write(randomiser.Settings.RemoveITStatue);
207 |                     br.Write((int)randomiser.Settings.ChosenEchidna);
208 |                     br.Write(randomiser.Settings.AutoScanTablets);
209 |                     br.Write(randomiser.Settings.AutoPlaceSkulls);
210 |                     br.Write(randomiser.Settings.StartingMoney);
211 |                     br.Write(randomiser.Settings.StartingWeights);
212 |                     br.Write((int)randomiser.Settings.ItemChestColour);
213 |                     br.Write((int)randomiser.Settings.WeightChestColour);
214 | 
215 |                     br.Write(randomiser.StartingItems.Count);
216 |                     foreach (var item in randomiser.StartingItems)
217 |                         br.Write((int)item.ID);
218 | 
219 |                     br.Write(items.Count);
220 |                     foreach(var item in items)
221 |                     {
222 |                         br.Write((int)item.Item1);
223 |                         br.Write((int)item.Item2);
224 |                     }
225 | 
226 |                     br.Write(shopItems.Count);
227 |                     foreach (var item in shopItems)
228 |                     {
229 |                         br.Write((int)item.Item1);
230 |                         br.Write((int)item.Item2);
231 |                         br.Write(item.Item3);
232 |                     }
233 | 
234 |                     br.Write(randomiser.CursedLocations.Count);
235 |                     foreach (Location location in randomiser.CursedLocations)
236 |                         br.Write((int)location.ID);
237 | 
238 |                     br.Write(randomiser.EntrancePairs.Count);
239 |                     foreach(var d in randomiser.EntrancePairs)
240 |                     {
241 |                         br.Write((int)d.Item1.ID);
242 |                         br.Write((int)d.Item2.ID);
243 |                     }
244 | 
245 |                     br.Write(randomiser.SoulGatePairs.Count);
246 |                     foreach (var s in randomiser.SoulGatePairs)
247 |                     {
248 |                         br.Write((int)s.Item1.ID);
249 |                         br.Write((int)s.Item2.ID);
250 |                         br.Write(s.Item3);
251 |                     }
252 |                 }
253 |                 Logger.Log($"Total items randomised {items.Count + shopItems.Count}");
254 |             }
255 |             catch (Exception ex)
256 |             {
257 |                 Logger.Log($"Failed to write seed file.\n {ex.ToString()}");
258 |                 throw new RandomiserException("Failed to write seed file.");
259 |             }
260 |         }
261 |     }
262 | }
263 | 


--------------------------------------------------------------------------------
/Assembly-CSharp/ExitDB.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using LaMulana2RandomizerShared;
  3 | 
  4 | namespace LM2RandomiserMod
  5 | {
  6 |     public abstract class ExitDB
  7 |     {
  8 |         public static ExitInfo GetExitInfo(ExitID id)
  9 |         {
 10 |             connectionData.TryGetValue(id, out ExitInfo result);
 11 |             return result;
 12 |         }
 13 | 
 14 |         private static readonly Dictionary<ExitID, ExitInfo> connectionData = new Dictionary<ExitID, ExitInfo>(){
 15 |             //left doors
 16 |             { ExitID.fLLeft,           new ExitInfo("PlayerStart fLLeft",        17, -1, -1)},
 17 |             { ExitID.fL02Left,         new ExitInfo("PlayerStart fL02Left",      18, -1, -1)},
 18 |             { ExitID.fP00Left,         new ExitInfo("PlayerStart",               23, -1, -1)},
 19 |             { ExitID.fP02Left,         new ExitInfo("PlayerStart",               25, -1, -1)},
 20 | 
 21 |             //right doors
 22 |             { ExitID.f01Right,         new ExitInfo("PlayerStart f01Right",      1,  -1, -1)},
 23 |             { ExitID.f03Right,         new ExitInfo("PlayerStart f03Right",      3,  -1, -1)},
 24 |             { ExitID.fL08Right,        new ExitInfo("PlayerStart",               21, -1, -1)},
 25 |             { ExitID.fP00Right,        new ExitInfo("PlayerStart2",              23, -1, -1)},
 26 | 
 27 |             //down ladders
 28 |             { ExitID.f00Down,          new ExitInfo("PlayerStart f00Down",       0,  -1, -1)},
 29 |             { ExitID.f01Down,          new ExitInfo("PlayerStart f01Down",       1,  -1, -1)},
 30 |             { ExitID.f02Down,          new ExitInfo("PlayerStart f02Down",       2,  -1, -1)},
 31 |             { ExitID.f03Down1,         new ExitInfo("PlayerStart f03Down1",      3,  -1, -1)},
 32 |             { ExitID.f03Down2,         new ExitInfo("PlayerStart f03Down2",      3,  -1, -1)},
 33 |             { ExitID.f03Down3,         new ExitInfo("PlayerStart f03Down3",      3,  -1, -1)},
 34 |             { ExitID.fLDown,           new ExitInfo("PlayerStart fLDown",        17, -1, -1)},
 35 | 
 36 |             //up ladders
 37 |             { ExitID.f02Up,            new ExitInfo("PlayerStart f02Up",         2,  -1, -1)},
 38 |             { ExitID.f03Up,            new ExitInfo("PlayerStart f03Up",         3,  -1, -1)}, //
 39 |             { ExitID.f04Up,            new ExitInfo("PlayerStart f04Up",         4,  -1, -1)},
 40 |             { ExitID.f04Up2,           new ExitInfo("PlayerStart f04Up2",        4,  -1, -1)},
 41 |             { ExitID.f04Up3,           new ExitInfo("PlayerStart f04Up3",        4,  -1, -1)}, //
 42 |             { ExitID.fL02Up,           new ExitInfo("PlayerStart fL02Up",        18, -1, -1)},
 43 |             { ExitID.fL05Up,           new ExitInfo("PlayerStart",               20, -1, -1)},
 44 | 
 45 |             //gates
 46 |             { ExitID.f00GateY0,       new ExitInfo("PlayerStart f00GateY0",       0,  0,  0)},
 47 |             { ExitID.f00GateYA,       new ExitInfo("PlayerStart f00GateYA",       0,  4,  0)},
 48 |             { ExitID.f00GateYB,       new ExitInfo("PlayerStart f00GateYB",       0,  4,  3)},
 49 |             { ExitID.f00GateYC,       new ExitInfo("PlayerStart f00GateYC",       0,  4,  8)},
 50 |             { ExitID.f02GateYA,       new ExitInfo("PlayerStart f02GateYA",       2,  0,  0)},
 51 |             { ExitID.f03GateYC,       new ExitInfo("PlayerStart f03GateYC",       3,  0,  0)},
 52 |             { ExitID.f04GateYB,       new ExitInfo("PlayerStart f04GateYB",       4,  0,  0)},
 53 |             { ExitID.f05GateP1,       new ExitInfo("PlayerStart f05GateP1",       5,  9,  4)},
 54 |             { ExitID.f06GateP0,       new ExitInfo("PlayerStart f06GateP0",       6,  0,  0)},
 55 |             { ExitID.f06_2GateP0,     new ExitInfo("PlayerStart f06-2GateP0",    16, 10,  4)},
 56 |             { ExitID.f07GateP0,       new ExitInfo("PlayerStart f07GateP0",       7, 11, 16)},
 57 |             { ExitID.f08GateP0,       new ExitInfo("PlayerStart f08GateP0",       8, 12, 50)},
 58 |             { ExitID.f09GateP0,       new ExitInfo("PlayerStart f09GateP0",       9, 13,  3)},
 59 |             { ExitID.f10GateP0,       new ExitInfo("PlayerStart f10GateP0",      10,  9,  4)},
 60 |             { ExitID.f11GateP0,       new ExitInfo("PlayerStart f11GateP0",      11,  0,  0)},
 61 |             { ExitID.f12GateP0,       new ExitInfo("PlayerStart f12GateP0",      12,  0,  0)},
 62 |             { ExitID.f13GateP0,       new ExitInfo("PlayerStart f13GateP0",      13,  0,  0)},
 63 |             { ExitID.fLGate,          new ExitInfo("PlayerStart fLGate",         17,  0,  0)},
 64 |             { ExitID.fL11GateY0,      new ExitInfo("PlayerStart fL11GateY0",     22,  5, 17)},
 65 |             { ExitID.fL11GateN,       new ExitInfo("PlayerStart fL11GateN",      22,  0,  0)},
 66 | 
 67 |             //soul gates
 68 |             { ExitID.f00GateN1,       new ExitInfo("PlayerStart f00GateN1",       0, -1, -1)},
 69 |             { ExitID.f02GateN2,       new ExitInfo("PlayerStart f02GateN2",       2, -1, -1)},
 70 |             { ExitID.f03GateN3,       new ExitInfo("PlayerStart f03GateN3",       3, -1, -1)},
 71 |             { ExitID.f03GateN4,       new ExitInfo("PlayerStart f03GateN4",       3, -1, -1)},
 72 |             { ExitID.f03GateN9,       new ExitInfo("PlayerStart f03GateN9",       3, -1, -1)},
 73 |             { ExitID.f04GateN5,       new ExitInfo("PlayerStart f04GateN5",       4, -1, -1)},
 74 |             { ExitID.f04GateN6,       new ExitInfo("PlayerStart f04GateN62",      4, -1, -1)},
 75 |             { ExitID.f05GateN1,       new ExitInfo("PlayerStart f05GateN1",       5, -1, -1)},
 76 |             { ExitID.f06GateN2,       new ExitInfo("PlayerStart f06GateN2",       6, -1, -1)},
 77 |             { ExitID.f06GateN7,       new ExitInfo("PlayerStart f06GateN7",       6, -1, -1)},
 78 |             { ExitID.f07GateN3,       new ExitInfo("PlayerStart f07GateN3",       7, -1, -1)},
 79 |             { ExitID.f08GateN4,       new ExitInfo("PlayerStart f08GateN4",       8, -1, -1)},
 80 |             { ExitID.f08GateN8,       new ExitInfo("PlayerStart f08GateN8",       8, -1, -1)},
 81 |             { ExitID.f09GateN5,       new ExitInfo("PlayerStart f09GateN5",       9, -1, -1)},
 82 |             { ExitID.f10GateN7,       new ExitInfo("PlayerStart f10GateN7",      10, -1, -1)},
 83 |             { ExitID.f12GateN8,       new ExitInfo("PlayerStart f12GateN8",      12, -1, -1)},
 84 |             { ExitID.f13GateN9,       new ExitInfo("PlayerStart f13GateN9",      13, -1, -1)},
 85 |             { ExitID.f14GateN6,       new ExitInfo("PlayerStart f14GateN6",      14, -1, -1)},
 86 | 
 87 |             //other
 88 |             { ExitID.fStart,          new ExitInfo("PlayerStart f01Right",       32, -1, -1)},
 89 |             { ExitID.f01Start,        new ExitInfo("PlayerStart f01Start",        1, -1, -1)},
 90 |             { ExitID.f02Bifrost,      new ExitInfo("PlayerStart f02Bifrost",      2, -1, -1)},
 91 |             { ExitID.f03In,           new ExitInfo("PlayerStart f03In",           3, -1, -1)},
 92 |             { ExitID.f08Neck,         new ExitInfo("PlayerStart f08Neck",         8, -1, -1)},
 93 |             { ExitID.f09In,           new ExitInfo("PlayerStart f09In",           9, -1, -1)},
 94 |             { ExitID.f11Pyramid,      new ExitInfo("PlayerStart f11Pyramid",     11, -1, -1)},
 95 |             { ExitID.fNibiru,         new ExitInfo("PlayerStart",                27, -1, -1)},
 96 |             { ExitID.f03GateP0,       new ExitInfo("PlayerStart f03GateP0",       3, -1, -1)},
 97 |             { ExitID.f03GateP1,       new ExitInfo("PlayerStart f03GateP1",       3, -1, -1)},
 98 |             { ExitID.fP01Left,        new ExitInfo("PlayerStart0",               24, -1, -1)},
 99 |             { ExitID.fP01Right,       new ExitInfo("PlayerStart1",               24, -1, -1)},
100 |         };
101 | 
102 | 
103 |         public static ExitID AnchorNameToExitID(string anchorName)
104 |         {
105 |             anchorNameToExitID.TryGetValue(anchorName, out ExitID result);
106 |             return result;
107 |         }
108 | 
109 |         private static readonly Dictionary<string, ExitID> anchorNameToExitID = new Dictionary<string, ExitID>()
110 |         {
111 |             //left doors
112 |             {"PlayerStart f01Right",       ExitID.fLLeft },
113 |             {"PlayerStart f03Right",       ExitID.fP00Left },
114 |             {"PlayerStart2",               ExitID.fP02Left },
115 |                                            
116 |             //right doors                  
117 |             {"PlayerStart fLLeft",         ExitID.f01Right },
118 |             {"PlayerStart fL02Left",       ExitID.fL08Right },
119 |                                            
120 |             //down ladders                 
121 |             {"PlayerStart f02Up",          ExitID.f00Down },
122 |             {"PlayerStart f04Up",          ExitID.f03Down1 },
123 |             {"PlayerStart f04Up2",         ExitID.f03Down3 },
124 |             {"PlayerStart fL02Up",         ExitID.fLDown },
125 |                                            
126 |             //up ladders                   
127 |             {"PlayerStart f00Down",        ExitID.f02Up },
128 |             {"PlayerStart f02Down",        ExitID.f03Up },
129 |             {"PlayerStart f03Down1",       ExitID.f04Up },
130 |             {"PlayerStart f03Down2",       ExitID.f04Up3 },
131 |             {"PlayerStart f03Down3",       ExitID.f04Up2 },
132 |             {"PlayerStart fLDown",         ExitID.fL02Up },
133 | 
134 |             //gates
135 |             {"PlayerStart fL11GateY0",     ExitID.f00GateY0 },
136 |             {"PlayerStart f02GateYA",      ExitID.f00GateYA },
137 |             {"PlayerStart f03GateYC",      ExitID.f00GateYC },
138 |             {"PlayerStart f04GateYB",      ExitID.f00GateYB },
139 |             {"PlayerStart f00GateYA",      ExitID.f02GateYA },
140 |             {"PlayerStart f00GateYC",      ExitID.f03GateYC },
141 |             {"PlayerStart f00GateYB",      ExitID.f04GateYB },
142 |             {"PlayerStart f10GateP0",      ExitID.f05GateP1 },
143 |             {"PlayerStart f06-2GateP0",    ExitID.f06GateP0 },
144 |             {"PlayerStart f06GateP0",      ExitID.f06_2GateP0 },
145 |             {"PlayerStart f11GateP0",      ExitID.f07GateP0 },
146 |             {"PlayerStart f12GateP0",      ExitID.f08GateP0 },
147 |             {"PlayerStart f13GateP0",      ExitID.f09GateP0 },
148 |             {"PlayerStart f05GateP1",      ExitID.f10GateP0 },
149 |             {"PlayerStart f07GateP0",      ExitID.f11GateP0 },
150 |             {"PlayerStart f08GateP0",      ExitID.f12GateP0 },
151 |             {"PlayerStart f09GateP0",      ExitID.f13GateP0 },
152 |             {"PlayerStart fL11GateN",      ExitID.fLGate },
153 |             {"PlayerStart f00GateY0",      ExitID.fL11GateY0 },
154 |             {"PlayerStart fLGate",         ExitID.fL11GateN },
155 | 
156 |             //soul gates
157 |             {"PlayerStart f05GateN1",      ExitID.f00GateN1 },
158 |             {"PlayerStart f06GateN2",      ExitID.f02GateN2 },
159 |             {"PlayerStart f07GateN3",      ExitID.f03GateN3 },
160 |             {"PlayerStart f08GateN4",      ExitID.f03GateN4 },
161 |             {"PlayerStart f13GateN9",      ExitID.f03GateN9 },
162 |             {"PlayerStart f09GateN5",      ExitID.f04GateN5 },
163 |             {"PlayerStart f14GateN6",      ExitID.f04GateN6 },
164 |             {"PlayerStart f00GateN1",      ExitID.f05GateN1 },
165 |             {"PlayerStart f02GateN2",      ExitID.f06GateN2 },
166 |             {"PlayerStart f10GateN7",      ExitID.f06GateN7 },
167 |             {"PlayerStart f03GateN3",      ExitID.f07GateN3 },
168 |             {"PlayerStart f03GateN4",      ExitID.f08GateN4 },
169 |             {"PlayerStart f12GateN8",      ExitID.f08GateN8 },
170 |             {"PlayerStart f04GateN5",      ExitID.f09GateN5 },
171 |             {"PlayerStart f06GateN7",      ExitID.f10GateN7 },
172 |             {"PlayerStart f08GateN8",      ExitID.f12GateN8 },
173 |             {"PlayerStart f03GateN9",      ExitID.f13GateN9 },
174 |             {"PlayerStart f04GateN6",      ExitID.f14GateN6 },
175 |             {"PlayerStart f04GateN62",     ExitID.f14GateN6 },
176 |             
177 |             //other
178 |             {"PlayerStart f01Start",       ExitID.fStart },
179 |             {"PlayerStart f03In",          ExitID.f02Bifrost },
180 |             {"PlayerStart f09In",          ExitID.f08Neck },
181 |             {"PlayerStart f11Pyramid",     ExitID.fNibiru },
182 |             {"PlayerStart f03GateP0",      ExitID.fP01Left },
183 |             {"PlayerStart f03GateP1",      ExitID.fP01Right },
184 |         };
185 |     }
186 | 
187 |     public class ExitInfo
188 |     {
189 |         public string AnchorName;
190 |         public int FieldNo;
191 |         public int SheetNo;
192 |         public int FlagNo;
193 | 
194 |         public ExitInfo(string anchorName, int fieldNo, int sheetNo, int flagNo)
195 |         {
196 |             AnchorName = anchorName;
197 |             FieldNo = fieldNo;
198 |             SheetNo = sheetNo;
199 |             FlagNo = flagNo;
200 |         }
201 |     }
202 | }
203 | 


--------------------------------------------------------------------------------