public bool correctPlacement(BuildingPlatformController bpc)
{
foreach (SolutionItem si in solutions)
{
if (si.platform.Equals(bpc))
{
// If it is found, the correct type of building and upgrade should have been placed
Upgrade.UpgradeType uType = Upgrade.UpgradeType.None;
if (si.platform.upgrade != null)
{
uType = si.platform.upgrade.type;
}
Building.BuildingType bType = Building.BuildingType.None;
if (si.platform.building != null)
{
bType = si.platform.building.type;
}
if (si.upgrade == uType && si.building == bType)
{
return(true);
}
return(false);
}
}
// If it isn't defined as solution, it should be empty
if ((bpc.building == null || bpc.building.type == Building.BuildingType.None) &&
(bpc.upgrade == null || bpc.upgrade.type == Upgrade.UpgradeType.None))
{
return(true);
}
return(false);
}
public void BoughtUpgrade(Upgrade.UpgradeType upgradeType)
{
switch (upgradeType)
{
case Upgrade.UpgradeType.OxygenUpgrade:
IncreaseOxygen();
break;
case Upgrade.UpgradeType.HealthUpgrade:
IncreaseHealth();
break;
case Upgrade.UpgradeType.LightUpgrade:
IncreaseLight();
break;
case Upgrade.UpgradeType.SpeedUpgrade:
IncreaseSpeed();
break;
case Upgrade.UpgradeType.HookUpgrade:
IncreaseHook();
break;
case Upgrade.UpgradeType.HullUpgrade:
IncreaseHull();
break;
}
AudioManager.Instance.PlaySound(SoundName.upgrade1);
}
private static List <string> GetUpgrades(Upgrade.UpgradeType slot)
{
List <string> results = new List <string>();
List <Type> typelist = Assembly.GetExecutingAssembly().GetTypes()
.Where(t => String.Equals(t.Namespace, "UpgradesList", StringComparison.Ordinal))
.ToList();
foreach (var type in typelist)
{
Upgrade.GenericUpgrade newUpgrade = (Upgrade.GenericUpgrade)System.Activator.CreateInstance(type);
if (!newUpgrade.IsHidden)
{
if (newUpgrade.Type == slot)
{
string upgradeKey = newUpgrade.Name + " (" + newUpgrade.Cost + ")";
if (!AllUpgrades.ContainsKey(upgradeKey))
{
AllUpgrades.Add(upgradeKey, type.ToString());
}
results.Add(upgradeKey);
}
}
}
return(results);
}
private void TryBuyUpgrade(Upgrade.UpgradeType upgradeType)
{
if (shopCustomer.TrySpendMoneyAmount(Upgrade.getCost(upgradeType)))
{
shopCustomer.BoughtUpgrade(upgradeType);
}
}
public static bool shouldCollapse(BuildingType bt, Upgrade.UpgradeType ut, Soil.SoilType st, float distance, float magnitude)
{
if (bt == BuildingType.StoneHouse && st == Soil.SoilType.Clay)
{
return(true);
}
return(false);
}
public void AddSlot(Upgrade.UpgradeType type, bool isPrinted = false)
{
UpgradeSlot slot = new UpgradeSlot(type);
UpgradeSlots.Add(slot);
if (isPrinted)
{
PrintedUpgradeSlots.Add(slot);
}
}
protected void AddUpgradeSlot(Upgrade.UpgradeType slot)
{
if (!BuiltInSlots.ContainsKey(slot))
{
BuiltInSlots.Add(slot, 1);
}
else
{
BuiltInSlots[slot]++;
}
}
public void ApplyUpgrade(Upgrade.UpgradeType type)
{
foreach (NodeTree <Upgrade.UpgradeType> t in upgradeTreePos.Children)
{
if (t.Data == type)
{
upgradeTreePos = t;
return;
}
}
}
public void undo(Upgrade.UpgradeType ut)
{
// for each buttons, if it equal bt then increment
for (int i = 0; i < upgradeItems.Count; i++)
{
if (ut.Equals(upgradeItems[i].prefab.type))
{
amountTexts[i].text = (int.Parse(amountTexts[i].text) + 1) + "";
return;
}
}
}
public void InstallUpgrade(string upgradeName)
{
Upgrade.GenericUpgrade newUpgrade = (Upgrade.GenericUpgrade)System.Activator.CreateInstance(System.Type.GetType(upgradeName));
Upgrade.UpgradeType slot = newUpgrade.Type;
if (HasFreeUpgradeSlot(slot))
{
newUpgrade.AttachToShip(this);
InstalledUpgrades.Add(new KeyValuePair <Upgrade.UpgradeType, Upgrade.GenericUpgrade>(newUpgrade.Type, newUpgrade));
Roster.OrganizeRosters();
}
}
public int GetUpgradeLevel(Upgrade.UpgradeType type)
{
var upgrades = Main.instance.score.playerData.currentUpgrades;
foreach (UpgradeVO currentUpgrade in upgrades)
{
if (currentUpgrade.type == type)
{
return(currentUpgrade.level);
}
}
return(0);
}
public double GetTotalUpgrades(Upgrade.UpgradeType type)
{
double multSum = 1;
foreach (Upgrade u in upgrades)
{
if (u.GetUpType() == type)
{
multSum += u.GetAmount();
}
}
return(multSum);
}
private static void UpdateUpgradePanels(PlayerNo playerNo, GameObject panel)
{
string pilotName = panel.transform.Find("GroupShip/DropdownPilot").GetComponent <Dropdown>().captionText.text;
string pilotId = AllPilots[pilotName];
Ship.GenericShip ship = (Ship.GenericShip)Activator.CreateInstance(Type.GetType(pilotId));
foreach (var slot in ship.BuiltInSlots)
{
if (panel.transform.Find("GroupUpgrades/Upgrade" + slot.Key.ToString() + "Line") == null)
{
AddUpgradeLine(playerNo, panel, slot.Key.ToString());
}
}
List <GameObject> toRemove = new List <GameObject>();
Dictionary <Upgrade.UpgradeType, int> existingUpgradeSlots = new Dictionary <Upgrade.UpgradeType, int>();
foreach (Transform group in panel.transform.Find("GroupUpgrades"))
{
Type type = typeof(Upgrade.UpgradeType);
string upgradeId = group.GetComponent <Dropdown>().options[0].text;
upgradeId = upgradeId.Substring(upgradeId.IndexOf(':') + 2);
Upgrade.UpgradeType slot = (Upgrade.UpgradeType)Enum.Parse(type, upgradeId);
if (existingUpgradeSlots.ContainsKey(slot))
{
existingUpgradeSlots[slot]++;
}
else
{
existingUpgradeSlots.Add(slot, 1);
}
if (!ship.BuiltInSlots.ContainsKey(slot))
{
toRemove.Add(group.gameObject);
}
else if (ship.BuiltInSlots[slot] < existingUpgradeSlots[slot])
{
toRemove.Add(group.gameObject);
}
}
foreach (var group in toRemove)
{
MonoBehaviour.DestroyImmediate(group);
OrganizeUpgradeLines(panel);
}
}
private void createUpgradeButton(Upgrade.UpgradeType upgradeType, Sprite upgradeSprite, string upgradeName, int upgradeCost, int positionIndex)
{
Transform shopUpgradeTransform = Instantiate(shopUpgradeTemplate, container);
RectTransform shopUpgradeRectTransform = shopUpgradeTransform.GetComponent <RectTransform>();
float shopUpgradeHeight = 80f;
shopUpgradeRectTransform.anchoredPosition = new Vector2(0, (-shopUpgradeHeight * positionIndex) + 200);
shopUpgradeTransform.Find("nameText").GetComponent <TextMeshProUGUI>().SetText(upgradeName);
shopUpgradeTransform.Find("costText").GetComponent <TextMeshProUGUI>().SetText(upgradeCost.ToString());
shopUpgradeTransform.Find("itemImage").GetComponent <Image>().sprite = upgradeSprite;
shopUpgradeTransform.GetComponent <Button_UI>().ClickFunc = () =>
{
TryBuyUpgrade(upgradeType);
};
}
private bool HasFreeUpgradeSlot(Upgrade.UpgradeType slot)
{
bool result = false;
if (BuiltInSlots.ContainsKey(slot))
{
int slotsAvailabe = BuiltInSlots[slot];
foreach (var upgrade in InstalledUpgrades)
{
if (upgrade.Key == slot)
{
slotsAvailabe--;
}
}
if (slotsAvailabe > 0)
{
result = true;
}
}
return(result);
}
public bool hasPassed()
{
foreach (SolutionItem si in solutions)
{
Upgrade.UpgradeType uType = Upgrade.UpgradeType.None;
if (si.platform.upgrade != null)
{
uType = si.platform.upgrade.type;
}
Building.BuildingType bType = Building.BuildingType.None;
if (si.platform.building != null)
{
bType = si.platform.building.type;
}
if (!(si.upgrade == uType && si.building == bType))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Whether the building/upgrade placed here are allowed
/// </summary>
/// <returns></returns>
public bool isCorrect()
{
Building.BuildingType thisBType = Building.BuildingType.None;
if (building != null)
{
thisBType = building.type;
}
Upgrade.UpgradeType thisUType = Upgrade.UpgradeType.None;
if (upgrade != null)
{
thisUType = upgrade.type;
}
foreach (AllowedPlacement ap in allowedPlacements)
{
if ((ap.building == thisBType || ap.building == Building.BuildingType.Any) &&
(ap.upgrade == thisUType || ap.upgrade == Upgrade.UpgradeType.Any))
{
return(true);
}
}
return(thisBType == Building.BuildingType.None && thisUType == Upgrade.UpgradeType.None);
}
public UpgradeSlot(Upgrade.UpgradeType type)
{
Type = type;
}
public void ApplyUpgrade(Upgrade.UpgradeType type)
{
}
//public void SetUpgrade(Upgrade.UpgradeType type)
//{
// if (!upgrades.Contains(type))
// {
// upgrades.Add(type);
// }
//}
public bool HasUpgrade(Upgrade.UpgradeType type)
{
return(upgrades.Contains(type));
}
