////////
private void ReceiveBaseRequestOnClient()
{
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
if (mymod.Config.DebugModeNetInfo && this.IsVerbose)
{
Type mytype = this.GetType();
string name = mytype.Namespace + "." + mytype.Name;
LogHelpers.Log("<" + name + " ReceiveBaseRequestOnClient...");
}
#pragma warning disable 612, 618
this.SetDefaults();
#pragma warning restore 612, 618
this.SetClientDefaults();
bool skip_send = false;
var method_info = this.GetType().GetMethod("ReceiveRequestOnClient");
if (method_info != null && method_info.DeclaringType != method_info.GetBaseDefinition().DeclaringType)
{
#pragma warning disable 612, 618
skip_send = this.ReceiveRequestOnClient();
#pragma warning restore 612, 618
}
else
{
skip_send = this.ReceiveRequestWithClient();
}
if (!skip_send)
{
this.SendToServer(false);
}
}
internal void Save(HamstarHelpersMod mymod, TagCompound tags)
{
var modworld = mymod.GetModWorld <HamstarHelpersWorld>();
tags.Set("world_mod_lock_count", this.WorldModLocks.Count);
int i = 0;
foreach (var kv in this.WorldModLocks)
{
string world_uid = kv.Key;
ISet <string> mod_names = kv.Value;
tags.Set("world_mod_lock_uid_" + i, world_uid);
tags.Set("world_mod_lock_mods_" + i + "_count", mod_names.Count);
int j = 0;
foreach (string mod_name in mod_names)
{
//LogHelpers.Log( "Save world_mod_lock_mods_" + i + "_" + j +": "+mod_name );
tags.Set("world_mod_lock_mods_" + i + "_" + j, mod_name);
j++;
}
i++;
}
}
internal void OnWorldLoad(HamstarHelpersMod mymod, HamstarHelpersWorld modworld)
{
this.IsInitialized = true;
this.MismatchBroadcastMade = false;
this.ScanMods(modworld);
this.ExitDuration = 60 * 20;
}
////////////////
internal void Update(HamstarHelpersMod mymod)
{
if (!LoadHelpers.IsWorldSafelyBeingPlayed())
{
this.IsDay = Main.dayTime;
}
else
{
if (this.IsDay != Main.dayTime)
{
this.HalfDaysElapsed++;
if (!this.IsDay)
{
foreach (var kv in mymod.WorldHelpers.DayHooks)
{
kv.Value();
}
}
else
{
foreach (var kv in mymod.WorldHelpers.NightHooks)
{
kv.Value();
}
}
}
this.IsDay = Main.dayTime;
}
this.TicksElapsed++;
}
////////////////
public void RefreshModLockButton(HamstarHelpersMod mymod)
{
bool are_mods_locked = ModLockHelpers.IsWorldLocked();
string status = are_mods_locked ? ": ON" : ": OFF";
bool is_enabled = true;
if (!mymod.Config.WorldModLockEnable)
{
status += " (disabled)";
is_enabled = false;
}
else if (Main.netMode != 0)
{
status += " (single-player only)";
is_enabled = false;
}
if (!is_enabled)
{
if (this.ModLockButton.IsEnabled)
{
this.ModLockButton.Disable();
}
}
else
{
if (!this.ModLockButton.IsEnabled)
{
this.ModLockButton.Enable();
}
}
this.ModLockButton.SetText(UIControlPanel.ModLockTitle + status);
}
////
private void PreUpdatePlayer(HamstarHelpersMod mymod)
{
this.PreUpdate(mymod);
mymod.AnimatedColors.Update();
UIControlPanel.UpdateModList(mymod);
}
////////////////
internal void LoadFromData(HamstarHelpersMod mymod, int half_days, string world_id)
{
var myworld = mymod.GetModWorld <HamstarHelpersWorld>();
this.HalfDaysElapsed = half_days;
myworld.ObsoleteID = world_id;
}
////////////////
public static void OnPostSetupContent(HamstarHelpersMod mymod)
{
if (!Main.dedServ)
{
UIControlPanel.ControlPanelIcon = mymod.GetTexture("Internals/ControlPanel/ControlPanelIcon");
UIControlPanel.ControlPanelIconLit = mymod.GetTexture("Internals/ControlPanel/ControlPanelIconLit");
}
}
////////////////
private void UpdateSafelyLoaded(HamstarHelpersMod mymod)
{
mymod.ModLockHelpers.Update();
#pragma warning disable 612, 618
AltProjectileInfo.UpdateAll();
AltNPCInfo.UpdateAll();
#pragma warning restore 612, 618
}
////////////////
internal void Load(HamstarHelpersMod mymod, TagCompound tags)
{
var myworld = mymod.GetModWorld <HamstarHelpersWorld>();
if (tags.ContainsKey("world_id"))
{
this.HalfDaysElapsed = tags.GetInt("half_days_elapsed_" + myworld.ObsoleteID);
}
}
////////////////
public void ApplyConfigChanges(HamstarHelpersMod mymod)
{
ConfigsRefreshCommand.RefreshConfigs();
string mod_names = string.Join(", ", mymod.ModMetaDataManager.ConfigMods.Keys.ToArray());
string output = "Mod configs reloaded for " + mod_names;
Main.NewText(output, Color.Yellow);
ErrorLogger.Log(output);
}
////////////////
private static void _Draw(GameTime game_time) // <- Just in case references are doing something funky...
{
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
if (mymod == null)
{
return;
}
mymod.MenuItemMngr.Draw(game_time);
}
////////////////
private static void _Update() // <- Just in case references are doing something funky...
{
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
if (mymod == null)
{
return;
}
mymod.Promises.Update();
}
////////////////
private static void _RunTimers() // <- Just in case references are doing something funky...
{
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
if (mymod == null)
{
return;
}
mymod.Timers.RunTimers();
}
////////////////
public void OnEnterWorldSingle(HamstarHelpersMod mymod, Player player)
{
if (!mymod.ConfigJson.LoadFile())
{
mymod.ConfigJson.SaveFile();
}
this.FinishModSettingsSync();
this.FinishWorldDataSync();
mymod.ControlPanel.LoadModListAsync();
}
private void ToggleModLock(HamstarHelpersMod mymod)
{
if (!ModLockHelpers.IsWorldLocked())
{
ModLockHelpers.LockWorld();
}
else
{
ModLockHelpers.UnlockWorld();
}
this.RefreshModLockButton(mymod);
}
public void OnEnterWorldClient(HamstarHelpersMod mymod, Player player)
{
if (this.HasUID)
{
PacketProtocol.QuickSendToServer <PlayerIdProtocol>();
}
PlayerDataProtocol.SyncToEveryone(this.PermaBuffsById, this.HasBuffIds, this.EquipSlotsToItemTypes);
PacketProtocol.QuickRequestToServer <ModSettingsProtocol>();
PacketProtocol.QuickRequestToServer <WorldDataProtocol>();
mymod.ControlPanel.LoadModListAsync();
}
public void PreUpdateServer(HamstarHelpersMod mymod, Player player)
{
if (player.whoAmI == Main.myPlayer) // Current player
{
var modworld = mymod.GetModWorld <HamstarHelpersWorld>();
mymod.LoadHelpers.HasServerBegunHavingPlayers = true;
}
foreach (int buff_id in this.PermaBuffsById)
{
player.AddBuff(buff_id, 3);
}
this.UpdateTml(mymod, player);
}
////////////////
private static void _Update(GameTime gametime) // <- Just in case references are doing something funky...
{
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
if (mymod == null)
{
return;
}
if (mymod.MenuUIMngr == null)
{
return;
}
mymod.MenuUIMngr.Update();
}
public static void Log(string msg)
{
try {
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
var log_helpers = mymod.LogHelpers;
double now_seconds = DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds - log_helpers.StartTime;
string now_seconds_whole = ((int)now_seconds).ToString("D6");
string now_seconds_decimal = (now_seconds - (int)now_seconds).ToString("N2");
string now = now_seconds_whole + "." + (now_seconds_decimal.Length > 2 ? now_seconds_decimal.Substring(2) : now_seconds_decimal);
string logged = Main.netMode + ":" + Main.myPlayer.ToString("D3") + ":" + log_helpers.LoggedMessages.ToString("D5") + " - " + now;
if (logged.Length < 26)
{
logged += new String(' ', 26 - logged.Length);
}
else
{
logged += " ";
}
if (mymod.Config.UseCustomLogging)
{
log_helpers.OutputDirect(log_helpers.GetHourlyLogFileName(), logged + msg);
if (mymod.Config.UseCustomLoggingPerNetMode)
{
log_helpers.OutputDirect(log_helpers.GetModalLogFileName(), logged + msg);
}
if (mymod.Config.UseAlsoNormalLogging)
{
ErrorLogger.Log(logged + msg);
}
}
else
{
ErrorLogger.Log(logged + msg);
}
log_helpers.LoggedMessages++;
} catch (Exception e) {
try {
ErrorLogger.Log("FALLBACK LOGGER 2 (" + e.GetType().Name + ") " + msg);
} catch { }
}
}
public void PreUpdateClient(HamstarHelpersMod mymod, Player player)
{
this.PreUpdatePlayer(mymod, player);
if (player.whoAmI == Main.myPlayer) // Current player
{
var myworld = mymod.GetModWorld <HamstarHelpersWorld>();
myworld.WorldLogic.PreUpdateClient(mymod);
}
// Update ping every 15 seconds
if (mymod.Config.IsServerGaugingAveragePing && this.TestPing++ > (60 * 15))
{
PacketProtocol.QuickSendToServer <PingProtocol>();
this.TestPing = 0;
}
}
////////////////
public override void Action(CommandCaller caller, string input, string[] args)
{
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
if (!mymod.Config.ModCallCommandEnabled)
{
throw new UsageException("Mod.Call() command disabled by settings.");
}
if (args.Length < 2)
{
if (args.Length == 0)
{
throw new UsageException("No arguments given.");
}
else
{
throw new UsageException("More arguments needed.");
}
}
Mod callmod = null;
try {
callmod = ModLoader.GetMod(args[0]);
if (callmod == null)
{
throw new Exception();
}
} catch (Exception) {
throw new UsageException("Invald mod name " + args[0]);
}
try {
object[] call_args = new object[args.Length - 1];
for (int i = 1; i < args.Length; i++)
{
call_args[i - 1] = DotNetHelpers.DotNetHelpers.ParseToInferredPrimitiveType(args[i]);
}
callmod.Call(call_args);
} catch (Exception e) {
caller.Reply(e.Message, Color.Red);
}
}
////////////////
public void UpdateElements(HamstarHelpersMod mymod)
{
if (!mymod.Config.WorldModLockEnable)
{
if (this.ModLockButton.IsEnabled)
{
this.RefreshModLockButton(mymod);
}
}
else
{
if (!this.ModLockButton.IsEnabled)
{
this.RefreshModLockButton(mymod);
}
}
}
////////////////
public static void UpdateModList(HamstarHelpersMod mymod)
{
var ctrl_panel = mymod.ControlPanel;
if (ctrl_panel == null || !ctrl_panel.ModListUpdateRequired || !ctrl_panel.IsOpen)
{
return;
}
ctrl_panel.ModListUpdateRequired = false;
lock (UIControlPanel.ModDataListLock) {
try {
ctrl_panel.ModListElem.Clear();
ctrl_panel.ModListElem.AddRange(ctrl_panel.ModDataList.ToArray());
} catch (Exception) { }
}
}
private void PreUpdatePlayer(HamstarHelpersMod mymod, Player player)
{
if (player.whoAmI == Main.myPlayer) // Current player
{
var modworld = mymod.GetModWorld <HamstarHelpersWorld>();
SimpleMessage.UpdateMessage();
mymod.PlayerMessages.Update();
this.DialogManager.Update(mymod);
this.OldDialogManager.Update(mymod);
}
foreach (int buff_id in this.PermaBuffsById)
{
player.AddBuff(buff_id, 3);
}
this.UpdateTml(mymod, player);
}
private void PreUpdate(HamstarHelpersMod mymod)
{
if (LoadHelpers.IsWorldLoaded())
{
mymod.Promises.FulfillWorldLoadPromises();
}
if (LoadHelpers.IsWorldBeingPlayed())
{
mymod.LoadHelpers.PostWorldLoadUpdate();
mymod.WorldHelpers.Update(mymod);
// Simply idle until ready (seems needed)
if (LoadHelpers.IsWorldSafelyBeingPlayed())
{
this.UpdateSafelyLoaded(mymod);
}
}
}
private void ReceiveBaseEither(BinaryReader reader, int from_who)
{
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
Type mytype = this.GetType();
try {
this.ReadStream(reader);
} catch (Exception e) {
LogHelpers.Log("Stream read error - " + e.ToString());
return;
}
if (mymod.Config.DebugModeNetInfo && this.IsVerbose)
{
string name = mytype.Namespace + "." + mytype.Name;
string json_str = JsonConvert.SerializeObject(this);
LogHelpers.Log("<" + name + " ReceiveBaseEither: " + json_str);
}
foreach (FieldInfo my_field in mytype.GetFields())
{
FieldInfo your_field = mytype.GetField(my_field.Name);
if (your_field == null)
{
string name = mytype.Namespace + "." + mytype.Name;
LogHelpers.Log("Missing " + name + " protocol field for " + my_field.Name);
return;
}
object val = your_field.GetValue(this);
if (val == null)
{
string name = mytype.Namespace + "." + mytype.Name;
LogHelpers.Log("Missing " + name + " protocol value for " + your_field.Name);
return;
}
my_field.SetValue(this, val);
}
}
private void ReceiveBaseRequestOnServer(int from_who)
{
HamstarHelpersMod mymod = HamstarHelpersMod.Instance;
if (mymod.Config.DebugModeNetInfo && this.IsVerbose)
{
Type mytype = this.GetType();
string name = mytype.Namespace + "." + mytype.Name;
LogHelpers.Log("<" + name + " ReceiveBaseRequestOnServer...");
}
this.SetServerDefaults();
bool skip_send = false;
var method_info = this.GetType().GetMethod("ReceiveRequestOnServer");
skip_send = this.ReceiveRequestWithServer(from_who);
if (!skip_send)
{
this.SendToClient(from_who, -1);
}
}
////////////////
internal void Update(HamstarHelpersMod mymod)
{
if (this.CurrentDialog == null)
{
return;
}
if (Main.InGameUI.CurrentState != this.CurrentDialog)
{
this.CurrentDialog.Close();
}
if (!this.CurrentDialog.IsOpen)
{
if (this.ForcedModalDialog)
{
this.CurrentDialog.Open();
}
else
{
this.CurrentDialog = null;
}
}
}
////////////////
internal void Load(HamstarHelpersMod mymod, TagCompound tags)
{
var modworld = mymod.GetModWorld <HamstarHelpersWorld>();
if (tags.ContainsKey("world_mod_lock_count"))
{
int world_count = tags.GetInt("world_mod_lock_count");
for (int i = 0; i < world_count; i++)
{
string world_uid = tags.GetString("world_mod_lock_uid_" + i);
int mod_count = tags.GetInt("world_mod_lock_mods_" + i + "_count");
this.WorldModLocks[world_uid] = new HashSet <string>();
for (int j = 0; j < mod_count; j++)
{
string mod_name = tags.GetString("world_mod_lock_mods_" + i + "_" + j);
//LogHelpers.Log( "Load world_mod_lock_mods_" + i + "_" + j +": "+mod_name );
this.WorldModLocks[world_uid].Add(mod_name);
}
}
}
}
