public void setExchangeItem(GameTypes.ItemType type, int amount)
{
Dictionary <GameTypes.ItemType, int> list = new Dictionary <GameTypes.ItemType, int>();
list.Add(type, amount);
setExchangeList(list);
}
public void dropdownChanged()
{
//get the chosen string
int index = mItemDropdown.value;
string choice = mOptStrings[index];
//get the type from the chosen string
string[] splitString = choice.Split('(');
if (splitString.Length != 2)
{
Debug.LogError("Reading of the choice string failed.");
}
choice = splitString[0];
//get type from the string
GameTypes.ItemType type = (GameTypes.ItemType)System.Enum.Parse(typeof(GameTypes.ItemType), choice);
if (type == 0)
{
Debug.LogError("Reading of the choise string as an Item type failed.");
}
//set chosen type
mChoiceType = type;
//set the min and max
if (!mOptDict.ContainsKey(type))
{
Debug.LogError("The options dictionary does not contain the chosen option?");
}
mChoiceMin = mOptDict[type].Key;
mChoiceMax = mOptDict[type].Value;
//reset the number field
mNumberField.text = "";
//Debug.Log(mChoiceType.ToString());
//Debug.Log(mChoiceMin.ToString());
//Debug.Log(mChoiceMax.ToString());
}
public bool makeInventorySpaceFor(GameTypes.ItemType itype)
{
//dumps everything in the inventory except items of a certain type
//return true if unit needs to return to stockpile, false other wise
Dictionary <GameTypes.ItemType, int> dict = getInventoryDictionary();
Building sp = getStockpile();
bool new_action = false;
foreach (KeyValuePair <GameTypes.ItemType, int> pair in dict)
{
//skip- if the item is equipped
Item it = getItemOfType(pair.Key);
EquipItem ei = it as EquipItem;
if (ei)
{
if (ei.isEquipped())
{
continue;
}
}
//skip if its the item we want
if (pair.Key != itype)
{
//make an exchange with the stockpile
exchangeWith(sp, pair.Key, pair.Value);
new_action = true;
}
}
return(new_action);
}
//init item function
public static Item initItem(GameTypes.ItemType type, Transform parent)
{
Item item = GameObject.Instantiate(getItem(type.ToString()), parent).GetComponent <Item>();
item.setAmount(0);
item.setType(type);
return(item);
}
public void exchangeWith(EntityAction target, GameTypes.ItemType type, int amount)
{
Exchange ex = ObjectManager.initExchange(transform);
ex.setTarget(target);
ex.setExchangeItem(type, amount);
mActions.prependAction(ex);
}
//init Resource function
public static Resource initResource(Vector3 pos, GameTypes.ItemType type, Region reg)
{
Resource res = GameObject.Instantiate(getResource(type.ToString()), reg.getResourceObject().transform).GetComponent <Resource>();
res.gameObject.transform.position = pos;
res.mType = type;
reg.addEntity("resources", res);
res.mAmount = Globals.RESOURCE_DEFAULT_AMOUNT;
return(res);
}
public Item getItemOfType(GameTypes.ItemType type)
{
foreach (Item item in mItems)
{
if (item.getType() == type)
{
return(item);
}
}
return(null);
}
private void _removeItemOfType(GameTypes.ItemType itype)
{
int ind = _getIndexOfItemOfType(itype);
if (ind < 0 || ind > mItems.Count - 1)
{
return;
}
//THIS SHOULD REALLY PLACE AN ENTITY THAT IS A BAG OF ITEMS THAT CAN BE PICKED UP BY SOMEONE ELSE
Destroy(mItems[ind].gameObject);
mItems.RemoveAt(ind);
}
public void returnToStockpile(GameTypes.ItemType type)
{
Item item = getItemOfType(type);
if (!item)
{
//this means the unit doesnt contain any of this item, which means the inventory is already full
//so dump the inventory
//Debug.Log("No item of type, the inventory must already be full. Dumping inventory");
dumpInventory();
return;
}
exchangeWith(getStockpile(), type, item.getAmount());
}
public void removeChoice()
{
//remove the last element from the choice dict
GameTypes.ItemType rmtype = GameTypes.ItemType.Unknown;
foreach (KeyValuePair <GameTypes.ItemType, int> entry in mExchangeList)
{
rmtype = entry.Key;
}
if (rmtype != GameTypes.ItemType.Unknown)
{
mExchangeList.Remove(rmtype);
updateSelection();
}
}
//-------------------------------------------------------------------------------------------------
// private methods
//-------------------------------------------------------------------------------------------------
private int _getIndexOfItemOfType(GameTypes.ItemType itype)
{
int ind = 0;
foreach (Item item in mItems)
{
if (item.getType() == itype)
{
return(ind);
}
ind++;
}
return(-1);
}
public Resource getClosestResourceOfType(GameTypes.ItemType type, Entity ent)
{
Resource res = null;
float mag = -1f;
float close_mag = -1f;
foreach (Resource lres in mGroupMap["resources"])
{
if (lres.mType == type)
{
mag = (ent.pointOfTouchingBounds(lres) - ent.transform.position).magnitude;
if (close_mag < 0 || mag < close_mag)
{
close_mag = mag;
res = lres;
}
}
}
return(res);
}
//-------------------------------------------------------------------------------------------------
// private methods
//-------------------------------------------------------------------------------------------------
private void setupType()
{
//sets up the type info in case it isnt initalised correct and so I can remember what it should be
switch (mType)
{
case GameTypes.BuildingType.Farm:
getInventory().mCapacity = 50; //default 50
mUnitInventory.mCapacity = 2;
mMaxProgress = 100; //default 100
mCreateItemType = GameTypes.ItemType.Food;
mWorkers.mCapacity = 2;
break;
default:
WorkedProdBuilding wpb = (WorkedProdBuilding)this;
if (!wpb)
{
Debug.LogError("Building type not recognised");
}
break;
}
}
public void populate(EntityAction acter, EntityAction target)
{
gameObject.SetActive(true);
mCancelled = false;
mInUse = true;
//add options to the acter drop down
//List<string> act_opts = new List<string> { "Item1", "Item2", "Item3", "Item4" };
//mItemDropdown.AddOptions(act_opts);
//make lsit of potential options
Dictionary <GameTypes.ItemType, int> act_items = acter.getInventoryDictionary();
Dictionary <GameTypes.ItemType, int> tar_items = target.getInventoryDictionary();
Dictionary <GameTypes.ItemType, KeyValuePair <int, int> > opts_dict = new Dictionary <GameTypes.ItemType, KeyValuePair <int, int> >();
KeyValuePair <int, int> temp_kp = new KeyValuePair <int, int>();
foreach (KeyValuePair <GameTypes.ItemType, int> it in act_items)
{
if (!opts_dict.ContainsKey(it.Key))
{
//the opt dict doesnt already contain this key
//get the max value which is how much the acter can give
temp_kp = new KeyValuePair <int, int>(0, it.Value);
opts_dict.Add(it.Key, temp_kp);
}
else
{
Debug.LogError("Opts Dict already contains the ItemType key. This shoudln't be possible if the inventory only has one of each item as it should.");
}
}
//now fill the min value with the target items
foreach (KeyValuePair <GameTypes.ItemType, int> it in tar_items)
{
if (opts_dict.ContainsKey(it.Key))
{
//the acter also has this item type
opts_dict[it.Key] = new KeyValuePair <int, int>(-1 * it.Value, opts_dict[it.Key].Value);
}
else
{
//the acter didnt contain this item and we need to make a ew entry
temp_kp = new KeyValuePair <int, int>(-1 * it.Value, 0);
opts_dict.Add(it.Key, temp_kp);
}
}
//now make a string for each entry
List <string> opt_strings = new List <string>();
GameTypes.ItemType first_opt = GameTypes.ItemType.Unknown;
int i = 0;
foreach (GameTypes.ItemType type in opts_dict.Keys)
{
opt_strings.Add(string.Format("{0}({1}:{2})", type.ToString(), opts_dict[type].Key, opts_dict[type].Value));
if (i == 0)
{
first_opt = type;
}
i++;
}
mOptDict = opts_dict;
mOptStrings = opt_strings;
mItemDropdown.AddOptions(opt_strings);
//set the first option as the chosen option
if (first_opt != GameTypes.ItemType.Unknown)
{
mChoiceType = first_opt;
mChoiceMin = mOptDict[first_opt].Key;
mChoiceMax = mOptDict[first_opt].Value;
mChoiceValue = mChoiceMax;
}
//bring to front of the sidebar
transform.SetAsLastSibling();
mPopulated = true;
}
public void setType(GameTypes.ItemType t)
{
mType = t;
}
private void doExchange()
{
//the exchange speed is too fast so only collect every nth cycle
if (mCycleCounter % mCyclesToSkip == 0)
{
if (mCycleCounter == mCyclesToSkip)
{
mCycleCounter = 1;
}
else
{
mCycleCounter++;
}
return;
}
//Debug.Log("doing the exchange");
//Debug.Log("in do exchange size of the exchange list is "+mExchangeList.Count.ToString());
mDoneType = GameTypes.ItemType.Unknown;
mEmptyItem = false;
//loop over the type,amount pairs in the ExchangeList
List <GameTypes.ItemType> tlist = new List <GameTypes.ItemType>(mExchangeList.Keys);
foreach (GameTypes.ItemType itype in tlist)
{
int ival = mExchangeList[itype];
//check if the amount is almost zero
if (Mathf.Abs(ival) <= 0)
{
//if its zero remove from the ExchangeList
setRemoveItem(itype);
continue;
}
//split it into separate functions for positive and negative amounts
//positive amount, move items from acter to target
float cycle_amount = mActer.getExchangeSpeed() / 0.1f;
if (ival > 0)
{
//Debug.Log("positive value");
if (checkAndExchangeItems(mActer, mTarget, itype, cycle_amount) == false)
{
continue;
}
else
{
break;
}
}
//negative amount, move items from target to acter
else if (ival < 0)
{
//Debug.Log("negative value");
if (checkAndExchangeItems(mTarget, mActer, itype, cycle_amount) == false)
{
continue;
}
else
{
break;
}
}
}
//remove the empty entries in ExchangeList
if (mEmptyItem && mDoneType != GameTypes.ItemType.Unknown)
{
mExchangeList.Remove(mDoneType);
}
}
public bool getResource(GameTypes.ItemType type, int amount = -1)
{
//tells the unit to get some of a resource. Chceks the unit inventory, if the
//unit has none of the item it checks the stockpile and tells them to get the item from there
//if theres none in the stockpile it tells them to go and find the resource.
//amount set to -1 means fill the inventory
//what amount do we need?
int invcap = getInventory().mCapacity;
int invsize = getInventorySize();
if (amount == -1 || invcap < invsize + amount)
{
amount = invcap - invsize;
}
//check the inventory and do nothing if the unit has the item
Item item = getItemOfType(type);
if (item)
{
//unit has it, do nothing, if it has the desired amount
if (item.getAmount() >= amount)
{
return(true);
}
}
//does the stockpile have some
Building sp = getStockpile();
item = sp.getItemOfType(type);
if (item)
{
//is the inventory full
if (isInventoryFull())
{
//is the stockpile full
if (sp.isInventoryFull())
{
dropInventory();
}
else
{
dumpInventory();
}
}
//stockpile has it, send Unit to get it
exchangeWith(sp, type, -1 * amount);
return(false);
}
//stockpile doesn't have it, get the closest resource of this type
Resource res = mTown.getRegion().getClosestResourceOfType(type, this);
if (res)
{
//Debug.Log(res.transform.position);
//go and collect this resource for one cycle
collectResource(res, true);
}
return(false);
}
//-------------------------------------------------------------------------------------------------
// private methods
//-------------------------------------------------------------------------------------------------
private bool checkAndExchangeItems(EntityAction giver, EntityAction getter, GameTypes.ItemType type, float cycle_amount)
//checks everything and moves some of one item from the giver to the getter
{
//check the progress
mCycleProgress += cycle_amount;
int amount = 0;
if (mCycleProgress >= 100)
{
amount = 1;
mCycleProgress = 0f;
}
else
{
return(false);
}
//does the acter have the item?
Item act_item = giver.getItemOfType(type);
if (!act_item)
{
//acter doesnt have the item, so cant do exchange
setRemoveItem(type);
//Debug.Log("acter doesnt have the item");
return(false);
}
//does the acter have enough of the item
if (act_item.getAmount() < amount)
{
amount = act_item.getAmount();
//Debug.Log("acter doesnt have enough of the item, adjusting amount");
}
//does the target have the item to receive?
Item tar_item = getter.getItemOfType(type);
if (!tar_item)
{
//target doesnt have the item, make one
tar_item = ObjectManager.initItem(type, getter.getInventory().transform);
getter.addItem(tar_item);
//Debug.Log("target doesnt have the item");
}
//does the target have enough space for this item
int cap = getter.getInventory().mCapacity;
int invsize = getter.getInventorySize();
if (invsize + amount > cap)
{
//target doesnt have space, reduce the amount
amount = cap - invsize;
if (amount <= 0)
{
setRemoveItem(type);
return(false);
}
//control flow moves on if cycle amount is big enough
}
//target has space, add and remove the amount
tar_item.setAmount(tar_item.getAmount() + amount);
act_item.setAmount(act_item.getAmount() - amount);
if (mExchangeList[type] >= 0)
{
mExchangeList[type] = mExchangeList[type] - amount;
}
else if (mExchangeList[type] < 0)
{
mExchangeList[type] = mExchangeList[type] + amount;
}
return(false);
}
public void setTarget(Resource target)
{
mTarget = target;
mType = mTarget.mType;
}
private void setRemoveItem(GameTypes.ItemType type)
{
//sets the members to remove an element from the list
mDoneType = type;
mEmptyItem = true;
}
public Item getItemOfType(GameTypes.ItemType type)
{
return(mInventory.getItemOfType(type));
}