public override void Execute(JObject j)
{
var type = j["building-type"].ToString();
var pos = new Point(
int.Parse(j["x"].ToString()),
int.Parse(j["y"].ToString()));
BuildingElement building;
try { building = buildables.First(b => b.Type == type); }
catch (Exception) { throw new ArgumentException(string.Format(
"Building with Keyword \"{0}\" does not work", type)); }
if (pos.X < 0 || pos.Y < 0 || pos.X >= grid.Width || pos.Y >= grid.Height)
{
throw new ArgumentException();
}
if (building.Spread != null)
{
foreach (var p in building.Spread)
{
if (p.X < 0 || p.Y < 0 || p.X >= grid.Width || p.Y >= grid.Height)
{
throw new ArgumentException();
}
}
}
if (grid.Get(pos).Unit != null)
{
throw new ArgumentException("There is already a unit");
}
var entity = new Entity(data.Lolicon.Entity.Name + ':' + type + count, data.Environment);
entity.AddElement(building.GetType());
(entity.GetElement(building.GetType()) as UnitElement).Lolicon = data.Lolicon;
(entity.GetElement(building.GetType()) as UnitElement).Position = pos;
(entity.GetElement(building.GetType()) as UnitElement).Name = type + count;
count++;
grid.Set(entity.GetElement(building.GetType()) as UnitElement, pos);
if (building.Spread != null)
{
foreach (var p in building.Spread)
{
grid.Set(entity.GetElement(building.GetType()) as UnitElement, p);
}
}
lock (data.Environment)
data.Environment.AddEntity(entity);
entity.Initialize();
}
public override void Execute(JObject j)
{
var buildingname = j["building"].ToString();
var lolitype = j["loli-type"].ToString();
var building = data.Lolicon.GetUnits()
.Where(u => u is BuildingElement)
.Select(u => u as BuildingElement)
.First(b => b.Name == buildingname);
if (building.IsTraining)
{
throw new ArgumentException();
}
lock (building)
building.IsTraining = true;
Thread.Sleep(building.TrainDuration * 1000);
lock (building)
building.IsTraining = false;
if (!building.Lolis.Contains(lolitype))
{
throw new ArgumentException(string.Format("Building {0} can not train {1}", building.Name, lolitype));
}
var loli = data.Environment.GetEntity("Lolis").Elements
.Where(e => e is LoliElement)
.Select(e => e as LoliElement)
.First(e => e.Type == lolitype);
var lolipos = new Point(building.Position.X + 1, building.Position.Y);
if (grid.Get(lolipos).Unit != null)
{
throw new ArgumentException("There is already an unit");
}
var entity = new Entity(data.Lolicon.Entity.Name + ':' + lolitype + count, data.Environment);
entity.AddElement(loli.GetType());
(entity.GetElement(loli.GetType()) as UnitElement).Lolicon = data.Lolicon;
(entity.GetElement(loli.GetType()) as UnitElement).Position = lolipos;
(entity.GetElement(loli.GetType()) as UnitElement).Name = lolitype + count;
count++;
grid.Set(entity.GetElement(loli.GetType()) as UnitElement, lolipos);
lock (data.Environment)
data.Environment.AddEntity(entity);
entity.Initialize();
}
public override void Execute(JObject j)
{
var name = j["loli"].ToString();
var loli = data.Lolicon.GetUnits()
.Where(u => u is LoliElement)
.Select(u => u as LoliElement)
.First(l => l.Name == name);
var from = loli.Position;
var to = new Point(
int.Parse(j["x"].ToString()),
int.Parse(j["y"].ToString()));
var vector = new Point(
to.X - loli.Position.X,
to.Y - loli.Position.Y);
var length = Math.Sqrt(vector.X * vector.X + vector.Y * vector.Y);
var direction = new
{
X = vector.X / length,
Y = vector.Y / length
};
var time = DateTime.Now;
var covered = 0.00001;
while (loli.Position != to)
{
Thread.Sleep(200);
var delta = (DateTime.Now - time).TotalSeconds;
time = DateTime.Now;
var nextField = new Point(
loli.Position.X +
(Math.Abs(1 / (direction.X * covered)) <= Math.Abs(1 / (direction.Y * covered))
? vector.X / Math.Abs(vector.X) : 0),
loli.Position.Y +
(Math.Abs(1 / (direction.X * covered)) >= Math.Abs(1 / (direction.Y * covered))
? vector.Y / Math.Abs(vector.Y) : 0));
Console.WriteLine(nextField);
var error = grid.Get(nextField).Height - grid.Get(loli.Position).Height;
var factor = f(error);
Console.WriteLine("error:{0}\nfactor:{1}", error, factor);
covered += loli.Speed * delta * factor;
covered = Math.Min(covered, length);
var x = direction.X * covered;
var y = direction.Y * covered;
Console.WriteLine("x={0} ; y={1}", x, y);
var old = loli.Position;
loli.Position = new Point(
from.X + (x > 0 ? (int)Math.Floor(x) : (int)Math.Ceiling(x)),
from.Y + (y > 0 ? (int)Math.Floor(y) : (int)Math.Ceiling(y)));
if (old != loli.Position)
{
lock (grid)
{
grid.Set(null, old);
grid.Set(loli, loli.Position);
}
}
}
}
