protected virtual void GenerateRidge(Ridge ridge, Area area, EcsManager ecs, Random random)
{
var landscape = ecs.GetContainer <Landscape>();
var building = ecs.GetContainer <Building>();
var delta = ridge.To - ridge.From;
for (var px = Math.Max(0, Math.Min(ridge.From.X, ridge.To.X) - ridge.Width);
px < Math.Min(area.Size.X - 1, Math.Max(ridge.From.X, ridge.To.X) + ridge.Width);
px++)
{
for (var py = Math.Max(0, Math.Min(ridge.From.Y, ridge.To.Y) - ridge.Width);
py < Math.Min(area.Size.Y - 1, Math.Max(ridge.From.Y, ridge.To.Y) + ridge.Width);
py++)
{
var position = new Vector(px, py);
var internalPosition = delta.TransitionMatrix() * (2 * position - ridge.From - ridge.To).ToMatrix() / 2;
var x = internalPosition[0, 0];
var y = internalPosition[1, 0] * delta.Magnitude / ridge.Width * 2;
if (random.Chance(
2 * (1 - Math.Sqrt(x * x + y * y))))
{
area.ContainerSlice <Landscape>()[position] = landscape.Plain;
area.ContainerSlice <Building>()[position] = building.Mountain;
}
}
}
}
public void Generate(Area area, EcsManager ecs, Random random)
{
var landscape = ecs.GetContainer <Landscape>();
var landscapeSlice = area.ContainerSlice <Landscape>();
var maximalLandNumber = LandFraction * area.Size.X * area.Size.Y;
var counter = 0;
while (counter < maximalLandNumber - 1)
{
var radius = random.NextDouble() * Math.Sqrt((maximalLandNumber - counter) / Math.PI) / 2;
var sourcePosition = random.NextPosition(area.Size);
var sizeVector = (int)radius * Vector.One;
foreach (var vector in (sizeVector * 2 + Vector.One).Range().Select(v => v - sizeVector))
{
var part = (vector.Magnitude - SeasideBorder * radius) / (radius * (1 - SeasideBorder));
if (random.Chance(0.5 * (Math.Abs(part - 1) - Math.Abs(part) + 1)))
{
var newPosition
= Vector.Clamp(
vector + sourcePosition,
Vector.Zero,
area.Size - Vector.One);
if (landscapeSlice[newPosition] < landscape.Water)
{
counter++;
landscapeSlice[newPosition] = landscape.Plain;
}
}
}
}
}
public void Modify(Area area, EcsManager ecs, Owner owner, Random random)
{
var landscape = ecs.GetContainer <Landscape>();
var building = ecs.GetContainer <Building>();
var squad = ecs.GetContainer <Squad>();
Vector position;
do
{
position = random.NextPosition(area.Size);
}while (area.ContainerSlice <Landscape>()[position] < landscape.Water ||
area.ContainerSlice <Building>()[position] < building.Mountain);
area.ContainerSlice <Building>()[position] = building.WoodenHouse;
area.ContainerSlice <Building>()[position].GetComponent <Owned>().Owner = owner;
do
{
position = random.NextPosition(area.Size);
}while (area.ContainerSlice <Landscape>()[position] < landscape.Water ||
area.ContainerSlice <Building>()[position] < building.Mountain);
area.ContainerSlice <Squad>()[position] = squad.Test;
area.ContainerSlice <Squad>()[position].GetComponent <Owned>().Owner = owner;
}
public static void Register(Server <Owner> server, EcsManager gameData)
{
gameData.SystemManager.GetSystem <ClientVision>().OnVisionChanged += (player, vision) =>
{
server.NewsManager.AddNews(
player,
"OnVisionChanged",
new NetData
{
["vision"] = vision,
},
unical: true);
};
gameData.SystemManager.GetSystem <Ownership>().OnPlayerCreated += player =>
{
player.OnResourcesChanged += resources =>
{
server.NewsManager.AddNews(
player,
"OnResourcesChanged",
new NetData
{
["value"] = resources.ResourcesArray,
},
unical: true);
};
};
}
protected override void InitializePrototypes(EcsManager ecs)
{
Player
= new Entity("<player>")
| new Owner()
| new ResearchHolder();
}
public void Generate(Area area, EcsManager ecs, Random random)
{
foreach (var generator in Subgenerators)
{
generator.Generate(area, ecs, random);
}
}
public EcsManager Generate()
{
var ecs = EcsManager.CreateNew();
GeneratePrototypes(ecs);
GenerateSystems(ecs);
return(ecs);
}
public override void Entry(IModHelper helper)
{
EcsManager.Ensure(helper);
this.systemManager = new SystemManager();
this.CreateEffectSystem(helper);
this.api = new FluidApi(this.effectApi);
this.RegisterDefaults();
this.Helper.Events.GameLoop.UpdateTicking += GameLoop_UpdateTicking;
}
public void Generate(Area area, EcsManager ecs, Random random)
{
var landscape = ecs.GetContainer <Landscape>();
var building = ecs.GetContainer <Building>();
foreach (var position in area.Size.Range())
{
area.ContainerSlice <Landscape>()[position] = landscape.Water;
area.ContainerSlice <Building>()[position] = building.None;
}
}
protected override void InitializePrototypes(EcsManager ecs)
{
Plain
= new Entity("Plain")
| new Placer()
| new Terrain(TerrainType.Plain);
Water
= new Entity("Water")
| new Placer()
| new Terrain(TerrainType.Water);
}
public void Initialize(EcsManager ecs)
{
InitializePrototypes(ecs);
foreach (var entity in GetType()
.GetFields(BindingFlags.Public | BindingFlags.Instance)
.Select(f => f.GetValue(this))
.OfType <Entity>())
{
Register(entity);
}
}
protected override void InitializePrototypes(EcsManager ecs)
{
WoodenHouse
= new Entity("Wooden house")
| new Placer()
| new Incomer {
IncomePerSecond = new Resources {
Food = 3600
}
}
| new Owned()
| new Observer()
| new Destructible(20)
| new Productor(TimeSpan.FromSeconds(1), ecs.GetContainer <Squad>().Test);
Sawmill
= new Entity("Sawmill")
| new Placer()
| new Incomer {
IncomePerSecond = new Resources {
Wood = 3600
}
}
| new Owned()
| new Observer();
None
= new Entity("None")
| new Placer()
| new Upgradable(
new Upgrade(WoodenHouse));
Field
= new Entity("Field")
| new Placer()
| new Incomer {
IncomePerSecond = new Resources {
Corn = 3600
}
}
| new Owned();
Forest
= new Entity("Forest")
| new Placer();
Mountain
= new Entity("Mountain")
| new Placer();
}
protected override void InitializePrototypes(EcsManager ecs)
{
Test
= new Entity("Test")
| new Placer()
| new Owned()
| new Observer {
VisionRange = 3
}
| new Executor()
| new Movable {
Duration = TimeSpan.FromSeconds(3)
}
| new Fighter(10)
| new Destructible(10);
}
private static void DecreaseRemainingTime()
{
var entitySets = EcsManager.Get().GetEntitiesWithComponents <IImpartedEffect>();
foreach (var entitySet in entitySets)
{
foreach (var component in entitySet.ComponentsOfType <IImpartedEffect>())
{
component.TimeRemaining -= TimeSpan.FromSeconds(1 / 60.0);
if (component.TimeRemaining.TotalMilliseconds <= 0)
{
entitySet.Entity.RemoveComponent(component);
}
}
}
}
public void Generate(Area area, EcsManager ecs, Random random)
{
var landscape = ecs.GetContainer <Landscape>();
var building = ecs.GetContainer <Building>();
foreach (var vector in area.Size.Range())
{
if (area.ContainerSlice <Landscape>()[vector] < landscape.Plain &&
random.Chance(
MaximalChance * (1 - 2 / (MaximalTemperature - MinimalTemperature) *
Math.Abs(area.GetTemperature(vector) + MinimalTemperature))))
{
area.ContainerSlice <Building>()[vector] = building.Forest;
}
}
}
private static void GeneratePrototypes(EcsManager ecs)
{
var containers = new PrototypeContainer[]
{
new Squad(),
new Global(),
new Science(),
new Landscape(),
new Building(),
};
foreach (var prototypeContainer in containers)
{
ecs.PrototypeManager.Register(prototypeContainer);
}
}
private IImpartedEffect ApplyAffect <TEffect>(object target) where TEffect : IImpartedEffect, new()
{
var affects = this.componentAffectsMap[typeof(TEffect)];
var effect = new TEffect();
switch (target)
{
case Farmer _ when(affects& Affects.AllPlayers) == 0:
throw new Exception($"Effect of type {typeof(TEffect).Name} cannot be applied to {nameof(Farmer)}.");
case Monster _ when(affects& Affects.Monsters) == 0:
throw new Exception($"Effect of type {typeof(TEffect).Name} cannot be applied to {nameof(Farmer)}.");
}
EcsManager.Get().AddComponent <TEffect, IImpartedEffect>(target, effect);
return(effect);
}
public static void Main(string[] consoleArgs)
{
Console.Title = "Imperium";
Console.SetWindowSize(120, 40);
Ecs = new EcsFactory().Generate();
Server = new ResponseServerFactory <Owner, EcsManager>().Generate(Ecs, typeof(Program).Assembly);
EventRegistrator.Register(Server, Ecs);
var player = Ecs.EntityManager.Create(Ecs.GetContainer <Global>().Player).GetComponent <Owner>();
Server.Accounts.Add(new Account <Owner>("", "", new[] { Permission.User, Permission.Admin }, player));
Ecs.SystemManager.GetSystem <Ownership>().Register(player);
new PlayerModifier().Modify(Ecs.SystemManager.GetSystem <Area>(), Ecs, player, new Random());
new Thread(Server.Start).Start();
Ecs.Start();
}
public void Generate(Area area, EcsManager ecs, Random random)
{
var ridges
= Enumerable
.Range(0, NumberOfRidges)
.Select(_ => random.NextPosition(area.Size))
.Select(p =>
new Ridge
{
From = p,
To = random.NextPosition(
p - MaximalLength / 2 * Vector.One,
p + MaximalLength / 2 * Vector.One),
Width = random.Next(MinimalWidth, MaximalWidth),
})
.ToArray();
foreach (var ridge in ridges)
{
GenerateRidge(ridge, area, ecs, random);
}
}
private static void GenerateSystems(EcsManager ecs)
{
var area = new Area(new Vector(40, 40));
var systems = new Ecs.System[]
{
area,
new Ownership(Resources.Zero),
new IncomeSystem(),
new ClientVision(),
new OrderManager(),
new ResearchSystem(ecs.GetContainer <Science>().Test),
new ProductionManager(),
};
foreach (var system in systems)
{
ecs.SystemManager.Register(system);
}
new AreaBasicGenerator().Generate(area, ecs, new Random());
}
protected abstract void InitializePrototypes(EcsManager ecs);
public static EntityComponentSet[] GetComponents <T>(this IEffectRenderer <T> @this)
{
return(EcsManager.Get().GetEntitiesWithComponents <T>());
}
protected override void InitializePrototypes(EcsManager ecs)
{
Test = new Research("test", 30, new Research[0]);
}
