private static void CacheAllModInfoAsync()
{
var mymod = ModHelpersMod.Instance;
var modInfoArgs = new ModInfoListPromiseArguments();
GetModInfo.RetrieveAllModInfoAsync((modInfo, found) => {
modInfoArgs.ModInfo = modInfo;
modInfoArgs.Found = found;
Promises.TriggerValidatedPromise(GetModInfo.ModInfoListPromiseValidator, GetModInfo.PromiseValidatorKey, modInfoArgs);
});
Promises.AddValidatedPromise <ModInfoListPromiseArguments>(GetModInfo.ModInfoListPromiseValidator, (modInfoArgs2) => {
if (modInfoArgs2.Found)
{
GetModInfo.RetrieveBadModsAsync((badMods, found) => {
if (found)
{
GetModInfo.RegisterBadMods(modInfoArgs2, badMods);
}
Promises.TriggerValidatedPromise(GetModInfo.BadModsListPromiseValidator, GetModInfo.PromiseValidatorKey, modInfoArgs2);
});
}
return(true);
});
}
////////////////
public void CheckForNewVersionAsync()
{
Promises.AddValidatedPromise <ModInfoListPromiseArguments>(GetModInfo.ModInfoListPromiseValidator, (args) => {
if (args.Found && args.ModInfo.ContainsKey(this.Mod.Name))
{
this.LatestAvailableVersion = args.ModInfo[this.Mod.Name].Version;
}
else
{
if (ModHelpersMod.Instance.Config.DebugModeNetInfo)
{
LogHelpers.Log("Error retrieving version number of '" + this.Mod.DisplayName + "'"); //+ "': " + reason );
}
}
return(false);
});
/*Action<Version> onSuccess = delegate ( Version vers ) {
* this.LatestAvailableVersion = vers;
* };
* Action<string> onFail = delegate ( string reason ) {
* if( ModHelpersMod.Instance.Config.DebugModeNetInfo ) {
* LogHelpers.Log( "Error retrieving version number of '" + this.Mod.DisplayName + "': " + reason );
* }
* };
*
* GetModVersion.GetLatestKnownVersionAsync( this.Mod, onSuccess, onFail );*/
}
protected override void StaticInitialize()
{
// Load all entities upon world load (single, server)
if (Main.netMode != 1)
{
Promises.AddValidatedPromise <PromiseArguments>(ModHelpersWorld.LoadValidator, (_) => {
MyStaticInitializer.LoadAll();
SaveableEntityComponent.PostLoadAll();
return(true);
});
}
// Save all entities upon world save (single, server)
if (Main.netMode != 1)
{
Promises.AddValidatedPromise <PromiseArguments>(ModHelpersWorld.SaveValidator, (_) => {
MyStaticInitializer.SaveAll();
return(true);
});
}
// Unload entities after world closes
Promises.AddPostWorldUnloadEachPromise(() => {
SaveableEntityComponent.PostUnloadAll();
});
}
public UIModData(UITheme theme, int?idx, Mod mod, bool willDrawOwnHoverElements = true)
{
this.InitializeMe(theme, idx, mod, willDrawOwnHoverElements);
Promises.AddValidatedPromise <ModTagsPromiseArguments>(GetModTags.TagsReceivedPromiseValidator, (args) => {
ISet <string> modTags = args.ModTags?.GetOrDefault(mod.Name);
this.ModTags = modTags ?? this.ModTags;
return(false);
});
}
public override void Show(UIState ui)
{
base.Show(ui);
Timers.SetTimer("ModHelpersUpdatesLoaderPause", 5, () => {
Promises.AddValidatedPromise <ModInfoListPromiseArguments>(GetModInfo.ModInfoListPromiseValidator, (args) => {
this.DisplayModListVersions(ui, args.ModInfo);
return(false);
});
return(false);
});
}
////////////////
internal void UpdateMode(bool isEditing)
{
if (!isEditing)
{
return;
}
Promises.AddValidatedPromise <ModInfoListPromiseArguments>(GetModInfo.BadModsListPromiseValidator, (modInfoArgs) => {
this.ApplyDefaultEditModeTags(modInfoArgs.ModInfo);
return(false);
});
}
private void OnConnectHost()
{
//Promises.AddPostWorldLoadOncePromise( () => {
Promises.AddValidatedPromise(SaveableEntityComponent.LoadAllValidator, () => {
if (TrainEntity.FindMyTrain(this.player) == -1)
{
var ent = TrainEntity.CreateTrainEntity(this.player);
CustomEntityManager.AddToWorld(ent);
}
return(false);
});
}
////////////////
public override void OnRespawn(Player player)
{
Promises.AddValidatedPromise(SaveableEntityComponent.LoadAllValidator, () => {
Timers.SetTimer("OnARailRespawn", 30, () => {
if (this.MyTrainWho != -1)
{
TrainEntity.WarpPlayerToTrain(player);
}
return(false);
});
return(false);
});
}
////////////////
public void AddModEntriesAsync(string forModName, IEnumerable <Tuple <string, string> > recomMods)
{
foreach (var recomMod in recomMods)
{
string recomModName = recomMod.Item1;
string recommendedBecause = recomMod.Item2;
Mod mod = ModLoader.GetMod(recomModName);
this.AddRawModEntry(mod?.DisplayName, recomModName, recommendedBecause);
}
Promises.AddValidatedPromise <ModInfoListPromiseArguments>(GetModInfo.ModInfoListPromiseValidator, (args) => {
string currModName = ModMenuHelpers.GetModName(MenuContextService.GetPreviousMenuUI(),
this.MenuContext.MyUI ?? MenuContextService.GetCurrentMenuUI());
// Validate we're in the same UI
if (this.MenuContext.MyUI.GetType().Name != "UIModInfo")
{
return(false);
}
// Validate we're viewing the mod we started with
if (forModName != currModName)
{
return(false);
}
this.List.RemoveAllChildren();
this.ModNameList.Clear();
foreach (var recomMod in recomMods)
{
string recomModName = recomMod.Item1;
string recommendedBecause = recomMod.Item2;
if (args.ModInfo.ContainsKey(recomModName))
{
this.AddModEntry(args.ModInfo[recomModName].DisplayName, recomModName, recommendedBecause);
}
else
{
this.AddRawModEntry(null, recomModName, recommendedBecause);
}
}
return(false);
});
this.EmptyText.Remove();
this.Recalculate();
}
////////////////
public void FilterModsAsync(IList <string> modNames, Action <bool, IList <string>, int, int> callback)
{
Promises.AddValidatedPromise <ModTagsPromiseArguments>(GetModTags.TagsReceivedPromiseValidator, (args) => {
if (!args.Found)
{
this.InfoDisplay?.SetText("Could not acquire mod data.");
callback(false, new List <string>(), 0, 0);
return(false);
}
this.FilterMods_Promised(modNames, callback, args.ModTags);
return(false);
});
}
public override void Show(UIState ui)
{
base.Show(ui);
this.BeginModBrowserPopulateCheck(ui);
this.RecalculateMenuObjects();
this.EnableTagButtons();
this.InfoDisplay.SetDefaultText("Click tags to filter the list. Right-click tags to filter without them.");
UIElement elem;
if (ReflectionHelpers.Get <UIElement>(ui, "uIElement", out elem))
{
elem.Left.Pixels += UITagButton.ColumnWidth;
elem.Recalculate();
}
Promises.AddValidatedPromise <ModTagsPromiseArguments>(GetModTags.TagsReceivedPromiseValidator, (args) => {
Timers.SetTimer("ModBrowserDefaultTagStates", 15, () => {
if (this.MyUI != ui)
{
return(false);
}
bool isLoading;
if (!ReflectionHelpers.Get(this.MyUI, "loading", out isLoading))
{
LogHelpers.Warn("ModBrowserTagsMenuContext - No 'loading'.");
return(false);
}
if (isLoading)
{
return(true);
}
else
{
UITagButton button = this.TagButtons["Misleading Info"];
button.SetTagState(-1);
return(false);
}
});
return(true);
});
}
////////////////
protected override bool ReceiveRequestWithServer(int from_who)
{
Player player = Main.player[from_who];
Promises.AddValidatedPromise(SaveableEntityComponent.LoadAllValidator, () => {
if (TrainEntity.FindMyTrain(player) != -1)
{
throw new HamstarException("Cannot spawn duplicate train for player " + player.name);
}
var ent = TrainEntity.CreateTrainEntity(player);
CustomEntityManager.AddToWorld(ent);
return(false);
});
return(true);
}
internal CustomEntityManager()
{
this.InitializeUpdate();
this.InitializeEntityTypes();
this.InitializeComponentTypes();
this.InitializeDrawingLayer();
// Reset any data from previous games
Promises.AddPostWorldUnloadEachPromise(() => {
lock (CustomEntityManager.MyLock) {
this.WorldEntitiesByIndexes.Clear();
this.WorldEntitiesByComponentType.Clear();
}
});
// Bind 'data dump' hotkey
DataDumper.SetDumpSource("CustomEntityList", () => {
lock (CustomEntityManager.MyLock) {
return(string.Join("\n ", this.WorldEntitiesByIndexes.OrderBy(kv => kv.Key)
.SafeSelect(kv => kv.Key + ": " + kv.Value?.ToString() ?? "null")));
}
});
// Refresh entity owners on player connect and sync entities to player
if (Main.netMode == 2)
{
Promises.AddValidatedPromise <PlayerLogicPromiseArguments>(PlayerLogic.ServerConnectValidator, (args) => {
if (this.WorldEntitiesByIndexes.Count == 0)
{
return(true);
}
foreach (var ent in this.WorldEntitiesByIndexes.Values)
{
ent.RefreshOwnerWho();
}
PacketProtocolSendToClient.QuickSend <CustomEntityAllProtocol>(args.Who, -1);
return(true);
});
}
}
public override void SetDefaults()
{
this.DisplayName.SetDefault("Train");
this.Description.SetDefault("Your home away from home.");
Main.buffNoTimeDisplay[this.Type] = true;
Main.buffNoSave[this.Type] = true;
if (!OnARailMod.Instance.HasBuffPromise)
{
OnARailMod.Instance.HasBuffPromise = true;
Promises.AddValidatedPromise <PlayerPromiseArguments>(OnARailPlayer.PlayerFuncsValidator, (args) => {
var mybuff = OnARailMod.Instance.GetBuff <TrainMountBuff>();
mybuff.RunUpdateForPlayer(Main.player[args.Who]);
return(true);
});
}
}
public static void IsListModProperlyPresented(string modName, Action <bool> callback)
{
Promises.AddValidatedPromise <ModInfoListPromiseArguments>(GetModInfo.ModInfoListPromiseValidator, (args) => {
if (args.Found && args.ModInfo.ContainsKey(modName))
{
BasicModInfoEntry modInfo = args.ModInfo[modName];
bool isProper = ModIdentityHelpers.IsProperlyPresented(modInfo);
callback(isProper);
}
else
{
if (ModHelpersMod.Instance.Config.DebugModeNetInfo)
{
LogHelpers.Log("Error retrieving mod data for '" + modName + "'"); //+ "': " + reason );
}
}
return(false);
});
}
public override void SetDefaults()
{
int total_frames = 4;
var player_y_offsets = new int[total_frames];
for (int i = 0; i < player_y_offsets.Length; i++)
{
player_y_offsets[i] = 32;
}
this.mountData.Minecart = true;
this.mountData.MinecartDirectional = true;
this.mountData.MinecartDust = new Action <Vector2>(DelegateMethods.Minecart.Sparks);
this.mountData.spawnDust = 213;
this.mountData.buff = this.mod.BuffType("TrainMountBuff");
//this.mountData.extraBuff = 185;
this.mountData.flightTimeMax = 0;
this.mountData.fallDamage = 1f;
this.mountData.runSpeed = 20f; //10f;
this.mountData.dashSpeed = 10f;
this.mountData.acceleration = 0.05f; //0.03f;
this.mountData.jumpHeight = 2; //12;
this.mountData.jumpSpeed = 5.15f;
this.mountData.blockExtraJumps = true;
this.mountData.totalFrames = total_frames;
this.mountData.heightBoost = 30;
this.mountData.playerYOffsets = player_y_offsets;
this.mountData.xOffset = 0; //8;
this.mountData.yOffset = 2;
this.mountData.bodyFrame = 3;
this.mountData.playerHeadOffset = 14;
this.mountData.standingFrameCount = 1;
this.mountData.standingFrameDelay = 12;
this.mountData.standingFrameStart = 0;
this.mountData.runningFrameCount = 4;
this.mountData.runningFrameDelay = 12;
this.mountData.runningFrameStart = 0;
this.mountData.flyingFrameCount = 0;
this.mountData.flyingFrameDelay = 0;
this.mountData.flyingFrameStart = 0;
this.mountData.inAirFrameCount = 0;
this.mountData.inAirFrameDelay = 0;
this.mountData.inAirFrameStart = 0;
this.mountData.idleFrameCount = 4;
this.mountData.idleFrameDelay = 12;
this.mountData.idleFrameStart = 0;
this.mountData.idleFrameLoop = false;
if (Main.netMode != 2)
{
this.mountData.textureWidth = this.mountData.backTexture.Width;
this.mountData.textureHeight = this.mountData.backTexture.Height;
}
if (!OnARailMod.Instance.HasMountPromise)
{
OnARailMod.Instance.HasMountPromise = true;
Promises.AddValidatedPromise <PlayerPromiseArguments>(OnARailPlayer.PlayerFuncsValidator, (args) => {
var mymount = OnARailMod.Instance.GetMount <TrainMount>();
mymount.RunUpdateForPlayer(Main.player[args.Who]);
return(true);
});
}
}
////////////////
private void SetCurrentMod(UIState ui, string modName)
{
this.CurrentModName = modName;
Promises.AddValidatedPromise <ModTagsPromiseArguments>(GetModTags.TagsReceivedPromiseValidator, (args) => {
if (!args.Found)
{
LogHelpers.Warn();
return(false);
}
this.AllModTagsSnapshot = args.ModTags;
ISet <string> netModTags = args.Found && args.ModTags.ContainsKey(modName) ?
args.ModTags[modName] :
new HashSet <string>();
bool hasNetTags = netModTags.Count > 0;
//LogHelpers.Log( "SetCurrentMod modname: " + modName + ", modTags: " + string.Join(",", netModTags ) );
if (hasNetTags)
{
this.InfoDisplay.SetDefaultText("Do these tags look incorrect? If so, modify them.");
this.FinishButton.SetModeReadOnly();
this.ResetButton.Disable();
}
else
{
this.InfoDisplay.SetDefaultText("No tags set for this mod. Why not add some?");
this.FinishButton.SetModeSubmit();
}
foreach (var kv in this.TagButtons)
{
string tagName = kv.Key;
UITagButton button = kv.Value;
bool hasTag = netModTags.Contains(tagName);
if (!hasNetTags)
{
button.Enable();
}
if (tagName == "Low Effort")
{
if (hasTag)
{
button.SetTagState(1);
}
else
{
string desc = this.GetModDataFromActiveMod(modName, "description");
if (string.IsNullOrEmpty(desc))
{
string _ = "";
desc = this.GetModDescriptionFromUI(modName, ref _);
}
if (desc.Contains("Modify this file with a description of your mod."))
{
button.SetTagState(1);
}
}
}
else
{
button.SetTagState(hasTag ? 1 : 0);
}
}
return(false);
});
}
public static CustomEntity AddToWorld(int who, CustomEntity ent, bool skipSync = false)
{
//if( ent == null ) { throw new HamstarException( "!ModHelpers.CustomEntityManager.AddToWorld - Null ent not allowed." ); }
//if( !ent.IsInitialized ) { throw new HamstarException( "!ModHelpers.CustomEntityManager.AddToWorld - Initialized ents only." ); }
if (ent == null)
{
throw new HamstarException("Null ent not allowed.");
}
if (!ent.IsInitialized)
{
throw new HamstarException("Initialized ents only.");
}
CustomEntityManager mngr = ModHelpersMod.Instance.CustomEntMngr;
CustomEntity realEnt = ent;
if (mngr.WorldEntitiesByIndexes.ContainsKey(who))
{
//throw new HamstarException( "!ModHelpers.CustomEntityManager.AddToWorld - "
// + "Attempting to add "+ent.ToString()+" to slot "+who+" occupied by "+mngr.WorldEntitiesByIndexes[who].ToString() );
throw new HamstarException("Attempting to add " + ent.ToString() + " to slot " + who + " occupied by "
+ mngr.WorldEntitiesByIndexes[who].ToString());
}
if (ent is SerializableCustomEntity)
{
realEnt = ((SerializableCustomEntity)ent).Convert();
}
Type compType;
Type baseType = typeof(CustomEntityComponent);
// Map entity to each of its components
foreach (CustomEntityComponent component in realEnt.InternalComponents)
{
compType = component.GetType();
lock (CustomEntityManager.MyLock) {
do
{
if (!mngr.WorldEntitiesByComponentType.ContainsKey(compType))
{
mngr.WorldEntitiesByComponentType[compType] = new HashSet <int>();
}
mngr.WorldEntitiesByComponentType[compType].Add(who);
compType = compType.BaseType;
} while(compType != baseType);
}
}
realEnt.Core.whoAmI = who;
mngr.WorldEntitiesByIndexes[who] = realEnt;
realEnt.InternalOnAddToWorld();
// Sync also
if (!skipSync)
{
if (Main.netMode == 1)
{
if (ent.SyncFromClient)
{
Promises.AddValidatedPromise(SaveableEntityComponent.LoadAllValidator, () => {
ent.SyncToAll();
return(false);
});
}
}
else if (Main.netMode == 2)
{
if (ent.SyncFromServer)
{
Promises.AddValidatedPromise(SaveableEntityComponent.LoadAllValidator, () => {
ent.SyncToAll();
return(false);
});
}
}
}
if (ModHelpersMod.Instance.Config.DebugModeCustomEntityInfo)
{
LogHelpers.Alert("Set " + realEnt.ToString());
}
return(realEnt);
}
