public void DeployTrain(LineTask lt)
{
var action = new DeployTrainAction(factory);
action.Act(lt);
Actions.AddLast(action);
}
/**
* 前の駅から次の駅までの距離をタスク距離合計とする
* 乗車プラットフォーム => 発車タスク => 到着プラットフォームとする
*/
private void Scan()
{
var f = Finders[FinderIdx];
var l = storage.List <RailLine>()[RailLineIdx];
// 各発車タスクを始発とし、電車で到達可能なプラットフォームを登録する
var deptList = l.Filter(lt => lt is DeptTask);
var dept = deptList[DeptTaskIdx] as DeptTask;
// 乗車タスクとホームは相互移動可能
f.Edge(dept, dept.Stay, 0);
f.Edge(dept.Stay, dept, 0);
LineTask current = dept;
var length = current.Length;
do
{
current = current.Next;
length += current.Length;
if (current is DeptTask)
{
// Dept -> P のみ登録する
// P -> P 接続にしてしまうと乗り換えが必要かどうか分からなくなるため
f.Edge(dept, (current as DeptTask).Stay, length * DistRatio + RideCost, Payment(length, l));
}
} while (dept != current);
DeptTaskIdx++;
if (DeptTaskIdx == deptList.Count)
{
DeptTaskIdx = 0;
RailLineIdx++;
}
}
public DeptTask(ModelStorage db, ModelListener lis, RailLine l, Platform p, LineTask lt) : base(db, lis, l, lt)
{
Stay = p;
Stay.Depts.AddLast(this);
db.Add(this);
Queue = new LinkedList <Human>();
router = new RouterImpl(this);
listener.Fire(EventType.CREATED, this);
}
protected TrainTask Generate(LineTask lt, TrainTask.OnComplete fn)
{
if (lt is DeptTask)
{
return(new StayTask(listener, train, lt as DeptTask, fn));
}
if (lt is EdgeTask)
{
return(new MoveTask(train, lt as EdgeTask, fn));
}
throw new ArgumentException("invalid type" + lt);
}
public Train NewInstance(LineTask current)
{
var obj = Instantiate(template);
obj.isTemplate = false;
obj.Passengers = new List <Human>();
obj.router = new RouterImpl(obj);
obj.GetComponent <SpriteRenderer>().enabled = true;
obj.executor = new TrainExecutor(listener, obj, current);
obj.transform.position = obj.executor.Position;
listener.Fire(EventType.CREATED, obj);
return(obj);
}
/// <summary>
/// Processes a list in parallel after dividing it in taskCount even regions
/// </summary>
/// <typeparam name="TInput"></typeparam>
/// <typeparam name="TOutput"></typeparam>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="processingAction"></param>
/// <param name="taskCount"></param>
public static void ProcessList <TInput, TOutput>(TInput[] input, TOutput output, Action <LineTask <TInput[], TOutput> > processingAction, int taskCount)
{
var elementCount = input.Length / taskCount;
var overflow = input.Length - elementCount * taskCount;
var tasks = new LineTask <TInput[], TOutput> [taskCount];
for (int i = 0; i < taskCount; i++)
{
tasks[i] = new LineTask <TInput[], TOutput>(input, output, i * elementCount, elementCount + (i == taskCount - 1 ? overflow : 0));
}
Parallel.ForEach(tasks, processingAction);
}
/**
* 現在のタスクの次を指定のタスクに設定します。
* 今ある中間タスクはすべて削除されます
*/
public void Shrink(LineTask to)
{
var obj = Next;
while (obj != to)
{
obj.Trains.ForEach(t => t.Skip(to));
obj.Remove();
obj = obj.Next;
}
Next = to;
to.Prev = this;
listener.Fire(EventType.MODIFIED, this);
listener.Fire(EventType.MODIFIED, to);
}
/**
* 指定された条件を満たすタスクを絞り込みます
*/
public List <LineTask> Filter(Cond cond)
{
if (Top == null)
{
return(new List <LineTask>());
}
var result = new List <LineTask>();
LineTask current = Top;
do
{
if (cond(current))
{
result.Add(current);
}
current = current.Next;
} while (current != Top);
return(result);
}
private void ProcessInParallel(ICollection <Point> path, Action <LineTask> process, Int32 parallelTaskCount = 4)
{
// checks parameters
Guard.CheckNull(process, "process");
// updates the palette
UpdatePalette();
// prepares parallel processing
Double pointsPerTask = (1.0 * path.Count) / parallelTaskCount;
LineTask[] lineTasks = new LineTask[parallelTaskCount];
Double pointOffset = 0.0;
// creates task for each batch of rows
for (Int32 index = 0; index < parallelTaskCount; index++)
{
lineTasks[index] = new LineTask((Int32)pointOffset, (Int32)(pointOffset + pointsPerTask));
pointOffset += pointsPerTask;
}
// process the image in a parallel manner
Parallel.ForEach(lineTasks, process);
}
public Train NewTrain(LineTask lt)
{
return(t.NewInstance(lt));
}
public LineTask(ModelStorage db, ModelListener lis, RailLine line, LineTask lt) : this(db, lis)
{
Parent = line;
Prev = lt;
Prev.Next = this;
}
public Train Act(LineTask lt)
{
train = factory.NewTrain(lt);
return(train);
}
// load_items / save / search_biblio
internal void AddTask(RegisterLine line,
string strTaskName,
object tag = null)
{
LineTask task = new LineTask();
task.TaskName = strTaskName;
task.Line = line;
task.Tag = tag;
lock (this._loadEntityTasks)
{
this._loadEntityTasks.Add(task);
}
this.ActivateThread();
}
public void Skip(LineTask to)
{
executor.Skip(to);
listener.Fire(EventType.MODIFIED, this);
}
private void ProcessInParallel(ICollection<Point> path, Action<LineTask> process, Int32 parallelTaskCount = 4)
{
// checks parameters
Guard.CheckNull(process, "process");
// updates the palette
UpdatePalette();
// prepares parallel processing
Double pointsPerTask = (1.0*path.Count)/parallelTaskCount;
LineTask[] lineTasks = new LineTask[parallelTaskCount];
Double pointOffset = 0.0;
// creates task for each batch of rows
for (Int32 index = 0; index < parallelTaskCount; index++)
{
lineTasks[index] = new LineTask((Int32) pointOffset, (Int32) (pointOffset + pointsPerTask));
pointOffset += pointsPerTask;
}
// process the image in a parallel manner
Parallel.ForEach(lineTasks, process);
}
public void Skip(LineTask to)
{
Current = Generate(to, () => Next());
}
public EdgeTask(ModelStorage db, ModelListener lis, RailLine l, RailEdge re, LineTask lt) : base(db, lis, l, lt)
{
Edge = re;
db.Add(this);
listener.Fire(EventType.CREATED, this);
}
public TrainExecutor(ModelListener lis, Train t, LineTask lt)
{
listener = lis;
train = t;
Current = Generate(lt, () => Next());
}
