public void Update()
{
data.value = valueProgression.Evaluate(data.level);
data.cost.Clear();
if (!IsMaxLevel())
{
AtomAmo amo = new AtomAmo();
for (int i = 0; i < atomProgression.Count; i++)
{
amo.amo = (int)amoProgression[i].Evaluate(data.level);
int index = (int)atomProgression[i].Evaluate(data.level);
if (index == 0)
{
amo.atom = null;
}
else
{
amo.atom = Game.Instance.gameData.FindAtom(index);
}
data.cost.Add(amo);
}
}
}
public CraftResult Craft(Craftable c, int amount)
{
CraftResult result = new CraftResult();
result.atomsUsed = new List <AtomAmo>();
var atoms = c.GetAtomsForProduction();
for (int i = 0; i < atoms.Length; i++) // Find Minumum
{
var atomAmo = atoms[i];
AtomData data = Game.Instance.gameData.FindAtomData(atomAmo.atom.GetAtomicNumber());
int needed = atomAmo.amo * amount;
if (data.GetCurrAmo() < needed)
{
amount = data.GetCurrAmo() / atomAmo.amo;
}
}
for (int i = 0; i < atoms.Length; i++)
{
var atomAmo = atoms[i];
AtomData data = Game.Instance.gameData.FindAtomData(atomAmo.atom.GetAtomicNumber());
int needed = atomAmo.amo * amount;
data.Lose(needed);
AtomAmo atomUsed = new AtomAmo();
atomUsed.atom = atomAmo.atom;
atomUsed.amo = needed;
result.atomsUsed.Add(atomUsed);
}
result.amountCreated = amount;
int amoOfCraftables;
if (!craftables.TryGetValue(c, out amoOfCraftables))
{
craftables[c] = amount;
}
else
{
craftables[c] = amoOfCraftables + amount;
}
if (OnCraftableProduced != null)
{
OnCraftableProduced(c, amount);
}
return(result);
}
public AtomCollisionResult ProduceCombine(Atom a, Atom b, int aAmo, int bAmo)
{
AtomCollision info = EstimateCombine(a, b, aAmo, bAmo);
AtomCollisionResult result = new AtomCollisionResult();
result.atomsProduced = new List <AtomAmo>();
result.atomsUsed = new List <AtomAmo>();
AtomData aData = Game.Instance.gameData.FindAtomData(a.GetAtomicNumber());
AtomData bData = Game.Instance.gameData.FindAtomData(b.GetAtomicNumber());
int usedAmo = Mathf.Min(Mathf.Min(aAmo, aData.GetCurrAmo()), Mathf.Min(bAmo, bData.GetCurrAmo()));
Atom target = info.targetAtom;
int maxAmo = info.amo;
float successChance = info.success;
float stabilityChance = 1.0f;
stabilityChance = info.stability;
int produced = (int)(maxAmo * successChance);
int stabilized = (int)(produced * stabilityChance);
AtomAmo atomAmo = new AtomAmo();
atomAmo.amo = stabilized;
atomAmo.atom = target;
result.atomsProduced.Add(atomAmo);
Game.Instance.Absorb(target, stabilized);
AtomAmo atomAUsed = new AtomAmo();
atomAUsed.atom = a;
atomAUsed.amo = usedAmo;
result.atomsUsed.Add(atomAUsed);
AtomAmo atomBUsed = new AtomAmo();
atomBUsed.atom = b;
atomBUsed.amo = usedAmo;
result.atomsUsed.Add(atomBUsed);
Game.Instance.Use(a, usedAmo);
Game.Instance.Use(b, usedAmo);
if (OnAtomCombine != null)
{
OnAtomCombine(target, stabilized);
}
return(result);
}
public void AddAtom(AtomRatio a)
{
atoms.Add(a);
currAtoms.Clear();
AtomAmo amo = new AtomAmo();
for (int i = 0; i < atoms.Count; i++)
{
amo.atom = atoms[i].atom;
double ratio = atoms[i].ratio / 100d;
amo.amo = (int)(ratio * totalAtomAmo);
currAtoms.Add(amo);
}
}
public bool Upgrade()
{
bool success = CanUpgrade();
if (success)
{
for (int i = 0; i < data.cost.Count; i++) // Use
{
AtomAmo atomCost = data.cost[i];
if (atomCost.atom == null)
{
continue;
}
AtomData atomData = Game.Instance.gameData.FindAtomData(data.cost[i].atom.GetAtomicNumber());
atomData.Lose(data.cost[i].amo);
}
data.level++;
data.value = valueProgression.Evaluate(data.level);
data.cost.Clear();
if (!IsMaxLevel())
{
AtomAmo amo = new AtomAmo();
for (int i = 0; i < atomProgression.Count; i++)
{
amo.amo = (int)amoProgression[i].Evaluate(data.level);
int index = (int)atomProgression[i].Evaluate(data.level);
if (index == 0)
{
amo.atom = null;
}
else
{
amo.atom = Game.Instance.gameData.FindAtom(index);
}
data.cost.Add(amo);
}
}
}
return(success);
}
public AtomCollisionResult ProduceSplit(Atom a, int aAmo)
{
AtomCollision info = EstimateSplit(a, aAmo);
AtomData aData = Game.Instance.gameData.FindAtomData(a.GetAtomicNumber());
aAmo = Mathf.Min(aAmo, aData.GetCurrAmo());
AtomCollisionResult result = new AtomCollisionResult();
result.atomsProduced = new List <AtomAmo>();
result.atomsUsed = new List <AtomAmo>();
Atom target = info.targetAtom;
// Split
int produced = (int)(info.amo * info.success); // Random Loss
// Stabilize
int stabilized = (int)(produced * info.stability);
// Result
AtomAmo atomAmo = new AtomAmo();
atomAmo.amo = stabilized;
atomAmo.atom = target;
result.atomsProduced.Add(atomAmo);
Game.Instance.Absorb(target, stabilized);
// Used
AtomAmo atomAUsed = new AtomAmo();
atomAUsed.atom = a;
atomAUsed.amo = aAmo;
result.atomsUsed.Add(atomAUsed);
Game.Instance.Use(a, aAmo);
if (OnAtomSplit != null)
{
OnAtomSplit(target, stabilized);
}
return(result);
}
public void Produce()
{
PlayerData.AtomCollisionResult result;
if (toHydrogenToggle.isOn)
{
result = new PlayerData.AtomCollisionResult();
result.atomsProduced = new List <AtomAmo>();
result.atomsUsed = new List <AtomAmo>();
AtomAmo atomAmo = new AtomAmo();
PlayerData.AtomCollisionResult resultTemp;
Atom atom = atomA;
int amo = (int)atomAAmo.value;
do
{
atomAmo.atom = atom;
atomAmo.amo = amo;
result.atomsUsed.Add(atomAmo);
resultTemp = Game.Instance.playerData.ProduceSplit(atom, amo);
atom = resultTemp.atomsProduced[0].atom;
amo = resultTemp.atomsProduced[0].amo;
} while (atom.GetAtomicNumber() != 1);
result.atomsProduced.Add(resultTemp.atomsProduced[0]);
}
else
{
result = Game.Instance.playerData.ProduceSplit(atomA, (int)atomAAmo.value);
}
// Display Popup
resultUI.Setup(result.atomsProduced, result.atomsUsed);
Reset();
for (int i = 0; i < result.atomsProduced.Count; i++)
{
print("Atoms Produced: " + result.atomsProduced[i].atom.GetName() + " " + result.atomsProduced[i].amo);
}
}
private void Start()
{
renderer = GetComponent <SpriteRenderer>();
aliveColor = renderer.color;
this.gameObject.layer = LayerMask.NameToLayer("AtomCollector");
AtomAmo amo = new AtomAmo();
float totalRatio = 0f;
for (int i = 0; i < atoms.Count; i++)
{
amo.atom = atoms[i].atom;
double ratio = atoms[i].ratio / 100d;
amo.amo = (int)(ratio * totalAtomAmo);
currAtoms.Add(amo);
totalRatio += atoms[i].ratio;
}
if (100.0f - totalRatio > .001f || totalRatio > 100.0f)
{
print(name + " has Ratio of " + totalRatio);
}
currAtomAmo = totalAtomAmo;
currColor = aliveColor;
int tempAtomAmo = GetSum(currAtoms);
if (tempAtomAmo > 0)
{
currAtomAmo = tempAtomAmo;
}
//if(tempAtomAmo != currAtomAmo) {
// print("Object " + name + " Total Amo (" + totalAtomAmo + ") doesnt equal Curr Amo (" + tempAtomAmo +
// ")");
//}
}
public bool CanUpgrade()
{
if (IsMaxLevel())
{
return(false);
}
for (int i = 0; i < data.cost.Count; i++) // Validation
{
AtomAmo atomCost = data.cost[i];
if (atomCost.atom == null)
{
continue;
}
AtomData atomData = Game.Instance.gameData.FindAtomData(atomCost.atom.GetAtomicNumber());
if (atomData.GetCurrAmo() < atomCost.amo)
{
return(false);
}
}
return(true);
}
public void Init()
{
data.level = 1;
data.value = valueProgression.Evaluate(data.level);
AtomAmo amo = new AtomAmo();
data.cost = new List <AtomAmo>();
for (int i = 0; i < atomProgression.Count; i++)
{
amo.amo = (int)amoProgression[i].Evaluate(data.level);
int index = (int)atomProgression[i].Evaluate(data.level);
if (index == 0)
{
amo.atom = null;
}
else
{
amo.atom = Game.Instance.gameData.FindAtom(index);
}
data.cost.Add(amo);
}
}
public List <AtomAmo> Absorb()
{
List <AtomAmo> atomsToBeAbsorbed = new List <AtomAmo>();
if (Time.time < nextCollectionTime)
{
return(atomsToBeAbsorbed);
}
PlayerData playerData = Game.Instance.playerData;
AtomAmo amoToCollect = new AtomAmo();
int atomCount = 0;
float weightLimit = playerData.GetValue(PlayerData.UpgradeType.Collect_Weight);
float speedRatio = playerData.GetValue(PlayerData.UpgradeType.Collect_Speed);
int efficiencyAmo = (int)playerData.GetValue(PlayerData.UpgradeType.Collect_Efficiency);
for (int i = 0; i < currAtoms.Count; i++)
{
AtomAmo atomAmo = currAtoms[i];
if (atomAmo.amo <= 0)
{
continue;
}
AtomInfo info = Game.Instance.gameData.FindAtomInfo(atomAmo.atom.GetAtomicNumber());
if (info.GetProtons() + info.GetNeutrons() > weightLimit)
{
continue;
}
int maxAmo = efficiencyAmo;/// info.GetProtons();
if (maxAmo < 2)
{
maxAmo = 2;
}
int randAmo = UnityEngine.Random.Range(0, maxAmo);
if (randAmo == 0)
{
continue;
}
amoToCollect.atom = atomAmo.atom;
amoToCollect.amo = randAmo > atomAmo.amo ? atomAmo.amo : randAmo;
atomsToBeAbsorbed.Add(amoToCollect);
atomCount += amoToCollect.amo;
if (hasLife)
{
atomAmo.amo -= amoToCollect.amo; // Because Dumb
currAtomAmo -= amoToCollect.amo;
currAtoms[i] = atomAmo;
}
}
// Time
if (atomCount != 0)
{
nextCollectionTime = Time.time + collectionPause * speedRatio;
}
// Life
if (hasLife)
{
CheckLife();
}
// Flash
if (canFlash && !isFlashing && atomCount != 0 && !IsDead())
{
StartCoroutine(Flash());
}
return(atomsToBeAbsorbed);
}
public void SetUpgradeInfo(PlayerData.UpgradeType type)
{
RemoveUpgrade();
if ((int)type >= choices.Count)
{
return;
}
// Button Stuff
ChoiceOption choiceOption = choices[(int)type];
choiceOption.SetButtonEvent(() => {
RemoveUpgrade();
AudioManager.Instance.PlaySound(choiceClick);
});
choiceOption.SetColors(ChoiceOption.defaultPressedColor, ChoiceOption.defaultHoverColor, ChoiceOption.defaultNormalColor);
choiceOption.SetFocus(false);
currUpgradeType = type;
// Display Stuff
List <AtomAmo> atomsNeeded = Game.Instance.playerData.GetCost(type);
upgradeName.text = Game.Instance.playerData.GetName(type);
upgradeDesc.text = Game.Instance.playerData.GetDescription(type);
double currValue = System.Math.Round(Game.Instance.playerData.GetValue(type), 3);
double nextValue = System.Math.Round(Game.Instance.playerData.GetNextValue(type), 3);
if (type == PlayerData.UpgradeType.Collect_Efficiency)
{
currValue *= 100;
nextValue *= 100;
}
upgradeCurrValue.text = "Curr Value: " + currValue + " " +
Game.Instance.playerData.GetMeasurementAbbr(type); //currValue;
upgradeNextValue.text = "Next Value: " + nextValue + " " +
Game.Instance.playerData.GetMeasurementAbbr(type); //nextValue;
bool canCraft = true;
upgradeAtomName.text = "";
upgradeAtomNeed.text = "";
upgradeAtomHave.text = "";
for (int i = 0; i < atomsNeeded.Count; i++)
{
AtomAmo cost = atomsNeeded[i];
if (cost.atom == null)
{
continue;
}
int amoHave = Game.Instance.gameData.FindAtomData(cost.atom.GetAtomicNumber()).GetCurrAmo();
if (amoHave >= cost.amo)
{
upgradeAtomName.text += cost.atom.GetName() + "\n";
upgradeAtomNeed.text += cost.amo + "\n";
upgradeAtomHave.text += amoHave + "\n";
}
else
{
upgradeAtomName.text += "<color=#ff8080>" + cost.atom.GetName() + "\n</color>";
upgradeAtomNeed.text += "<color=#ff8080>" + cost.amo + "\n</color>";
upgradeAtomHave.text += "<color=#ff8080>" + amoHave + "\n</color>";
canCraft = false;
}
}
upgradeBtn.interactable = canCraft;
}
