public static void RegisterTowerInInventory(ShopTowerDetailsModel details, string insertBefore, List <TowerDetailsModel> allTowersInTheGame)
{
// get the tower details for the tower insertBefore and insert the new tower into the index towerBefore is at, shifting everything after it by 1
TowerDetailsModel towerAfter = allTowersInTheGame.ToArray().FirstOrDefault(tower => tower.towerId == insertBefore);
allTowersInTheGame.Insert(allTowersInTheGame.IndexOf(towerAfter), details);
}
/// <summary>
/// Get the number position of this TowerModel in the list of all tower models
/// </summary>
public static int?GetIndex(this TowerModel towerModel)
{
List <TowerDetailsModel> allTowers = Game.instance.model.towerSet.ToList();
TowerDetailsModel detail = allTowers.FirstOrDefault(towerDetail => towerDetail.towerId == towerModel.baseId);
return(allTowers.IndexOf(detail));
}
public static bool IsHero(this TowerDetailsModel towerDetailsModel)
{
var heroDetailsModel = towerDetailsModel.TryCast <HeroDetailsModel>();
var isHero = heroDetailsModel != null;
return(isHero);
}
/// <summary>
/// Adds a TowerDetailsModel to the GameModel's TowerSet at a particular index
/// </summary>
/// <param name="model"></param>
/// <param name="towerDetailsModel"></param>
/// <param name="index"></param>
public static void AddTowerDetails(this GameModel model, TowerDetailsModel towerDetailsModel, int index)
{
var towerSet = model.towerSet.ToList();
if (index < 0)
{
index = 0;
}
else if (index > towerSet.Count)
{
index = towerSet.Count;
}
towerSet.Insert(index, towerDetailsModel);
model.towerSet = towerSet.ToArray();
for (var i = 0; i < model.towerSet.Count; i++)
{
model.towerSet[i].towerIndex = i;
}
var towerList = Game.towers.ToList();
towerList.Insert(index, towerDetailsModel.towerId);
Game.towers = towerList.ToArray();
}
public static TowerDetailsModel MakeCopy(this TowerDetailsModel towerDetailsModel, string newName, bool addToGame = false)
{
var duplicate = towerDetailsModel.Duplicate();
duplicate.towerId = newName;
duplicate.SetName(newName);
if (addToGame)
{
Game.instance.model.towerSet = Game.instance.model.towerSet.AddTo(towerDetailsModel);
}
return(duplicate);
}
/// <summary>
/// Adds a TowerDetailsModel to the GameModel's TowerSet, taking into account what set of towers it's a part of
/// <br/>
/// For example, a new custom Primary tower would be added right at the end of the primary towers,
/// and right before the start of the military towers
/// </summary>
/// <param name="model">The GameModel</param>
/// <param name="towerDetailsModel">The TowerDetailsModel to be added</param>
/// <param name="set">The TowerSet of the tower to be added</param>
public static void AddTowerDetails(this GameModel model, TowerDetailsModel towerDetailsModel, string set)
{
var towerSet = model.towerSet.ToList();
var index = towerSet.Count;
if (!string.IsNullOrEmpty(set))
{
var lastOfSet = towerSet.LastOrDefault(tdm => tdm.GetTower().towerSet == set);
if (lastOfSet != default)
{
index = towerSet.IndexOf(lastOfSet) + 1;
}
}
AddTowerDetails(model, towerDetailsModel, index);
}
public static int GetIndex(this TowerDetailsModel towerDetailsModel)
{
var towers = Game.instance.model.towerSet;
if (towers is null)
{
return(-1);
}
for (int i = 0; i < towers.Count; i++)
{
if (towers[i].name == towerDetailsModel.name)
{
return(i);
}
}
return(-1);
}
//needs more work
/*public static bool HasPlayerUnlocked(this TowerDetailsModel towerDetailsModel)
* {
* var towerModel = Game.instance.model.GetTower(towerDetailsModel.towerId);
* return towerModel.IsTowerUnlocked().Value;
* }*/
// this would be helpful but might not use it because it requires user in game
/*public static void SetCount(this TowerDetailsModel towerDetailsModel, int count)
* {
* towerDetailsModel.towerCount = count;
* var details = Game.instance?.model.towerSet.ToIl2CppList();
* //var details = Game.instance?.GetTowerDetailModels().TryCast<Il2CppSystem.Collections.Generic.List<TowerDetailsModel>>();
* InGame.instance?.GetTowerInventory(1).SetTowerMaxes(details);
* }*/
public static TowerModel GetTower(this TowerDetailsModel towerDetailsModel)
{
return(Game.instance.model.GetTowerWithName(towerDetailsModel.towerId));
}
/// <summary>
/// Sets the name of this TowerDetailsModel, following the naming convention of ofther TowerDetailModels.
/// Example, using "NewMonkey" will set the name to "TowerDetailsModel_NewMonkey"
/// </summary>
/// <param name="towerDetailsModel"></param>
/// <param name="newName"></param>
public static void SetName(this TowerDetailsModel towerDetailsModel, string newName)
{
towerDetailsModel.name = string.Concat(towerDetailsModel.GetIl2CppType().Name, "_", newName);
}
/// <summary>
/// Get the ShopTowerDetails for this TowerDetailModel
/// </summary>
public static ShopTowerDetailsModel GetShopTowerDetails(this TowerDetailsModel towerDetailsModel)
{
return(towerDetailsModel.TryCast <ShopTowerDetailsModel>());
}
/// <summary>
/// Get the TowerPurchaseButton that is used to buy this specific TowerDetailModel
/// </summary>
public static TowerPurchaseButton GetTowerPurchaseButton(this TowerDetailsModel towerDetailsModel)
{
Assets.Scripts.Models.Towers.TowerModel towerModel = Game.instance.model.GetTower(towerDetailsModel.towerId);
return(towerModel.GetTowerPurchaseButton());
}
public static TowerDetailsModel MakeCopy(this TowerDetailsModel towerDetailsModel, string newName, bool addToGame = false)
{
return(towerDetailsModel.MakeCopy(newName, towerDetailsModel.towerIndex, addToGame));
}
/// <summary>
/// Adds a tower
/// </summary>
/// <param name="model"></param>
/// <param name="towerDetailsModel"></param>
public static void AddTowerDetails(this GameModel model, TowerDetailsModel towerDetailsModel)
{
AddTowerDetails(model, towerDetailsModel, "");
}
/// <summary>
/// Adds a TowerModel to the official list of TowerModels being used by the game
///
/// Equivalent to calling Game.instance.model.AddTowerToGame(...)
/// </summary>
/// <param name="newTowerModel">The new tower model</param>
/// <param name="towerDetailsModel">A TowerDetailsModel to go with it, if it'll be in the shop</param>
public static void AddTowerToGame(TowerModel newTowerModel, TowerDetailsModel towerDetailsModel = null)
{
Game.instance.model.AddTowerToGame(newTowerModel, towerDetailsModel);
}
/// <summary>
/// Add a TowerModel to the game.
/// </summary>
/// <param name="towerModel">TowerModel to add</param>
/// <param name="towerDetailsModel">Optionally add a TowerDetailsModel for your towerModel</param>
public static void AddTowerToGame(this GameModel model, TowerModel towerModel, TowerDetailsModel towerDetailsModel = null)
{
model.towers = model.towers.AddTo(towerModel);
if (towerDetailsModel != null)
{
model.towerSet = model.towerSet.AddTo(towerDetailsModel);
}
}
/// <summary>
/// Add a TowerModel to the game.
/// </summary>
/// <param name="towerModel">TowerModel to add</param>
/// <param name="towerDetailsModel">Optionally add a TowerDetailsModel for your towerModel</param>
public static void AddTowerToGame(this GameModel model, TowerModel towerModel, TowerDetailsModel towerDetailsModel = null)
{
model.towers = model.towers.AddTo(towerModel);
ModTowerHandler.TowerCache[towerModel.name] = towerModel;
if (towerDetailsModel != null)
{
model.towerSet = model.towerSet.AddTo(towerDetailsModel);
}
}
/// <summary>
/// Add a TowerModel to the game.
/// <br/>
/// Using this method is preferable than modifying the GameModel's towers list manually, as this does more things
/// to more fully integrate the tower within the game
/// </summary>
/// <param name="towerModel">TowerModel to add</param>
/// <param name="towerDetailsModel">Optionally add a TowerDetailsModel for your towerModel</param>
public static void AddTowerToGame(this GameModel model, TowerModel towerModel, TowerDetailsModel towerDetailsModel = null)
{
model.towers = model.towers.AddTo(towerModel);
model.AddChildDependant(towerModel);
ModTowerHelper.TowerCache[towerModel.name] = towerModel;
if (towerDetailsModel != null)
{
model.AddTowerDetails(towerDetailsModel, towerModel.towerSet);
}
// MelonLogger.Msg($"Added towerModel {towerModel.name} to the game");
}
