using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using LifeSync.Valheim.Config;
using LifeSync.Valheim.Controllers;
using LifeSync.Valheim.Models;
using LifeSync.Valheim.Services;
using LifeSync.Valheim.UI;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.Networking;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LifeSync-Games-Valheim")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LifeSync-Games-Valheim")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("ae94fb50-7a19-489c-90d1-142ac4878a2c")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace LifeSync.Valheim
{
[BepInPlugin("com.lifesyncgames.valheim", "LifeSyncGames Plugin", "0.1.0")]
public class Main : BaseUnityPlugin
{
public static Harmony Harmony;
public static UserLifeSyncController Users;
public static PointsService Points;
public static BuffService Buffs;
public static SessionTrackingService SessionTracking;
private GameObject uiRoot;
public static ConfigEntry<float> LevelsPerPoint;
private void Awake()
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Expected O, but got Unknown
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Expected O, but got Unknown
Game.isModded = true;
try
{
_ = typeof(JsonConvert).Assembly;
}
catch (Exception ex)
{
((BaseUnityPlugin)this).Logger.LogError((object)("[LifeSync] Newtonsoft error: " + ex.Message));
}
LevelsPerPoint = ((BaseUnityPlugin)this).Config.Bind<float>("LifeSync", "LevelsPerPoint", 1f, "How many levels are gained per point spent in the UI. Default is 1 (1 point = 1 level, 2 points = 2 levels, etc).");
((BaseUnityPlugin)this).Logger.LogInfo((object)"[LifeSync] starting...");
Harmony = new Harmony("com.lifesyncgames.valheim");
Harmony.PatchAll(Assembly.GetExecutingAssembly());
Users = new UserLifeSyncController();
Points = new PointsService(() => Users.UserLifeSyncModel);
Buffs = new BuffService(() => Users.UserLifeSyncModel);
Buffs.InitializeEffectService();
uiRoot = new GameObject("LifeSync.UI");
uiRoot.AddComponent<LoginUI>();
uiRoot.AddComponent<PointsUI>();
GameObject val = new GameObject("LifeSync.SessionTracking");
SessionTracking = val.AddComponent<SessionTrackingService>();
Object.DontDestroyOnLoad((Object)val);
uiRoot.AddComponent<LifeSyncQuickAccessUI>();
Object.DontDestroyOnLoad((Object)(object)uiRoot);
Users.LoadCredentials();
}
private void Update()
{
}
private void OnDestroy()
{
try
{
Buffs?.SaveActiveBuffs();
}
catch (Exception ex)
{
((BaseUnityPlugin)this).Logger.LogError((object)("[LifeSync] Error al guardar buffs: " + ex.Message));
}
}
private void OnApplicationQuit()
{
try
{
Buffs?.SaveActiveBuffs();
}
catch (Exception ex)
{
((BaseUnityPlugin)this).Logger.LogError((object)("[LifeSync] Error al guardar buffs: " + ex.Message));
}
}
}
}
namespace LifeSync.Valheim.UI
{
internal class LoginUI : MonoBehaviour
{
[CompilerGenerated]
private sealed class <CenterMousePositionCoroutine>d__23 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public LoginUI <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CenterMousePositionCoroutine>d__23(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
LoginUI loginUI = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
try
{
int x = Screen.width / 2;
int y = Screen.height / 2;
loginUI.SetCursorPosition(x, y);
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] Error al centrar el mouse: " + ex.Message));
}
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <LoginFlow>d__16 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public LoginUI <>4__this;
public string user;
public string pass;
private Task<int> <tCheck>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoginFlow>d__16(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<tCheck>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
LoginUI loginUI = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
loginUI.isSubmitting = true;
loginUI.statusText = "Checking credentials...";
Debug.Log((object)("[LifeSync][LOGIN] Intentando login: " + user));
<tCheck>5__2 = Main.Users.UserCheck(user, pass);
<>2__current = WaitTask(<tCheck>5__2);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
switch (<tCheck>5__2.Result)
{
case 1:
{
Debug.Log((object)("[LifeSync][LOGIN] Autenticación OK: " + user));
loginUI.statusText = "Loading user...";
Task task = Main.Users.SaveUserLifeSync(user, pass);
<>2__current = WaitTask(task);
<>1__state = 2;
return true;
}
case 3:
Debug.LogWarning((object)"[LifeSync][LOGIN] Usuario o contraseña vacíos.");
loginUI.statusText = "Please enter username and password.";
break;
default:
Debug.LogWarning((object)("[LifeSync][LOGIN] Credenciales inválidas para: " + user));
loginUI.statusText = "Invalid credentials.";
break;
}
break;
case 2:
{
<>1__state = -1;
loginUI.isLoggedIn = true;
loginUI.showLogin = false;
Cursor.visible = false;
Cursor.lockState = (CursorLockMode)1;
loginUI.ResumeGame();
Chat instance = Chat.instance;
if (instance != null)
{
((Terminal)instance).AddString("[LifeSync] Welcome, " + user);
}
Object.FindFirstObjectByType<PointsUI>()?.Open();
break;
}
}
loginUI.isSubmitting = false;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <ResetCursorPosition>d__26 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ResetCursorPosition>d__26(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Cursor.lockState = (CursorLockMode)1;
Cursor.lockState = (CursorLockMode)0;
Cursor.lockState = (CursorLockMode)1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitTask>d__17 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public Task task;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitTask>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if (!task.IsCompleted)
{
<>2__current = null;
<>1__state = 1;
return true;
}
if (task.Exception != null)
{
throw task.Exception;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private UserLifeSyncController userCtrl = new UserLifeSyncController();
public bool showLogin;
private string username = "";
private string password = "";
public bool isLoggedIn;
private bool initialized;
private bool isSubmitting;
private string statusText = "";
private Rect windowRect = new Rect(20f, 20f, 300f, 220f);
public static void ForceLogout()
{
LoginUI loginUI = Object.FindFirstObjectByType<LoginUI>();
if ((Object)(object)loginUI != (Object)null)
{
loginUI.ApplyLogoutUI();
}
}
public void ApplyLogoutUI()
{
isLoggedIn = false;
showLogin = false;
username = string.Empty;
password = string.Empty;
statusText = "Logged out.";
if (!showLogin)
{
Cursor.visible = false;
Cursor.lockState = (CursorLockMode)1;
ResumeGame();
}
}
private void Start()
{
if (initialized)
{
return;
}
try
{
Task<int> task = userCtrl.LoadCredentials();
((MonoBehaviour)this).StartCoroutine(WaitTask(task));
task.ContinueWith(delegate(Task<int> t)
{
if (!t.IsFaulted && t.Result > 0)
{
isLoggedIn = true;
showLogin = false;
statusText = "User logged in!";
}
});
}
catch (Exception ex)
{
Debug.LogError((object)((object)this).Equals((object?)("[LifeSync] Error initializing LoginUI: " + ex.Message)));
}
}
public void ToggleLoginWindow()
{
showLogin = !showLogin;
Cursor.visible = showLogin;
Cursor.lockState = (CursorLockMode)((!showLogin) ? 1 : 0);
if (showLogin)
{
PauseGame();
return;
}
((MonoBehaviour)this).StartCoroutine(ResetCursorPosition());
ResumeGame();
}
private void Update()
{
if (Input.GetKeyDown((KeyCode)288) && Object.op_Implicit((Object)(object)Player.m_localPlayer))
{
if (!isLoggedIn)
{
ToggleLoginWindow();
}
else
{
PointsUI pointsUI = Object.FindFirstObjectByType<PointsUI>();
if ((Object)(object)pointsUI != (Object)null)
{
pointsUI.Open();
}
}
}
if (showLogin)
{
Cursor.visible = true;
Cursor.lockState = (CursorLockMode)0;
}
}
private void OnGUI()
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Invalid comparison between Unknown and I4
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Expected O, but got Unknown
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Invalid comparison between Unknown and I4
if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
{
if (!initialized)
{
((Rect)(ref windowRect)).x = ((float)Screen.width - ((Rect)(ref windowRect)).width) / 2f;
((Rect)(ref windowRect)).y = ((float)Screen.height - ((Rect)(ref windowRect)).height) / 2f;
initialized = true;
}
if (showLogin && (int)Event.current.type == 4 && (int)Event.current.keyCode == 27)
{
ToggleLoginWindow();
Event.current.Use();
}
else if (showLogin)
{
windowRect = GUILayout.Window(7701, windowRect, new WindowFunction(DrawLoginWindow), "Login to LifeSync", Array.Empty<GUILayoutOption>());
}
}
}
private void DrawLoginWindow(int id)
{
GUI.enabled = !isSubmitting;
GUILayout.Label("Username:", Array.Empty<GUILayoutOption>());
username = GUILayout.TextField(username, 64, Array.Empty<GUILayoutOption>());
GUILayout.Label("Password:", Array.Empty<GUILayoutOption>());
password = GUILayout.PasswordField(password, '*', 64, Array.Empty<GUILayoutOption>());
if (GUILayout.Button(isSubmitting ? "Logging in..." : "Login to LifeSync-Games", Array.Empty<GUILayoutOption>()) && !isSubmitting)
{
((MonoBehaviour)this).StartCoroutine(LoginFlow(username, password));
}
if (GUILayout.Button("Cancel", Array.Empty<GUILayoutOption>()))
{
showLogin = false;
Cursor.visible = false;
Cursor.lockState = (CursorLockMode)1;
((MonoBehaviour)this).StartCoroutine(ResetCursorPosition());
ResumeGame();
}
GUI.enabled = true;
if (!string.IsNullOrEmpty(statusText))
{
GUILayout.Space(6f);
GUILayout.Label(statusText, Array.Empty<GUILayoutOption>());
}
GUI.DragWindow();
}
[IteratorStateMachine(typeof(<LoginFlow>d__16))]
private IEnumerator LoginFlow(string user, string pass)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoginFlow>d__16(0)
{
<>4__this = this,
user = user,
pass = pass
};
}
[IteratorStateMachine(typeof(<WaitTask>d__17))]
private static IEnumerator WaitTask(Task task)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitTask>d__17(0)
{
task = task
};
}
private void PauseGame()
{
try
{
if (!Game.IsPaused())
{
Game.Pause();
Cursor.visible = true;
Cursor.lockState = (CursorLockMode)0;
BlockCamera();
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo pausar el juego: " + ex.Message));
}
}
private void ResumeGame()
{
try
{
if (Game.IsPaused())
{
Game.Unpause();
Cursor.visible = false;
Cursor.lockState = (CursorLockMode)1;
UnblockCamera();
RestoreMousePosition();
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo reanudar el juego: " + ex.Message));
}
}
private void BlockCamera()
{
try
{
if ((Object)(object)GameCamera.instance != (Object)null)
{
((Behaviour)GameCamera.instance).enabled = false;
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo bloquear la cámara: " + ex.Message));
}
}
private void UnblockCamera()
{
try
{
if ((Object)(object)GameCamera.instance != (Object)null)
{
((Behaviour)GameCamera.instance).enabled = true;
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo desbloquear la cámara: " + ex.Message));
}
}
private void RestoreMousePosition()
{
try
{
((MonoBehaviour)this).StartCoroutine(CenterMousePositionCoroutine());
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo centrar el mouse: " + ex.Message));
}
}
[IteratorStateMachine(typeof(<CenterMousePositionCoroutine>d__23))]
private IEnumerator CenterMousePositionCoroutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CenterMousePositionCoroutine>d__23(0)
{
<>4__this = this
};
}
[DllImport("user32.dll")]
private static extern bool SetCursorPos(int x, int y);
private void SetCursorPosition(int x, int y)
{
SetCursorPos(x, y);
}
[IteratorStateMachine(typeof(<ResetCursorPosition>d__26))]
private IEnumerator ResetCursorPosition()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ResetCursorPosition>d__26(0);
}
}
internal class LifeSyncQuickAccessUI : MonoBehaviour
{
[CompilerGenerated]
private sealed class <CheckInitialLoginStatus>d__9 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public LifeSyncQuickAccessUI <>4__this;
private Task<bool> <t>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CheckInitialLoginStatus>d__9(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<t>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
LifeSyncQuickAccessUI lifeSyncQuickAccessUI = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
lifeSyncQuickAccessUI.checking = true;
<t>5__2 = lifeSyncQuickAccessUI.userCtrl.IsLoggedInAsync();
break;
case 1:
<>1__state = -1;
break;
}
if (!<t>5__2.IsCompleted)
{
<>2__current = null;
<>1__state = 1;
return true;
}
lifeSyncQuickAccessUI.isLoggedIn = !<t>5__2.IsFaulted && <t>5__2.Result;
lifeSyncQuickAccessUI.statusText = (lifeSyncQuickAccessUI.isLoggedIn ? "Conectado" : "Desconectado");
lifeSyncQuickAccessUI.checking = false;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <CheckLoginStatus>d__11 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public LifeSyncQuickAccessUI <>4__this;
private Task<bool> <t>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CheckLoginStatus>d__11(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<t>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
LifeSyncQuickAccessUI lifeSyncQuickAccessUI = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
lifeSyncQuickAccessUI.checking = true;
<t>5__2 = lifeSyncQuickAccessUI.userCtrl.IsLoggedInAsync();
break;
case 1:
<>1__state = -1;
break;
}
if (!<t>5__2.IsCompleted)
{
<>2__current = null;
<>1__state = 1;
return true;
}
bool flag = !<t>5__2.IsFaulted && <t>5__2.Result;
if (flag != lifeSyncQuickAccessUI.isLoggedIn)
{
lifeSyncQuickAccessUI.isLoggedIn = flag;
lifeSyncQuickAccessUI.statusText = (lifeSyncQuickAccessUI.isLoggedIn ? "Conectado" : "Desconectado");
}
lifeSyncQuickAccessUI.checking = false;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private UserLifeSyncController userCtrl = new UserLifeSyncController();
private bool checking;
private GUIStyle statusStyle;
private bool stylesInitialized;
private Rect statusRect;
private bool isLoggedIn;
private string statusText = "";
private void Start()
{
InitializeButtonPositions();
((MonoBehaviour)this).StartCoroutine(CheckInitialLoginStatus());
}
private void InitializeButtonPositions()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
statusRect = new Rect((float)(Screen.width - 220), 20f, 200f, 20f);
}
[IteratorStateMachine(typeof(<CheckInitialLoginStatus>d__9))]
private IEnumerator CheckInitialLoginStatus()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CheckInitialLoginStatus>d__9(0)
{
<>4__this = this
};
}
private void Update()
{
if ((float)Screen.width != ((Rect)(ref statusRect)).x + ((Rect)(ref statusRect)).width + 20f)
{
InitializeButtonPositions();
}
if (!checking && Time.frameCount % 300 == 0)
{
((MonoBehaviour)this).StartCoroutine(CheckLoginStatus());
}
}
[IteratorStateMachine(typeof(<CheckLoginStatus>d__11))]
private IEnumerator CheckLoginStatus()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CheckLoginStatus>d__11(0)
{
<>4__this = this
};
}
private void InitializeStyles()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
if (!stylesInitialized)
{
statusStyle = new GUIStyle(GUI.skin.label);
statusStyle.fontSize = 12;
statusStyle.normal.textColor = Color.white;
stylesInitialized = true;
}
}
private void OnGUI()
{
if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
{
InitializeStyles();
InitializeButtonPositions();
DrawKeybindText();
DrawStatusText();
}
}
private void DrawKeybindText()
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: 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_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
GUIStyle val = new GUIStyle(GUI.skin.label)
{
fontSize = 9
};
val.normal.textColor = new Color(0.8f, 0.8f, 0.8f, 0.7f);
val.alignment = (TextAnchor)6;
GUIStyle val2 = val;
string text = ((!isLoggedIn) ? "LifeSync-Games Mod\nF7: Login" : "LifeSync-Games Mod\nF7: Menu");
GUI.Label(new Rect(20f, (float)(Screen.height - 100), 250f, 80f), text, val2);
}
private void DrawStatusText()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: 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_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
Color textColor = statusStyle.normal.textColor;
if (isLoggedIn)
{
statusStyle.normal.textColor = Color.green;
}
else
{
statusStyle.normal.textColor = Color.red;
}
GUI.Label(statusRect, statusText, statusStyle);
statusStyle.normal.textColor = textColor;
}
}
internal class PointsUI : MonoBehaviour
{
[CompilerGenerated]
private sealed class <CenterMousePositionCoroutine>d__39 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public PointsUI <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CenterMousePositionCoroutine>d__39(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
PointsUI pointsUI = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
try
{
int num2 = Screen.width / 2;
int num3 = Screen.height / 2;
pointsUI.SetCursorPosition(num2, num3);
Debug.Log((object)$"[LifeSync] Mouse centrado en: {num2}, {num3}");
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] Error al centrar el mouse: " + ex.Message));
}
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <LoadLogoCoroutine>d__22 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
private string[] <>7__wrap1;
private int <>7__wrap2;
private byte[] <fileData>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoadLogoCoroutine>d__22(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>7__wrap1 = null;
<fileData>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0270: Unknown result type (might be due to invalid IL or missing references)
//IL_027a: Expected O, but got Unknown
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
bool flag = false;
logoTexture = new Texture2D(2, 2);
try
{
Type type = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule");
if (type != null)
{
MethodInfo method = type.GetMethod("LoadImage", new Type[2]
{
typeof(Texture2D),
typeof(byte[])
});
if (method != null)
{
method.Invoke(null, new object[2] { logoTexture, <fileData>5__4 });
flag = ((Texture)logoTexture).width > 2 && ((Texture)logoTexture).height > 2;
Debug.Log((object)$"[LifeSync] Logo cargado con ImageConversion: {((Texture)logoTexture).width}x{((Texture)logoTexture).height}");
}
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] ImageConversion no disponible: " + ex.Message));
}
if (!flag)
{
try
{
MethodInfo method2 = typeof(Texture2D).GetMethod("LoadImage", new Type[1] { typeof(byte[]) });
if (method2 != null)
{
flag = (bool)method2.Invoke(logoTexture, new object[1] { <fileData>5__4 });
}
}
catch (Exception ex2)
{
Debug.LogWarning((object)("[LifeSync] LoadImage no disponible: " + ex2.Message));
}
}
if (flag && (Object)(object)logoTexture != (Object)null && ((Texture)logoTexture).width > 2 && ((Texture)logoTexture).height > 2)
{
logoLoaded = true;
return false;
}
if ((Object)(object)logoTexture != (Object)null)
{
Object.Destroy((Object)(object)logoTexture);
logoTexture = null;
}
<fileData>5__4 = null;
goto IL_041f;
}
<>1__state = -1;
string text = null;
string text2 = null;
try
{
text = Assembly.GetExecutingAssembly().Location;
text2 = Path.GetDirectoryName(text);
Debug.Log((object)("[LifeSync] Assembly path: " + text));
Debug.Log((object)("[LifeSync] Assembly directory: " + text2));
}
catch (Exception ex3)
{
Debug.LogError((object)("[LifeSync] Error al obtener ruta del assembly: " + ex3.Message));
logoLoaded = true;
return false;
}
string[] array = new string[6]
{
Path.Combine(text2, "ITO-iso.png"),
Path.Combine(text2, "LifeSync-Games-Valheim", "ITO-iso.png"),
Path.Combine(Path.GetDirectoryName(Application.dataPath), "BepInEx", "plugins", "LifeSync-Games-Valheim", "ITO-iso.png"),
Path.Combine(Path.GetDirectoryName(Application.dataPath), "BepInEx", "plugins", "ITO-iso.png"),
Path.Combine(text2, "..", "ITO-iso.png"),
Path.Combine(text2, "..", "..", "ITO-iso.png")
};
for (int i = 0; i < array.Length; i++)
{
try
{
array[i] = Path.GetFullPath(array[i]);
}
catch (Exception ex4)
{
Debug.LogWarning((object)("[LifeSync] Error al normalizar ruta " + array[i] + ": " + ex4.Message));
}
}
Debug.Log((object)$"[LifeSync] Buscando logo en {array.Length} ubicaciones posibles:");
string[] array2 = array;
foreach (string text3 in array2)
{
Debug.Log((object)$"[LifeSync] - {text3} (existe: {File.Exists(text3)})");
}
<>7__wrap1 = array;
<>7__wrap2 = 0;
goto IL_042d;
IL_042d:
if (<>7__wrap2 < <>7__wrap1.Length)
{
string text4 = <>7__wrap1[<>7__wrap2];
if (File.Exists(text4))
{
Debug.Log((object)("[LifeSync] Intentando cargar logo desde: " + text4));
<fileData>5__4 = null;
try
{
<fileData>5__4 = File.ReadAllBytes(text4);
}
catch (Exception ex5)
{
Debug.LogWarning((object)("[LifeSync] Error al leer archivo " + text4 + ": " + ex5.Message));
goto IL_041f;
}
if (<fileData>5__4 != null && <fileData>5__4.Length != 0)
{
<>2__current = null;
<>1__state = 1;
return true;
}
}
goto IL_041f;
}
<>7__wrap1 = null;
Debug.LogWarning((object)"[LifeSync] No se pudo cargar ITO-iso.png");
logoLoaded = true;
return false;
IL_041f:
<>7__wrap2++;
goto IL_042d;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <ResetCursorPosition>d__46 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ResetCursorPosition>d__46(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
Cursor.lockState = (CursorLockMode)1;
Cursor.lockState = (CursorLockMode)0;
Cursor.lockState = (CursorLockMode)1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public bool open;
private Rect win;
private int selectedTab;
private readonly string[] tabNames = new string[3] { "Subir Nivel", "Potenciadores", "Sesiones" };
private GUIStyle tabStyle;
private GUIStyle activeTabStyle;
private GUIStyle boxStyle;
private bool stylesInitialized;
private Vector2 scrollPosition = Vector2.zero;
private UserLifeSyncController userCtrl = new UserLifeSyncController();
private static Texture2D texBg;
private static Texture2D texFill;
private static Texture2D texPreview;
private static Texture2D logoTexture;
private static bool logoLoaded = false;
private readonly Dictionary<SkillType, float> previewPerSkill = new Dictionary<SkillType, float>();
private const float defaultPreview = 0.2f;
private static readonly BindingFlags BF = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
private readonly Dictionary<string, SkillType[]> attributeMap;
private static bool TryGetLevelAndAccumulator(Skills skills, SkillType type, out int levelI, out float frac)
{
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
levelI = 0;
frac = 0f;
FieldInfo field = typeof(Skills).GetField("m_skills", BF);
IEnumerable enumerable = ((field != null) ? (field.GetValue(skills) as IEnumerable) : null);
if (enumerable == null)
{
return false;
}
foreach (object item in enumerable)
{
FieldInfo field2 = item.GetType().GetField("m_info", BF);
object obj = ((field2 != null) ? field2.GetValue(item) : null);
if (obj == null)
{
continue;
}
FieldInfo field3 = obj.GetType().GetField("m_skill", BF);
if (!(field3 == null) && (SkillType)field3.GetValue(obj) == type)
{
FieldInfo field4 = item.GetType().GetField("m_level", BF);
FieldInfo field5 = item.GetType().GetField("m_accumulator", BF);
if (field4 == null || field5 == null)
{
return false;
}
levelI = Mathf.FloorToInt((float)field4.GetValue(item));
frac = Mathf.Clamp01((float)field5.GetValue(item));
return true;
}
}
return false;
}
private void EnsureTextures()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
//IL_0037: 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)
//IL_0057: Expected O, but got Unknown
//IL_0072: 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_0092: Expected O, but got Unknown
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)texBg == (Object)null)
{
texBg = new Texture2D(1, 1);
texBg.SetPixel(0, 0, new Color(0f, 0f, 0f, 0.35f));
texBg.Apply();
texFill = new Texture2D(1, 1);
texFill.SetPixel(0, 0, new Color(0.2f, 0.8f, 0.2f, 0.9f));
texFill.Apply();
texPreview = new Texture2D(1, 1);
texPreview.SetPixel(0, 0, new Color(1f, 0.9f, 0.2f, 0.65f));
texPreview.Apply();
}
if (!logoLoaded)
{
LoadLogo();
}
}
private void LoadLogo()
{
((MonoBehaviour)this).StartCoroutine(LoadLogoCoroutine());
}
[IteratorStateMachine(typeof(<LoadLogoCoroutine>d__22))]
private IEnumerator LoadLogoCoroutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoadLogoCoroutine>d__22(0);
}
public void Open()
{
open = true;
Cursor.visible = true;
Cursor.lockState = (CursorLockMode)0;
PauseGame();
InitializeWindow();
}
private void InitializeWindow()
{
//IL_0047: 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)
float num = Screen.width;
float num2 = Screen.height;
float num3 = Mathf.Min(600f, num * 0.4f);
float num4 = Mathf.Min(700f, num2 * 0.6f);
win = new Rect((num - num3) / 2f, (num2 - num4) / 2f, num3, num4);
}
public void Close()
{
open = false;
Cursor.visible = false;
Cursor.lockState = (CursorLockMode)1;
((MonoBehaviour)this).StartCoroutine(ResetCursorPosition());
ResumeGame();
}
private void Update()
{
if (!((Object)(object)Player.m_localPlayer == (Object)null) && open)
{
Cursor.visible = true;
Cursor.lockState = (CursorLockMode)0;
Main.Buffs?.UpdateActiveBuffs();
}
}
private void InitializeStyles()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Expected O, but got Unknown
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Expected O, but got Unknown
//IL_00bf: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Expected O, but got Unknown
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Expected O, but got Unknown
if (!stylesInitialized)
{
tabStyle = new GUIStyle(GUI.skin.button);
tabStyle.fontSize = 14;
tabStyle.normal.textColor = Color.white;
tabStyle.hover.textColor = Color.yellow;
tabStyle.padding = new RectOffset(10, 10, 8, 8);
tabStyle.margin = new RectOffset(2, 2, 0, 0);
activeTabStyle = new GUIStyle(tabStyle);
activeTabStyle.normal.background = GUI.skin.button.active.background;
activeTabStyle.normal.textColor = Color.yellow;
boxStyle = new GUIStyle(GUI.skin.box);
boxStyle.padding = new RectOffset(8, 8, 8, 8);
boxStyle.margin = new RectOffset(4, 4, 4, 4);
stylesInitialized = true;
}
}
private void OnGUI()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Invalid comparison between Unknown and I4
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: 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_002f: Invalid comparison between Unknown and I4
if (open && !((Object)(object)Player.m_localPlayer == (Object)null))
{
if ((int)Event.current.type == 4 && (int)Event.current.keyCode == 27)
{
Close();
Event.current.Use();
}
else
{
EnsureTextures();
InitializeStyles();
win = GUILayout.Window(7702, win, new WindowFunction(Draw), "LifeSync Points", Array.Empty<GUILayoutOption>());
}
}
}
private void Draw(int id)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: 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)
PointsService points = Main.Points;
BuffService buffs = Main.Buffs;
if ((Object)(object)logoTexture != (Object)null && ((Texture)logoTexture).width > 2 && ((Texture)logoTexture).height > 2)
{
Color color = GUI.color;
GUI.color = new Color(1f, 1f, 1f, 0.3f);
float num = 20f;
float width = ((Rect)(ref win)).width;
float num2 = ((Rect)(ref win)).height - num;
float num3 = Mathf.Min(width, num2) * 0.6f;
float num4 = (width - num3) / 2f;
float num5 = num + (num2 - num3) / 2f;
GUI.DrawTexture(new Rect(num4, num5, num3, num3), (Texture)(object)logoTexture, (ScaleMode)2, true);
GUI.color = color;
}
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
for (int i = 0; i < tabNames.Length; i++)
{
if (GUILayout.Button(tabNames[i], (i == selectedTab) ? activeTabStyle : tabStyle, Array.Empty<GUILayoutOption>()))
{
selectedTab = i;
}
}
GUILayout.EndHorizontal();
GUILayout.Space(10f);
if (selectedTab == 0)
{
DrawSkillsTab(points);
}
else if (selectedTab == 1)
{
DrawBuffsTab(buffs, points);
}
else if (selectedTab == 2)
{
DrawSessionsTab();
}
if (GUILayout.Button("Close", Array.Empty<GUILayoutOption>()))
{
Close();
}
if (GUILayout.Button("Logout", Array.Empty<GUILayoutOption>()))
{
userCtrl.ClearCredentials();
LoginUI.ForceLogout();
Chat instance = Chat.instance;
if (instance != null)
{
((Terminal)instance).AddString("[LifeSync] You have been logged out.");
}
Close();
}
GUI.DragWindow();
}
private void DrawSkillsTab(PointsService svc)
{
//IL_001b: 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_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
GUILayout.Label("Gasta puntos de atributos para subir habilidades. El costo aumenta según el nivel actual.", Array.Empty<GUILayoutOption>());
GUILayout.Space(6f);
scrollPosition = GUILayout.BeginScrollView(scrollPosition, Array.Empty<GUILayoutOption>());
PointsLifeSyncModel[] attributes = svc.GetAttributes();
for (int i = 0; i < attributes.Length; i++)
{
string name = attributes[i].Name;
int points = svc.GetPoints(name);
GUILayout.BeginVertical(boxStyle, Array.Empty<GUILayoutOption>());
GUILayout.Label($"{name}: {points} puntos", GUI.skin.box, Array.Empty<GUILayoutOption>());
if (attributeMap.TryGetValue(name, out var value))
{
SkillType[] array = value;
foreach (SkillType skill in array)
{
DrawSkillRow(name, skill, points, svc);
points = svc.GetPoints(name);
}
}
else
{
GUILayout.Label("No hay habilidades mapeadas para este atributo.", Array.Empty<GUILayoutOption>());
}
GUILayout.EndVertical();
GUILayout.Space(6f);
}
GUILayout.EndScrollView();
}
private void DrawBuffsTab(BuffService buffService, PointsService pointsService)
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
if (buffService == null)
{
GUILayout.Label("Servicio de potenciadores no disponible.", Array.Empty<GUILayoutOption>());
return;
}
GUILayout.Label("Gasta puntos de atributos para activar potenciadores temporales (máximo 5 minutos).", Array.Empty<GUILayoutOption>());
GUILayout.Label("Solo puedes tener 1 potenciador activo a la vez.", GUI.skin.label, Array.Empty<GUILayoutOption>());
GUILayout.Space(6f);
ActiveBuff currentActiveBuff = buffService.GetCurrentActiveBuff();
if (currentActiveBuff != null)
{
DrawActiveBuffDisplay(currentActiveBuff, buffService);
GUILayout.Space(10f);
}
scrollPosition = GUILayout.BeginScrollView(scrollPosition, Array.Empty<GUILayoutOption>());
foreach (string key in attributeMap.Keys)
{
List<BuffModel> buffsForDimension = buffService.GetBuffsForDimension(key);
if (buffsForDimension.Count == 0)
{
continue;
}
GUILayout.BeginVertical(boxStyle, Array.Empty<GUILayoutOption>());
GUILayout.Label($"{key}: {pointsService.GetPoints(key)} puntos", GUI.skin.box, Array.Empty<GUILayoutOption>());
GUILayout.Space(4f);
foreach (BuffModel item in buffsForDimension)
{
DrawBuffItem(item, pointsService, buffService, currentActiveBuff);
}
GUILayout.EndVertical();
GUILayout.Space(6f);
}
GUILayout.EndScrollView();
}
private void DrawActiveBuffDisplay(ActiveBuff activeBuff, BuffService buffService)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
GUILayout.BeginVertical(boxStyle, Array.Empty<GUILayoutOption>());
Color color = GUI.color;
GUI.color = Color.green;
GUILayout.Label("POTENCIADOR ACTIVO: " + activeBuff.Name, GUI.skin.box, Array.Empty<GUILayoutOption>());
GUI.color = color;
GUILayout.Space(4f);
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(300f) });
GUILayout.Label("Efectos: " + string.Join(", ", activeBuff.Effects.Select((KeyValuePair<string, float> e) => $"{e.Key}: +{(e.Value - 1f) * 100f:F0}%")), GUI.skin.label, Array.Empty<GUILayoutOption>());
GUILayout.EndVertical();
GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
string text = FormatTime(activeBuff.RemainingTime);
GUILayout.Label("Tiempo restante: " + text, GUI.skin.label, Array.Empty<GUILayoutOption>());
GUILayout.Space(4f);
if (GUILayout.Button("DESACTIVAR", (GUILayoutOption[])(object)new GUILayoutOption[2]
{
GUILayout.Width(100f),
GUILayout.Height(25f)
}))
{
buffService.DeactivateCurrentBuff();
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
private string FormatTime(float seconds)
{
int num = Mathf.FloorToInt(seconds / 60f);
int num2 = Mathf.FloorToInt(seconds % 60f);
return $"{num:00}:{num2:00}";
}
private void PauseGame()
{
try
{
if (!Game.IsPaused())
{
Game.Pause();
Cursor.visible = true;
Cursor.lockState = (CursorLockMode)0;
BlockCamera();
Debug.Log((object)"[LifeSync] Juego pausado - menú abierto");
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo pausar el juego: " + ex.Message));
}
}
private void ResumeGame()
{
try
{
if (Game.IsPaused())
{
Game.Unpause();
Cursor.visible = false;
Cursor.lockState = (CursorLockMode)1;
UnblockCamera();
RestoreMousePosition();
Debug.Log((object)"[LifeSync] Juego reanudado - menú cerrado");
}
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo reanudar el juego: " + ex.Message));
}
}
private void BlockCamera()
{
try
{
if ((Object)(object)GameCamera.instance != (Object)null)
{
((Behaviour)GameCamera.instance).enabled = false;
}
Debug.Log((object)"[LifeSync] Cámara bloqueada");
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo bloquear la cámara: " + ex.Message));
}
}
private void UnblockCamera()
{
try
{
if ((Object)(object)GameCamera.instance != (Object)null)
{
((Behaviour)GameCamera.instance).enabled = true;
}
Debug.Log((object)"[LifeSync] Cámara desbloqueada");
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo desbloquear la cámara: " + ex.Message));
}
}
private void RestoreMousePosition()
{
try
{
((MonoBehaviour)this).StartCoroutine(CenterMousePositionCoroutine());
}
catch (Exception ex)
{
Debug.LogWarning((object)("[LifeSync] No se pudo centrar el mouse: " + ex.Message));
}
}
[IteratorStateMachine(typeof(<CenterMousePositionCoroutine>d__39))]
private IEnumerator CenterMousePositionCoroutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CenterMousePositionCoroutine>d__39(0)
{
<>4__this = this
};
}
[DllImport("user32.dll")]
private static extern bool SetCursorPos(int x, int y);
private void SetCursorPosition(int x, int y)
{
SetCursorPos(x, y);
}
private void DrawBuffItem(BuffModel buff, PointsService pointsService, BuffService buffService, ActiveBuff currentActiveBuff)
{
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(300f) });
GUILayout.Label("<b>" + buff.Name + "</b>", GUI.skin.label, Array.Empty<GUILayoutOption>());
GUILayout.Label(buff.Description, GUI.skin.label, Array.Empty<GUILayoutOption>());
GUILayout.Label($"Duración: {buff.Duration} minutos", GUI.skin.label, Array.Empty<GUILayoutOption>());
GUILayout.EndVertical();
GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
bool flag = pointsService.GetPoints(buff.Dimension) >= buff.Cost;
bool flag2 = currentActiveBuff != null;
GUILayout.Label($"Costo: {buff.Cost} {buff.Dimension}", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) });
GUI.enabled = flag && !flag2;
if (GUILayout.Button(flag2 ? "OTRO ACTIVO" : "ACTIVAR", (GUILayoutOption[])(object)new GUILayoutOption[2]
{
GUILayout.Width(80f),
GUILayout.Height(25f)
}))
{
buffService.TryActivateBuff(buff.Id, pointsService);
}
GUI.enabled = true;
if (flag2)
{
GUILayout.Label("Otro activo", GUI.skin.label, Array.Empty<GUILayoutOption>());
}
else if (!flag)
{
GUILayout.Label("Sin puntos", GUI.skin.label, Array.Empty<GUILayoutOption>());
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.Space(2f);
}
private void DrawSkillRow(string attrName, SkillType skill, int availableAttrPoints, PointsService svc)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
Player localPlayer = Player.m_localPlayer;
if ((Object)(object)localPlayer == (Object)null)
{
return;
}
Skills skills = ((Character)localPlayer).GetSkills();
if (!((Object)(object)skills == (Object)null))
{
int num = Mathf.FloorToInt(skills.GetSkillLevel(skill));
int num2 = CalculateDynamicCost(num);
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.Label(((object)(SkillType)(ref skill)).ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(160f) });
GUILayout.FlexibleSpace();
GUILayout.Label($"Lvl: {num}", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
bool flag2 = (GUI.enabled = availableAttrPoints >= num2);
if (GUILayout.Button($"+1 (-{num2} {attrName})", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(170f) }))
{
svc.TryUpgradeFrom(attrName, skill, num2, 0f, out var _);
}
GUI.enabled = true;
GUILayout.EndHorizontal();
if (!flag2)
{
GUILayout.Label($" Necesitas {num2} puntos de {attrName} (tienes {availableAttrPoints})", GUI.skin.label, Array.Empty<GUILayoutOption>());
}
GUILayout.Space(4f);
}
}
private int CalculateDynamicCost(int currentLevel)
{
if (currentLevel <= 10)
{
return 1;
}
if (currentLevel <= 25)
{
return 2;
}
if (currentLevel <= 50)
{
return 3;
}
return 4;
}
private void DrawSessionsTab()
{
//IL_003b: 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_004a: Unknown result type (might be due to invalid IL or missing references)
SessionTrackingService sessionTracking = Main.SessionTracking;
if ((Object)(object)sessionTracking == (Object)null)
{
GUILayout.Label("Servicio de sesiones no disponible.", Array.Empty<GUILayoutOption>());
return;
}
SessionConfigModel config = sessionTracking.GetConfig();
if (config == null)
{
GUILayout.Label("Configuración de sesiones no disponible.", Array.Empty<GUILayoutOption>());
return;
}
scrollPosition = GUILayout.BeginScrollView(scrollPosition, Array.Empty<GUILayoutOption>());
GUILayout.Label("Sistema de Bienestar Digital", GUI.skin.box, Array.Empty<GUILayoutOption>());
GUILayout.Space(8f);
GUILayout.BeginVertical(boxStyle, Array.Empty<GUILayoutOption>());
GUILayout.Label("Estado Actual de la Sesión", GUI.skin.box, Array.Empty<GUILayoutOption>());
GUILayout.Label("Tiempo de sesión: " + sessionTracking.GetFormattedSessionTime(), Array.Empty<GUILayoutOption>());
GUILayout.Label("Sesión activa: " + (config.IsEnabled ? "Sí" : "No"), Array.Empty<GUILayoutOption>());
GUILayout.Label("Actividad actual: " + sessionTracking.GetCurrentActivity(), Array.Empty<GUILayoutOption>());
List<string> currentActivityDimensions = sessionTracking.GetCurrentActivityDimensions();
GUILayout.Label("Dimensiones afectadas: " + string.Join(", ", currentActivityDimensions), Array.Empty<GUILayoutOption>());
GUILayout.EndVertical();
GUILayout.Space(8f);
GUILayout.BeginVertical(boxStyle, Array.Empty<GUILayoutOption>());
GUILayout.Label("Configuración", GUI.skin.box, Array.Empty<GUILayoutOption>());
bool flag = GUILayout.Toggle(config.IsEnabled, "Activar sistema de bienestar digital", Array.Empty<GUILayoutOption>());
if (flag != config.IsEnabled)
{
config.IsEnabled = flag;
sessionTracking.UpdateConfig(config);
}
GUILayout.Space(4f);
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.Label("Tiempo límite saludable (min):", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) });
if (int.TryParse(GUILayout.TextField(config.MinSessionMinutes.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) }), out var result) && result > 0 && result != config.MinSessionMinutes)
{
config.MinSessionMinutes = result;
sessionTracking.UpdateConfig(config);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.Label("Intervalo de recordatorios (min):", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) });
if (int.TryParse(GUILayout.TextField(config.DiscountIntervalMinutes.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) }), out var result2) && result2 > 0 && result2 != config.DiscountIntervalMinutes)
{
config.DiscountIntervalMinutes = result2;
sessionTracking.UpdateConfig(config);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.Label("Impacto inicial:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) });
if (int.TryParse(GUILayout.TextField(config.BasePointsToDeduct.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) }), out var result3) && result3 >= 0 && result3 != config.BasePointsToDeduct)
{
config.BasePointsToDeduct = result3;
sessionTracking.UpdateConfig(config);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
GUILayout.Label("Impacto adicional:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) });
if (int.TryParse(GUILayout.TextField(config.AdditionalPointsPerInterval.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) }), out var result4) && result4 >= 0 && result4 != config.AdditionalPointsPerInterval)
{
config.AdditionalPointsPerInterval = result4;
sessionTracking.UpdateConfig(config);
}
GUILayout.EndHorizontal();
bool flag2 = GUILayout.Toggle(config.ShowNotifications, "Mostrar notificaciones", Array.Empty<GUILayoutOption>());
if (flag2 != config.ShowNotifications)
{
config.ShowNotifications = flag2;
sessionTracking.UpdateConfig(config);
}
GUILayout.Space(4f);
GUILayout.EndVertical();
GUILayout.Space(8f);
GUILayout.BeginVertical(boxStyle, Array.Empty<GUILayoutOption>());
GUILayout.Label("Áreas de Bienestar Afectadas", GUI.skin.box, Array.Empty<GUILayoutOption>());
string[] array = new string[5] { "Fisico", "Mental", "Afectivo", "Linguistico", "Social" };
foreach (string dimension in array)
{
bool flag3 = config.AffectedDimensions.Any((string d) => string.Equals(d, dimension, StringComparison.OrdinalIgnoreCase));
bool flag4 = GUILayout.Toggle(flag3, dimension, Array.Empty<GUILayoutOption>());
if (flag4 == flag3)
{
continue;
}
if (flag4)
{
if (!config.AffectedDimensions.Any((string d) => string.Equals(d, dimension, StringComparison.OrdinalIgnoreCase)))
{
config.AffectedDimensions.Add(dimension);
Debug.Log((object)("[LifeSync][UI] Dimensión agregada: " + dimension));
}
}
else
{
int num = config.AffectedDimensions.RemoveAll((string d) => string.Equals(d, dimension, StringComparison.OrdinalIgnoreCase));
Debug.Log((object)$"[LifeSync][UI] Dimensión removida: {dimension} ({num} ocurrencias)");
}
sessionTracking.UpdateConfig(config);
}
GUILayout.EndVertical();
GUILayout.Space(8f);
GUILayout.EndScrollView();
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
if (GUILayout.Button("Guardar Configuración", Array.Empty<GUILayoutOption>()))
{
sessionTracking.UpdateConfig(config);
Chat instance = Chat.instance;
if (instance != null)
{
((Terminal)instance).AddString("[LifeSync] Configuración de sesiones guardada.");
}
}
if (GUILayout.Button("Reiniciar Sesión", Array.Empty<GUILayoutOption>()))
{
sessionTracking.StartSession();
Chat instance2 = Chat.instance;
if (instance2 != null)
{
((Terminal)instance2).AddString("[LifeSync] Sesión reiniciada.");
}
}
GUILayout.EndHorizontal();
}
[IteratorStateMachine(typeof(<ResetCursorPosition>d__46))]
private IEnumerator ResetCursorPosition()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ResetCursorPosition>d__46(0);
}
public PointsUI()
{
//IL_0025: 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)
Dictionary<string, SkillType[]> dictionary = new Dictionary<string, SkillType[]>();
SkillType[] array = new SkillType[3];
RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
dictionary.Add("Fisico", (SkillType[])(object)array);
dictionary.Add("Mental", (SkillType[])(object)new SkillType[2]
{
(SkillType)6,
(SkillType)8
});
dictionary.Add("Afectivo", (SkillType[])(object)new SkillType[1] { (SkillType)101 });
dictionary.Add("Linguistico", (SkillType[])(object)new SkillType[1] { (SkillType)2 });
dictionary.Add("Social", (SkillType[])(object)new SkillType[1] { (SkillType)11 });
attributeMap = dictionary;
((MonoBehaviour)this)..ctor();
}
}
}
namespace LifeSync.Valheim.Services
{
public class ApiPointsService : MonoBehaviour
{
[CompilerGenerated]
private sealed class <SavePointsCoroutine>d__3 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public string playerId;
public string attributeId;
public int newPoints;
private UnityWebRequest <request>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SavePointsCoroutine>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<request>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Expected O, but got Unknown
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Expected O, but got Unknown
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Invalid comparison between Unknown and I4
try
{
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
string text = "https://lsg.diinf.usach.cl/post-routes/player_attributes_single";
string text2 = JsonConvert.SerializeObject((object)new
{
id_player = int.Parse(playerId),
id_attributes = int.Parse(attributeId),
new_data = newPoints
});
byte[] bytes = Encoding.UTF8.GetBytes(text2);
Debug.Log((object)"[LifeSync][API] Enviando puntos a la API:");
Debug.Log((object)("[LifeSync][API] URL: " + text));
Debug.Log((object)("[LifeSync][API] Payload: " + text2));
<request>5__2 = new UnityWebRequest(text, "PUT");
<>1__state = -3;
<request>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(bytes);
<request>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
<request>5__2.SetRequestHeader("Content-Type", "application/json");
<>2__current = <request>5__2.SendWebRequest();
<>1__state = 1;
return true;
}
case 1:
<>1__state = -3;
if ((int)<request>5__2.result == 1)
{
Debug.Log((object)("[LifeSync][API] Puntos guardados exitosamente: " + <request>5__2.downloadHandler.text));
}
else
{
Debug.LogError((object)("[LifeSync][API] Error al guardar puntos: " + <request>5__2.error));
Debug.LogError((object)("[LifeSync][API] Response: " + <request>5__2.downloadHandler.text));
}
<>m__Finally1();
<request>5__2 = null;
return false;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<request>5__2 != null)
{
((IDisposable)<request>5__2).Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private const string API_BASE_URL = "https://lsg.diinf.usach.cl/post-routes/";
private const string ENDPOINT = "player_attributes_single";
public void SavePointsToApi(string playerId, string attributeId, int newPoints)
{
((MonoBehaviour)this).StartCoroutine(SavePointsCoroutine(playerId, attributeId, newPoints));
}
[IteratorStateMachine(typeof(<SavePointsCoroutine>d__3))]
private IEnumerator SavePointsCoroutine(string playerId, string attributeId, int newPoints)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SavePointsCoroutine>d__3(0)
{
playerId = playerId,
attributeId = attributeId,
newPoints = newPoints
};
}
public void SaveAllPointsToApi(UserLifeSyncModel user)
{
if (user?.Points == null)
{
return;
}
foreach (PointsLifeSyncModel point in user.Points)
{
if (int.TryParse(point.Data, out var result))
{
SavePointsToApi(user.Id_players, point.Id_attributes, result);
}
}
}
}
public class BuffEffectService : MonoBehaviour
{
private Player player;
private Dictionary<BuffType, float> originalValues = new Dictionary<BuffType, float>();
private Dictionary<BuffType, ActiveBuff> activeEffects = new Dictionary<BuffType, ActiveBuff>();
private int frameCounter;
private const int UPDATE_INTERVAL = 30;
private void Start()
{
player = Player.m_localPlayer;
Debug.Log((object)"[LifeSync][SISTEMA] BuffEffectService inicializado");
}
private void Update()
{
frameCounter++;
if (frameCounter >= 30)
{
frameCounter = 0;
if ((Object)(object)player == (Object)null)
{
player = Player.m_localPlayer;
}
else if (!Game.IsPaused())
{
ReapplyActiveEffects();
MaintainSpeedBoost();
UpdateActiveEffects();
}
}
}
public void ApplyBuffEffects(ActiveBuff buff)
{
if (!((Object)(object)player == (Object)null))
{
if (!originalValues.ContainsKey(buff.Type))
{
StoreOriginalValues(buff.Type);
}
switch (buff.Type)
{
case BuffType.HealthBoost:
ApplyHealthBoost(buff);
break;
case BuffType.StaminaBoost:
ApplyStaminaBoost(buff);
break;
case BuffType.DamageBoost:
ApplyDamageBoost(buff);
break;
case BuffType.SpeedBoost:
ApplySpeedBoost(buff);
break;
case BuffType.DefenseBoost:
ApplyDefenseBoost(buff);
break;
case BuffType.SkillBoost:
ApplySkillBoost(buff);
break;
case BuffType.CarryWeightBoost:
ApplyCarryWeightBoost(buff);
break;
}
activeEffects[buff.Type] = buff;
Debug.Log((object)$"[LifeSync][SISTEMA] Buff {buff.Name} guardado en activeEffects. Total activos: {activeEffects.Count}");
}
}
public void RemoveBuffEffects(ActiveBuff buff)
{
if (!((Object)(object)player == (Object)null))
{
switch (buff.Type)
{
case BuffType.HealthBoost:
RestoreHealthBoost();
break;
case BuffType.StaminaBoost:
RestoreStaminaBoost();
break;
case BuffType.DamageBoost:
RestoreDamageBoost();
break;
case BuffType.SpeedBoost:
RestoreSpeedBoost();
break;
case BuffType.DefenseBoost:
RestoreDefenseBoost();
break;
case BuffType.SkillBoost:
RestoreSkillBoost();
break;
case BuffType.CarryWeightBoost:
RestoreCarryWeightBoost();
break;
}
activeEffects.Remove(buff.Type);
Debug.Log((object)$"[LifeSync][SISTEMA] Buff {buff.Name} removido de activeEffects. Total activos: {activeEffects.Count}");
}
}
private void ReapplyActiveEffects()
{
foreach (KeyValuePair<BuffType, ActiveBuff> activeEffect in activeEffects)
{
if (!activeEffect.Value.IsExpired)
{
switch (activeEffect.Value.Type)
{
case BuffType.HealthBoost:
ReapplyHealthBoost(activeEffect.Value);
break;
case BuffType.StaminaBoost:
ReapplyStaminaBoost(activeEffect.Value);
break;
case BuffType.SpeedBoost:
ReapplySpeedBoost(activeEffect.Value);
break;
}
}
}
}
private void MaintainSpeedBoost()
{
if (!IsBuffActive(BuffType.SpeedBoost))
{
return;
}
ActiveBuff activeBuff = GetActiveBuff(BuffType.SpeedBoost);
if (activeBuff == null || activeBuff.IsExpired)
{
return;
}
float originalValue = GetOriginalValue(BuffType.SpeedBoost);
if (activeBuff.Effects.TryGetValue("speed_multiplier", out var value))
{
float num = originalValue * value;
if (Mathf.Abs(((Character)player).m_runSpeed - num) > 0.01f)
{
((Character)player).m_runSpeed = num;
}
}
}
private void UpdateActiveEffects()
{
List<BuffType> list = new List<BuffType>();
foreach (KeyValuePair<BuffType, ActiveBuff> activeEffect in activeEffects)
{
if (activeEffect.Value.IsExpired)
{
RemoveBuffEffects(activeEffect.Value);
list.Add(activeEffect.Key);
}
}
foreach (BuffType item in list)
{
activeEffects.Remove(item);
}
}
private void StoreOriginalValues(BuffType type)
{
switch (type)
{
case BuffType.HealthBoost:
originalValues[type] = GetBaseHealth();
break;
case BuffType.StaminaBoost:
originalValues[type] = GetBaseStamina();
break;
case BuffType.SpeedBoost:
originalValues[type] = ((Character)player).m_runSpeed;
break;
default:
originalValues[type] = 1f;
break;
}
}
private float GetBaseHealth()
{
if ((Object)(object)player != (Object)null)
{
return player.GetBaseFoodHP();
}
return 25f;
}
private float GetBaseStamina()
{
if ((Object)(object)player != (Object)null)
{
return player.m_baseStamina;
}
return 75f;
}
private void ApplyHealthBoost(ActiveBuff buff)
{
if (buff.Effects.TryGetValue("health_multiplier", out var value))
{
float baseHealth = GetBaseHealth();
float num = 0f;
List<Food> foods = player.GetFoods();
if (foods != null)
{
for (int i = 0; i < foods.Count; i++)
{
num += foods[i].m_health;
}
}
float num2 = baseHealth * value + num;
float health = ((Character)player).GetHealth();
Debug.Log((object)"[LifeSync][VIGOR] Aplicando potenciador de salud:");
Debug.Log((object)$"[LifeSync][VIGOR] - Salud base (sin comida): {baseHealth}");
Debug.Log((object)$"[LifeSync][VIGOR] - Bonus de comida: {num}");
Debug.Log((object)$"[LifeSync][VIGOR] - Multiplicador: {value}x");
Debug.Log((object)$"[LifeSync][VIGOR] - Nuevo máximo calculado: {num2}");
Debug.Log((object)$"[LifeSync][VIGOR] - Salud actual antes: {health}");
player.SetMaxHealth(num2, false);
((Character)player).Heal(num2 - health, true);
Debug.Log((object)$"[LifeSync][VIGOR] - Salud máxima después: {((Character)player).GetMaxHealth()}");
Debug.Log((object)$"[LifeSync][VIGOR] - Salud actual después: {((Character)player).GetHealth()}");
}
else
{
Debug.LogWarning((object)"[LifeSync][VIGOR] No se encontró health_multiplier en los efectos del buff");
}
}
private void RestoreHealthBoost()
{
if (originalValues.TryGetValue(BuffType.HealthBoost, out var value))
{
Debug.Log((object)$"[LifeSync][VIGOR] Restaurando salud a valor original: {value}");
player.SetMaxHealth(value, false);
Debug.Log((object)$"[LifeSync][VIGOR] Salud restaurada - Máximo: {((Character)player).GetMaxHealth()}, Actual: {((Character)player).GetHealth()}");
}
}
private void ApplyStaminaBoost(ActiveBuff buff)
{
if (buff.Effects.TryGetValue("stamina_multiplier", out var value))
{
float baseStamina = GetBaseStamina();
float num = 0f;
List<Food> foods = player.GetFoods();
if (foods != null)
{
for (int i = 0; i < foods.Count; i++)
{
num += foods[i].m_stamina;
}
}
float num2 = baseStamina * value + num;
float stamina = player.GetStamina();
Debug.Log((object)"[LifeSync][RESISTENCIA] Aplicando potenciador de resistencia:");
Debug.Log((object)$"[LifeSync][RESISTENCIA] - Stamina base (sin comida): {baseStamina}");
Debug.Log((object)$"[LifeSync][RESISTENCIA] - Bonus de comida: {num}");
Debug.Log((object)$"[LifeSync][RESISTENCIA] - Multiplicador: {value}x");
Debug.Log((object)$"[LifeSync][RESISTENCIA] - Nuevo máximo calculado: {num2}");
Debug.Log((object)$"[LifeSync][RESISTENCIA] - Stamina actual antes: {stamina}");
player.SetMaxStamina(num2, false);
((Character)player).AddStamina(num2 - stamina);
Debug.Log((object)$"[LifeSync][RESISTENCIA] - Stamina máxima después: {((Character)player).GetMaxStamina()}");
Debug.Log((object)$"[LifeSync][RESISTENCIA] - Stamina actual después: {player.GetStamina()}");
}
else
{
Debug.LogWarning((object)"[LifeSync][RESISTENCIA] No se encontró stamina_multiplier en los efectos del buff");
}
}
private void RestoreStaminaBoost()
{
if (originalValues.TryGetValue(BuffType.StaminaBoost, out var value))
{
Debug.Log((object)$"[LifeSync][RESISTENCIA] Restaurando stamina a valor original: {value}");
player.SetMaxStamina(value, false);
Debug.Log((object)$"[LifeSync][RESISTENCIA] Stamina restaurada - Máximo: {((Character)player).GetMaxStamina()}, Actual: {player.GetStamina()}");
}
}
private void ReapplyHealthBoost(ActiveBuff buff)
{
if (!buff.Effects.TryGetValue("health_multiplier", out var value))
{
return;
}
float baseHealth = GetBaseHealth();
float num = 0f;
List<Food> foods = player.GetFoods();
if (foods != null)
{
for (int i = 0; i < foods.Count; i++)
{
num += foods[i].m_health;
}
}
float num2 = baseHealth * value + num;
float maxHealth = ((Character)player).GetMaxHealth();
if (Mathf.Abs(maxHealth - num2) > 0.1f)
{
Debug.Log((object)$"[LifeSync][VIGOR] Reaplicando salud: {maxHealth:F1} -> {num2:F1}");
player.SetMaxHealth(num2, false);
}
}
private void ReapplyStaminaBoost(ActiveBuff buff)
{
if (!buff.Effects.TryGetValue("stamina_multiplier", out var value))
{
return;
}
float baseStamina = GetBaseStamina();
float num = 0f;
List<Food> foods = player.GetFoods();
if (foods != null)
{
for (int i = 0; i < foods.Count; i++)
{
num += foods[i].m_stamina;
}
}
float num2 = baseStamina * value + num;
float maxStamina = ((Character)player).GetMaxStamina();
if (Mathf.Abs(maxStamina - num2) > 0.1f)
{
Debug.Log((object)$"[LifeSync][RESISTENCIA] Reaplicando stamina: {maxStamina:F1} -> {num2:F1}");
player.SetMaxStamina(num2, false);
}
}
private void ReapplySpeedBoost(ActiveBuff buff)
{
if (buff.Effects.TryGetValue("speed_multiplier", out var value))
{
float num = originalValues[BuffType.SpeedBoost] * value;
float runSpeed = ((Character)player).m_runSpeed;
if (Mathf.Abs(runSpeed - num) > 0.01f)
{
Debug.Log((object)$"[LifeSync][VELOCIDAD] Reaplicando velocidad: {runSpeed:F2} -> {num:F2}");
((Character)player).m_runSpeed = num;
}
}
}
private void ApplySpeedBoost(ActiveBuff buff)
{
if (buff.Effects.TryGetValue("speed_multiplier", out var value))
{
float num = originalValues[BuffType.SpeedBoost];
float num2 = num * value;
Debug.Log((object)"[LifeSync][VELOCIDAD] Aplicando potenciador de velocidad:");
Debug.Log((object)$"[LifeSync][VELOCIDAD] - Velocidad original: {num}");
Debug.Log((object)$"[LifeSync][VELOCIDAD] - Multiplicador: {value}x");
Debug.Log((object)$"[LifeSync][VELOCIDAD] - Nueva velocidad: {num2}");
((Character)player).m_runSpeed = num2;
Debug.Log((object)$"[LifeSync][VELOCIDAD] - Velocidad aplicada: {((Character)player).m_runSpeed}");
}
}
private void RestoreSpeedBoost()
{
if (originalValues.TryGetValue(BuffType.SpeedBoost, out var value))
{
Debug.Log((object)$"[LifeSync][VELOCIDAD] Restaurando velocidad a valor original: {value}");
((Character)player).m_runSpeed = value;
Debug.Log((object)$"[LifeSync][VELOCIDAD] Velocidad restaurada: {((Character)player).m_runSpeed}");
}
}
private void ApplyDamageBoost(ActiveBuff buff)
{
}
private void RestoreDamageBoost()
{
}
private void ApplyDefenseBoost(ActiveBuff buff)
{
}
private void RestoreDefenseBoost()
{
}
private void ApplySkillBoost(ActiveBuff buff)
{
}
private void RestoreSkillBoost()
{
}
private void ApplyCarryWeightBoost(ActiveBuff buff)
{
}
private void RestoreCarryWeightBoost()
{
}
public float GetBuffMultiplier(BuffType type, string effectKey)
{
if (activeEffects.TryGetValue(type, out var value) && value.Effects.TryGetValue(effectKey, out var value2))
{
return value2;
}
return 1f;
}
public bool IsBuffActive(BuffType type)
{
if (activeEffects.ContainsKey(type))
{
return !activeEffects[type].IsExpired;
}
return false;
}
public ActiveBuff GetActiveBuff(BuffType type)
{
if (!activeEffects.ContainsKey(type))
{
return null;
}
return activeEffects[type];
}
public float GetOriginalValue(BuffType type)
{
if (!originalValues.ContainsKey(type))
{
return GetDefaultValue(type);
}
return originalValues[type];
}
private float GetDefaultValue(BuffType type)
{
return type switch
{
BuffType.HealthBoost => 25f,
BuffType.StaminaBoost => 50f,
BuffType.SpeedBoost => 6f,
_ => 1f,
};
}
}
public class BuffService
{
private readonly Func<UserLifeSyncModel> _getUser;
private readonly List<ActiveBuff> _activeBuffs = new List<ActiveBuff>();
private readonly Dictionary<string, BuffModel> _availableBuffs = new Dictionary<string, BuffModel>();
private BuffEffectService _effectService;
private PersistenceService _persistenceService;
public BuffService(Func<UserLifeSyncModel> getUser)
{
_getUser = getUser;
InitializeBuffs();
}
public void InitializeEffectService()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Expected O, but got Unknown
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Expected O, but got Unknown
if ((Object)(object)_effectService == (Object)null)
{
GameObject val = new GameObject("BuffEffectService");
_effectService = val.AddComponent<BuffEffectService>();
Object.DontDestroyOnLoad((Object)(object)val);
}
if ((Object)(object)_persistenceService == (Object)null)
{
GameObject val2 = new GameObject("PersistenceService");
_persistenceService = val2.AddComponent<PersistenceService>();
Object.DontDestroyOnLoad((Object)(object)val2);
LoadSavedBuffs();
}
}
private void InitializeBuffs()
{
_availableBuffs["phys_health"] = new BuffModel
{
Id = "phys_health",
Name = "Vigor Mejorado",
Description = "Aumenta la salud máxima en +20%",
Dimension = "Fisico",
Cost = 2,
Duration = 4f,
Type = BuffType.HealthBoost,
Effects = new Dictionary<string, float> { { "health_multiplier", 1.2f } }
};
_availableBuffs["phys_stamina"] = new BuffModel
{
Id = "phys_stamina",
Name = "Resistencia Superior",
Description = "Aumenta la resistencia máxima en +25%",
Dimension = "Fisico",
Cost = 2,
Duration = 4f,
Type = BuffType.StaminaBoost,
Effects = new Dictionary<string, float> { { "stamina_multiplier", 1.25f } }
};
_availableBuffs["phys_damage"] = new BuffModel
{
Id = "phys_damage",
Name = "Fuerza Bruta",
Description = "Aumenta el daño físico en +15%",
Dimension = "Fisico",
Cost = 2,
Duration = 3f,
Type = BuffType.DamageBoost,
Effects = new Dictionary<string, float> { { "damage_multiplier", 1.15f } }
};
_availableBuffs["cog_skill"] = new BuffModel
{
Id = "cog_skill",
Name = "Aprendizaje Acelerado",
Description = "Aumenta la experiencia ganada en +30%",
Dimension = "Mental",
Cost = 2,
Duration = 5f,
Type = BuffType.SkillBoost,
Effects = new Dictionary<string, float> { { "skill_exp_multiplier", 1.3f } }
};
_availableBuffs["cog_precision"] = new BuffModel
{
Id = "cog_precision",
Name = "Precisión Mental",
Description = "Aumenta el daño a distancia en +20%",
Dimension = "Mental",
Cost = 2,
Duration = 3f,
Type = BuffType.DamageBoost,
Effects = new Dictionary<string, float> { { "ranged_damage_multiplier", 1.2f } }
};
_availableBuffs["aff_luck"] = new BuffModel
{
Id = "aff_luck",
Name = "Fortuna del Corazón",
Description = "Aumenta la suerte en drops en +20%",
Dimension = "Afectivo",
Cost = 2,
Duration = 5f,
Type = BuffType.LuckBoost,
Effects = new Dictionary<string, float> { { "luck_multiplier", 1.2f } }
};
_availableBuffs["aff_stealth"] = new BuffModel
{
Id = "aff_stealth",
Name = "Sigilo Emocional",
Description = "Mejora la capacidad de sigilo en +25%",
Dimension = "Afectivo",
Cost = 2,
Duration = 4f,
Type = BuffType.SpeedBoost,
Effects = new Dictionary<string, float> { { "stealth_multiplier", 1.25f } }
};
_availableBuffs["ling_speed"] = new BuffModel
{
Id = "ling_speed",
Name = "Agilidad Verbal",
Description = "Aumenta la velocidad de movimiento en +15%",
Dimension = "Linguistico",
Cost = 2,
Duration = 4f,
Type = BuffType.SpeedBoost,
Effects = new Dictionary<string, float> { { "speed_multiplier", 1.15f } }
};
_availableBuffs["ling_carry"] = new BuffModel
{
Id = "ling_carry",
Name = "Carga Lingüística",
Description = "Aumenta la capacidad de carga en +30%",
Dimension = "Linguistico",
Cost = 2,
Duration = 5f,
Type = BuffType.CarryWeightBoost,
Effects = new Dictionary<string, float> { { "carry_weight_multiplier", 1.3f } }
};
_availableBuffs["soc_defense"] = new BuffModel
{
Id = "soc_defense",
Name = "Protección Grupal",
Description = "Aumenta la defensa en +25%",
Dimension = "Social",
Cost = 2,
Duration = 4f,
Type = BuffType.DefenseBoost,
Effects = new Dictionary<string, float> { { "defense_multiplier", 1.25f } }
};
_availableBuffs["soc_leadership"] = new BuffModel
{
Id = "soc_leadership",
Name = "Liderazgo Inspirador",
Description = "Mejora todas las estadísticas en +10%",
Dimension = "Social",
Cost = 2,
Duration = 3f,
Type = BuffType.HealthBoost,
Effects = new Dictionary<string, float>
{
{ "health_multiplier", 1.1f },
{ "stamina_multiplier", 1.1f },
{ "damage_multiplier", 1.1f }
}
};
}
public List<BuffModel> GetBuffsForDimension(string dimension)
{
return _availableBuffs.Values.Where((BuffModel buff) => string.Equals(buff.Dimension, dimension, StringComparison.OrdinalIgnoreCase)).ToList();
}
public List<BuffModel> GetAllBuffs()
{
return _availableBuffs.Values.ToList();
}
public List<ActiveBuff> GetActiveBuffs()
{
return _activeBuffs.Where((ActiveBuff buff) => !buff.IsExpired).ToList();
}
public bool TryActivateBuff(string buffId, PointsService pointsService)
{
if (!_availableBuffs.TryGetValue(buffId, out var value))
{
return false;
}
ActiveBuff activeBuff = _activeBuffs.FirstOrDefault((ActiveBuff ab) => !ab.IsExpired);
if (activeBuff != null)
{
Chat instance = Chat.instance;
if (instance != null)
{
((Terminal)instance).AddString("[LifeSync] Ya tienes un potenciador activo: " + activeBuff.Name + ". Desactívalo primero.");
}
return false;
}
if (!pointsService.SpendFrom(value.Dimension, value.Cost))
{
Chat instance2 = Chat.instance;
if (instance2 != null)
{
((Terminal)instance2).AddString("[LifeSync] No tienes suficientes puntos de " + value.Dimension + ".");
}
return false;
}
ActiveBuff activeBuff2 = new ActiveBuff
{
BuffId = value.Id,
Name = value.Name,
StartTime = Time.time,
Duration = value.Duration * 60f,
Type = value.Type,
Effects = new Dictionary<string, float>(value.Effects)
};
_activeBuffs.Add(activeBuff2);
ApplyBuffEffects(activeBuff2);
SaveActiveBuffs();
Chat instance3 = Chat.instance;
if (instance3 != null)
{
((Terminal)instance3).AddString($"[LifeSync] ¡{value.Name} activado! Duración: {value.Duration} minutos.");
}
Debug.Log((object)string.Format("[LifeSync] Potenciador activado: {0} (ID: {1}) - Duración: {2} minutos - Efectos: {3}", value.Name, value.Id, value.Duration, string.Join(", ", value.Effects.Select((KeyValuePair<string, float> e) => $"{e.Key}={e.Value}"))));
return true;
}
private void ApplyBuffEffects(ActiveBuff buff)
{
if (!((Object)(object)Player.m_localPlayer == (Object)null))
{
InitializeEffectService();
_effectService?.ApplyBuffEffects(buff);
Debug.Log((object)("[LifeSync] Aplicando efectos de " + buff.Name + ": " + string.Join(", ", buff.Effects.Select((KeyValuePair<string, float> e) => $"{e.Key}={e.Value}"))));
}
}
public void UpdateActiveBuffs()
{
List<ActiveBuff> list = _activeBuffs.Where((ActiveBuff buff) => buff.IsExpired).ToList();
if (list.Count <= 0)
{
return;
}
foreach (ActiveBuff item in list)
{
RemoveBuffEffects(item);
_activeBuffs.Remove(item);
Chat instance = Chat.instance;
if (instance != null)
{
((Terminal)instance).AddString("[LifeSync] " + item.Name + " ha expirado.");
}
}
SaveActiveBuffs();
}
private void RemoveBuffEffects(ActiveBuff buff)
{
_effectService?.RemoveBuffEffects(buff);
}
public float GetBuffRemainingTime(BuffType type)
{
return _activeBuffs.FirstOrDefault((ActiveBuff ab) => ab.Type == type && !ab.IsExpired)?.RemainingTime ?? 0f;
}
public bool IsBuffActive(BuffType type)
{
return _activeBuffs.Any((ActiveBuff ab) => ab.Type == type && !ab.IsExpired);
}
public bool DeactivateCurrentBuff()
{
ActiveBuff activeBuff = _activeBuffs.FirstOrDefault((ActiveBuff ab) => !ab.IsExpired);
if (activeBuff == null)
{
Chat instance = Chat.instance;
if (instance != null)
{
((Terminal)instance).AddString("[LifeSync] No tienes ningún potenciador activo.");
}
return false;
}
RemoveBuffEffects(activeBuff);
_activeBuffs.Remove(activeBuff);
SaveActiveBuffs();
Chat instance2 = Chat.instance;
if (instance2 != null)
{
((Terminal)instance2).AddString("[LifeSync] " + activeBuff.Name + " desactivado.");
}
return true;
}
public ActiveBuff GetCurrentActiveBuff()
{
return _activeBuffs.FirstOrDefault((ActiveBuff ab) => !ab.IsExpired);
}
public void LogActiveBuffsStatus()
{
List<ActiveBuff> activeBuffs = GetActiveBuffs();
if (activeBuffs.Count == 0)
{
Debug.Log((object)"[LifeSync][ESTADO] No hay potenciadores activos");
return;
}
Debug.Log((object)$"[LifeSync][ESTADO] Potenciadores activos ({activeBuffs.Count}):");
foreach (ActiveBuff item in activeBuffs)
{
float num = item.RemainingTime / 60f;
Debug.Log((object)$"[LifeSync][ESTADO] - {item.Name}: {num:F1} minutos restantes");
Debug.Log((object)("[LifeSync][ESTADO] Efectos: " + string.Join(", ", item.Effects.Select((KeyValuePair<string, float> e) => $"{e.Key}={e.Value}"))));
}
}
public void DebugBuffStatus(BuffType buffType)
{
ActiveBuff activeBuff = _activeBuffs.FirstOrDefault((ActiveBuff ab) => ab.Type == buffType && !ab.IsExpired);
if (activeBuff != null)
{
Debug.Log((object)$"[LifeSync][DEBUG] Buff {buffType} está ACTIVO:");
Debug.Log((object)("[LifeSync][DEBUG] - Nombre: " + activeBuff.Name));
Debug.Log((object)$"[LifeSync][DEBUG] - Tiempo restante: {activeBuff.RemainingTime:F1} segundos");
Debug.Log((object)("[LifeSync][DEBUG] - Efectos: " + string.Join(", ", activeBuff.Effects.Select((KeyValuePair<string, float> e) => $"{e.Key}={e.Value}"))));
}
else
{
Debug.Log((object)$"[LifeSync][DEBUG] Buff {buffType} NO está activo");
}
}
public void DebugCarryWeightBuff()
{
Debug.Log((object)"[LifeSync][DEBUG] === ESTADO DEL BUFF DE CAPACIDAD DE CARGA ===");
BuffModel buffModel = _availableBuffs.Values.FirstOrDefault((BuffModel b) => b.Type == BuffType.CarryWeightBoost);
if (buffModel != null)
{
Debug.Log((object)("[LifeSync][DEBUG] - Buff disponible: " + buffModel.Name));
Debug.Log((object)("[LifeSync][DEBUG] - ID: " + buffModel.Id));
Debug.Log((object)("[LifeSync][DEBUG] - Dimensión: " + buffModel.Dimension));
Debug.Log((object)$"[LifeSync][DEBUG] - Costo: {buffModel.Cost} puntos");
Debug.Log((object)$"[LifeSync][DEBUG] - Duración: {buffModel.Duration} minutos");
Debug.Log((object)("[LifeSync][DEBUG] - Efectos: " + string.Join(", ", buffModel.Effects.Select((KeyValuePair<string, float> e) => $"{e.Key}={e.Value}"))));
}
else
{
Debug.Log((object)"[LifeSync][DEBUG] - Buff de capacidad de carga NO encontrado en buffs disponibles");
}
ActiveBuff activeBuff = _activeBuffs.FirstOrDefault((ActiveBuff ab) => ab.Type == BuffType.CarryWeightBoost && !ab.IsExpired);
if (activeBuff != null)
{
Debug.Log((object)("[LifeSync][DEBUG] - Buff ACTIVO: " + activeBuff.Name));
Debug.Log((object)$"[LifeSync][DEBUG] - Tiempo restante: {activeBuff.RemainingTime:F1} segundos");
Debug.Log((object)("[LifeSync][DEBUG] - Efectos activos: " + string.Join(", ", activeBuff.Effects.Select((KeyValuePair<string, float> e) => $"{e.Key}={e.Value}"))));
}
else
{
Debug.Log((object)"[LifeSync][DEBUG] - Buff de capacidad de carga NO está activo");
}
}
private void LoadSavedBuffs()
{
if ((Object)(object)_persistenceService == (Object)null)
{
return;
}
try
{
List<ActiveBuff> list = _persistenceService.LoadActiveBuffs();
foreach (ActiveBuff item in list)
{
_activeBuffs.Add(item);
if ((Object)(object)_effectService != (Object)null)
{
_effectService.ApplyBuffEffects(item);
}
}
if (list.Count > 0)
{
Debug.Log((object)$"[LifeSync][PERSISTENCIA] Se restauraron {list.Count} potenciadores activos");
}
}
catch (Exception ex)
{
Debug.LogError((object)("[LifeSync][PERSISTENCIA] Error al cargar buffs guardados: " + ex.Message));
}
}
public void SaveActiveBuffs()
{
if ((Object)(object)_persistenceService == (Object)null)
{
return;
}
try
{
_persistenceService.SaveActiveBuffs(_activeBuffs);
Debug.Log((object)$"[LifeSync][PERSISTENCIA] Buffs activos guardados: {_activeBuffs.Count}");
}
catch (Exception ex)
{
Debug.LogError((object)("[LifeSync][PERSISTENCIA] Error al guardar buffs: " + ex.Message));
}
}
public void ClearSaveData()
{
if ((Object)(object)_persistenceService == (Object)null)
{
return;
}
try
{
_persistenceService.ClearSaveData();
Debug.Log((object)"[LifeSync][PERSISTENCIA] Datos de guardado eliminados");
}
catch (Exception ex)
{
Debug.LogError((object)("[LifeSync][PERSISTENCIA] Error al limpiar datos: " + ex.Message));
}
}
}
public class PersistenceService : MonoBehaviour
{
private const string SAVE_FILE_NAME = "lifesync_save.json";
private string SaveFilePath => Path.Combine(Application.persistentDataPath, "lifesync_save.json");
public void SaveActiveBuffs(List<ActiveBuff> activeBuffs)
{
try
{
LifeSyncSaveData lifeSyncSaveData = new LifeSyncSaveData();
foreach (ActiveBuff activeBuff in activeBuffs)
{
if (!activeBuff.IsExpired)
{
lifeSyncSaveData.ActiveBuffs.Add(PersistentBuffData.FromActiveBuff(activeBuff));
}
}
string contents = JsonConvert.SerializeObject((object)lifeSyncSaveData, (Formatting)1);
File.WriteAllText(SaveFilePath, contents);
Debug.Log((object)$"[LifeSync][PERSISTENCIA] Guardados {lifeSyncSaveData.ActiveBuffs.Count} potenciadores activos");
Debug.Log((object)("[LifeSync][PERSISTENCIA] Archivo guardado en: " + SaveFilePath));
}
catch (Exception ex)
{
Debug.LogError((object)("[LifeSync][PERSISTENCIA] Error al guardar: " + ex.Message));
}
}
public List<ActiveBuff> LoadActiveBuffs()
{
try
{
if (!File.Exists(SaveFilePath))
{
Debug.Log((object)"[LifeSync][PERSISTENCIA] No hay archivo de guardado existente");
return new List<ActiveBuff>();
}
LifeSyncSaveData lifeSyncSaveData = JsonConvert.DeserializeObject<LifeSyncSaveData>(File.ReadAllText(SaveFilePath));
if (lifeSyncSaveData?.ActiveBuffs == null)
{
Debug.Log((object)"[LifeSync][PERSISTENCIA] Datos de guardado inválidos");
return new List<ActiveBuff>();
}
List<ActiveBuff> list = new List<ActiveBuff>();
foreach (PersistentBuffData activeBuff2 in lifeSyncSaveData.ActiveBuffs)
{
ActiveBuff activeBuff = activeBuff2.ToActiveBuff();
float num = activeBuff2.Duration - activeBuff2.StartTime;
if (num > 0f)
{
activeBuff.StartTime = Time.time;
activeBuff.Duration = num;
list.Add(activeBuff);
Debug.Log((object)$"[LifeSync][PERSISTENCIA] Restaurado buff: {activeBuff.Name} (tiempo restante: {activeBuff.RemainingTime:F1}s)");
}
else
{
Debug.Log((object)("[LifeSync][PERSISTENCIA] Buff expirado durante la carga: " + activeBuff.Name));
}
}
Debug.Log((object)$"[LifeSync][PERSISTENCIA] Cargados {list.Count} potenciadores activos de {lifeSyncSaveData.ActiveBuffs.Count} guardados");
return list;
}
catch (Exception ex)
{
Debug.LogError((object)("[LifeSync][PERSISTENCIA] Error al cargar: " + ex.Message));
return new List<ActiveBuff>();
}
}
public void ClearSaveData()
{
try
{
if (File.Exists(SaveFilePath))
{
File.Delete(SaveFilePath);
Debug.Log((object)"[LifeSync][PERSISTENCIA] Archivo de guardado eliminado");
}
}
catch (Exception ex)
{
Debug.LogError((object)("[LifeSync][PERSISTENCIA] Error al eliminar archivo: " + ex.Message));
}
}
public bool HasSaveData()
{
return File.Exists(SaveFilePath);
}
}
public class PointsService
{
private readonly Func<UserLifeSyncModel> _getUser;
private ApiPointsService _apiService;
private static readonly BindingFlags BF = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
public PointsService(Func<UserLifeSyncModel> getUser)
{
_getUser = getUser;
}
public void InitializeApiService()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Expected O, but got Unknown
if ((Object)(object)_apiService == (Object)null)
{
GameObject val = new GameObject("ApiPointsService");
_apiService = val.AddComponent<ApiPointsService>();
Object.DontDestroyOnLoad((Object)(object)val);
}
}
public PointsLifeSyncModel[] GetAttributes()
{
return _getUser()?.Points?.ToArray() ?? Array.Empty<PointsLifeSyncModel>();
}
private static bool TryGetLevelAndAccumulator(Skills skills, SkillType type, out float level, out float acc)
{
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
level = 0f;
acc = 0f;
FieldInfo field = typeof(Skills).GetField("m_skills", BF);
IEnumerable enumerable = ((field != null) ? (field.GetValue(skills) as IEnumerable) : null);
if (enumerable == null)
{
return false;
}
foreach (object item in enumerable)
{
FieldInfo field2 = item.GetType().GetField("m_info", BF);
object obj = ((field2 != null) ? field2.GetValue(item) : null);
if (obj == null)
{
continue;
}
FieldInfo field3 = obj.GetType().GetField("m_skill", BF);
if (!(field3 == null) && (SkillType)field3.GetValue(obj) == type)
{
FieldInfo field4 = item.GetType().GetField("m_level", BF);
FieldInfo field5 = item.GetType().GetField("m_accumulator", BF);
if (field4 == null || field5 == null)
{
return false;
}
level = (float)field4.GetValue(item);
acc = Mathf.Clamp01((float)field5.GetValue(item));
return true;
}
}
return false;
}
public int GetPoints(string attrName)
{
PointsLifeSyncModel pointsLifeSyncModel = _getUser()?.Points?.FirstOrDefault((PointsLifeSyncModel x) => string.Equals(x.Name, attrName, StringComparison.OrdinalIgnoreCase));
if (pointsLifeSyncModel == null || !int.TryParse(pointsLifeSyncModel.Data, out var result))
{
return 0;
}
return result;
}
public bool SpendFrom(string attrName, int cost)
{
UserLifeSyncModel userLifeSyncModel = _getUser();
if (userLifeSyncModel == null)
{
return false;
}
PointsLifeSyncModel pointsLifeSyncModel = userLifeSyncModel.Points?.FirstOrDefault((PointsLifeSyncModel x) => string.Equals(x.Name, attrName, StringComparison.OrdinalIgnoreCase));
if (pointsLifeSyncModel == null)
{
return false;
}
if (!int.TryParse(pointsLifeSyncModel.Data, out var result) || result < cost)
{
return false;
}
int newPoints = result - cost;
pointsLifeSyncModel.Data = newPoints.ToString();
SavePointsToApi(userLifeSyncModel.Id_players, pointsLifeSyncModel.Id_attributes, newPoints);
return true;
}
private void SavePointsToApi(string playerId, string attributeId, int newPoints)
{
InitializeApiService();
_apiService?.SavePointsToApi(playerId, attributeId, newPoints);
}
public bool TryUpgradeFrom(string attrName, SkillType type, int cost, float gain, out float progressDelta)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
progressDelta = 0f;
Player localPlayer = Player.m_localPlayer;
if ((Object)(object)localPlayer == (Object)null)
{
return false;
}
Skills skills = ((Character)localPlayer).GetSkills();
if ((Object)(object)skills == (Object)null)
{
return false;
}
int num = Mathf.FloorToInt(skills.GetSkillLevel(type));
int num2 = CalculateDynamicCost(num);
if (!SpendFrom(attrName, num2))
{
Chat instance = Chat.instance;
if (instance != null)
{
((Terminal)instance).AddString($"[LifeSync] Necesitas {num2} puntos de {attrName} para subir de nivel {num}.");
}
return false;
}
float num3 = Mathf.Max(0f, Main.LevelsPerPoint.Value);
if (num3 <= 0f)
{
return false;
}
if (!TryGetLevelAndAccumulator(skills, type, out var level, out var acc))
{
level = skills.GetSkillLevel(type);
acc = 0f;
}
int num4 = Mathf.FloorToInt(level);
int num5 = 0;
float num6 = level + num3;
float num7 = Mathf.Max(0.01f, num3 / 50f);
float num8 = level;
while (num8 + 0.0001f < num6 && num5 < 4096)
{
skills.RaiseSkill(type, num7);
num8 = skills.GetSkillLevel(type);
num5++;
}
if (!TryGetLevelAndAccumulator(skills, type, out var level2, out var acc2))
{
level2 = num8;
acc2 = 0f;
}
if (Mathf.FloorToInt(level2) > num4)
{
progressDelta = 1f - acc + acc2;
}
else
{
progressDelta = Mathf.Max(0f, acc2 - acc);
}
Chat instance2 = Chat.instance;
if (instance2 != null)
{
((Terminal)instance2).AddString($"[LifeSync] {attrName}: {type} +{num3:0.##} lvl (~{progressDelta:P0}) - Costo: {num2} puntos");
}
return true;
}
private int CalculateDynamicCost(int currentLevel)
{
if (currentLevel <= 10)
{
return 1;
}
if (currentLevel <= 25)
{
return 2;
}
if (currentLevel <= 50)
{
return 3;
}
return 4;
}
}
public class SessionTrackingService : MonoBehaviour
{
private SessionConfigModel config;
private PointsService pointsService;
private float sessionStartTime;
private float lastUpdateTime;
private bool isSessionActive;
private string configPath;
private void Start()
{
Debug.Log((object)"[LifeSync][SESIONES] Iniciando SessionTrackingService...");
configPath = Path.Combine(Application.persistentDataPath, "LifeSync", "session_config.json");
LoadConfig();
pointsService = Main.Points;
if (pointsService == null)
{
Debug.LogError((object)"[LifeSync][SESIONES] PointsService no encontrado");
return;
}
Debug.Log((object)"[LifeSync][SESIONES] PointsService encontrado correctamente");
StartSession();
Debug.Log((object)"[LifeSync][SESIONES] SessionTrackingServi
