public void UpdateInventory()
{
if (ParentFloor == null)
{
HomeUpgrade = GameManager.Instance.Inventory[InventoryIndex];
}
}
public void DropFloatingUpgrade()
{
if (FloatingUpgrade != null)
{
GameManager.Instance.Inventory.Add(FloatingUpgrade);
FloatingUpgrade = null;
}
}
public void Setup(BuildCost buildCost, HomeUpgrade homeUpgrade, BasicChar owner, string buildingName)
{
this.buildCost = buildCost;
this.homeUpgrade = homeUpgrade;
this.owner = owner;
this.buildingName = buildingName;
DisplayCost();
btn.onClick.AddListener(Upgrade);
}
public override void OnClick()
{
if (GameManager.Instance.State != GameManager.GameState.Battle)
{
HomeUpgrade newUpgrade = inventoryManager.FloatingUpgrade;
inventoryManager.FloatingUpgrade = Remove();
Insert(newUpgrade);
}
}
public HomeUpgrade CreateNewRandomItem(int furnitureTier, int modifierTier)
{
HomeUpgrade newItem = ContentManager.Instance.
GetRandomHomeUpgrade(furnitureTier, modifierTier);
bool itemAddedToInv = AddItem(newItem);
if (itemAddedToInv)
{
return(newItem);
}
else
{
return(null);
}
}
// Pop the item out
public HomeUpgrade Remove()
{
HomeUpgrade previousUpgrade = HomeUpgrade;
HomeUpgrade = null;
if (ParentFloor != null)
{
ParentFloor.FloorData.HomeUpgrades[ParentFloorSlotIndex] = null;
}
else
{
GameManager.Instance.Inventory[InventoryIndex] = null;
}
return(previousUpgrade);
}
public bool AddItem(HomeUpgrade itemToAdd)
{
List <HomeUpgrade> inventory = GameManager.Instance.Inventory;
for (int i = 0; i < inventory.Count; i++)
{
if (inventory[i] == null)
{
inventory[i] = itemToAdd;
UpdateUpgradeSlots();
return(true);
}
}
Debug.LogWarning("Inventory is full");
return(false);
}
public bool GetRandomItems(int itemCount, int furnitureTier, int modifierTier)
{
for (int i = 0; i < itemCount; i++)
{
HomeUpgrade receivedItem = inventoryManager.
CreateNewRandomItem(furnitureTier, modifierTier);
if (receivedItem != null)
{
Debug.Log("Got item [" + receivedItem + "] of tier " + furnitureTier);
}
else
{
return(false);
}
}
return(true);
}
private void SetPromisedRewardUpgrade(EventType actionEvent)
{
if (actionEvent.Choices.Count > 0)
{
bool itemReward = false;
foreach (EventChoice choice in actionEvent.Choices)
{
if (choice.Action == Action.Gain &&
choice.Gain.Type == EventGain.GainType.Upgrade)
{
promisedRewardItem = ContentManager.Instance.
GetRandomHomeUpgrade(actionEvent.Tier, actionEvent.Tier);
itemReward = true;
break;
}
}
if (!itemReward)
{
promisedRewardItem = null;
}
}
}
// Insert new upgrade to the slot
public HomeUpgrade Insert(HomeUpgrade upgrade)
{
HomeUpgrade previousUpgrade = HomeUpgrade;
HomeUpgrade = upgrade;
if (ParentFloor != null)
{
ParentFloor.FloorData.HomeUpgrades[ParentFloorSlotIndex] = upgrade;
if (upgrade != null)
{
if (buildSound != null && buildSound.isPlaying)
{
buildSound.Stop();
}
buildSound = SFXPlayer.Instance.Play(Sound.Repair, volumeFactor: 0.5f);
}
}
else
{
GameManager.Instance.Inventory[InventoryIndex] = upgrade;
}
return(previousUpgrade);
}
public void UpdateStats()
{
MaxCooldown = 0f;
Comfort = Type.BaseComfort + WallType.ComfortBonus + Type.Bonuses.ComfortBonus + WallType.Bonuses.ComfortBonus;
BaseComfort = Comfort;
StenchRemovalBonus = Type.Bonuses.StenchRemovalBonus + WallType.Bonuses.StenchRemovalBonus;
GlobalReloadSpeedBonus = Type.Bonuses.GlobalReloadSpeedBonus + WallType.Bonuses.GlobalReloadSpeedBonus;
GlobalHitChanceBonus = Type.Bonuses.GlobalHitChanceBonus + WallType.Bonuses.GlobalHitChanceBonus;;
GlobalRandomHitsBonus = Type.Bonuses.GlobalRandomHitsBonus + WallType.Bonuses.GlobalRandomHitsBonus;;
GlobalRandomHits = new List <int>();
Resistances.Clear();
for (int i = 0; i < 4; i++)
{
// Loop through every upgrade in the floor
HomeUpgrade upgrade = HomeUpgrades[i];
if (upgrade != null)
{
float time = upgrade.UpgradeData.TargetingModule.ReloadTime;
if (upgrade.UpgradeData.IsWeapon)
{
MaxCooldown = Mathf.Max(time, MaxCooldown);
}
BonusModule bonusModule = upgrade.UpgradeData.BonusModule;
// Comfort
Comfort += bonusModule.ComfortBonus;
StenchRemovalBonus += bonusModule.StenchRemovalBonus;
GlobalReloadSpeedBonus += bonusModule.GlobalReloadSpeedBonus;
GlobalHitChanceBonus += bonusModule.GlobalHitChanceBonus;
GlobalRandomHitsBonus += bonusModule.GlobalRandomHitsBonus;
GlobalRandomHits.AddRange(bonusModule.GlobalRandomHits);
// Collect resistance bonuses
foreach (StatBonus statBonus in upgrade.UpgradeData.BonusModule.ResistanceBonuses)
{
DamageTypes type = statBonus.DamageType;
int amount = statBonus.Bonus;
if (!Resistances.ContainsKey(type))
{
Resistances[type] = amount;
}
else
{
Resistances[type] += amount;
}
}
// Collect damage bonuses
foreach (StatBonus statBonus in upgrade.UpgradeData.BonusModule.GlobalDamageBonuses)
{
DamageTypes type = statBonus.DamageType;
int amount = statBonus.Bonus;
if (!DamageBonuses.ContainsKey(type))
{
DamageBonuses[type] = amount;
}
else
{
DamageBonuses[type] += amount;
}
}
}
}
StenchLevel = 0;
MaxCooldown -= GlobalReloadSpeedBonus;
}
private void EventResults(EventType actionEvent, int actionIndex)
{
eventResultsSeen = true;
EventChoice choice = actionEvent.Choices[actionIndex];
startBattle = false;
switch (choice.Action)
{
case Action.Fight:
{
startBattle = true;
break;
}
case Action.Gain:
{
if (choice.Gain.Type == EventGain.GainType.Upgrade)
{
inventoryManager.AddItem(promisedRewardItem);
Debug.Log("Got item [" + promisedRewardItem + "] of tier "
+ promisedRewardItem.UpgradeData.Tier);
SFXPlayer.Instance.Play(Sound.Hop1, volumeFactor: 0.7f);
}
else if (choice.Gain.Type == EventGain.GainType.Floor)
{
FloorData fd = new FloorData(
ContentManager.Instance.GetRandomFloorType(actionEvent.Tier),
ContentManager.Instance.GetRandomWallType(actionEvent.Tier));
GameManager.Instance.PlayerHome.Floors.Add(fd);
GameManager.Instance.home.UpdateHome();
SFXPlayer.Instance.Play(Sound.Repair, volumeFactor: 0.5f);
}
else if (choice.Gain.Type == EventGain.GainType.Money)
{
GameManager.Instance.ChangeMoney(choice.Gain.Amount);
}
else if (choice.Gain.Type == EventGain.GainType.Score)
{
GameManager.Instance.ChangeScore(choice.Gain.Amount);
}
break;
}
case Action.Lose:
{
if (choice.Gain.Type == EventGain.GainType.Upgrade)
{
// TODO
}
else if (choice.Gain.Type == EventGain.GainType.Floor)
{
// TODO
}
else if (choice.Gain.Type == EventGain.GainType.Money)
{
GameManager.Instance.ChangeMoney(-1 * choice.Gain.Amount);
}
else if (choice.Gain.Type == EventGain.GainType.Score)
{
GameManager.Instance.ChangeScore(-1 * choice.Gain.Amount);
}
break;
}
case Action.Advance:
{
GameManager.Instance.NextRegion();
break;
}
default:
{
break;
}
}
ShowConfirmScreen(choice);
promisedRewardItem = null;
}
private void FirstPart(BuildCost buildCost, HomeUpgrade homeUpgrade, string buildingName)
{
Instantiate(buildButtonPrefab, buildContainer).Setup(buildCost, homeUpgrade, owner, buildingName);
}
public void Fire()
{
if (FloorData.MaxCooldown > 0 &&
GameManager.Instance.State == GameManager.GameState.Battle &&
!GameManager.Instance.FadeActive)
{
foreach (UpgradeSlot slot in UpgradeSlots)
{
HomeUpgrade item = slot.HomeUpgrade;
if (item != null && item.UpgradeData != null && item.UpgradeData.IsWeapon && item.UpgradeData.BaseDamage != null)
{
if (item.UpgradeData.Sound != Sound.None)
{
SFXPlayer.Instance.Play(item.UpgradeData.Sound, volumeFactor: 0.3f);
}
Home targetHome = FindObjectsOfType <Home>().Where(x => x != MyHome).First();
int baseTargetIndex = Index;
switch (item.UpgradeData.TargetingModule.TargetingType)
{
case TargetTypes.Bottom: baseTargetIndex = 0;
break;
case TargetTypes.Top: baseTargetIndex = targetHome.Floors.Count - 1;
break;
}
List <StatBonus> baseDamage = item.UpgradeData.BaseDamage;
foreach (DamageTypes type in FloorData.DamageBonuses.Keys)
{
for (int i = 0; i < baseDamage.Count; i++)
{
if (baseDamage[i].DamageType == type)
{
baseDamage[i] = new StatBonus(baseDamage[i].DamageType, baseDamage[i].Bonus + FloorData.DamageBonuses[type]);
break;
}
}
baseDamage.Add(new StatBonus(type, FloorData.DamageBonuses[type]));
}
foreach (int targetIndex in item.UpgradeData.TargetingModule.Targets)
{
int projectileTargetIndex = targetIndex + baseTargetIndex;
Projectile proj = Instantiate(ProjectilePrefab).GetComponent <Projectile>();
proj.transform.position = slot.transform.position;
proj.TargetFloorIndex = projectileTargetIndex;
proj.TargetHome = targetHome;
proj.Damage = baseDamage;
}
for (int i = 0; i < item.UpgradeData.TargetingModule.RandomHits; i++)
{
int projectileTargetIndex = Utilities.UtilityFunctions.GetRandomElement(item.UpgradeData.TargetingModule.RandomTargets) + baseTargetIndex;
Projectile proj = Instantiate(ProjectilePrefab).GetComponent <Projectile>();
proj.transform.position = slot.transform.position;
proj.TargetFloorIndex = projectileTargetIndex;
proj.TargetHome = targetHome;
proj.Damage = baseDamage;
}
}
}
}
Cooldown -= FloorData.MaxCooldown;
}
