public double CountAverage(EResource res, EResource resDemanded, double Value) {
string key = AverageCounter.GetKey(res, resDemanded);
if (!Storage.ContainsKey(key)) {
Storage.Add(key, new AverageCounter(res, resDemanded));
}
return Storage[key].Add(Value, UpperBoundaryExclusive, LowerBoundaryExclusive, HistoricalFactor);
}
public AverageCounter GetAverage(EResource res, EResource resDemanded) {
string key = AverageCounter.GetKey(res, resDemanded);
if (Storage.ContainsKey(key)) {
return Storage[key];
}
return null;
}
public List <AverageCounter> GetSortedStorage(EResource res, bool asDemanded)
{
List <AverageCounter> list = new List <AverageCounter>();
Array resourceValues = Enum.GetValues(typeof(EResource));
foreach (var entry in resourceValues)
{
EResource resDemanded = (EResource)entry;
AverageCounter avg = (asDemanded == false ? GetAverage(res, resDemanded) : GetAverage(resDemanded, res));
if (avg != null)
{
list.Add(avg);
}
}
list.Sort(delegate(AverageCounter a, AverageCounter b) {
return(a.Value.CompareTo(b.Value));
});
// Reverse sorting only if we need the demanded resources
if (asDemanded == true)
{
list.Reverse();
}
return(list);
}
public void ChangeStat(EResource stat, int value)
{
switch (stat)
{
case EResource.danger:
danger += value;
danger = Mathf.Clamp(danger, 0, max);
break;
case EResource.sleep:
sleep += value;
sleep = Mathf.Clamp(sleep, 0, max);
break;
case EResource.hunger:
hunger += value;
hunger = Mathf.Clamp(hunger, 0, max);
break;
case EResource.dirty:
dirty += value;
dirty = Mathf.Clamp(dirty, 0, max);
break;
default:
break;
}
}
public int GetResource(EResource _resource, int _reduceAmount)
{
switch (_resource)
{
case EResource.Wood:
return(GetWood(_reduceAmount));
case EResource.Stone:
return(GetStone(_reduceAmount));
case EResource.Steel:
return(GetSteel(_reduceAmount));
case EResource.Toilette:
return(GetToilettePaper(_reduceAmount));
case EResource.Food:
return(GetFood(_reduceAmount));
break;
default:
Debug.Log("GetResError");
break;
}
UpdateResText();
return(0);
}
private bool IsResourceMax()
{
switch (CurrentResource)
{
case EResource.Wood:
bool isMax1 = PlayerData.GetInstance.GetIsWoodOnMax;
if (isMax1)
{
CurrentResource = EResource.Stone;
}
return(isMax1);
case EResource.Stone:
bool isMax2 = PlayerData.GetInstance.GetIsStoneOnMax;
if (isMax2)
{
CurrentResource = EResource.Steel;
}
return(isMax2);
case EResource.Steel:
bool isMax3 = PlayerData.GetInstance.GetIsSteelOnMax;
if (isMax3)
{
CurrentResource = EResource.Wood;
}
return(isMax3);
default:
break;
}
return(true);
}
public void AddResource(EResource _res, int _amount)
{
switch (_res)
{
case EResource.Wood:
WoodAmount += _amount;
break;
case EResource.Stone:
StoneAmount += _amount;
break;
case EResource.Steel:
SteelAmount += _amount;
break;
case EResource.Toilette:
ToilettePaperAmount += _amount;
break;
case EResource.Food:
FoodAmount += _amount;
break;
}
}
public SShopGoodsItemMeta(SShopGoodsItemMeta Obj_)
{
id = Obj_.id;
type = Obj_.type;
cost_type = Obj_.cost_type;
cost_value = Obj_.cost_value;
data = Obj_.data;
}
public SShopGoodsItemMeta(TID id_, EGoodsItemType type_, EResource cost_type_, TResource cost_value_, String data_)
{
id = id_;
type = type_;
cost_type = cost_type_;
cost_value = cost_value_;
data = data_;
}
public static string GetKey(EResource res, EResource resDemanded)
{
// Build a key from both resources
// This ensures a unique entry for each resource trade
string key = string.Format("{0};{1}", res.ToString(), resDemanded.ToString());
return(key);
}
public override void Push(CStream Stream_)
{
{
Int32 Var = 0;
Stream_.Pop(ref Var);
Type = (EResource)Var;
}
Stream_.Pop(ref Num);
}
public override void Push(JsonDataObject Value_)
{
{
Int32 Var = 0;
Value_.Pop("Type", ref Var);
Type = (EResource)Var;
}
Value_.Pop("Num", ref Num);
}
public AverageCounter GetAverage(EResource res, EResource resDemanded)
{
string key = AverageCounter.GetKey(res, resDemanded);
if (Storage.ContainsKey(key))
{
return(Storage[key]);
}
return(null);
}
Resource getSpecificSample(EResource type, float amount)
{
if (contains(type))
{
Resource r = resources [type];
return(r.removeNew(amount));
}
return(new Resource(type));
}
public double CountAverage(EResource res, EResource resDemanded, double Value)
{
string key = AverageCounter.GetKey(res, resDemanded);
if (!Storage.ContainsKey(key))
{
Storage.Add(key, new AverageCounter(res, resDemanded));
}
return(Storage[key].Add(Value, UpperBoundaryExclusive, LowerBoundaryExclusive, HistoricalFactor));
}
public AverageCounter(EResource res, EResource resDemanded) {
Resource = res;
ResourceDemanded = resDemanded;
Value = 0.0;
Count = 0;
Created = DateTime.Now;
LastUpdate = DateTime.Now;
Min = double.NaN;
Max = double.NaN;
MinTime = DateTime.Now;
MaxTime = DateTime.Now;
}
public void AddResource(EResource resourceType, int resourceAmount)
{
if (m_resourceDictionary.ContainsKey(resourceType))
{
m_resourceDictionary[resourceType] += resourceAmount;
}
else
{
m_resourceDictionary.Add(resourceType, resourceAmount);
}
m_goldAmount.text = m_resourceDictionary[resourceType].ToString();
}
public AverageCounter(EResource res, EResource resDemanded)
{
Resource = res;
ResourceDemanded = resDemanded;
Value = 0.0;
Count = 0;
Created = DateTime.Now;
LastUpdate = DateTime.Now;
Min = double.NaN;
Max = double.NaN;
MinTime = DateTime.Now;
MaxTime = DateTime.Now;
}
public override void Push(JsonDataObject Value_)
{
Value_.Pop("id", ref id);
{
Int32 Var = 0;
Value_.Pop("type", ref Var);
type = (EGoodsItemType)Var;
}
{
Int32 Var = 0;
Value_.Pop("cost_type", ref Var);
cost_type = (EResource)Var;
}
Value_.Pop("cost_value", ref cost_value);
Value_.Pop("data", ref data);
}
public void GetResources(EResource type, int qty)
{
switch (type)
{
case EResource.Copper:
m_copperAmount += qty;
break;
case EResource.Iron:
m_ironAmount += qty;
break;
default:
break;
}
}
public override void Push(CStream Stream_)
{
Stream_.Pop(ref id);
{
Int32 Var = 0;
Stream_.Pop(ref Var);
type = (EGoodsItemType)Var;
}
{
Int32 Var = 0;
Stream_.Pop(ref Var);
cost_type = (EResource)Var;
}
Stream_.Pop(ref cost_value);
Stream_.Pop(ref data);
}
public void AddRes(EResource _res, int _amount)
{
switch (_res)
{
case EResource.Wood:
AmountOfWood += _amount;
break;
case EResource.Stone:
AmountOfStone += _amount;
break;
case EResource.Steel:
AmountOfSteel += _amount;
break;
}
}
private void RemoveResourceObject(GameObject _resourceObj, EResource _res)
{
if (Resources.Contains(_resourceObj))
{
Resources.Remove(_resourceObj);
if (_res == EResource.Wood)
{
WoodPointsToAdd++;
}
Destroy(_resourceObj);
}
else
{
Debug.Log("Resource konnte in der Liste nicht gefunden werden");
}
}
public int GetStat(EResource stat)
{
switch (stat)
{
case EResource.danger:
return(danger);
case EResource.sleep:
return(sleep);
case EResource.hunger:
return(hunger);
case EResource.dirty:
return(dirty);
default:
return(0);
}
}
public List<AverageCounter> GetSortedStorage(EResource res, bool asDemanded) {
List<AverageCounter> list = new List<AverageCounter>();
Array resourceValues = Enum.GetValues(typeof(EResource));
foreach (var entry in resourceValues) {
EResource resDemanded = (EResource)entry;
AverageCounter avg = (asDemanded == false ? GetAverage(res, resDemanded) : GetAverage(resDemanded, res));
if (avg != null) {
list.Add(avg);
}
}
list.Sort(delegate(AverageCounter a, AverageCounter b) {
return a.Value.CompareTo(b.Value);
});
// Reverse sorting only if we need the demanded resources
if (asDemanded == true) {
list.Reverse();
}
return list;
}
private bool IsEmpty()
{
if (AmountOfWood <= 0)
{
AmountOfWood = 0;
CurrentResource = EResource.Stone;
if (AmountOfStone <= 0)
{
AmountOfStone = 0;
CurrentResource = EResource.Steel;
if (AmountOfSteel <= 0)
{
AmountOfSteel = 0;
CurrentResource = EResource.Wood;
}
}
}
return(AmountOfWood <= 0 && AmountOfStone <= 0 && AmountOfSteel <= 0);
}
private bool IsCurrentResEmpty()
{
switch (CurrentResource)
{
case EResource.Wood:
bool isWoodEmpty = AmountOfWood <= 0;
if (isWoodEmpty)
{
AmountOfWood = 0;
CurrentResource = EResource.Stone;
}
return(isWoodEmpty);
case EResource.Stone:
bool isStoneEmpty = AmountOfStone <= 0;
if (isStoneEmpty)
{
AmountOfWood = 0;
CurrentResource = EResource.Steel;
}
return(isStoneEmpty);
case EResource.Steel:
bool isSteelEmpty = AmountOfSteel <= 0;
if (isSteelEmpty)
{
AmountOfSteel = 0;
CurrentResource = EResource.Wood;
}
return(isSteelEmpty);
default:
break;
}
return(true);
}
public Resource(EResource type)
{
resType = type;
}
public static string GetKey(EResource res, EResource resDemanded) {
// Build a key from both resources
// This ensures a unique entry for each resource trade
string key = string.Format("{0};{1}", res.ToString(), resDemanded.ToString());
return key;
}
private void RemoveResourcesFromPanel(int amount, EResource resource)
{
StackPanel panel = spPanels.Children.OfType<StackPanel>().Where(p => (EResource)p.Tag == resource).First();
for (int i = 0; i < amount; i++)
{
panel.Children.RemoveAt(0);
}
}
public Resource(EResource type, float amt)
{
resType = type;
amount = amt;
}
public SCashItemResourcesPack(EResource Type_, TResource Num_)
{
Type = Type_;
Num = Num_;
}
protected string FormatBodyText(string inText)
{
string outText = "";
char[] inChars = inText.ToCharArray();
int lastSubSEnd = 0;
for (int i = 0; i < inText.Length; ++i)
{
if (inChars[i] == '{')
{
outText += inText.Substring(lastSubSEnd, i - lastSubSEnd);
string sample = "";
while (inChars[++i] != '}')
{
sample += inChars[i];
}
string[] splits = sample.Split(',');
bool multiplyNegative = false;
EResource action = EResource.none;
for (int j = 0; j < splits.Length; ++j)
{
switch (splits[j])
{
case "-":
multiplyNegative = true;
break;
default:
action = (EResource)System.Enum.Parse(typeof(EResource), splits[j].ToLower());
break;
}
}
int value = 0;
foreach (BasicEffect be in basicCardInfo.effects)
{
if (be.resource == action)
{
value = be.effect;
break;
}
}
if (multiplyNegative)
{
value *= -1;
}
outText += value;
lastSubSEnd = i + 1;
}
}
outText += inText.Substring(lastSubSEnd, inText.Length - lastSubSEnd);
return(outText);
}
public static ImageSource GetIcon(EResource resource)
{
switch (resource)
{
case EResource.Timber: return (ImageSource)Core.Instance.Icons["IconTimber"];
case EResource.Wheat: return (ImageSource)Core.Instance.Icons["IconWheat"];
case EResource.Ore: return (ImageSource)Core.Instance.Icons["IconOre"];
case EResource.Clay: return (ImageSource)Core.Instance.Icons["IconClay"];
case EResource.Sheep: return (ImageSource)Core.Instance.Icons["IconSheep"];
case EResource.Gold: return (ImageSource)Core.Instance.Icons["IconGold"];
}
return null;
}
public static string Location_To_String(EResource its)
{
// Explicit enum to string.
switch (its)
{
case EResource.Coal:
return "miningResource";
case EResource.Ore:
return "miningResource";
case EResource.None:
return "location";
case EResource.Timber:
return "forest";
}
return its.ToString().ToLower();
}
public SResourceTypeData(EResource Type_, TResource Data_)
{
Type = Type_;
Data = Data_;
}
public SResourceTypeData(SResourceTypeData Obj_)
{
Type = Obj_.Type;
Data = Obj_.Data;
}
private void OnResouresChanged(SettleIn.UI.Game.ResourcePicker.EAddRemove addRemove, EResource resource, int amount)
{
if (ResourcesChanged != null)
ResourcesChanged(addRemove, resource,amount);
}
void uiWanted_ResourcesChanged(ResourcePicker.EAddRemove addRemove, EResource resource, int amount)
{
CheckOffer();
}
private void OnResourcesChanged(EAddRemove addRemove, EResource resource, int amount)
{
if (ResourcesChanged != null)
ResourcesChanged(addRemove, resource, amount);
}
public SCashItemResourcesPack(SCashItemResourcesPack Obj_)
{
Type = Obj_.Type;
Num = Obj_.Num;
}
public static string Resource_To_String(EResource its)
{
return its.ToString().ToLower();
}
void uiResources_ResourcesChanged(ResourcePicker.EAddRemove addRemove, EResource resource, int amount)
{
StackPanel panel = spPanels.Children.OfType<StackPanel>().Where(p => (EResource)p.Tag == resource).First();
_AvailableResources.AddResources(resource, amount);
if (addRemove == ResourcePicker.EAddRemove.Remove)
{
RefreshPanel(panel);
}
}
