public bool CanExportCopiesOfResource(
IResourceDefinition resource, int copies,
ICivilization exporter, ICivilization importer
)
{
return(GetTradeableCopiesOfResourceForCiv(resource, exporter) >= copies);
}
public static IResourceDefinition <T> Named <T>(this IResourceDefinition <T> resource, string name)
{
resource.Resource.ResourceKey = Tuple.Create(name, typeof(T));
resource.Resource.ResourceType = typeof(T);
resource.Resource.Name = name;
return(resource);
}
private ResourceObject GetIncludedEntity(IIdentifiable entity, RelationshipAttribute relationship)
{
if (entity == null)
{
return(null);
}
var contextEntity = _jsonApiContext.ResourceGraph.GetContextEntity(entity.GetType());
//var resourceDefinition = _scopedServiceProvider.GetService(contextEntity.ResourceType) as IResourceDefinition;
IResourceDefinition resourceDefinition = null;
var data = GetData(contextEntity, entity, resourceDefinition);
data.Attributes = new Dictionary <string, object>();
contextEntity.Attributes.ForEach(attr =>
{
var attributeValue = attr.GetValue(entity);
if (ShouldIncludeAttribute(attr, attributeValue, relationship))
{
data.Attributes.Add(attr.PublicAttributeName, attributeValue);
}
});
return(data);
}
public static IResourceDefinition <T> SupportedOperation <T>(
this IResourceDefinition <T> resource,
Operation operation)
{
resource.Resource.Hydra().SupportedOperations.Add(operation);
return(resource);
}
private void DistributeResource(
IResourceDefinition resource, IEnumerable <IHexCell> validLocations,
int count
)
{
var nodeLocations = CellRandomSampler.SampleElementsFromSet(
validLocations, count, GetResourceWeightFunction(resource)
);
if (nodeLocations.Count < count)
{
Debug.LogWarningFormat(
"Could not find enough valid locations to place {0} {1} after weighting. Only found {2}",
count, resource.name, nodeLocations.Count
);
}
foreach (var location in nodeLocations)
{
int copies = resource.Type == ResourceType.Strategic
? UnityEngine.Random.Range(Config.MinStrategicCopies, Config.MaxStrategicCopies) : 1;
NodeFactory.BuildNode(location, resource, copies);
}
}
public static IResourceDefinition <T> LastModified <T>(
this IResourceDefinition <T> resource,
Func <T, DateTimeOffset?> reader)
{
((IResourceTarget)resource).Resource.SetLastModifiedMapper(r => reader((T)r));
return(resource);
}
public int GetFreeCopiesOfResourceForCiv(IResourceDefinition resource, ICivilization civ)
{
return
(ExtractionLogic.GetExtractedCopiesOfResourceForCiv(resource, civ) +
TransferCanon.GetImportedCopiesOfResourceForCiv(resource, civ) -
TransferCanon.GetExportedCopiesOfResourceForCiv(resource, civ) -
LockingCanon.GetLockedCopiesOfResourceForCiv(resource, civ));
}
public int GetTradeableCopiesOfResourceForCiv(IResourceDefinition resource, ICivilization civ)
{
int extractedCopies = ExtractionLogic.GetExtractedCopiesOfResourceForCiv(resource, civ);
int exportedCopies = GetExportedCopiesOfResourceForCiv(resource, civ);
int lockedCopies = LockingCanon.GetLockedCopiesOfResourceForCiv(resource, civ);
return(extractedCopies - exportedCopies - lockedCopies);
}
public ResourceObject GetData(ContextEntity contextEntity, IIdentifiable entity,
IResourceDefinition resourceDefinition = null)
{
ResourceObject resourceObj = _internalBuilder.GetData(contextEntity, entity, resourceDefinition);
UpdateResourceObject(resourceObj);
return(resourceObj);
}
private IResourceNode BuildResourceNode(IResourceDefinition resource)
{
var mockNode = new Mock <IResourceNode>();
mockNode.Setup(node => node.Resource).Returns(resource);
return(mockNode.Object);
}
public ResourceTransfer(
ICivilization exporter, ICivilization importer, IResourceDefinition resource, int copies
)
{
Exporter = exporter;
Importer = importer;
Resource = resource;
Copies = copies;
}
private IResourceNode BuildResourceNode(ResourceNodeTestData data, IResourceDefinition resource)
{
var mockNode = new Mock <IResourceNode>();
mockNode.Setup(node => node.Copies).Returns(data.Copies);
mockNode.Setup(node => node.Resource).Returns(resource);
return(mockNode.Object);
}
public void SetActiveResource(int index)
{
ActiveResource = AvailableResources[index];
var shouldHaveCopies = ActiveResource.Type == ResourceType.Strategic;
CopiesSection.gameObject.SetActive(shouldHaveCopies);
ActiveCopies = shouldHaveCopies ? ActiveCopies : 1;
}
public static IResourceDefinition <T> Link <T>(this IResourceDefinition <T> resource, SubLink link)
{
resource.Resource.Links.Add(new ResourceLinkModel
{
Relationship = link.Rel,
Uri = link.Uri,
CombinationType = ResourceLinkCombination.SubResource,
Type = link.Type
});
return(resource);
}
public void UnlockCopyOfResourceForCiv(IResourceDefinition resource, ICivilization civ)
{
if (!CanUnlockCopyOfResourceForCiv(resource, civ))
{
throw new InvalidOperationException("CanUnlockCopyOfResourceForCiv must return true on the given arguments");
}
var newLockedCopies = LockedResourcesDict.GetNestedDict(civ, resource) - 1;
LockedResourcesDict.SetNestedDict(civ, resource, newLockedCopies);
}
public int GetWeightOfResource(IResourceDefinition resource)
{
if (ResourceWeights == null)
{
BuildResourceWeightDictionary();
}
int retval;
ResourceWeights.TryGetValue(resource, out retval);
return(retval);
}
public bool IsResourceVisible(IResourceDefinition resource)
{
switch (ResourceVisibilityMode)
{
case ResourceVisibilityMode.ActiveCiv: return(GameCore.ActiveCiv != null && TechCanon.IsResourceDiscoveredByCiv(resource, GameCore.ActiveCiv));
case ResourceVisibilityMode.RevealAll: return(true);
case ResourceVisibilityMode.HideAll: return(false);
default: throw new NotImplementedException("No behavior defined for ResourceVisibilityMode " + ResourceVisibilityMode);
}
}
private Func <IHexCell, int> GetCellPlacementWeightFunction(IResourceDefinition resource)
{
return(delegate(IHexCell cell) {
if (ResourceNodeFactory.CanBuildNode(cell, resource))
{
return ResourceRestrictionCanon.GetPlacementWeightOnCell(resource, cell);
}
else
{
return 0;
}
});
}
private IResourceNode BuildResourceNode(IResourceDefinition resource)
{
var mockNode = new Mock <IResourceNode>();
mockNode.SetupAllProperties();
mockNode.Setup(node => node.Resource).Returns(resource);
var newNode = mockNode.Object;
AllResourceNodes.Add(newNode);
return(mockNode.Object);
}
public int GetPlacementWeightOnCell(IResourceDefinition resource, IHexCell cell)
{
if (NodeLocationCanon.GetPossessionsOfOwner(cell).Any() || cell.Feature != CellFeature.None)
{
return(0);
}
int weight = resource.GetWeightFromTerrain(cell.Terrain) +
resource.GetWeightFromShape(cell.Shape) +
resource.GetWeightFromVegetation(cell.Vegetation);
return(Math.Max(0, weight));
}
public bool CanBuildNode(IHexCell location, IResourceDefinition resource)
{
if (location == null)
{
throw new ArgumentNullException("location");
}
else if (resource == null)
{
throw new ArgumentNullException("resource");
}
return(ResourceNodeLocationCanon.GetPossessionsOfOwner(location).Count() == 0 &&
RestrictionCanon.IsResourceValidOnCell(resource, location));
}
private void BuildSummary(IResourceDefinition resource, int totalCopies)
{
int freeCopies = FreeResourcesLogic.GetFreeCopiesOfResourceForCiv(resource, GameCore.ActiveCiv);
var newSummaryPrefab = Instantiate(ResourceSummaryPrefab);
newSummaryPrefab.gameObject.SetActive(true);
newSummaryPrefab.transform.SetParent(ResourceSummaryContainer, false);
InstantiatedSummaries.Add(newSummaryPrefab);
var newSummary = newSummaryPrefab.GetComponent <SpecialtyResourceDefinitionSummary>();
newSummary.Initialize(resource, freeCopies, totalCopies);
}
private void ExecuteLockingSequence(
ResourceLockingCanon lockingCanon, List <LockingType> sequence,
IResourceDefinition resource, ICivilization civ
)
{
foreach (var lockingOperation in sequence)
{
switch (lockingOperation)
{
case LockingType.Lock: lockingCanon.LockCopyOfResourceForCiv(resource, civ); break;
case LockingType.Unlock: lockingCanon.UnlockCopyOfResourceForCiv(resource, civ); break;
}
}
}
public ResourceTransfer ExportCopiesOfResource(
IResourceDefinition resource, int copies,
ICivilization exporter, ICivilization importer
)
{
if (!CanExportCopiesOfResource(resource, copies, exporter, importer))
{
throw new InvalidOperationException("CanExportCopiesOfResource must return true on the given arguments");
}
var newTransfer = new ResourceTransfer(exporter, importer, resource, copies);
AllActiveTransfers.Add(newTransfer);
return(newTransfer);
}
private IResourceNode BuildResourceNode(IHexCell location, IResourceDefinition resource)
{
var mockNode = new Mock <IResourceNode>();
mockNode.Setup(node => node.Resource).Returns(resource);
var newNode = mockNode.Object;
MockNodeLocationCanon.Setup(canon => canon.GetPossessionsOfOwner(location))
.Returns(new List <IResourceNode>()
{
newNode
});
return(newNode);
}
public void SynchronizeResourceForCiv(IResourceDefinition resource, ICivilization civ)
{
int tradeDeficit = GetTradeableCopiesOfResourceForCiv(resource, civ);
if (tradeDeficit < 0)
{
foreach (var exportOfResource in GetAllExportTransfersFromCiv(civ).Where(transfer => transfer.Resource == resource).ToList())
{
CancelTransfer(exportOfResource);
tradeDeficit += exportOfResource.Copies;
if (tradeDeficit >= 0)
{
break;
}
}
}
}
private IDiplomaticExchange BuildExchange(
ExchangeType type, int integerInput, ICity cityInput,
IResourceDefinition resourceInput
)
{
var mockExchange = new Mock <IDiplomaticExchange>();
mockExchange.SetupAllProperties();
mockExchange.Setup(exchange => exchange.Type).Returns(type);
var newExchange = mockExchange.Object;
newExchange.IntegerInput = integerInput;
newExchange.CityInput = cityInput;
newExchange.ResourceInput = resourceInput;
return(newExchange);
}
private IOngoingDiplomaticExchange BuildOngoingExchange(
ExchangeType type, ICivilization sender, ICivilization receiver,
IResourceDefinition resourceInput, int integerInput
)
{
var mockExchange = new Mock <IOngoingDiplomaticExchange>();
mockExchange.SetupAllProperties();
mockExchange.Setup(exchange => exchange.Type).Returns(type);
var newExchange = mockExchange.Object;
newExchange.Sender = sender;
newExchange.Receiver = receiver;
newExchange.ResourceInput = resourceInput;
newExchange.IntegerInput = integerInput;
return(newExchange);
}
public Document Build(IIdentifiable entity)
{
var contextEntity = _resourceGraph.GetContextEntity(entity.GetType());
//var resourceDefinition = _scopedServiceProvider?.GetService(contextEntity.ResourceType) as IResourceDefinition;
IResourceDefinition resourceDefinition = null;
var document = new Document
{
Data = GetData(contextEntity, entity, resourceDefinition),
//Meta = GetMeta(entity)
};
//if (ShouldIncludePageLinks(contextEntity))
//document.Links = _jsonApiContext.PageManager.GetPageLinks(new LinkBuilder(_jsonApiContext));
document.Included = AppendIncludedObject(document.Included, contextEntity, entity);
return(document);
}
public int GetExtractedCopiesOfResourceForCiv(IResourceDefinition resource, ICivilization civ)
{
int retval = 0;
if (!TechCanon.IsResourceDiscoveredByCiv(resource, civ))
{
return(0);
}
foreach (var city in CityPossessionCanon.GetPossessionsOfOwner(civ))
{
foreach (var cell in CellPossessionCanon.GetPossessionsOfOwner(city))
{
var nodeOnCell = NodePositionCanon.GetPossessionsOfOwner(cell).FirstOrDefault();
if (nodeOnCell != null && nodeOnCell.Resource == resource)
{
var improvementAtLocation = ImprovementLocationCanon.GetPossessionsOfOwner(cell).FirstOrDefault();
if (resource.Extractor == null || (
improvementAtLocation != null && improvementAtLocation.Template == resource.Extractor &&
improvementAtLocation.IsConstructed && !improvementAtLocation.IsPillaged
))
{
if (resource.Type == MapResources.ResourceType.Strategic)
{
retval += nodeOnCell.Copies;
}
else if (resource.Type == MapResources.ResourceType.Luxury)
{
retval++;
}
}
}
}
}
return(retval);
}
