/// <summary>
/// Updates the next task to execute. Technites can memorize and execute only one task per round, thus the logic
/// must redefine this task each round. If the last task result is TaskResult.MoreWorkNeeded, then the last task
/// is not cleared automatically, but can be redefined if desired.
/// Calling the method several times on the same technite before a new round is processed will overwrite the previously set task.
/// Calling SetNextTask() at all is optional. The technite will sooner or later default to not doing anything in this case.
/// </summary>
/// <param name="t">Task to execute next</param>
/// <param name="target">Location target of the task</param>
/// <param name="parameter">Task parameter. What the parameter does depends on the task executed.</param>
public void SetNextTask(Task t, Grid.RelativeCell target, byte parameter = 0)
{
//Out.Log(Significance.Low, this + "->" + t + " @" + target);
Grid.CellID absoluteTarget = Location + target;
if (!absoluteTarget.IsValid)
{
throw new TaskException(this, "Trying to set invalid relative target " + target + ". Task not set.");
}
if (t == Task.SelfTransformToType)
{
if (parameter > MatterYield.Length)
{
throw new TaskException(this, "Parameter for task " + t + " (" + parameter + ") is not a valid matter type.");
}
if (MatterYield[parameter] == 0)
{
throw new TaskException(this, "Parameter for task " + t + " (" + parameter + "/" + ((Grid.Content)parameter) + ") is not a suitable transformation output.");
}
}
else
if ((t == Task.TransferEnergyTo || t == Task.TransferMatterTo) && parameter == 0)
{
throw new TaskException(this, "Task " + t + " requires a non-zero parameter value");
}
Grid.Content content = Grid.World.CellStacks[absoluteTarget.StackID].volumeCell[absoluteTarget.Layer].content;
nextTask = t;
taskParameter = parameter;
taskTarget = target;
}
public ControlMarker(Interface.Struct.ControlMarker other)
{
BirthRound = other.birthRound;
Location = new Technite.CompressedLocation(other.location).CellID;
Radius = other.radius;
TypeIndex = other.typeIndex;
}
/// <summary>
/// Attempts to a find a technite based on its location.
/// Hashtable lookup is used to quickly locate the technite.
/// </summary>
/// <param name="location">Location to look at</param>
/// <returns>Technite reference, if a technite was found in the given location, null otherwise</returns>
public static Technite Find(Grid.CellID location)
{
Technite rs;
if (map.TryGetValue(location, out rs))
{
return(rs);
}
return(null);
}
/// <summary>
/// Determines a feasible, possibly ideal technite neighbor cell that is at the very least on the same height level.
/// Higher and/or lit neighbor technites are favored
/// </summary>
/// <param name="location"></param>
/// <returns></returns>
public static Grid.RelativeCell GetLitOrUpperTechnite(Grid.CellID location)
{
return(EvaluateNeighborTechnites(location, (relative, technite) =>
{
int rs = 0;
if (technite.Status.Lit)
{
rs++;
}
rs += relative.HeightDelta;
return rs;
}));
}
/// <summary>
/// Determines a food source in the neighborhood of the specified location
/// </summary>
/// <param name="location"></param>
/// <returns></returns>
public static Grid.RelativeCell GetFoodChoice(Grid.CellID location)
{
return(EvaluateChoices(location, (relative, cell) =>
{
Grid.Content content = Grid.World.GetCell(cell).content;
int yield = Technite.MatterYield[(int)content]; //zero is zero, no exceptions
if (Grid.World.GetCell(cell.BottomNeighbor).content != Grid.Content.Technite)
{
return yield;
}
return NotAChoice;
}
));
}
internal static bool EnoughSupportHere(Grid.CellID cell)
{
if (Grid.IsSolid(cell.BottomNeighbor.BottomNeighbor))
{
return(true);
}
foreach (var n0 in cell.GetHorizontalNeighbors())
{
if (Grid.IsSolid(n0) && Grid.IsSolid(n0.BottomNeighbor))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Determines a feasible, possibly ideal neighbor technite target, based on a given evaluation function
/// </summary>
/// <param name="location"></param>
/// <param name="f">Evaluation function. Must return 0/NotAChoice if not applicable, and >1 otherwise. Higher values indicate higher probability</param>
/// <returns>Chocen relative cell, or Grid.RelativeCell.Invalid if none was found.</returns>
public static Grid.RelativeCell EvaluateNeighborTechnites(Grid.CellID location, Func <Grid.RelativeCell, Technite, int> f)
{
return(EvaluateChoices(location, (relative, cell) =>
{
Grid.Content content = Grid.World.GetCell(cell).content;
if (content != Grid.Content.Technite)
{
return NotAChoice;
}
Technite other = Technite.Find(cell);
if (other == null)
{
Out.Log(Significance.Unusual, "Located neighboring technite in " + cell + ", but cannot find reference to class instance");
return NotAChoice;
}
return f(relative, other);
}
));
}
/// <summary>
/// Determines a feasible neighborhood cell that can work as a replication destination.
/// </summary>
/// <param name="location"></param>
/// <returns></returns>
public static Grid.RelativeCell GetSplitTarget(Grid.CellID location)
{
return(EvaluateChoices(location, (relative, cell) =>
{
Grid.Content content = Grid.World.GetCell(cell).content;
int rs = 100;
if (content != Grid.Content.Clear && content != Grid.Content.Water)
{
rs -= 90;
}
if (Grid.World.GetCell(cell.TopNeighbor).content == Grid.Content.Technite)
{
return NotAChoice; //probably a bad idea to split beneath technite
}
if (Technite.EnoughSupportHere(cell))
{
return relative.HeightDelta + rs;
}
return NotAChoice;
}
));
}
/// <summary>
/// Evaluates all possible neighbor cells. The return values of <paramref name="f"/> are used as probability multipliers
/// to chose a random a option.
/// Currently not thread-safe
/// </summary>
/// <param name="location">Location to evaluate the neighborhood of</param>
/// <param name="f">Evaluation function. Must return 0/NotAChoice if not applicable, and >1 otherwise. Higher values indicate higher probability</param>
/// <returns>Chocen relative cell, or Grid.RelativeCell.Invalid if none was found.</returns>
public static Grid.RelativeCell EvaluateChoices(Grid.CellID location, Func <Grid.RelativeCell, Grid.CellID, int> f)
{
options.Clear();
int total = 0;
foreach (var n in location.GetRelativeNeighbors())
{
Grid.CellID cellLocation = location + n;
int q = f(n, cellLocation);
if (q > 0)
{
total += q;
options.Add(new KeyValuePair <int, Grid.RelativeCell>(q, n));
}
}
if (total == 0)
{
return(Grid.RelativeCell.Invalid);
}
if (options.Count == 1)
{
return(options[0].Value);
}
int c = random.Next(total);
foreach (var o in options)
{
if (c <= o.Key)
{
return(o.Value);
}
c -= o.Key;
}
Out.Log(Significance.ProgramFatal, "Logic error");
return(Grid.RelativeCell.Invalid);
}
protected /**/ Technite(Grid.CellID loc)
{
Location = loc;
}
protected /**/ Technite(Grid.CellID loc)
{
Location = loc;
}
public ObjectID(Interface.Struct.GameObjectID id) : this()
{
Location = new Technite.CompressedLocation(id.location).CellID;
IsGhost = id.isGhost;
Type = id.type;
}
public ObjectID(Interface.Struct.GameObjectID id) : this()
{
Location = new Technite.CompressedLocation(id.location).CellID;
IsGhost = id.isGhost;
Type = id.type;
}
public ControlMarker(Interface.Struct.ControlMarker other)
{
BirthRound = other.birthRound;
Location = new Technite.CompressedLocation(other.location).CellID;
Radius = other.radius;
TypeIndex = other.typeIndex;
}
