public void swapWith(MenuSlot releaseTo)
{
MenuSlotItem meTemp = this.getItem();
MenuSlotItem youTemp = releaseTo.getItem();
bool changedInventory = false;
//If the two items can't be combined
if (!combineSuccess(releaseTo))
{
//Maybe add/remove the items to the home inventories
//tip to future William: only use one | so the evaluation doesn't short curcuit
changedInventory = changedInventory | maybeAddToInventory(releaseTo);
changedInventory = changedInventory | maybeRemoveFromInventory(releaseTo);
changedInventory = changedInventory | releaseTo.maybeAddToInventory(this);
changedInventory = changedInventory | releaseTo.maybeRemoveFromInventory(this);
//Swap them
this.setItem(youTemp);
releaseTo.setItem(meTemp);
}
if (changedInventory && releaseTo.type != SlotType.DisplaySlot)
{
HomeBaseUIController hbuic = GetComponentInParent <HomeBaseUIController>();
hbuic.updateInventoryItemCount();
}
}
//Gathers all the items in the player inventory and stores them in the home inventory
public void storeAllItems()
{
dropItem();
//get the 0th home inventory slot
//MenuSlot storeSlot = homeFlowerSlots[0].GetComponent<MenuSlot>();
//Loop through the inventory
for (int ii = 0; ii < fpc.inventorySize; ii += 1)
{
//Store the item if it's not null
MenuSlot storeItemSlot = playerInventoryContainer.GetChild(ii).GetComponent <MenuSlot>();
MenuSlotItem storeItem = storeItemSlot.getItem();
if (storeItem != null)
{
storeItemSlot.storeItem(false);
}
}
updateInventoryItemCount();
//If the player is in the flower tab then refresh the tab
if (currentTab == TabType.Flowers)
{
SetFlowersTab();
}
}
private bool combineSuccess(MenuSlot releaseTo)
{
MenuSlotItem meTemp = this.getItem();
MenuSlotItem youTemp = releaseTo.getItem();
//If the two items should be merged
if (this.getItem() != null && releaseTo.getItem() != null && meTemp.id == youTemp.id && meTemp.isFlower == youTemp.isFlower)
{
HomeBaseUIController hbuic = GetComponentInParent <HomeBaseUIController>();
if (releaseTo.type == SlotType.PlayerInventory)//if moving to inventory
{
hbuic.addHomeInventoryItem(releaseTo.getItem().id, -releaseTo.getItem().count, releaseTo.getItem().isFlower);
}
else if (this.type == SlotType.PlayerInventory)//if moving out of inventory
{
hbuic.addHomeInventoryItem(this.getItem().id, this.getItem().count, this.getItem().isFlower);
}
//Set the other item's count
int oldCount = releaseTo.getItem().count;
//Destroy the item in the other slot because the grabbed item will be stored
GameObject.Destroy(releaseTo.getItem().gameObject);
//Set the other slot to the grabbed item
releaseTo.setItem(this.getItem());
releaseTo.setCount(oldCount + this.getItem().count);
//Clear the item in the grabbed slot
this.setItem(null);
//It was successful so return true
return(true);
}
return(false);
}
//Shifts all the flowers to the next slot in the list
public void reSortFlowerList()
{
if (currentTab == TabType.Flowers)
{
int ii = 0;
MenuSlotItem previousItem = null;
while (ii < homeFlowerSlots.Count)
{
MenuSlot fromSlot = homeFlowerSlots[ii].GetComponent <MenuSlot>();
MenuSlotItem tempItem = fromSlot.getItem();
fromSlot.setItemNoSort(previousItem);
previousItem = tempItem;
//Break out of the lop
if (previousItem == null)
{
break;
}
ii += 1;
}
if (previousItem != null)
{
Destroy(previousItem.gameObject);
}
}
}
//Returns the first slot wit hthe gien item
public MenuSlot findSlotWithItem(MenuSlotItem inItem)
{
//Grab all the slots
MenuSlot[] slots = GameObject.FindObjectsOfType <MenuSlot>();
//Loop through the slots
foreach (MenuSlot s in slots)
{
//If the slot is in the home inventory or the display slot
//(both slots hold items that are currently "in" the home inventory
if (s.type == MenuSlot.SlotType.HomeInventory || s.type == MenuSlot.SlotType.DisplaySlot || s.type == MenuSlot.SlotType.DecorationSlot)
{
//If there's an item at the slot
if (s.getItem() != null)
{
//If it matches id and isFlower
if (s.getItem().id == inItem.id && s.getItem().isFlower == inItem.isFlower)
{
return(s);
}
}
}
}
return(null);
}
private void FillPlayerInventoryPanel()
{
//Get the player's inventory
UIControllerScript uic = otherCanvas.GetComponent <UIControllerScript>();
List <Placeable> inventoryData = uic.getInventoryData();
List <int> inventoryCount = uic.getInventoryCount();
//Get the panel to add to
RectTransform pip = GameObject.Find("playerInventoryPanel").GetComponent <RectTransform>();
for (int ii = 0; ii < fpc.inventorySize; ii++)
{
//Add item to player inventory rect
//Build the slot regardless of whether or not it will be empty
GameObject slotObject = Instantiate(playerInventorySlotPrefab, pip);
MenuSlot slot = slotObject.GetComponent <MenuSlot>();
slot.slotIndex = ii;
//Add an item to the slot if it shouldn't be empty
if (inventoryData[ii] != null && inventoryCount[ii] > 0)
{
//Add the slot item to the slot
GameObject itemObject = Instantiate(slotItemPrefab, slot.GetComponent <RectTransform>());
MenuSlotItem item = itemObject.GetComponent <MenuSlotItem>();
item.setID(inventoryData[ii].id, inventoryData[ii].isFlower);
item.setCount(inventoryCount[ii]);
slot.GetComponent <MenuSlot>().setItem(item);
}
}
}
private GameObject newSlotItem(uint id, int count, bool isFlower)
{
HomeBaseUIController hbuic = GetComponentInParent <HomeBaseUIController>();
GameObject resultObject = GameObject.Instantiate(hbuic.slotItemPrefab);
MenuSlotItem slotItem = resultObject.GetComponent <MenuSlotItem>();
slotItem.count = count;
slotItem.setID(id, isFlower);
return(resultObject);
}
public void updateFlowerDisplaySlot(MenuSlotItem item)
{
if (currentTab == TabType.Flowers || currentTab == TabType.Decorations)
{
GameObject sellButton = GameObject.Find("sellButton");
//Remove all the listeners because they ended up stacking on top of each other every time the display slot was updated
sellButton.GetComponent <UnityEngine.UI.Button>().onClick.RemoveAllListeners();
if (item != null)
{
if (item.isFlower)
{
uint sellID = item.id;
int sellCount = item.count;
int sellPrice = HomeBaseController.instance.getFlowerValue(sellID);
sellButton.GetComponentInChildren <Text>().text = sellPrefix + ": " + sellPrice;
sellButton.GetComponent <UnityEngine.UI.Button>().interactable = true;
sellButton.GetComponent <UnityEngine.UI.Button>().onClick.AddListener(delegate { sellFlower(sellID, 1); });
updatePriceBreakdownButton(true);
}
else
{
uint sellID = item.id;
int actuallySellable = 1;
try
{
if (homeDecorationsBought[sellID] < actuallySellable)
{
actuallySellable = homeDecorationsBought[sellID];
}
}
catch { actuallySellable = 0; }
int sellPrice = (int)(decorationValue[(uint)sellID] * 0.75f) * actuallySellable;
sellButton.GetComponentInChildren <Text>().text = sellPrefix + ": " + sellPrice;
sellButton.GetComponent <UnityEngine.UI.Button>().interactable = true;
sellButton.GetComponent <UnityEngine.UI.Button>().onClick.AddListener(delegate { sellDecoration(sellID, 1); });
updatePriceBreakdownButton(false, sellID, item.count);
}
}
else
{
sellButton.GetComponentInChildren <Text>().text = sellPrefix;
sellButton.GetComponent <UnityEngine.UI.Button>().interactable = false;
if (currentTab == TabType.Flowers)
{
updatePriceBreakdownButton(true);
}
else if (currentTab == TabType.Decorations)
{
updatePriceBreakdownButton(false);
}
}
}
}
public void setItemNoSort(MenuSlotItem item)
{
this.item = item;
if (item != null)
{
item.GetComponent <RectTransform>().SetParent(gameObject.GetComponent <RectTransform>(), false);
item.GetComponent <RectTransform>().localPosition = Vector3.zero;
GetComponent <RectTransform>().ForceUpdateRectTransforms();
item.GetComponent <RectTransform>().sizeDelta = Vector2.zero;
}
}
private void postSetDecorationsTab()
{
Transform grid = currentPageObject.transform.Find("decorationInventoryHolder");
Canvas myCanvas = transform.GetComponentInParent <Canvas>();
GetComponent <RectTransform>().ForceUpdateRectTransforms();
float rectWidth = grid.GetComponent <RectTransform>().rect.width *myCanvas.scaleFactor * .5f;
float rectHeight = grid.GetComponent <RectTransform>().rect.height *myCanvas.scaleFactor * .5f;
rectHeight = Mathf.Min(rectWidth * .75f, rectHeight);
List <GameObject> slotList = new List <GameObject>();
for (int ii = 0; ii < 4; ii += 1)
{
uint itemID = (uint)decorationTabIDs[decorationTab, ii];
//GetComponent<RectTransform>().ForceUpdateRectTransforms();
GameObject seller = Instantiate(decorationPurchasePrefab, grid);
GameObject slot = Instantiate(homeInventorySlotPrefab, seller.GetComponent <RectTransform>());
slotList.Add(slot);
Text priceText = seller.GetComponentInChildren <Text>();
slot.transform.SetAsFirstSibling();
slot.GetComponent <MenuSlot>().slotIndex = 0;
slot.GetComponent <MenuSlot>().type = MenuSlot.SlotType.DecorationSlot;
GameObject item = Instantiate(slotItemPrefab, slot.GetComponent <RectTransform>());
MenuSlotItem itemObject = item.GetComponent <MenuSlotItem>();
itemObject.setID(itemID, false);
itemObject.setCount(getHomeInventoryCount(itemID, false));
slot.GetComponent <MenuSlot>().setItemNoSort(itemObject);
slot.GetComponent <MenuSlot>().getItem().updateModelScale(rectWidth * .5f, rectHeight);
GameObject buyButtom = seller.transform.GetComponentInChildren <UnityEngine.UI.Button>().gameObject;
priceText.text = "PRICE: " + decorationValue[(uint)decorationTabIDs[decorationTab, ii]];
buyButtom.GetComponent <UnityEngine.UI.Button>().onClick.AddListener(delegate { purchaseDecoration(itemID, slot.GetComponent <MenuSlot>()); });
buyButtom.GetComponentInChildren <Text>().text = "BUY";
}
GameObject priceBreakdownButton = GameObject.Find("priceBreakdownButton");
priceBreakdownButton.GetComponentInChildren <Text>().text = sellAllPrefix;
grid.GetComponent <GridLayoutGroup>().cellSize = new Vector2(rectWidth, rectHeight);
//LayoutRebuilder.ForceRebuildLayoutImmediate(GetComponent<RectTransform>());
GetComponent <RectTransform>().ForceUpdateRectTransforms();
updatePriceBreakdownButton(false);
//Set up the sell display slot
updateFlowerDisplaySlot(null);
}
public void setCount(int count)
{
this.getItem().setCount(count);
if (this.type != SlotType.DecorationSlot)
{
if (this.getItem().count <= 0)
{
GameObject.Destroy(this.getItem().gameObject);
this.item = null;
}
}
}
private void purchaseDecoration(uint id, MenuSlot item)
{
if (grabbedSlot == null)
{
if (fpc.money >= decorationValue[(uint)id])
{
if (!homeDecorationsBought.ContainsKey(id))
{
homeDecorationsBought.Add(id, 0);
}
homeDecorationsBought[id] += 1;
fpc.money -= decorationValue[(uint)id];
updateMoneyText();
bool pushedToInventory = false;
Transform playerInventoryPanel = GameObject.Find("playerInventoryPanel").transform;
for (int i = 0; i < 10 && pushedToInventory == false; i++)
{
if (playerInventoryPanel.GetChild(i).childCount != 0)
{
MenuSlotItem msi = playerInventoryPanel.GetChild(i).GetChild(0).GetComponent <MenuSlotItem>();
if (msi.isFlower == false && msi.id == id)
{
msi.setCount(msi.count + 1);
pushedToInventory = true;
}
}
}
if (!pushedToInventory)
{
item.setCount(item.getCount() + 1);
addHomeInventoryItem(id, 1, false);
}
for (int i = 0; i < 10 && pushedToInventory == false; i++)
{
if (playerInventoryPanel.GetChild(i).childCount == 0)
{
item.releaseItem(playerInventoryPanel.GetChild(i).GetComponent <MenuSlot>());
pushedToInventory = true;
}
}
}
}
}
public void setItem(MenuSlotItem item)
{
if (item == null)
{
//If it's a decoration slot then set the count to 0
if (this.type == SlotType.DecorationSlot)
{
//Make a new item for this slot
uint id = this.getItem().id;
MenuSlotItem newItem = newSlotItem(id, 0, false).GetComponent <MenuSlotItem>();
this.setItem(newItem);
}
else //If it's anything other than a decoration slot then clear it
{
this.item = null;
}
}
else
{
this.item = item;
item.GetComponent <RectTransform>().SetParent(gameObject.GetComponent <RectTransform>(), false);
item.GetComponent <RectTransform>().localPosition = Vector3.zero;
GetComponent <RectTransform>().ForceUpdateRectTransforms();
item.GetComponent <RectTransform>().sizeDelta = Vector2.zero;
if (slotIndex == 0)
{
HomeBaseUIController hbuic = GetComponentInParent <HomeBaseUIController>();
hbuic.reSortFlowerList();
}
prepareUpdateScale();
}
if (type == SlotType.DisplaySlot)
{
HomeBaseUIController hbuic = GetComponentInParent <HomeBaseUIController>();
hbuic.updateFlowerDisplaySlot(this.getItem());
}
}
private void postSetFlowersTab()
{
//Fill in the display inventory
if (searchMask != 0)
{
displayInventory = new Dictionary <uint, int>();
for (int ii = 0; ii < homeFlowerInventory.Keys.Count; ii++)
{
if (shouldDisplayFlower(homeFlowerInventory.Keys.ElementAt(ii)))
{
displayInventory.Add(homeFlowerInventory.Keys.ElementAt(ii), homeFlowerInventory.Values.ElementAt(ii));
}
}
}
else
{
displayInventory = homeFlowerInventory;
}
//Just add some slots and things
GameObject flowerGridObject = GameObject.Find("flowerGrid");
Transform grid = flowerGridObject.transform;
//Figure out how many flowers to put on each page
Canvas myCanvas = transform.GetComponentInParent <Canvas>();
float rectWidth = grid.GetComponent <RectTransform>().rect.width *myCanvas.scaleFactor;
float rectHeight = grid.GetComponent <RectTransform>().rect.height *myCanvas.scaleFactor;
Debug.Log(rectWidth + "," + rectHeight + " with a scale factor of " + myCanvas.scaleFactor);
int gridWidth = (int)Mathf.Floor(rectWidth / slotSize);
int gridHeight = (int)Mathf.Floor(rectHeight / slotSize);
flowersPerPage = (gridHeight * gridWidth) - 1;
//Add an empty slot
//Fill the screen with flowers and slots
int startPosition = flowersPerPage * currentFlowerPage;
Debug.Log("start position is: " + startPosition);
//Loop and fill the page with the right flowers
for (int ii = startPosition; ii <= Mathf.Min(startPosition + flowersPerPage - 1, displayInventory.Count - 1); ii += 1)
{
uint flowerID = displayInventory.Keys.ElementAt(ii);
int count = displayInventory.Values.ElementAt(ii);
if (shouldDisplayFlower(flowerID))
{
GameObject slot = Instantiate(homeInventorySlotPrefab, grid);
slot.GetComponent <MenuSlot>().slotIndex = ii;
GameObject item = Instantiate(slotItemPrefab, slot.GetComponent <RectTransform>());
MenuSlotItem itemObject = item.GetComponent <MenuSlotItem>();
itemObject.setID(flowerID, true);
itemObject.setCount(count);
slot.GetComponent <MenuSlot>().setItem(itemObject);
homeFlowerSlots.Add(slot);
}
}
//If there are more flowersPerPage than flowers in the home inventory then...
//fill in the rest of the screen with blank slots
int ss = homeFlowerSlots.Count; //this is just for setting indexes
while (homeFlowerSlots.Count <= flowersPerPage)
{
GameObject slot = Instantiate(homeInventorySlotPrefab, grid);
slot.GetComponent <MenuSlot>().slotIndex = ss;
homeFlowerSlots.Add(slot);
ss += 1;
}
setPageCountText();
updatePriceBreakdownButton(true);
//Set up the sell display slot
updateFlowerDisplaySlot(null);
}
