using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DiskCardGame;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("InscryptionMP")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2+8f6fd59bdc97ea4068e67397f3da01bf95cd2e24")]
[assembly: AssemblyProduct("InscryptionMP")]
[assembly: AssemblyTitle("InscryptionMP")]
[assembly: AssemblyMetadata("AI_Assisted_Creation", "This assembly was partially or fully created with the assistance of Generative AI (e.g., Code Suggestions, Refactoring, Documentation Generation).")]
[assembly: AssemblyMetadata("AI_Model_Vendor", "Anthropic")]
[assembly: AssemblyMetadata("AI_Model", "Claude Opus 5")]
[assembly: AssemblyVersion("1.0.2.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace InscryptionMP
{
[HarmonyPatch]
internal static class DeckOverride
{
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPrefix]
private static bool DeckData(ref List<CardInfo> __result)
{
if (!Match.Active)
{
return true;
}
__result = Match.Deck;
Trace.Info($"[deck] serving versus deck ({__result.Count} cards) instead of save deck");
return false;
}
}
public static class DeckStore
{
public const int MinCards = 6;
public const int MaxCards = 20;
private static readonly string[] Starter = new string[10] { "Stoat", "Stoat", "Bullfrog", "Bullfrog", "Wolf", "Wolf", "Adder", "Squirrel", "Squirrel", "Squirrel" };
private static List<string> _deck;
private static List<CardInfo> _pool;
private static string Path
{
get
{
string path = Paths.ConfigPath ?? ".";
return System.IO.Path.Combine(path, "inscryptionmp-deck.txt");
}
}
public static List<string> Deck
{
get
{
if (_deck == null)
{
Load();
}
return _deck;
}
}
public static bool IsValid => Deck.Count >= 6 && Deck.Count <= 20;
public static List<CardInfo> Pool
{
get
{
if (_pool != null)
{
return _pool;
}
try
{
_pool = (from c in ScriptableObjectLoader<CardInfo>.AllData
where (Object)(object)c != (Object)null && (int)c.temple == 0 && c.metaCategories != null && c.metaCategories.Contains((CardMetaCategory)0)
orderby c.BloodCost, c.DisplayedNameEnglish
select c).ToList();
Trace.Info($"[deck] card pool: {_pool.Count} cards");
}
catch (Exception ex)
{
Trace.Error("[deck] pool build failed: " + ex.Message);
_pool = new List<CardInfo>();
}
return _pool;
}
}
public static void Load()
{
try
{
if (File.Exists(Path))
{
_deck = (from l in File.ReadAllLines(Path)
select l.Trim() into l
where l.Length > 0 && !l.StartsWith("#")
select l).ToList();
Trace.Info($"[deck] loaded {_deck.Count} cards from disk");
}
else
{
_deck = new List<string>(Starter);
Trace.Info("[deck] no saved deck - using starter");
}
}
catch (Exception ex)
{
Trace.Error("[deck] load failed: " + ex.Message);
_deck = new List<string>(Starter);
}
}
public static void Save()
{
try
{
File.WriteAllLines(Path, Deck.ToArray());
Trace.Info($"[deck] saved {Deck.Count} cards");
}
catch (Exception ex)
{
Trace.Error("[deck] save failed: " + ex.Message);
}
}
public static void Add(string cardName)
{
if (Deck.Count < 20)
{
Deck.Add(cardName);
Match.Reset();
}
}
public static void Remove(string cardName)
{
Deck.Remove(cardName);
Match.Reset();
}
public static int CountOf(string cardName)
{
return Deck.Count((string c) => c == cardName);
}
public static void ResetToStarter()
{
_deck = new List<string>(Starter);
Match.Reset();
}
}
public static class Match
{
private static List<CardInfo> _cache;
public static bool Active => VersusMode.InMatch;
public static List<CardInfo> Deck
{
get
{
if (_cache != null)
{
return new List<CardInfo>(_cache);
}
List<CardInfo> list = new List<CardInfo>();
foreach (string item in DeckStore.Deck)
{
CardInfo cardByName = CardLoader.GetCardByName(item);
if ((Object)(object)cardByName == (Object)null)
{
Trace.Warn("[match] card '" + item + "' did not resolve - skipping");
}
else
{
list.Add(cardByName);
}
}
Trace.Info($"[match] built versus deck with {list.Count} cards from the player's list");
_cache = list;
return new List<CardInfo>(_cache);
}
}
public static void Reset()
{
_cache = null;
}
}
[HarmonyPatch]
internal static class MatchEnd
{
[HarmonyPatch(typeof(TurnManager), "TransitionToNextGameState")]
[HarmonyPrefix]
private static bool InterceptEnd(TurnManager __instance)
{
if (!VersusMode.InMatch)
{
return true;
}
VersusMode.Finish((MonoBehaviour)(object)__instance, __instance.PlayerWon, "battle resolved");
return false;
}
}
[HarmonyPatch]
internal static class MatchLock
{
[HarmonyPatch(typeof(GameFlowManager), "TransitionToFirstPerson")]
[HarmonyPrefix]
private static bool BlockStandingUp()
{
if (!VersusMode.InMatch)
{
return true;
}
return false;
}
[HarmonyPatch(typeof(GameFlowManager), "TransitionToGameState")]
[HarmonyPrefix]
private static bool BlockStateChange(GameState gameState)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Invalid comparison between Unknown and I4
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (!VersusMode.InMatch)
{
return true;
}
if ((int)gameState == 0)
{
return true;
}
Trace.Warn($"[lock] blocked transition to {gameState} during match");
return false;
}
}
internal class MpMenu : MonoBehaviour
{
internal static string Ip = "127.0.0.1";
internal static string PortText = 27333.ToString();
private const float PanelW = 480f;
private const float PanelH = 520f;
private bool _open;
private bool _matchWasActive;
private Rect _rect;
private Vector2 _lobbyScroll;
private GUIStyle _chip;
private GUIStyle _label;
private GUIStyle _dim;
private GUIStyle _header;
private GUIStyle _section;
private GUIStyle _field;
private GUIStyle _button;
private GUIStyle _small;
private Texture2D _panelBg;
private Texture2D _chipBg;
private Texture2D _accent;
private Texture2D _rule;
private static int ParsedPort
{
get
{
int result;
return (int.TryParse(PortText, out result) && result > 0 && result < 65536) ? result : 27333;
}
}
private void Update()
{
SteamTransport.Poll();
if (Input.GetKeyDown((KeyCode)288))
{
if (NativeDeckBuilder.IsOpen)
{
NativeDeckBuilder.Close();
}
else
{
_open = !_open;
}
}
if (Input.GetKeyDown((KeyCode)289))
{
VersusMode.StartAnywhere((MonoBehaviour)(object)this);
}
if (Input.GetKeyDown((KeyCode)293))
{
VersusMode.Abort((MonoBehaviour)(object)this);
}
VersusMode.TickPendingStart((MonoBehaviour)(object)this);
NativeDeckBuilder.TickPendingOpen((MonoBehaviour)(object)this);
bool flag = VersusMode.InMatch || VersusMode.PendingStart;
if (flag && !_matchWasActive)
{
_open = false;
}
_matchWasActive = flag;
if (Net.PendingStartRequest)
{
Net.PendingStartRequest = false;
if (!VersusMode.InMatch && !VersusMode.PendingStart)
{
Trace.Info("[versus] peer started a match - joining");
VersusMode.StartAnywhere((MonoBehaviour)(object)this, tellPeer: false);
}
}
if (Net.PendingResult.HasValue)
{
bool value = Net.PendingResult.Value;
Net.PendingResult = null;
if (VersusMode.InMatch)
{
VersusMode.Finish((MonoBehaviour)(object)this, value, "peer reported the result");
}
}
if (VersusMode.InMatch && !Net.Connected)
{
VersusMode.NoteDisconnected();
}
if (VersusMode.InMatch && Net.Connected && VersusMode.Suspended)
{
VersusMode.NoteReconnected();
}
VersusMode.TickSuspension((MonoBehaviour)(object)this);
}
private static Texture2D Solid(Color c)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Expected O, but got Unknown
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
Texture2D val = new Texture2D(1, 1);
val.SetPixel(0, 0, c);
val.Apply();
((Object)val).hideFlags = (HideFlags)61;
return val;
}
private void EnsureStyles()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Expected O, but got Unknown
//IL_00e4: Expected O, but got Unknown
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Expected O, but got Unknown
//IL_0129: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_014c: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Expected O, but got Unknown
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Expected O, but got Unknown
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
//IL_01dc: Expected O, but got Unknown
//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0212: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Expected O, but got Unknown
//IL_022d: Unknown result type (might be due to invalid IL or missing references)
//IL_0232: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
//IL_0240: Unknown result type (might be due to invalid IL or missing references)
//IL_024a: Expected O, but got Unknown
//IL_024b: Unknown result type (might be due to invalid IL or missing references)
//IL_0251: Unknown result type (might be due to invalid IL or missing references)
//IL_025c: Unknown result type (might be due to invalid IL or missing references)
//IL_0276: Unknown result type (might be due to invalid IL or missing references)
//IL_0286: Unknown result type (might be due to invalid IL or missing references)
//IL_028c: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Unknown result type (might be due to invalid IL or missing references)
//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
//IL_02c6: Expected O, but got Unknown
//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
//IL_02df: Unknown result type (might be due to invalid IL or missing references)
//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
//IL_02f2: Expected O, but got Unknown
//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
//IL_0308: Unknown result type (might be due to invalid IL or missing references)
//IL_0313: Unknown result type (might be due to invalid IL or missing references)
//IL_032d: Unknown result type (might be due to invalid IL or missing references)
//IL_033d: Unknown result type (might be due to invalid IL or missing references)
//IL_0343: Unknown result type (might be due to invalid IL or missing references)
//IL_034e: Unknown result type (might be due to invalid IL or missing references)
//IL_0368: Unknown result type (might be due to invalid IL or missing references)
//IL_0378: Unknown result type (might be due to invalid IL or missing references)
//IL_037e: Unknown result type (might be due to invalid IL or missing references)
//IL_0389: Unknown result type (might be due to invalid IL or missing references)
//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
//IL_03b8: Expected O, but got Unknown
if (_chip == null)
{
_panelBg = Solid(new Color(0.06f, 0.05f, 0.04f, 0.98f));
_chipBg = Solid(new Color(0.06f, 0.05f, 0.04f, 0.88f));
_accent = Solid(new Color(0.85f, 0.62f, 0.25f, 1f));
_rule = Solid(new Color(1f, 1f, 1f, 0.1f));
GUIStyle val = new GUIStyle(GUI.skin.label)
{
fontSize = 14
};
val.normal.textColor = Color.white;
val.padding = new RectOffset(10, 10, 5, 5);
_chip = val;
GUIStyle val2 = new GUIStyle(GUI.skin.label)
{
fontSize = 15
};
val2.normal.textColor = new Color(0.96f, 0.94f, 0.88f);
_label = val2;
GUIStyle val3 = new GUIStyle(_label)
{
fontSize = 13
};
val3.normal.textColor = new Color(0.6f, 0.57f, 0.51f);
_dim = val3;
GUIStyle val4 = new GUIStyle(_label)
{
fontSize = 12
};
val4.normal.textColor = new Color(0.55f, 0.52f, 0.47f);
_small = val4;
GUIStyle val5 = new GUIStyle(GUI.skin.label)
{
fontSize = 21,
fontStyle = (FontStyle)1
};
val5.normal.textColor = new Color(1f, 0.8f, 0.38f);
_header = val5;
GUIStyle val6 = new GUIStyle(GUI.skin.label)
{
fontSize = 12,
fontStyle = (FontStyle)1
};
val6.normal.textColor = new Color(0.85f, 0.62f, 0.25f);
_section = val6;
GUIStyle val7 = new GUIStyle(GUI.skin.textField)
{
fontSize = 15,
padding = new RectOffset(8, 8, 6, 6)
};
val7.normal.textColor = Color.white;
val7.normal.background = Solid(new Color(0.15f, 0.14f, 0.12f, 1f));
val7.focused.textColor = Color.white;
val7.focused.background = Solid(new Color(0.21f, 0.19f, 0.16f, 1f));
_field = val7;
GUIStyle val8 = new GUIStyle(GUI.skin.button)
{
fontSize = 15,
padding = new RectOffset(12, 12, 9, 9)
};
val8.normal.textColor = new Color(0.96f, 0.94f, 0.88f);
val8.normal.background = Solid(new Color(0.18f, 0.16f, 0.13f, 1f));
val8.hover.textColor = Color.white;
val8.hover.background = Solid(new Color(0.31f, 0.26f, 0.18f, 1f));
val8.active.textColor = Color.white;
val8.active.background = Solid(new Color(0.44f, 0.35f, 0.2f, 1f));
_button = val8;
}
}
private void OnGUI()
{
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
EnsureStyles();
if (NativeDeckBuilder.IsOpen)
{
DrawCardViewHint();
DrawCursor();
return;
}
if (!_open)
{
DrawChip();
return;
}
float num = 520f;
_rect = new Rect(((float)Screen.width - 480f) * 0.5f, ((float)Screen.height - num) * 0.5f, 480f, num);
GUI.BeginGroup(_rect);
DrawWindow(0);
GUI.EndGroup();
DrawCursor();
}
private void DrawChip()
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
string text = ((!VersusMode.InMatch) ? "" : (TurnOrder.IsMyTurn ? " | YOUR TURN" : " | opponent's turn"));
string text2 = "MP: " + Net.StatusLine + text + " [F7] menu";
Vector2 val = _chip.CalcSize(new GUIContent(text2));
Rect val2 = default(Rect);
((Rect)(ref val2))..ctor(10f, 10f, val.x + 16f, val.y + 8f);
GUI.DrawTexture(val2, (Texture)(object)_chipBg);
bool flag = VersusMode.InMatch && TurnOrder.IsMyTurn;
GUI.DrawTexture(new Rect(((Rect)(ref val2)).x, ((Rect)(ref val2)).y, 3f, ((Rect)(ref val2)).height), (Texture)(object)(flag ? _accent : (Net.Connected ? _rule : _accent)));
GUI.Label(val2, text2, _chip);
}
private void DrawCursor()
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
DrawCursor(default(Rect));
}
private void DrawCursor(Rect _unused)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
Vector3 mousePosition = Input.mousePosition;
float x = mousePosition.x;
float num = (float)Screen.height - mousePosition.y;
Color color = default(Color);
((Color)(ref color))..ctor(0f, 0f, 0f, 0.9f);
Color color2 = GUI.color;
GUI.color = color;
GUI.DrawTexture(new Rect(x - 11f - 1f, num - 1f, 24f, 5f), (Texture)(object)Texture2D.whiteTexture);
GUI.DrawTexture(new Rect(x - 1f, num - 11f - 1f, 5f, 24f), (Texture)(object)Texture2D.whiteTexture);
GUI.color = new Color(1f, 0.85f, 0.35f, 1f);
GUI.DrawTexture(new Rect(x - 11f, num, 22f, 3f), (Texture)(object)Texture2D.whiteTexture);
GUI.DrawTexture(new Rect(x, num - 11f, 3f, 22f), (Texture)(object)Texture2D.whiteTexture);
GUI.color = color2;
}
private void DrawCardViewHint()
{
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_028f: Unknown result type (might be due to invalid IL or missing references)
//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
bool poolMode = NativeDeckBuilder.PoolMode;
string text = (poolMode ? "CLICK A CARD TO ADD IT" : "CLICK A CARD TO REMOVE IT");
string text2 = $"deck {DeckStore.Deck.Count}/{20}" + $" page {NativeDeckBuilder.Page + 1}/{NativeDeckBuilder.PageCount}";
Rect val = default(Rect);
((Rect)(ref val))..ctor(((float)Screen.width - 700f) * 0.5f, 12f, 700f, 84f);
GUI.DrawTexture(val, (Texture)(object)_accent);
GUI.DrawTexture(new Rect(((Rect)(ref val)).x + 2f, ((Rect)(ref val)).y + 2f, ((Rect)(ref val)).width - 4f, ((Rect)(ref val)).height - 4f), (Texture)(object)_panelBg);
GUILayout.BeginArea(new Rect(((Rect)(ref val)).x + 12f, ((Rect)(ref val)).y + 8f, ((Rect)(ref val)).width - 24f, ((Rect)(ref val)).height - 16f));
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.Label(text, _section, Array.Empty<GUILayoutOption>());
GUILayout.FlexibleSpace();
GUILayout.Label(text2, _small, Array.Empty<GUILayoutOption>());
GUILayout.EndHorizontal();
GUILayout.Space(4f);
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
if (GUILayout.Button("< Prev", _button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) }))
{
NativeDeckBuilder.PrevPage();
}
if (GUILayout.Button("Next >", _button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) }))
{
NativeDeckBuilder.NextPage();
}
GUILayout.FlexibleSpace();
if (GUILayout.Button(poolMode ? "View My Deck" : "Browse All Cards", _button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(190f) }))
{
NativeDeckBuilder.ToggleMode();
}
GUILayout.FlexibleSpace();
if (GUILayout.Button("Done [F7]", _button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
{
NativeDeckBuilder.Close();
}
GUILayout.EndHorizontal();
GUILayout.EndArea();
if (!poolMode && DeckStore.Deck.Count == 0)
{
Rect val2 = default(Rect);
((Rect)(ref val2))..ctor(((float)Screen.width - 400f) * 0.5f, ((Rect)(ref val)).yMax + 16f, 400f, 30f);
GUI.DrawTexture(val2, (Texture)(object)_panelBg);
GUI.Label(new Rect(((Rect)(ref val2)).x + 10f, ((Rect)(ref val2)).y + 5f, ((Rect)(ref val2)).width, ((Rect)(ref val2)).height), "Your deck is empty - browse all cards to add some.", _chip);
}
}
private void Rule()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
GUILayout.Space(6f);
GUILayout.Box(GUIContent.none, GUIStyle.none, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(1f) });
Rect lastRect = GUILayoutUtility.GetLastRect();
GUI.DrawTexture(new Rect(((Rect)(ref lastRect)).x, ((Rect)(ref lastRect)).y, 452f, 1f), (Texture)(object)_rule);
GUILayout.Space(6f);
}
private void DrawWindow(int id)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_02da: Unknown result type (might be due to invalid IL or missing references)
//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0334: Unknown result type (might be due to invalid IL or missing references)
float num = 520f;
GUI.DrawTexture(new Rect(0f, 0f, 480f, num), (Texture)(object)_accent);
GUI.DrawTexture(new Rect(2f, 2f, 476f, num - 4f), (Texture)(object)_panelBg);
GUILayout.BeginArea(new Rect(14f, 12f, 452f, num - 24f));
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.Label("INSCRYPTION ONLINE", _header, Array.Empty<GUILayoutOption>());
GUILayout.FlexibleSpace();
GUILayout.Label("v1.0.2", _small, Array.Empty<GUILayoutOption>());
GUILayout.EndHorizontal();
GUILayout.Label(Net.StatusLine, Net.Connected ? _label : _dim, Array.Empty<GUILayoutOption>());
if (Net.HandshakeError != null)
{
GUILayout.Label("INCOMPATIBLE VERSIONS", _section, Array.Empty<GUILayoutOption>());
GUILayout.Label(Net.HandshakeError, _small, Array.Empty<GUILayoutOption>());
GUILayout.Label("Both players need the same build of the mod.", _small, Array.Empty<GUILayoutOption>());
}
GUILayout.Space(6f);
GUI.enabled = !VersusMode.InMatch;
if (GUILayout.Button($"EDIT DECK ({DeckStore.Deck.Count}/{20})", _button, Array.Empty<GUILayoutOption>()))
{
OpenCardView();
}
GUI.enabled = true;
if (VersusMode.InMatch)
{
GUILayout.Label("Finish the match to edit your deck.", _small, Array.Empty<GUILayoutOption>());
}
else if (!DeckStore.IsValid)
{
GUILayout.Label($"Your deck needs {6}-{20} cards.", _small, Array.Empty<GUILayoutOption>());
}
if (NativeDeckBuilder.LastError != null)
{
GUILayout.Label(NativeDeckBuilder.LastError, _small, Array.Empty<GUILayoutOption>());
}
Rule();
bool enabled = !Net.Connected && !VersusMode.InMatch;
GUILayout.Label("STEAM", _section, Array.Empty<GUILayoutOption>());
if (!SteamTransport.Available)
{
GUILayout.Label("Steam not detected - use a direct address below.", _small, Array.Empty<GUILayoutOption>());
}
else
{
GUI.enabled = enabled;
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
if (GUILayout.Button("Host Lobby", _button, Array.Empty<GUILayoutOption>()))
{
SteamTransport.HostLobby();
}
if (GUILayout.Button("Find Games", _button, Array.Empty<GUILayoutOption>()))
{
SteamTransport.RefreshLobbies();
}
GUILayout.EndHorizontal();
if (SteamTransport.Lobbies.Count > 0)
{
GUILayout.Space(4f);
_lobbyScroll = GUILayout.BeginScrollView(_lobbyScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(86f) });
foreach (KeyValuePair<CSteamID, string> lobby in SteamTransport.Lobbies)
{
if (GUILayout.Button(lobby.Value, _button, Array.Empty<GUILayoutOption>()))
{
SteamTransport.JoinLobby(lobby.Key);
}
}
GUILayout.EndScrollView();
}
GUI.enabled = true;
}
Rule();
GUILayout.Label("DIRECT (LAN / non-Steam)", _section, Array.Empty<GUILayoutOption>());
GUI.enabled = enabled;
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
Ip = GUILayout.TextField(Ip, 64, _field, Array.Empty<GUILayoutOption>());
GUILayout.Label(":", _label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(8f) });
PortText = GUILayout.TextField(PortText, 5, _field, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(64f) });
GUILayout.EndHorizontal();
GUILayout.Space(4f);
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
if (GUILayout.Button("Host", _button, Array.Empty<GUILayoutOption>()))
{
Net.Host(ParsedPort);
}
if (GUILayout.Button("Join", _button, Array.Empty<GUILayoutOption>()))
{
Net.Join(Ip, ParsedPort);
}
GUILayout.EndHorizontal();
GUI.enabled = true;
Rule();
GUI.enabled = Net.Connected && !VersusMode.InMatch && !VersusMode.PendingStart && DeckStore.IsValid && Net.HandshakeError == null;
if (GUILayout.Button("START MATCH", _button, Array.Empty<GUILayoutOption>()))
{
VersusMode.StartAnywhere((MonoBehaviour)(object)this);
}
GUI.enabled = true;
if (!DeckStore.IsValid)
{
GUILayout.Label($"Your deck needs {6}-{20} cards - see the DECK tab.", _small, Array.Empty<GUILayoutOption>());
}
if (VersusMode.Suspended)
{
GUILayout.Space(6f);
GUILayout.Label("OPPONENT DISCONNECTED", _section, Array.Empty<GUILayoutOption>());
GUILayout.Label($"Holding the match for {Mathf.CeilToInt(VersusMode.SuspendedSecondsLeft)}s.", _small, Array.Empty<GUILayoutOption>());
GUILayout.Label("They can relaunch and rejoin - nothing is lost.", _small, Array.Empty<GUILayoutOption>());
}
if (!Net.Connected && !VersusMode.InMatch)
{
GUILayout.Label("Host a lobby, or find one, to play someone.", _small, Array.Empty<GUILayoutOption>());
}
else if (Net.Connected && !VersusMode.InMatch && DeckStore.IsValid && Net.HandshakeError == null)
{
GUILayout.Label("Either player can start - you both enter together.", _small, Array.Empty<GUILayoutOption>());
}
GUILayout.Space(4f);
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
if (VersusMode.InMatch && GUILayout.Button(VersusMode.Suspended ? "Give Up Waiting" : "Abort Match", _button, Array.Empty<GUILayoutOption>()))
{
VersusMode.Abort((MonoBehaviour)(object)this);
}
if (Net.Running && GUILayout.Button("Disconnect", _button, Array.Empty<GUILayoutOption>()))
{
Net.Shutdown();
}
GUILayout.EndHorizontal();
if (VersusMode.LastResult != null && !VersusMode.InMatch)
{
GUILayout.Label("Last match: " + VersusMode.LastResult, _label, Array.Empty<GUILayoutOption>());
}
GUILayout.FlexibleSpace();
GUILayout.Label("F7 menu F8 start match F12 abort", _small, Array.Empty<GUILayoutOption>());
GUILayout.EndArea();
}
private void OpenCardView()
{
_open = false;
if (NativeDeckBuilder.Available)
{
NativeDeckBuilder.Open((MonoBehaviour)(object)this, poolMode: true);
return;
}
NativeDeckBuilder.PendingOpen = true;
VersusMode.LoadTableOnly();
}
}
internal static class NativeDeckBuilder
{
public const int PageSize = 10;
private static bool _refresh;
public static bool IsOpen { get; private set; }
public static bool PoolMode { get; private set; }
public static string LastError { get; private set; }
public static int Page { get; private set; }
public static int PageCount
{
get
{
int num = SourceCount();
return (num <= 0) ? 1 : ((num + 10 - 1) / 10);
}
}
public static bool Available => (Object)(object)Singleton<DeckReviewSequencer>.Instance != (Object)null;
private static SelectableCardArray Array
{
get
{
DeckReviewSequencer instance = Singleton<DeckReviewSequencer>.Instance;
if ((Object)(object)instance == (Object)null)
{
return null;
}
object? obj = AccessTools.Field(typeof(DeckReviewSequencer), "cardArray")?.GetValue(instance);
return (SelectableCardArray)((obj is SelectableCardArray) ? obj : null);
}
}
public static bool PendingOpen { get; set; }
public static void NextPage()
{
Page = (Page + 1) % PageCount;
_refresh = true;
}
public static void PrevPage()
{
Page = (Page - 1 + PageCount) % PageCount;
_refresh = true;
}
public static void ToggleMode()
{
PoolMode = !PoolMode;
Page = 0;
_refresh = true;
}
private static int SourceCount()
{
return PoolMode ? DeckStore.Pool.Count : DeckStore.Deck.Count;
}
public static void TickPendingOpen(MonoBehaviour host)
{
if (PendingOpen && !IsOpen && Available)
{
GameFlowManager instance = Singleton<GameFlowManager>.Instance;
if (!((Object)(object)instance == (Object)null) && !instance.Transitioning)
{
PendingOpen = false;
Trace.Info("[deckui] table ready - opening card view");
Open(host, poolMode: true);
}
}
}
public static void Open(MonoBehaviour host, bool poolMode)
{
if (!IsOpen)
{
if (VersusMode.InMatch)
{
LastError = "finish the match before editing your deck";
Trace.Warn("[deckui] " + LastError);
return;
}
if (!Available)
{
LastError = "card view needs the Act 1 table - use Load Table first";
Trace.Warn("[deckui] " + LastError);
return;
}
if ((Object)(object)Array == (Object)null)
{
LastError = "could not reach the card array";
Trace.Error("[deckui] " + LastError);
return;
}
LastError = null;
PoolMode = poolMode;
Page = 0;
_refresh = false;
host.StartCoroutine(Loop(host));
}
}
public static void Close()
{
IsOpen = false;
}
private static IEnumerator Loop(MonoBehaviour host)
{
IsOpen = true;
Trace.Info("[deckui] opening card view (" + (PoolMode ? "pool" : "deck") + ")");
ViewManager views = Singleton<ViewManager>.Instance;
GameFlowManager flow = Singleton<GameFlowManager>.Instance;
ViewLockState prevLock = (ViewLockState)0;
GameMap map = Singleton<GameMap>.Instance;
if ((Object)(object)map != (Object)null && (Object)(object)flow != (Object)null && (int)flow.CurrentGameState == 1)
{
Trace.Info("[deckui] hiding map");
views.Controller.SwitchToControlMode((ControlMode)16, false);
yield return map.HideMapSequence();
yield return (object)new WaitForSeconds(0.2f);
}
TableProps.HidePlayerMarker();
if ((Object)(object)views != (Object)null)
{
prevLock = views.Controller.LockState;
views.SwitchToView((View)23, false, false);
views.Controller.LockState = (ViewLockState)1;
}
yield return (object)new WaitForSeconds(0.3f);
while (IsOpen)
{
_refresh = false;
if (Page >= PageCount)
{
Page = 0;
}
List<CardInfo> cards = BuildList();
if (cards.Count == 0)
{
yield return (object)new WaitUntil((Func<bool>)(() => _refresh || !IsOpen));
continue;
}
SelectableCard picked = null;
yield return Array.SelectCardFrom(new List<CardInfo>(cards), (CardPile)null, (Action<SelectableCard>)delegate(SelectableCard c)
{
picked = c;
}, (Func<bool>)(() => !IsOpen || _refresh), true);
if (!IsOpen)
{
break;
}
if (_refresh)
{
continue;
}
if ((Object)(object)picked == (Object)null)
{
break;
}
string id = (((Object)(object)((Card)picked).Info != (Object)null) ? ((Object)((Card)picked).Info).name : null);
if (!string.IsNullOrEmpty(id))
{
if (PoolMode)
{
DeckStore.Add(id);
Trace.Info($"[deckui] added {id} ({DeckStore.Deck.Count} cards)");
}
else
{
DeckStore.Remove(id);
Trace.Info($"[deckui] removed {id} ({DeckStore.Deck.Count} cards)");
}
DeckStore.Save();
if ((Object)(object)picked != (Object)null)
{
Object.Destroy((Object)(object)((Component)picked).gameObject);
}
yield return (object)new WaitForSeconds(0.15f);
}
}
IsOpen = false;
if ((Object)(object)views != (Object)null)
{
views.SwitchToView((View)1, false, false);
views.Controller.LockState = prevLock;
}
Trace.Info("[deckui] closed card view");
if (VersusMode.LoadedTableForDeck && !VersusMode.InMatch)
{
yield return (object)new WaitForSeconds(0.35f);
VersusMode.LeaveDeckTable();
}
else
{
TableProps.RestorePlayerMarker();
}
}
private static List<CardInfo> BuildList()
{
List<CardInfo> list = new List<CardInfo>();
if (PoolMode)
{
list.AddRange(DeckStore.Pool);
}
else
{
foreach (string item in DeckStore.Deck)
{
CardInfo cardByName = CardLoader.GetCardByName(item);
if ((Object)(object)cardByName != (Object)null)
{
list.Add(cardByName);
}
}
}
int num = Page * 10;
if (num >= list.Count)
{
Page = 0;
num = 0;
}
int count = Mathf.Min(10, list.Count - num);
return list.GetRange(num, count);
}
}
public static class Net
{
public const int DefaultPort = 27333;
private static TcpListener _listener;
private static TcpClient _client;
private static StreamWriter _writer;
private static Thread _thread;
private static volatile bool _running;
private static readonly ConcurrentQueue<string> Inbox = new ConcurrentQueue<string>();
private static bool TcpIsHost { get; set; }
public static bool IsHost => SteamTransport.Active ? SteamTransport.IsHost : TcpIsHost;
public static bool TcpConnected { get; private set; }
public static bool Running => _running || SteamTransport.Active;
public static bool Connected => SteamTransport.Active ? SteamTransport.Connected : TcpConnected;
public static bool? PendingResult { get; set; }
public static string HandshakeError { get; set; }
public static bool PeerVerified { get; private set; }
public static bool PendingStartRequest { get; set; }
public static bool Reconnecting { get; set; }
public static string StatusLine
{
get
{
if (SteamTransport.Active)
{
return "steam: " + SteamTransport.Status;
}
if (TcpConnected)
{
return TcpIsHost ? "connected (host)" : "connected (client)";
}
if (_running)
{
return TcpIsHost ? "hosting - waiting for peer" : "connecting...";
}
return "offline";
}
}
public static void Host(int port = 27333)
{
if (_running)
{
Trace.Info("[net] already " + (Connected ? "connected" : "hosting") + " - ignoring");
return;
}
Shutdown();
TcpIsHost = true;
_running = true;
_thread = new Thread((ThreadStart)delegate
{
HostLoop(port);
})
{
IsBackground = true,
Name = "InscryptionMP-Host"
};
_thread.Start();
Trace.Info($"[net] hosting on port {port}, waiting for peer...");
}
public static void Join(string host, int port = 27333)
{
if (_running)
{
Trace.Info("[net] already " + (Connected ? "connected" : "connecting") + " - ignoring");
return;
}
Shutdown();
TcpIsHost = false;
_running = true;
_thread = new Thread((ThreadStart)delegate
{
JoinLoop(host, port);
})
{
IsBackground = true,
Name = "InscryptionMP-Client"
};
_thread.Start();
Trace.Info($"[net] connecting to {host}:{port}...");
}
private static void HostLoop(int port)
{
try
{
_listener = new TcpListener(IPAddress.Any, port);
_listener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, optionValue: true);
_listener.Start();
while (_running)
{
_client = _listener.AcceptTcpClient();
Trace.Info("[net] peer connected.");
Pump();
TcpConnected = false;
if (!_running)
{
break;
}
Trace.Warn("[net] peer dropped - listening again");
}
}
catch (Exception ex)
{
if (_running)
{
Trace.Error("[net] host error: " + ex.Message);
}
}
finally
{
TcpConnected = false;
_running = false;
}
}
private static void JoinLoop(string host, int port)
{
try
{
while (_running)
{
try
{
_client = new TcpClient();
_client.Connect(host, port);
Trace.Info("[net] connected to host.");
Pump();
TcpConnected = false;
}
catch (Exception ex)
{
if (!_running)
{
break;
}
Trace.Warn("[net] connect failed (" + ex.Message + ") - retrying");
}
if (!_running || !Reconnecting)
{
break;
}
Thread.Sleep(2000);
}
}
catch (Exception ex2)
{
if (_running)
{
Trace.Error("[net] join error: " + ex2.Message);
}
}
finally
{
TcpConnected = false;
_running = false;
}
}
private static void Pump()
{
NetworkStream stream = _client.GetStream();
_writer = new StreamWriter(stream)
{
AutoFlush = true,
NewLine = "\n"
};
TcpConnected = true;
SendHello();
using StreamReader streamReader = new StreamReader(stream);
string text;
while (_running && (text = streamReader.ReadLine()) != null)
{
text = text.Trim();
if (text.Length != 0)
{
Trace.Info("[net] <- " + text);
if (!CaptureResult(text))
{
Inbox.Enqueue(text);
}
}
}
}
public static void Send(string msg)
{
if (SteamTransport.Active)
{
SteamTransport.Send(msg);
return;
}
if (!TcpConnected || _writer == null)
{
Trace.Warn("[net] dropped (not connected): " + msg);
return;
}
try
{
_writer.WriteLine(msg);
Trace.Info("[net] -> " + msg);
}
catch (Exception ex)
{
Trace.Error("[net] send failed: " + ex.Message);
}
}
public static bool CaptureResult(string line)
{
switch (line)
{
case "START":
PendingStartRequest = true;
return true;
case "OVER WON":
PendingResult = false;
return true;
case "OVER LOST":
PendingResult = true;
return true;
default:
{
if (Protocol.TryParseHello(line, out var protocolVersion, out var modVersion))
{
if (protocolVersion != 1)
{
HandshakeError = "version mismatch - you have mod 1.0.2 (protocol " + 1 + "), they have " + modVersion + " (protocol " + protocolVersion + ")";
Trace.Error("[net] " + HandshakeError);
PeerVerified = false;
}
else
{
PeerVerified = true;
Trace.Info("[net] peer verified - mod " + modVersion + ", protocol " + protocolVersion);
}
return true;
}
return false;
}
}
}
public static void SendHello()
{
HandshakeError = null;
PeerVerified = false;
Send(Protocol.Hello);
}
public static bool TryDequeue(out string msg)
{
if (SteamTransport.Active)
{
return SteamTransport.TryDequeue(out msg);
}
return Inbox.TryDequeue(out msg);
}
public static void Shutdown()
{
if (SteamTransport.Active)
{
SteamTransport.Shutdown();
}
_running = false;
TcpConnected = false;
try
{
_writer?.Dispose();
}
catch
{
}
try
{
_client?.Close();
}
catch
{
}
try
{
_listener?.Stop();
}
catch
{
}
string result;
while (Inbox.TryDequeue(out result))
{
}
PendingResult = null;
PendingStartRequest = false;
HandshakeError = null;
PeerVerified = false;
_writer = null;
_client = null;
_listener = null;
}
}
public class NetworkOpponent : Opponent
{
protected override string BlueprintSubfolderName => "";
public override bool QueueFirstCardBeforePlayer => false;
public override IEnumerator QueueNewCards(bool doTween = true, bool changeView = true)
{
Trace.Info("[opp] waiting for peer's turn...");
ViewManager views = Singleton<ViewManager>.Instance;
ViewLockState previousLock = (ViewLockState)1;
if ((Object)(object)views != (Object)null)
{
previousLock = views.Controller.LockState;
views.SwitchToView((View)1, false, false);
views.Controller.LockState = (ViewLockState)0;
}
try
{
while (true)
{
if (Net.TryDequeue(out var msg))
{
if (msg == "END")
{
Trace.Info("[opp] peer ended turn.");
TurnOrder.TakenFromPeer();
yield break;
}
if (Protocol.TryParseSacrifice(msg, out var sacSlot))
{
yield return SacrificePeerCard(sacSlot);
continue;
}
if (Protocol.TryParseBoard(msg, out var slotNames))
{
yield return ReconcileBoard(slotNames);
continue;
}
if (Protocol.TryParsePlay(msg, out var cardName, out var slotIndex))
{
yield return PlacePeerCard(cardName, slotIndex);
}
slotNames = null;
cardName = null;
}
if (!VersusMode.InMatch)
{
break;
}
if (!Net.Connected)
{
VersusMode.NoteDisconnected();
}
yield return (object)new WaitForEndOfFrame();
msg = null;
}
Trace.Info("[opp] match ended while waiting");
}
finally
{
if ((Object)(object)views != (Object)null)
{
views.Controller.LockState = previousLock;
}
}
}
private IEnumerator PlacePeerCard(string cardName, int slotIndex)
{
CardInfo info = CardLoader.GetCardByName(cardName);
if ((Object)(object)info == (Object)null)
{
Trace.Error("[opp] unknown card '" + cardName + "' - skipping");
yield break;
}
BoardManager board = Singleton<BoardManager>.Instance;
List<CardSlot> slots = board.OpponentSlotsCopy;
if (slotIndex < 0 || slotIndex >= slots.Count)
{
Trace.Error($"[opp] slot {slotIndex} out of range - skipping");
yield break;
}
CardSlot slot = slots[slotIndex];
if ((Object)(object)slot.Card != (Object)null)
{
Trace.Info($"[opp] slot {slotIndex} occupied - replacing");
RemoveCard(slot);
}
Trace.Info($"[opp] placing peer card '{cardName}' in opponent slot {slotIndex}");
yield return board.CreateCardInSlot(info, slot, 0.1f, true);
yield return (object)new WaitForSeconds(0.15f);
}
private IEnumerator ReconcileBoard(string[] slotNames)
{
BoardManager board = Singleton<BoardManager>.Instance;
if ((Object)(object)board == (Object)null)
{
yield break;
}
List<CardSlot> slots = board.OpponentSlotsCopy;
int count = Mathf.Min(slotNames.Length, slots.Count);
for (int i = 0; i < count; i++)
{
string wanted = slotNames[i];
CardSlot slot = slots[i];
string actual = (((Object)(object)slot.Card != (Object)null && (Object)(object)((Card)slot.Card).Info != (Object)null) ? ((Object)((Card)slot.Card).Info).name : "-");
if (wanted == actual)
{
continue;
}
if ((Object)(object)slot.Card != (Object)null)
{
Trace.Info($"[opp] reconcile: clearing slot {i} ({actual})");
yield return RemoveCardAnimated(slot);
}
if (wanted != "-")
{
CardInfo info = CardLoader.GetCardByName(wanted);
if ((Object)(object)info == (Object)null)
{
Trace.Error("[opp] reconcile: unknown card '" + wanted + "'");
continue;
}
Trace.Info($"[opp] reconcile: slot {i} -> {wanted}");
yield return board.CreateCardInSlot(info, slot, 0.1f, true);
yield return (object)new WaitForSeconds(0.05f);
}
}
}
private IEnumerator SacrificePeerCard(int slotIndex)
{
BoardManager board = Singleton<BoardManager>.Instance;
if ((Object)(object)board == (Object)null)
{
yield break;
}
List<CardSlot> slots = board.OpponentSlotsCopy;
if (slotIndex >= 0 && slotIndex < slots.Count)
{
PlayableCard card = slots[slotIndex].Card;
if ((Object)(object)card == (Object)null)
{
Trace.Warn($"[opp] sacrifice: slot {slotIndex} already empty");
yield break;
}
Trace.Info($"[opp] peer sacrificed slot {slotIndex}");
yield return card.Die(true, (PlayableCard)null, true);
}
}
private static IEnumerator RemoveCardAnimated(CardSlot slot)
{
PlayableCard card = slot.Card;
if (!((Object)(object)card == (Object)null))
{
yield return card.Die(false, (PlayableCard)null, false);
}
}
private static void RemoveCard(CardSlot slot)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
PlayableCard card = slot.Card;
if (!((Object)(object)card == (Object)null))
{
card.UnassignFromSlot();
((Card)card).ExitBoard(0.2f, Vector3.zero);
}
}
}
[HarmonyPatch]
internal static class OpponentInjector
{
[HarmonyPatch(typeof(Opponent), "SpawnOpponent")]
[HarmonyPostfix]
private static void Swap(ref Opponent __result, EncounterData encounterData)
{
if (VersusMode.InMatch && !((Object)(object)__result == (Object)null))
{
GameObject gameObject = ((Component)__result).gameObject;
Trace.Info("[inject] replacing " + ((object)__result).GetType().Name + " with NetworkOpponent");
Object.DestroyImmediate((Object)(object)__result);
NetworkOpponent networkOpponent = gameObject.AddComponent<NetworkOpponent>();
((Opponent)networkOpponent).NumLives = ((Opponent)networkOpponent).StartingLives;
((Opponent)networkOpponent).TurnPlan = new List<List<CardInfo>>();
((Opponent)networkOpponent).Difficulty = 0;
__result = (Opponent)(object)networkOpponent;
}
}
}
[BepInPlugin("dev.snoz.inscryptionmp", "InscryptionMP", "1.0.2")]
public class Plugin : BaseUnityPlugin
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static LogCallback <>9__6_0;
internal void <Awake>b__6_0(string condition, string stack, LogType type)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if ((int)type == 4 || (int)type == 0)
{
Trace.Error($"[unity] {type}: {condition} || {stack}");
}
}
}
public const string Guid = "dev.snoz.inscryptionmp";
public const string Name = "InscryptionMP";
public const string Version = "1.0.2";
internal static ManualLogSource Log;
internal static MonoBehaviour Runner;
private Harmony _harmony;
private void Awake()
{
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
Runner = (MonoBehaviour)(object)this;
Trace.Init();
object obj = <>c.<>9__6_0;
if (obj == null)
{
LogCallback val = delegate(string condition, string stack, LogType type)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if ((int)type == 4 || (int)type == 0)
{
Trace.Error($"[unity] {type}: {condition} || {stack}");
}
};
<>c.<>9__6_0 = val;
obj = (object)val;
}
Application.logMessageReceived += (LogCallback)obj;
Log.LogInfo((object)"=====================================");
Log.LogInfo((object)"InscryptionMP v1.0.2 loaded.");
Log.LogInfo((object)("Unity: " + Application.unityVersion));
Log.LogInfo((object)"=====================================");
_harmony = new Harmony("dev.snoz.inscryptionmp");
_harmony.PatchAll(typeof(Plugin).Assembly);
Log.LogInfo((object)"Harmony patches applied.");
((Component)this).gameObject.AddComponent<MpMenu>();
Log.LogInfo((object)"Press F7 for the multiplayer menu. F8 = start match, F12 = abort.");
ConfigEntry<bool> val2 = ((BaseUnityPlugin)this).Config.Bind<bool>("Dev", "AutoHost", true, "Start hosting automatically on launch. Convenient while iterating.");
if (val2.Value)
{
Trace.Info("[boot] AutoHost enabled - hosting immediately.");
Net.Host();
}
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
}
[HarmonyPatch]
internal static class Probe
{
[HarmonyPatch(typeof(TurnManager), "OnCombatBellRang")]
[HarmonyPostfix]
private static void BellRang()
{
if (VersusMode.InMatch)
{
TurnManager instance = Singleton<TurnManager>.Instance;
Trace.Info($"[probe] bell rang - local player ended turn {((instance != null) ? new int?(instance.TurnNumber) : ((int?)null))}");
}
}
}
public static class Protocol
{
public const string EndTurn = "END";
public const int Version = 1;
public const string HelloPrefix = "HELLO ";
public const string StartMatch = "START";
public const string SacrificePrefix = "SAC ";
public const string BoardPrefix = "BOARD ";
public const string EmptySlot = "-";
public const string Won = "OVER WON";
public const string Lost = "OVER LOST";
public static string Hello => "HELLO " + 1 + " 1.0.2";
public static bool TryParseHello(string msg, out int protocolVersion, out string modVersion)
{
protocolVersion = 0;
modVersion = "?";
if (msg == null || !msg.StartsWith("HELLO "))
{
return false;
}
string[] array = msg.Substring("HELLO ".Length).Split(new char[1] { ' ' });
if (array.Length < 1 || !int.TryParse(array[0], out protocolVersion))
{
return false;
}
if (array.Length > 1)
{
modVersion = array[1];
}
return true;
}
public static string Sacrifice(int slotIndex)
{
return "SAC " + slotIndex;
}
public static bool TryParseSacrifice(string msg, out int slotIndex)
{
slotIndex = -1;
return msg != null && msg.StartsWith("SAC ") && int.TryParse(msg.Substring("SAC ".Length), out slotIndex);
}
public static string Board(string[] slotCardNames)
{
return "BOARD " + string.Join("|", slotCardNames);
}
public static bool TryParseBoard(string msg, out string[] slots)
{
slots = null;
if (msg == null || !msg.StartsWith("BOARD "))
{
return false;
}
slots = msg.Substring("BOARD ".Length).Split(new char[1] { '|' });
return true;
}
public static string Play(string cardName, int slotIndex)
{
return $"PLAY {cardName} {slotIndex}";
}
public static bool TryParsePlay(string msg, out string cardName, out int slotIndex)
{
cardName = null;
slotIndex = -1;
if (msg == null || !msg.StartsWith("PLAY "))
{
return false;
}
string[] array = msg.Split(new char[1] { ' ' });
if (array.Length != 3)
{
return false;
}
if (!int.TryParse(array[2], out slotIndex))
{
return false;
}
cardName = array[1];
return true;
}
}
[HarmonyPatch]
internal static class SilenceLeshy
{
[HarmonyPatch(typeof(TextDisplayer), "PlayDialogueEvent")]
[HarmonyPrefix]
private static bool SkipDialogueEvent(ref IEnumerator __result, string eventId)
{
if (!VersusMode.InMatch)
{
return true;
}
Trace.Info("[quiet] suppressed dialogue '" + eventId + "'");
__result = Nothing();
return false;
}
[HarmonyPatch(typeof(TextDisplayer), "ShowUntilInput")]
[HarmonyPrefix]
private static bool SkipShowUntilInput(ref IEnumerator __result)
{
if (!VersusMode.InMatch)
{
return true;
}
__result = Nothing();
return false;
}
[HarmonyPatch(typeof(TextDisplayer), "ShowThenClear")]
[HarmonyPrefix]
private static bool SkipShowThenClear(ref IEnumerator __result)
{
if (!VersusMode.InMatch)
{
return true;
}
__result = Nothing();
return false;
}
private static IEnumerator Nothing()
{
yield break;
}
}
public static class SteamTransport
{
private class PropertyInfoCache
{
private readonly PropertyInfo _prop;
public PropertyInfoCache()
{
Type type = AccessTools.TypeByName("SteamManager");
_prop = ((type == null) ? null : AccessTools.Property(type, "Initialized"));
if (_prop == null)
{
Trace.Warn("[steam] SteamManager.Initialized not found");
}
}
public bool Read()
{
if (_prop == null)
{
return false;
}
object value = _prop.GetValue(null, null);
bool flag = default(bool);
int num;
if (value is bool)
{
flag = (bool)value;
num = 1;
}
else
{
num = 0;
}
return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
}
}
private const string LobbyKey = "inscryption_mp";
private const string LobbyValue = "1";
private const string LobbyHostKey = "host_name";
private static PropertyInfoCache _initCache;
private static CSteamID _lobby;
private static CSteamID _peer;
private static Callback<LobbyCreated_t> _cbCreated;
private static Callback<LobbyEnter_t> _cbEntered;
private static Callback<P2PSessionRequest_t> _cbSession;
private static Callback<LobbyChatUpdate_t> _cbChatUpdate;
private static CallResult<LobbyMatchList_t> _crList;
private static readonly ConcurrentQueue<string> Inbox = new ConcurrentQueue<string>();
private static readonly StringBuilder RecvBuffer = new StringBuilder();
public static readonly List<KeyValuePair<CSteamID, string>> Lobbies = new List<KeyValuePair<CSteamID, string>>();
public static bool Available
{
get
{
try
{
if (_initCache == null)
{
_initCache = new PropertyInfoCache();
}
return _initCache.Read();
}
catch (Exception ex)
{
Trace.Warn("[steam] availability check failed: " + ex.Message);
return false;
}
}
}
public static bool Active { get; private set; }
public static bool Connected { get; private set; }
public static bool IsHost { get; private set; }
public static string Status { get; private set; } = "idle";
private static void EnsureCallbacks()
{
if (_cbCreated == null)
{
_cbCreated = Callback<LobbyCreated_t>.Create((DispatchDelegate<LobbyCreated_t>)OnLobbyCreated);
_cbEntered = Callback<LobbyEnter_t>.Create((DispatchDelegate<LobbyEnter_t>)OnLobbyEntered);
_cbSession = Callback<P2PSessionRequest_t>.Create((DispatchDelegate<P2PSessionRequest_t>)OnSessionRequest);
_cbChatUpdate = Callback<LobbyChatUpdate_t>.Create((DispatchDelegate<LobbyChatUpdate_t>)OnLobbyChatUpdate);
_crList = CallResult<LobbyMatchList_t>.Create((APIDispatchDelegate<LobbyMatchList_t>)OnLobbyList);
}
}
public static void HostLobby()
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
if (!Available)
{
Trace.Warn("[steam] not initialised");
return;
}
EnsureCallbacks();
Reset();
Active = true;
IsHost = true;
Status = "creating lobby...";
Trace.Info("[steam] creating lobby");
SteamMatchmaking.CreateLobby((ELobbyType)2, 2);
}
public static void RefreshLobbies()
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
if (!Available)
{
Trace.Warn("[steam] not initialised");
return;
}
EnsureCallbacks();
Lobbies.Clear();
Status = "searching...";
Trace.Info("[steam] requesting lobby list");
SteamMatchmaking.AddRequestLobbyListStringFilter("inscryption_mp", "1", (ELobbyComparison)0);
SteamAPICall_t val = SteamMatchmaking.RequestLobbyList();
_crList.Set(val, (APIDispatchDelegate<LobbyMatchList_t>)null);
}
public unsafe static void JoinLobby(CSteamID lobby)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
if (Available)
{
EnsureCallbacks();
Reset();
Active = true;
IsHost = false;
Status = "joining...";
CSteamID val = lobby;
Trace.Info("[steam] joining lobby " + ((object)(*(CSteamID*)(&val))/*cast due to .constrained prefix*/).ToString());
SteamMatchmaking.JoinLobby(lobby);
}
}
private unsafe static void OnLobbyCreated(LobbyCreated_t e)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Invalid comparison between Unknown and I4
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
if ((int)e.m_eResult != 1)
{
Status = "lobby failed (" + ((object)(*(EResult*)(&e.m_eResult))/*cast due to .constrained prefix*/).ToString() + ")";
Trace.Error("[steam] lobby creation failed: " + ((object)(*(EResult*)(&e.m_eResult))/*cast due to .constrained prefix*/).ToString());
Active = false;
}
else
{
_lobby = new CSteamID(e.m_ulSteamIDLobby);
SteamMatchmaking.SetLobbyData(_lobby, "inscryption_mp", "1");
SteamMatchmaking.SetLobbyData(_lobby, "host_name", SteamFriends.GetPersonaName());
Status = "waiting for opponent";
Trace.Info("[steam] lobby created - waiting for opponent");
}
}
private unsafe static void OnLobbyList(LobbyMatchList_t e, bool failed)
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
Lobbies.Clear();
if (failed)
{
Status = "search failed";
return;
}
for (int i = 0; i < e.m_nLobbiesMatching; i++)
{
CSteamID lobbyByIndex = SteamMatchmaking.GetLobbyByIndex(i);
string value = SteamMatchmaking.GetLobbyData(lobbyByIndex, "host_name");
if (string.IsNullOrEmpty(value))
{
value = ((object)(*(CSteamID*)(&lobbyByIndex))/*cast due to .constrained prefix*/).ToString();
}
Lobbies.Add(new KeyValuePair<CSteamID, string>(lobbyByIndex, value));
}
Status = ((Lobbies.Count == 0) ? "no lobbies found" : (Lobbies.Count + " lobbies"));
Trace.Info("[steam] found " + Lobbies.Count + " lobbies");
}
private static void OnLobbyEntered(LobbyEnter_t e)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
_lobby = new CSteamID(e.m_ulSteamIDLobby);
Active = true;
CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(_lobby);
CSteamID steamID = SteamUser.GetSteamID();
IsHost = lobbyOwner == steamID;
TryFindPeer(steamID);
if (((CSteamID)(ref _peer)).IsValid())
{
Connected = true;
Status = "connected to " + SteamFriends.GetFriendPersonaName(_peer);
Trace.Info("[steam] " + Status);
Net.SendHello();
}
else
{
Status = "waiting for opponent";
Trace.Info("[steam] in lobby, waiting for opponent");
}
}
private static void TryFindPeer(CSteamID me)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
if (!((CSteamID)(ref _lobby)).IsValid())
{
return;
}
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(_lobby);
for (int i = 0; i < numLobbyMembers; i++)
{
CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(_lobby, i);
if (lobbyMemberByIndex != me)
{
_peer = lobbyMemberByIndex;
break;
}
}
}
private static void OnLobbyChatUpdate(LobbyChatUpdate_t e)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
CSteamID val = default(CSteamID);
((CSteamID)(ref val))..ctor(e.m_ulSteamIDUserChanged);
if ((e.m_rgfChatMemberStateChange & 0xE) != 0 && val == _peer)
{
Trace.Warn("[steam] opponent left the lobby");
SteamNetworking.CloseP2PSessionWithUser(_peer);
_peer = CSteamID.Nil;
Connected = false;
Status = "opponent disconnected";
}
else if ((e.m_rgfChatMemberStateChange & 1) != 0 && val != SteamUser.GetSteamID())
{
Trace.Info("[steam] opponent (re)joined the lobby");
_peer = val;
Connected = true;
Status = "connected to " + SteamFriends.GetFriendPersonaName(_peer);
Net.SendHello();
}
}
private unsafe static void OnSessionRequest(P2PSessionRequest_t e)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
CSteamID steamIDRemote = e.m_steamIDRemote;
Trace.Info("[steam] accepting P2P session from " + ((object)(*(CSteamID*)(&steamIDRemote))/*cast due to .constrained prefix*/).ToString());
SteamNetworking.AcceptP2PSessionWithUser(e.m_steamIDRemote);
if (!((CSteamID)(ref _peer)).IsValid())
{
_peer = e.m_steamIDRemote;
Connected = true;
Status = "connected to " + SteamFriends.GetFriendPersonaName(_peer);
}
}
public static void Send(string msg)
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
if (!Connected || !((CSteamID)(ref _peer)).IsValid())
{
Trace.Warn("[steam] dropped (no peer): " + msg);
return;
}
byte[] bytes = Encoding.UTF8.GetBytes(msg + "\n");
if (SteamNetworking.SendP2PPacket(_peer, bytes, (uint)bytes.Length, (EP2PSend)2, 0))
{
Trace.Info("[steam] -> " + msg);
}
else
{
Trace.Error("[steam] send failed: " + msg);
}
}
public static void Poll()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
if (!Active || !Available)
{
return;
}
if (!Connected && IsHost && ((CSteamID)(ref _lobby)).IsValid())
{
CSteamID steamID = SteamUser.GetSteamID();
TryFindPeer(steamID);
if (((CSteamID)(ref _peer)).IsValid())
{
Connected = true;
Status = "connected to " + SteamFriends.GetFriendPersonaName(_peer);
Trace.Info("[steam] opponent joined");
Net.SendHello();
}
}
uint num = default(uint);
uint count = default(uint);
CSteamID val = default(CSteamID);
while (SteamNetworking.IsP2PPacketAvailable(ref num, 0))
{
byte[] array = new byte[num];
if (!SteamNetworking.ReadP2PPacket(array, num, ref count, ref val, 0))
{
break;
}
RecvBuffer.Append(Encoding.UTF8.GetString(array, 0, (int)count));
}
string text = RecvBuffer.ToString();
int num2;
while ((num2 = text.IndexOf('\n')) >= 0)
{
string text2 = text.Substring(0, num2).Trim();
text = text.Substring(num2 + 1);
if (text2.Length != 0)
{
Trace.Info("[steam] <- " + text2);
if (!Net.CaptureResult(text2))
{
Inbox.Enqueue(text2);
}
}
}
RecvBuffer.Length = 0;
RecvBuffer.Append(text);
}
public static bool TryDequeue(out string msg)
{
return Inbox.TryDequeue(out msg);
}
public static void Reset()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
string result;
while (Inbox.TryDequeue(out result))
{
}
RecvBuffer.Length = 0;
Connected = false;
_peer = CSteamID.Nil;
}
public static void Shutdown()
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
if (((CSteamID)(ref _peer)).IsValid())
{
SteamNetworking.CloseP2PSessionWithUser(_peer);
}
if (((CSteamID)(ref _lobby)).IsValid() && Available)
{
SteamMatchmaking.LeaveLobby(_lobby);
}
_lobby = CSteamID.Nil;
Reset();
Active = false;
IsHost = false;
Status = "idle";
Trace.Info("[steam] shut down");
}
}
[HarmonyPatch]
internal static class Sync
{
[HarmonyPatch(typeof(PlayableCard), "Sacrifice")]
[HarmonyPrefix]
private static void OnLocalSacrifice(PlayableCard __instance)
{
if (!Net.Connected || !VersusMode.InMatch || (Object)(object)__instance == (Object)null)
{
return;
}
CardSlot slot = __instance.Slot;
if (!((Object)(object)slot == (Object)null) && slot.IsPlayerSlot)
{
TurnManager instance = Singleton<TurnManager>.Instance;
if (!((Object)(object)instance == (Object)null) && instance.IsPlayerTurn)
{
Net.Send(Protocol.Sacrifice(slot.Index));
}
}
}
internal static string[] SnapshotPlayerSlotsPublic()
{
return SnapshotPlayerSlots();
}
private static string[] SnapshotPlayerSlots()
{
BoardManager instance = Singleton<BoardManager>.Instance;
List<CardSlot> list = (((Object)(object)instance != (Object)null) ? instance.PlayerSlotsCopy : null);
int num = list?.Count ?? 4;
string[] array = new string[num];
for (int i = 0; i < num; i++)
{
PlayableCard val = (((Object)(object)list[i] != (Object)null) ? list[i].Card : null);
array[i] = (((Object)(object)val != (Object)null && (Object)(object)((Card)val).Info != (Object)null) ? ((Object)((Card)val).Info).name : "-");
}
Trace.Info("[sync] board snapshot: " + string.Join("|", array));
return array;
}
[HarmonyPatch(typeof(BoardManager), "ResolveCardOnBoard")]
[HarmonyPrefix]
private static void OnLocalCardPlayed(PlayableCard card, CardSlot slot)
{
if (!Net.Connected || !VersusMode.InMatch || (Object)(object)slot == (Object)null || (Object)(object)card == (Object)null || !slot.IsPlayerSlot)
{
return;
}
TurnManager instance = Singleton<TurnManager>.Instance;
if (!((Object)(object)instance == (Object)null) && instance.IsPlayerTurn)
{
string text = (((Object)(object)((Card)card).Info != (Object)null) ? ((Object)((Card)card).Info).name : null);
if (!string.IsNullOrEmpty(text))
{
Net.Send(Protocol.Play(text, slot.Index));
}
}
}
[HarmonyPatch(typeof(TurnManager), "OnCombatBellRang")]
[HarmonyPostfix]
private static void OnLocalTurnEnded()
{
if (Net.Connected && VersusMode.InMatch)
{
Net.Send(Protocol.Board(SnapshotPlayerSlots()));
TurnOrder.PassedToPeer();
Net.Send("END");
}
}
}
internal static class TableProps
{
private static bool _markerHidden;
public static void HidePlayerMarker()
{
PlayerMarker instance = PlayerMarker.Instance;
if (!((Object)(object)instance == (Object)null) && !_markerHidden)
{
((Component)instance).gameObject.SetActive(false);
_markerHidden = true;
Trace.Info("[props] hid the player figurine");
}
}
public static void RestorePlayerMarker()
{
if (_markerHidden)
{
PlayerMarker instance = PlayerMarker.Instance;
if ((Object)(object)instance != (Object)null)
{
((Component)instance).gameObject.SetActive(true);
}
_markerHidden = false;
Trace.Info("[props] restored the player figurine");
}
}
}
internal static class Trace
{
private static readonly object Gate = new object();
private static string _path;
public static void Init()
{
try
{
string path = Path.Combine(Paths.BepInExRootPath ?? ".", "");
_path = Path.Combine(path, "mp-trace.log");
File.AppendAllText(_path, $"--- InscryptionMP trace pid={Process.GetCurrentProcess().Id} {DateTime.Now:HH:mm:ss} ---{Environment.NewLine}");
}
catch
{
_path = null;
}
}
public static void Info(string msg)
{
Plugin.Log.LogInfo((object)msg);
Write("INFO ", msg);
}
public static void Warn(string msg)
{
Plugin.Log.LogWarning((object)msg);
Write("WARN ", msg);
}
public static void Error(string msg)
{
Plugin.Log.LogError((object)msg);
Write("ERROR", msg);
}
private static void Write(string level, string msg)
{
if (_path == null)
{
return;
}
try
{
lock (Gate)
{
using StreamWriter streamWriter = new StreamWriter(_path, append: true);
streamWriter.WriteLine($"{DateTime.Now:HH:mm:ss.fff} [{Process.GetCurrentProcess().Id}] {level} {msg}");
streamWriter.Flush();
}
}
catch
{
}
}
}
[HarmonyPatch]
internal static class TurnOrder
{
public static bool IsMyTurn { get; private set; }
public static void BeginMatch(bool goFirst)
{
IsMyTurn = goFirst;
Trace.Info("[turn] match begins - " + (goFirst ? "we go first" : "peer goes first"));
}
public static void PassedToPeer()
{
IsMyTurn = false;
Trace.Info("[turn] passed to peer");
}
public static void TakenFromPeer()
{
IsMyTurn = true;
Trace.Info("[turn] taken from peer");
}
[HarmonyPatch(typeof(TurnManager), "PlayerTurn")]
[HarmonyPrefix]
private static bool SkipWhenNotOurTurn(ref IEnumerator __result)
{
if (!VersusMode.InMatch)
{
return true;
}
if (IsMyTurn)
{
return true;
}
Trace.Info("[turn] not our turn - skipping player phase");
__result = NoTurn();
return false;
}
private static IEnumerator NoTurn()
{
yield break;
}
}
internal static class VersusMode
{
private const string Act1Scene = "Part1_Cabin";
private static RunState _stashedRun;
private static string _stashedScene;
public const float ReconnectWindowSeconds = 120f;
private static float _suspendedAt;
public static bool InMatch { get; private set; }
public static bool PendingStart { get; private set; }
public static string Blocker
{
get
{
if (Net.HandshakeError != null)
{
return Net.HandshakeError;
}
if (!Net.Connected)
{
return "no peer connected";
}
if (InMatch)
{
return null;
}
if (PendingStart)
{
return "loading...";
}
if (!DeckStore.IsValid)
{
return $"deck needs {6}-{20} cards";
}
return null;
}
}
public static bool LoadedTableForDeck { get; private set; }
public static string LastResult { get; private set; }
public static bool Suspended { get; private set; }
public static float SuspendedSecondsLeft => Mathf.Max(0f, 120f - (Time.realtimeSinceStartup - _suspendedAt));
public static void StartAnywhere(MonoBehaviour host)
{
StartAnywhere(host, tellPeer: true);
}
public static void StartAnywhere(MonoBehaviour host, bool tellPeer)
{
if (!Net.Connected)
{
Trace.Warn("[versus] no peer connected");
}
else
{
if (InMatch || PendingStart)
{
return;
}
if (Net.HandshakeError != null)
{
Trace.Warn("[versus] refusing to start: " + Net.HandshakeError);
return;
}
if (Net.HandshakeError != null)
{
Trace.Warn("[versus] refusing to start: " + Net.HandshakeError);
return;
}
if (!DeckStore.IsValid)
{
Trace.Warn($"[versus] deck has {DeckStore.Deck.Count} cards - needs {6}-{20}");
return;
}
DeckStore.Save();
if (tellPeer)
{
Trace.Info("[versus] telling peer to start");
Net.Send("START");
}
if ((Object)(object)Singleton<TurnManager>.Instance != (Object)null)
{
Start(host);
return;
}
Trace.Info("[versus] not in gameplay scene - loading Part1_Cabin");
SaveManager.savingDisabled = true;
PrepareIsolatedRun();
PendingStart = true;
LoadingScreenManager.LoadScene("Part1_Cabin");
}
}
private static void PrepareIsolatedRun()
{
try
{
if (SaveManager.SaveFile == null)
{
Trace.Info("[versus] no save file - creating one");
SaveManager.CreateNewSaveFile();
}
SaveFile saveFile = SaveManager.SaveFile;
if (_stashedRun == null)
{
_stashedRun = saveFile.currentRun;
_stashedScene = saveFile.currentScene;
}
else
{
Trace.Info("[versus] campaign run already stashed - keeping it");
}
saveFile.ResetPart1Run();
saveFile.currentScene = "Part1_Cabin";
if (saveFile.currentRun != null)
{
saveFile.currentRun.runIntroCompleted = true;
}
Opponent.debugSkipIntro = true;
Trace.Info("[versus] synthesised an isolated Act 1 run for the match");
}
catch (Exception ex)
{
Trace.Error("[versus] could not prepare run state: " + ex.Message);
}
}
private static void RestoreCampaignRun()
{
try
{
if (_stashedRun == null)
{
return;
}
SaveFile saveFile = SaveManager.SaveFile;
if (saveFile != null)
{
saveFile.currentRun = _stashedRun;
if (_stashedScene != null)
{
saveFile.currentScene = _stashedScene;
}
Trace.Info("[versus] restored the campaign run");
}
}
catch (Exception ex)
{
Trace.Error("[versus] could not restore run state: " + ex.Message);
}
finally
{
_stashedRun = null;
_stashedScene = null;
}
}
public static void LoadTableOnly()
{
if ((Object)(object)Singleton<TurnManager>.Instance != (Object)null)
{
Trace.Info("[versus] already in the gameplay scene");
return;
}
LoadedTableForDeck = true;
Trace.Info("[versus] loading the table for deck building");
SaveManager.savingDisabled = true;
PrepareIsolatedRun();
LoadingScreenManager.LoadScene("Part1_Cabin");
}
public static void TickPendingStart(MonoBehaviour host)
{
if (PendingStart && !InMatch && !((Object)(object)Singleton<TurnManager>.Instance == (Object)null) && !((Object)(object)Singleton<BoardManager>.Instance == (Object)null) && !((Object)(object)Singleton<PlayerHand>.Instance == (Object)null))
{
GameFlowManager instance = Singleton<GameFlowManager>.Instance;
if (!((Object)(object)instance == (Object)null) && !instance.Transitioning)
{
PendingStart = false;
Trace.Info("[versus] scene ready - starting match");
Start(host);
}
}
}
public static bool CanStart()
{
if (!Net.Connected)
{
Trace.Warn("[versus] no peer connected");
return false;
}
if (InMatch)
{
Trace.Warn("[versus] already in a match");
return false;
}
if ((Object)(object)Singleton<TurnManager>.Instance == (Object)null)
{
Trace.Warn("[versus] no TurnManager - must be in the Act 1 scene");
return false;
}
return true;
}
public static void Start(MonoBehaviour host)
{
if (CanStart())
{
host.StartCoroutine(StartSequence());
}
}
private static IEnumerator StartSequence()
{
InMatch = true;
LoadedTableForDeck = false;
Suspended = false;
Net.Reconnecting = true;
SaveManager.savingDisabled = true;
TurnOrder.BeginMatch(Net.IsHost);
Trace.Info("[versus] starting match");
GameFlowManager flow = Singleton<GameFlowManager>.Instance;
ViewManager views = Singleton<ViewManager>.Instance;
if ((Object)(object)flow != (Object)null && (int)flow.CurrentGameState == 2)
{
Trace.Info("[versus] sitting down at the table");
flow.TransitionFromFirstPerson(true);
yield return (object)new WaitForSeconds(1f);
}
GameMap map = Singleton<GameMap>.Instance;
if ((Object)(object)map != (Object)null && (Object)(object)flow != (Object)null && (int)flow.CurrentGameState == 1)
{
Trace.Info("[versus] hiding map");
views.Controller.SwitchToControlMode((ControlMode)16, false);
yield return map.HideMapSequence();
yield return (object)new WaitForSeconds(0.25f);
}
TableProps.HidePlayerMarker();
views.Controller.SwitchToControlMode((ControlMode)0, false);
if ((Object)(object)flow != (Object)null)
{
flow.CurrentGameState = (GameState)0;
}
views.SwitchToView((View)1, false, false);
yield return (object)new WaitForSeconds(0.35f);
EncounterData encounter = new EncounterData
{
opponentType = (Type)0,
aiId = "AI",
opponentTurnPlan = new List<List<CardInfo>>(),
startConditions = new List<StartCondition>(),
Difficulty = 0
};
Trace.Info("[versus] handing encounter to TurnManager");
Singleton<TurnManager>.Instance.StartGame(encounter);
}
public static void NoteDisconnected()
{
if (InMatch && !Suspended)
{
Suspended = true;
_suspendedAt = Time.realtimeSinceStartup;
Trace.Warn("[versus] peer lost - match suspended, waiting for them to return");
}
}
public static void NoteReconnected()
{
if (Suspended)
{
Suspended = false;
Trace.Info("[versus] peer returned - resuming match");
Net.Send(Protocol.Board(Sync.SnapshotPlayerSlotsPublic()));
}
}
public static void TickSuspension(MonoBehaviour host)
{
if (Suspended && !(SuspendedSecondsLeft > 0f))
{
Trace.Warn("[versus] reconnect window expired");
Suspended = false;
Finish(host, playerWon: true, "opponent did not return");
}
}
public static void Finish(MonoBehaviour host, bool playerWon, string reason)
{
if (InMatch)
{
LastResult = (playerWon ? "you won" : "you lost");
Trace.Info("[versus] match over - " + LastResult + " (" + reason + ")");
Net.Send(playerWon ? "OVER LOST" : "OVER WON");
InMatch = false;
Suspended = false;
Net.Reconnecting = false;
PendingStart = false;
Match.Reset();
RestoreCampaignRun();
TableProps.RestorePlayerMarker();
MonoBehaviour runner = Plugin.Runner;
if ((Object)(object)runner != (Object)null)
{
runner.StartCoroutine(ReturnToMenu());
}
else
{
MenuController.ReturnToStartScreen();
}
}
}
private static IEnumerator ReturnToMenu()
{
yield return (object)new WaitForSeconds(1.5f);
Trace.Info("[versus] returning to main menu");
MenuController.ReturnToStartScreen();
}
public static void LeaveDeckTable()
{
if (LoadedTableForDeck && !InMatch)
{
LoadedTableForDeck = false;
Trace.Info("[versus] leaving the deck table - back to the title");
RestoreCampaignRun();
TableProps.RestorePlayerMarker();
MenuController.ReturnToStartScreen();
}
}
public static void Abort(MonoBehaviour host)
{
if (!InMatch && !PendingStart)
{
Trace.Info("[versus] abort requested but no match is running");
return;
}
Trace.Warn("[versus] match aborted by player");
InMatch = false;
Suspended = false;
Net.Reconnecting = false;
PendingStart = false;
Match.Reset();
RestoreCampaignRun();
TableProps.RestorePlayerMarker();
MenuController.ReturnToStartScreen();
}
}
}
