public void CheckItemAdd(CraftingResources resource, int amount)
{
var itemList = GetItemList();
foreach (var item in itemList)
{
Debug.Log(item.Resource);
}
Debug.Log("Resource: " + resource + " - amount: " + amount);
var foundRequest = itemList.FirstOrDefault(i => i.Resource == resource);
// Check if we have current request for this resource
if (foundRequest != null)
{
if (!_currentRequestData.ContainsKey(resource))
{
var craftingRequest = new TakenCraftingResourceRequest {
Request = foundRequest, CurrentAmount = amount
};
_currentRequestData.Add(resource, craftingRequest);
}
else
{
_currentRequestData[resource].AddAmount(amount);
}
if (_currentRequestData[resource].Complete)
{
requestRecord.CompleteRequest(this, _currentRequestData[resource].Request);
_currentRequestData.Remove(resource);
}
requestSystem.Refresh();
}
}
public void MakeChoice(ShopAgent agent, CraftingResources craftingResources)
{
switch (GetInputMode(agent))
{
case RequestActions.SetInput:
Debug.Log("Make Request");
requestSystem.MakeRequest(craftingResources, agent.craftingInventory, agent.wallet);
break;
case RequestActions.RemoveRequest:
Debug.Log("Remove Request");
requestSystem.RemoveRequest(craftingResources, agent.craftingInventory);
break;
case RequestActions.IncreasePrice:
Debug.Log("IncreasePrice");
requestSystem.ChangePrice(craftingResources, agent.craftingInventory, agent.wallet, 1);
break;
case RequestActions.DecreasePrice:
Debug.Log("DecreasePrice");
requestSystem.ChangePrice(craftingResources, agent.craftingInventory, agent.wallet, -1);
break;
}
}
public void Request_MakeResourceRequest()
{
CraftingResources randomCraftingResource = listCraftingResources[Random.Range(0, listCraftingResources.Count)];
//Make a request
requestShopSystem.MakeChoice(shopAgent, randomCraftingResource);
//Count the requests
Assert.AreEqual(1, requestSystem.GetAllCraftingRequests(shopAgent.craftingInventory).Count, "A request should be created");
Assert.AreEqual(1, requestSystem.GetAllCraftingRequests().Count, "One request should be created");
//Make another request with the same resource
requestShopSystem.MakeChoice(shopAgent, randomCraftingResource);
//Count the requests
Assert.AreEqual(1, requestSystem.GetAllCraftingRequests().Count, "Only one request should be created");
//randomCraftingResource1 != randomCraftingResource2
CraftingResources randomCraftingResource2 = listCraftingResources[Random.Range(0, listCraftingResources.Count)];
if (randomCraftingResource2 == randomCraftingResource && listCraftingResources.Count > 1)
{
randomCraftingResource2 = (CraftingResources)((int)(randomCraftingResource + 1) % listCraftingResources.Count);
}
//Make another request
requestShopSystem.MakeChoice(shopAgent, randomCraftingResource2);
//Count the requests
Assert.AreEqual(2, requestSystem.GetAllCraftingRequests().Count, "2 requests should be created");
}
public CraftingResources GetResourceIndicatorContainerInstance(GameObject followObject)
{
CraftingResources instance = Instantiate(this, this.transform.parent);
followingObject = followObject;
//instance.transform.position = Camera.main.WorldToScreenPoint(followingObject.transform.position) + Vector3.up * 100;
return(instance);
}
public int GetResourceCount(CraftingResources craftingResource)
{
if (_numResources.ContainsKey(craftingResource))
{
return(_numResources[craftingResource]);
}
return(0);
}
private void Start()
{
ui_Resources = UIManager.Instance.CraftingRequirementsObject.GetResourceIndicatorContainerInstance(this.gameObject);
UpdateRequirementLocation();
for (int i = 0; i < mRequirements.Length; i++)
{
mRequirements[i].mIndicatorUI = ui_Resources.CreateResourceRequirement(mRequirements[i].mResourceRequired, mRequirements[i].mResourceCountRequired, ref mRequirements[i]);
}
}
public CraftingResourceRequest(CraftingResources resource, CraftingInventory inventory, int price, Sprite icon)
{
Number = 1;
Resource = resource;
Inventory = inventory;
Price = price;
Icon = icon;
CreationTime = Time.time;
}
public int GetCurrentStock(CraftingResources resource)
{
var amount = 0;
if (_currentRequestData.ContainsKey(resource))
{
amount = _currentRequestData[resource].CurrentAmount;
}
return(amount);
}
public int GetResourceNumber(CraftingResources key)
{
if (_numResources != null)
{
if (_numResources.ContainsKey(key))
{
return(_numResources[key]);
}
}
return(0);
}
public void AddResource(CraftingResources resource, int count)
{
var hasResource = _numResources.ContainsKey(resource);
if (!hasResource)
{
_numResources[resource] = 0;
}
_numResources[resource] += count;
}
private int GetRequestNumber(CraftingInventory inventory, CraftingResources resources)
{
if (_craftingRequests.ContainsKey(inventory))
{
if (_craftingRequests[inventory].ContainsKey(resources))
{
return(_craftingRequests[inventory][resources].Number);
}
}
return(0);
}
public void RemoveRequest(CraftingResources resource, CraftingInventory inventory)
{
if (_craftingRequests.ContainsKey(inventory))
{
if (_craftingRequests[inventory].ContainsKey(resource))
{
var request = _craftingRequests[inventory][resource];
_requestWallets[request].EarnMoney(request.Reward);
_craftingRequests[inventory].Remove(resource);
_requestWallets.Remove(request);
Refresh();
}
}
}
public void Request_TakeResourceRequest()
{
CraftingResources randomCraftingRessource = listCraftingResources[UnityEngine.Random.Range(0, listCraftingResources.Count)];
//Make a request
requestShopSystem.MakeChoice(shopAgent, randomCraftingRessource);
CraftingResourceRequest requestMade = requestShopSystem.requestSystem.GetAllCraftingRequests()[0];
Assert.NotNull(requestMade, "CraftingResourceRequest empty");
//Take a request
adventurerAgent.requestTaker.TakeRequest(requestMade);
//Check the taken quest
List <CraftingResourceRequest> takenQuests = adventurerAgent.requestTaker.GetItemList();
Assert.AreEqual(1, takenQuests.Count, "The adventurer should have one request");
}
public void MakeRequest(CraftingResources resources, CraftingInventory inventory, EconomyWallet wallet)
{
void CheckExchange(CraftingResourceRequest request)
{
if (request.Price <= wallet.Money)
{
if (_craftingRequests[inventory].ContainsKey(resources))
{
_craftingRequests[inventory][resources].Number++;
}
else
{
_craftingRequests[inventory].Add(resources, request);
}
wallet.SpendMoney(request.Price);
}
}
CheckInventory(inventory);
var requestNumber = GetRequestNumber(inventory, resources);
var canRequest = requestNumber < 10;
if (canRequest)
{
var containsKey = _craftingRequests[inventory].ContainsKey(resources);
if (!containsKey)
{
Sprite icon = GetIconByResource(resources);
var newResource = new CraftingResourceRequest(resources, inventory, defaultResourcePrices[resources], icon);
_requestWallets.Add(newResource, wallet);
CheckExchange(newResource);
}
else
{
CheckExchange(_craftingRequests[inventory][resources]);
}
}
Refresh();
}
public Sprite GetIconByResource(CraftingResources resource)
{
switch (resource)
{
case CraftingResources.Wood:
return(iconResources[0]);
case CraftingResources.Metal:
return(iconResources[1]);
case CraftingResources.Gem:
return(iconResources[2]);
case CraftingResources.DragonScale:
return(iconResources[3]);
default:
Debug.Log("Wrong Crafting resource : " + resource);
return(iconResources[0]);
}
}
public void Config_SetResourceRequirements()
{
List <CraftingMap> defaultListRequirements = shopCraftingSystemBehaviour.system.craftingSubSubSystem.craftingRequirement;
List <CraftingMap> newListRequirements = new List <CraftingMap>();
foreach (CraftingMap craftingMap in defaultListRequirements)
{
CraftingChoice newCraftingChoice = craftingMap.choice;
UsableItem newResultingItem = craftingMap.resource.resultingItem;
float newTimeToCreation = craftingMap.resource.timeToCreation;
List <ResourceRequirement> newResourcesRequirements = new List <ResourceRequirement>();
foreach (ResourceRequirement resourceRequirement in craftingMap.resource.resourcesRequirements)
{
CraftingResources newType = resourceRequirement.type;
int newNumber = UnityEngine.Random.Range(1, 10);
newResourcesRequirements.Add(new ResourceRequirement(newType, newNumber));
}
CraftingRequirements newCraftingRequirements = new CraftingRequirements
{
resultingItem = newResultingItem,
timeToCreation = newTimeToCreation,
resourcesRequirements = newResourcesRequirements
};
CraftingMap newCraftingMap = new CraftingMap
{
choice = newCraftingChoice,
resource = newCraftingRequirements
};
newListRequirements.Add(newCraftingMap);
}
configSystem.SetResourceRequirements(newListRequirements);
Assert.AreEqual(shopCraftingSystemBehaviour.system.craftingSubSubSystem.craftingRequirement, newListRequirements);
Assert.AreNotEqual(defaultListRequirements, newListRequirements);
}
public void Request_CompleteResourceRequest()
{
CraftingResources randomCraftingRessource = listCraftingResources[UnityEngine.Random.Range(0, listCraftingResources.Count)];
//Make a request
requestShopSystem.MakeChoice(shopAgent, randomCraftingRessource);
CraftingResourceRequest requestMade = requestShopSystem.requestSystem.GetAllCraftingRequests()[0];
int reward = requestMade.Reward;
//Take a request
adventurerAgent.requestTaker.TakeRequest(requestMade);
//Give the ressource = Complete request
adventurerAgent.requestTaker.CheckItemAdd(randomCraftingRessource, 1);
//No more requests?
Assert.AreEqual(0, requestSystem.GetAllCraftingRequests().Count, "No more requests after giving the resource");
//Reward obtained?
Assert.AreEqual(adventurerAgent.wallet.startMoney + reward, adventurerAgent.wallet.Money);
//Resource given?
Assert.AreEqual(0, adventurerAgent.requestTaker.GetCurrentStock(randomCraftingRessource));
}
public void ChangePrice(CraftingResources resources, CraftingInventory inventory, EconomyWallet wallet, int change)
{
CheckInventory(inventory);
var craftingInventory = _craftingRequests[inventory];
var containsKey = craftingInventory.ContainsKey(resources);
if (containsKey)
{
if (craftingInventory.ContainsKey(resources))
{
var newPrice = craftingInventory[resources].Price + change;
var newReward = craftingInventory[resources].GetReward(newPrice);
var rewardDifference = newReward - craftingInventory[resources].Reward;
var validTransaction = false;
if (rewardDifference > 0)
{
if (rewardDifference <= wallet.Money)
{
wallet.SpendMoney(rewardDifference);
validTransaction = true;
}
}
else
{
wallet.EarnMoney(Mathf.Abs(rewardDifference));
validTransaction = true;
}
if (validTransaction)
{
craftingInventory[resources].Price = newPrice;
}
}
}
Refresh();
}
public CraftingResourceUi(CraftingResources resourceType, int inventoryNumber, Sprite icon)
{
ResourceType = resourceType;
InventoryNumber = inventoryNumber;
Icon = icon;
}
public BattleDrop(BattleDrop original)
{
resource = original.resource;
minDrop = original.minDrop;
maxDrop = original.maxDrop;
}
public static float[] GetSenses(Dictionary <CraftingResources, TakenCraftingResourceRequest> dictionary, CraftingResources key)
{
var output = new float [SensorCount];
if (dictionary.ContainsKey(key))
{
output[0] = (float)dictionary[key].Request.Resource;
output[1] = dictionary[key].Request.Price;
output[2] = dictionary[key].Request.Number;
output[3] = dictionary[key].CurrentAmount;
}
return(output);
}
public ResourceRequirement(CraftingResources newType, int newNumber)
{
type = newType;
number = newNumber;
}
