public virtual string GetForestCampLaborerString(IStructure lumbermill)
{
int max = GetLumbermillMaxLabor(lumbermill);
int cur = lumbermill.City.Where(s => ObjectTypeFactory.IsStructureType("ForestCamp", s)).Sum(x => x.Stats.Labor);
return(string.Format("{0}/{1}", cur, max));
}
/// <summary>
/// Returns the amount of gold the user should get for the specified city
/// </summary>
/// <param name="city">City to recalculate resources for</param>
/// <returns></returns>
public virtual int GetGoldRate(ICity city)
{
int value = 0;
var weaponExportMax =
city.Technologies.GetEffects(EffectCode.WeaponExport)
.DefaultIfEmpty()
.Max(x => x == null ? 0 : (int)x.Value[0]);
if (weaponExportMax > 0)
{
value += GetWeaponExportLaborProduce(weaponExportMax, city.Resource.Labor.Value, city.Resource.Gold.Value);
}
foreach (Structure structure in city.Where(x => ObjectTypeFactory.IsStructureType("Market", x)))
{
if (structure.Lvl >= 10)
{
value += 50;
}
else if (structure.Lvl >= 6)
{
value += 18;
}
else if (structure.Lvl >= 4)
{
value += 4;
}
}
return(value);
}
/// <summary>
/// Returns the amount of crop the user should get for the specified city
/// </summary>
/// <param name="city">City to recalculate resources for</param>
/// <returns></returns>
public virtual int GetCropRate(ICity city)
{
double[] lvlBonus = { 1, 1, 1, 1, 1, 1, 1, 1.1, 1.1, 1.2, 1.2, 1.3, 1.3, 1.4, 1.4, 1.5 };
return(60 + city.Lvl * 5 +
(int)
city.Sum(x => ObjectTypeFactory.IsStructureType("Crop", x) ? x.Stats.Labor * lvlBonus[x.Lvl] : 0));
}
public static T Dump <T>(this T item)
{
var dumpItemBase = ObjectTypeFactory.Create(item);
WriterDelegate(dumpItemBase.Value);
return(item);
}
/// <summary>
/// Returns the rate that the specified structure should gather from the given forest.
/// </summary>
/// <param name="forestCamp"></param>
/// <param name="efficiency"></param>
/// <returns></returns>
public virtual int GetWoodRateForForestCamp(IStructure forestCamp, float efficiency)
{
var lumbermill = forestCamp.City.FirstOrDefault(s => ObjectTypeFactory.IsStructureType("Lumbermill", s));
if (lumbermill == null)
{
return(0);
}
double[] rate = { 0, .75, .75, 1, 1, 1, 1, 1.25, 1.25, 1.25, 1.25, 1.25, 1.5, 1.5, 1.5, 1.5 };
return((int)(forestCamp.Stats.Labor * rate[lumbermill.Lvl] * (1f + efficiency)));
}
/// <summary>
/// Returns the amount of wood the user should get for the specified city.
/// Notice: This function looks at all the Forest Camps Rate property and adds them up.
/// </summary>
/// <param name="city">City to recalculate resources for</param>
/// <returns></returns>
public virtual int GetWoodRate(ICity city)
{
return(60 + city.Lvl * 5 + city.Sum(x =>
{
object rate;
if (!ObjectTypeFactory.IsStructureType("ForestCamp", x) || x.Lvl == 0 ||
!x.Properties.TryGet("Rate", out rate))
{
return 0;
}
return (int)rate;
}));
}
public CollectionObject(IEnumerable items)
: base(items)
{
_value = new Lazy <string>(() =>
{
var sb = new StringBuilder();
var name = TextForCollectionOf(Items.GetType(), Children.Count());
var dumpItems = (from object item in Items
select ObjectTypeFactory.Create(item)).ToList();
var totalWidth = name.Length;
var valueColumnWidth = dumpItems.Select(s => s.ValueWidth).Concat(new[] { totalWidth }).Max();
Action writeDividerLine = () =>
{
sb.Append("|");
sb.Append(new string('-', valueColumnWidth + 2));
sb.AppendLine("|");
};
Action <string> writeTextLine = lineToWrite =>
{
sb.Append("| ");
sb.Append(string.Format("{0,-" + (valueColumnWidth) + "}", lineToWrite));
sb.AppendLine(" |");
};
writeDividerLine();
writeTextLine(name);
writeDividerLine();
foreach (DumpItemBase dumpItem in dumpItems)
{
var eachRowInChildItem = dumpItem.Value.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
writeTextLine(eachRowInChildItem.First());
foreach (string row in eachRowInChildItem.Skip(1))
{
writeTextLine(row);
}
writeDividerLine();
}
return(sb.ToString());
});
}
public void CreateObjectType()
{
// arrange
var scalarType = new StringType();
var parser = new Parser();
DocumentNode document = parser.Parse(
"type Simple { a: String b: [String] }");
ObjectTypeDefinitionNode objectTypeDefinition = document
.Definitions.OfType <ObjectTypeDefinitionNode>().First();
var resolverBinding = new DelegateResolverBinding(
"Simple", "a",
(c, r) => "hello");
var serviceManager = new ServiceManager();
var schemaContext = new SchemaContext(serviceManager);
schemaContext.Types.RegisterType(scalarType);
schemaContext.Resolvers.RegisterResolver(resolverBinding);
// act
var factory = new ObjectTypeFactory();
ObjectType objectType = factory.Create(objectTypeDefinition);
schemaContext.Types.RegisterType(objectType);
var initializationContext = new TypeInitializationContext(
schemaContext, error => { }, objectType, false);
((INeedsInitialization)objectType)
.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
// assert
Assert.Equal("Simple", objectType.Name);
Assert.Equal(3, objectType.Fields.Count);
Assert.True(objectType.Fields.ContainsField("a"));
Assert.True(objectType.Fields.ContainsField("b"));
Assert.False(objectType.Fields["a"].Type.IsNonNullType());
Assert.False(objectType.Fields["a"].Type.IsListType());
Assert.True(objectType.Fields["a"].Type.IsScalarType());
Assert.Equal("String", objectType.Fields["a"].Type.TypeName());
Assert.False(objectType.Fields["b"].Type.IsNonNullType());
Assert.True(objectType.Fields["b"].Type.IsListType());
Assert.False(objectType.Fields["b"].Type.IsScalarType());
Assert.Equal("String", objectType.Fields["b"].Type.TypeName());
Assert.Equal("hello", (objectType.Fields["a"]
.Resolver(null, CancellationToken.None)));
}
public virtual int GetInstantTrainCount(IStructure structure)
{
var effectForStructureType =
structure.City.Technologies.GetEffects(EffectCode.UnitTrainInstantTime).Where(x => (int)x.Value[0] == structure.Type).ToList();
if (!effectForStructureType.Any())
{
return(0);
}
var units = structure.City.Troops.MyStubs().SelectMany(stub => stub.ToUnitList());
var current = units.Sum(x => ObjectTypeFactory.IsObjectType((string)effectForStructureType[0].Value[1], x.Type) ? x.Count : 0);
var threshold = Math.Min(effectForStructureType.Sum(x => (int)x.Value[2]), (int)effectForStructureType[0].Value[3]);
return(Math.Max(threshold - current, 0));
}
public void ObjectFieldDeprecationReason()
{
// arrange
ObjectTypeDefinitionNode typeDefinition =
CreateTypeDefinition <ObjectTypeDefinitionNode>(@"
type Simple {
a: String @deprecated(reason: ""reason123"")
}");
// act
var factory = new ObjectTypeFactory();
ObjectType type = factory.Create(typeDefinition);
CompleteType(type);
// assert
Assert.True(type.Fields["a"].IsDeprecated);
Assert.Equal("reason123", type.Fields["a"].DeprecationReason);
}
/// <summary>
/// Gets amount of resources that are hidden
/// </summary>
/// <param name="city"></param>
/// <param name="checkAlignmentPointBonus"></param>
/// <returns></returns>
public virtual Resource HiddenResource(ICity city, bool checkAlignmentPointBonus = false)
{
int[] rateCrop = { 0, 100, 150, 220, 330, 500, 740, 1100, 1100, 1100, 1100 };
int[] rateWood = { 0, 100, 150, 220, 330, 500, 740, 1100, 1100, 1100, 1100 };
int[] rateGold = { 0, 0, 0, 0, 0, 100, 150, 220, 330, 500, 740 };
int[] rateIron = { 0, 0, 0, 0, 0, 0, 0, 0, 200, 360, 660 };
var resource = new Resource();
foreach (var structure in city.Where(x => ObjectTypeFactory.IsStructureType("Basement", x)))
{
resource.Add(rateCrop[structure.Lvl],
rateGold[structure.Lvl],
rateIron[structure.Lvl],
rateWood[structure.Lvl],
0);
}
int[] tempRateCrop = { 0, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700 };
int[] tempRateWood = { 0, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700 };
int[] tempRateGold = { 0, 0, 0, 0, 0, 500, 600, 700, 800, 900, 1000 };
int[] tempRateIron = { 0, 0, 0, 0, 0, 0, 0, 0, 500, 750, 1000 };
foreach (var structure in city.Where(x => ObjectTypeFactory.IsStructureType("TempBasement", x)))
{
resource.Add(tempRateCrop[structure.Lvl],
tempRateGold[structure.Lvl],
tempRateIron[structure.Lvl],
tempRateWood[structure.Lvl],
0);
}
if (checkAlignmentPointBonus && city.AlignmentPoint >= 75m)
{
const double pct = .75;
return(new Resource((int)Math.Max(city.Resource.Crop.Limit * pct, resource.Crop),
(int)Math.Max(city.Resource.Gold.Limit * pct, resource.Gold),
(int)Math.Max(city.Resource.Iron.Limit * pct, resource.Iron),
(int)Math.Max(city.Resource.Wood.Limit * pct, resource.Wood),
0));
}
return(resource);
}
public void CreateObjectType()
{
// arrange
ObjectTypeDefinitionNode typeDefinition =
CreateTypeDefinition <ObjectTypeDefinitionNode>(@"
type Simple { a: String b: [String] }");
var resolverBinding = new FieldResolver(
"Simple", "a",
c => Task.FromResult <object>("hello"));
// act
var factory = new ObjectTypeFactory();
ObjectType type = factory.Create(typeDefinition);
CompleteType(type,
s => s.Resolvers.RegisterResolver(resolverBinding));
// assert
Assert.Equal("Simple", type.Name);
Assert.Equal(3, type.Fields.Count);
Assert.True(type.Fields.ContainsField("a"));
Assert.False(type.Fields["a"].Type.IsNonNullType());
Assert.False(type.Fields["a"].Type.IsListType());
Assert.True(type.Fields["a"].Type.IsScalarType());
Assert.Equal("String", type.Fields["a"].Type.TypeName());
Assert.True(type.Fields.ContainsField("b"));
Assert.False(type.Fields["b"].Type.IsNonNullType());
Assert.True(type.Fields["b"].Type.IsListType());
Assert.False(type.Fields["b"].Type.IsScalarType());
Assert.Equal("String", type.Fields["b"].Type.TypeName());
Assert.Equal("hello", (type.Fields["a"]
.Resolver(null).Result));
}
/// <summary>
/// Returns the amount of iron the user should get for the specified city
/// </summary>
/// <param name="city">City to recalculate resources for.</param>
/// <returns></returns>
public virtual int GetIronRate(ICity city)
{
int[] multiplier = { int.MaxValue, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 5, 5, 5, 5, 4 };
return(city.Sum(x => ObjectTypeFactory.IsStructureType("Iron", x) ? x.Stats.Labor / multiplier[x.Lvl] : 0));
}
public virtual ushort CalculateCityValue(ICity city)
{
return((ushort)city.Where(structure => !ObjectTypeFactory.IsStructureType("NoInfluencePoint", structure)).Sum(x => x.Lvl * x.Size));
}
/// <summary>
/// Helper extension that allows you to easily capture the text value that was created.
/// </summary>
/// <param name="item">The instance of the object you would like to dump.</param>
/// <returns>The ASCII representation of the object as generated by the DumpToText extension.</returns>
public static string DumpAsString(this object item)
{
return(ObjectTypeFactory.Create(item).Value);
}
public virtual int BuildTime(int baseValue, ICity city, ITechnologyManager em)
{
IStructure university = city.FirstOrDefault(structure => ObjectTypeFactory.IsStructureType("University", structure));
return((int)(baseValue * (100 - (university == null ? 0 : university.Stats.Labor) * 0.25) / 100));
}
