1

私は、労働者が現在に基づいて行動を起こすゲームを作っていTaskます。各ワーカーには、タスクのリストが優先順に割り当てられます（これはプレイヤーの決定に影響されます）。

タスクが完了すると（たとえば、アイテムをXからYに移動する）、ワーカーは、可能なタスクのリストを確認して新しいタスクを開始し、それぞれを実行できるかどうかを確認し、実行できる場合は、現在のタスクをそのタスクに設定する必要があります。そしてそれを開始します（最後のタスク-「WanderAround」は常に利用可能になります）。

私は現在、大きなswitchステートメントと列挙型を使用してこれを機能させていますが、このコードを一般化してTaskクラスを作成し、ワーカーに優先タスクとGetNextTask()関数のリストを提供し、ワーカーのUpdate()メソッドで呼び出しますcurrentTask.update()（これにより、ワーカーは、現在のタスクで必要なことをすべて実行しworker.GetNextTask()、タスクが完了すると呼び出されます）。

私がよくわからないのは、タスクをワーカーに保存するための最良の方法です。使用する必要があります：

1）反射。可能なタスクをタイプのリストとして保存し、リフレクションを使用して、public static virtual bool CanPerformThisTask()a）各サブクラスでオーバーライドされる静的メソッドを呼び出し、b）ワーカー用にそのタスクのインスタンスを作成しますか？（以下のコードの例-ただし、まだテストできません）

2）ワーカーが新しいタスクを取得する必要があるときはいつでも（おそらくActivatorを使用して）すべてのタスクをインスタンス化し、(Task)task.CanPerformThisTask()各タスクをチェックします-trueの場合、そのタスクを実行します。しかし、それらすべてをインスタンス化することは非効率に思えますか？

3）ジェネリック。これはジェネリックを使用して行うことができますか？もしそうなら、どのように？

これが私のクラスのスニペットで、私がやろうとしていることを理解するためのものです。

労働者クラス：

protected List<Point> waypoints = new List<Point>();
public bool reachedDestination { get { return waypoints.Count == 0; } }
protected Task task;
public List<Type> possibleTasks;

public Worker(Task initialTask, List<Type> initialPossibleTasks ...)
: base(...)
{
     task = initialTask;
     possibleTasks = initialPossibleTasks;
}

public override void Update()
{
     base.Update();
     if (!reachedDestination) Move();
     task.Update();
}

public void GetNextTask()
{
    foreach (Type t in possibleTasks)
    {
        //reflection code here - will this work and can we do this with generics instead?
        Bool canDoT = (bool)t.GetMethod("CanPerformThisTask", BindingFlags.Static | BindingFlags.Public).Invoke(null, null);
        if (canDoT)
        {
            task = Activator.CreateInstance(t);
            return;
        }
    }
}

これが私の基本タスククラスの不完全なコードです（インスタンス化されるべきではありません）：

public class Task
{
    public Worker worker;

    public virtual static bool CanPerformThisTask()
    {
        //never call this from here - always from subclasses
        return false;
    }

    public Task()
    {
        //set up code here
    }

    public virtual void Update()
    {
        //make worker do relevant activities here
        //call finish task when done
    }

    public void FinishTask()
    {
        worker.GetNextTask();
    }

}

ワーカーが可能なタスクのリストに含めるタスクの例を次に示します。

public class T_WorkerWander : Task
{

    public static override bool CanPerformThisTask()
    {
        //can always wander (other Tasks will have conditions here)
        return true;
    }

    public T_WorkerWander()
        : base()
    {
    }

    override public void Update()
    {
        //make the worker wander here
        if (worker.reachedDestination) FinishTask();
    }

}

更新：これが私が今動作しているコードです

タスククラス：

public abstract class Task
{
    //the entity holding this task
    public TaskableEntity taskEntity;

    public List<TaskStage> taskStages;
    public TaskStage currentTaskStage { get { return taskStages[0]; } }

    public Task(TaskableEntity t) { taskEntity = t; }

    /// <summary>
    /// the conditions for the Task to be started
    /// </summary>
    public virtual bool CanStart()
    {
        return true;
    }

    public void Start()
    {
        taskStages = new List<TaskStage>();
        InitialiseTaskStages();
        taskStages[0].Start();
    }

    public abstract void InitialiseTaskStages();

    public void Update()
    {
        currentTaskStage.Update();
        if (currentTaskStage.IsComplete()) TaskStageComplete();
    }

    public void TaskStageComplete()
    {
        taskStages.RemoveAt(0);
        if (taskStages.Count == 0) taskEntity.TaskComplete();
        else currentTaskStage.Start();
    }

    public void SetTaskStages(params TaskStage[] t)
    {
        taskStages = t.ToList();
    }

    public void Interrupt()
    {
        currentTaskStage.Interrupt();
    }

}

TaskStageクラス：

public sealed class TaskStage
{
    private Task task;

    private List<Point> pointsToMoveTo;
    public void SetPointsToMoveTo(Point p) { pointsToMoveTo = new List<Point>() { p }; }
    public void SetPointsToMoveTo(params Point[] p) { pointsToMoveTo = p.ToList(); }
    public void SetPointsToMoveTo(List<Point> p) { pointsToMoveTo = p; }
    public Action actionToApply;

    private float timeToWait;
    public void SetWait(float wait) { timeToWait = wait; }

    private IReservable[] itemsToReserve;
    public void SetItemsToReserve(params IReservable[] items) { itemsToReserve = items; }

    private IReservable[] itemsToUnreserve;
    public void SetItemsToUnreserve(params IReservable[] items) { itemsToUnreserve = items; }

    private Emotion emotionToSet;
    public void SetEmotionToSet(Emotion e) { emotionToSet = e; }

    private TaskStage _interrupt;
    public void SetInterruptAction(TaskStage t) { _interrupt = t; }
    public void Interrupt() { _interrupt.Start(); }

    public TaskStage(Task t)
    {
        task = t;
    }

    public void Start()
    {
        if (actionToApply != null) actionToApply();
        if (itemsToUnreserve != null) UnreserveItems();
        if (itemsToReserve != null) ReserveItems();
        if (pointsToMoveTo != null)
        {
            //this will need changing after pathfinding sorted out...
            if (pointsToMoveTo.Count == 1) task.taskEntity.SetWaypoints(pointsToMoveTo[0]);
            else task.taskEntity.waypoints = pointsToMoveTo;
        }
        if (emotionToSet != null) emotionToSet.StartEmotion();
    }

    public void Update()
    {
        if (timeToWait > 0) timeToWait -= GV.elapsedTime;
    }

    public bool IsComplete()
    {
        if (pointsToMoveTo != null && !task.taskEntity.reachedDestination) return false;
        if (timeToWait > 0) return false;
        return true;
    }

    public void ReserveItems()
    {
        foreach (IReservable i in itemsToReserve)
        {
            i.reserved = true;
        }
    }

    public void UnreserveItems()
    {
        foreach (IReservable i in itemsToUnreserve)
        {
            i.reserved = false;
        }
    }

}

タスクの例：

public class T_WorkerGoToBed : Task
{
    public FactoryWorker worker { get { return taskEntity as FactoryWorker; } }
    public T_WorkerGoToBed(TaskableEntity t)
        : base(t) { }

    public override bool CanStart()
    {
        return Room.Available<Bed>(GV.Bedrooms);
    }

    public override void InitialiseTaskStages()
    {
        Bed bedToSleepIn = Room.NearestAvailableFurniture<Bed>(GV.Bedrooms, taskEntity.X, taskEntity.Y);

        //stage 1 - reserve bed and move there
        TaskStage ts1 = new TaskStage(this);
        ts1.SetItemsToReserve(bedToSleepIn);
        ts1.SetPointsToMoveTo(bedToSleepIn.XY);

        //stage 2 - sleep in bed
        TaskStage ts2 = new TaskStage(this);
        ts2.SetWait((worker.maxEnergy - worker.energy) / worker.energyRegeneratedPerSecondWhenSleeping);
        ts2.SetEmotionToSet(new E_Sleeping(worker, false));

        //stage 3 - unreserve bed
        TaskStage ts3 = new TaskStage(this);
        ts3.SetItemsToUnreserve(bedToSleepIn);
        ts3.SetEmotionToSet(new E_Happy(worker, false));

        SetTaskStages(ts1, ts2, ts3);
    }

}
4

2 に答える 2

3

タスクとワーカーの間で責任を逆転させる必要があるようです。タスクを実行できるかどうかを尋ねる代わりに、ワーカーに特定のタスクを実行できるかどうかを尋ねます。

class Worker
{
    bool CanPerformTask<T>() where T : Task
    {
        var type = typeof(T);
        // code to determine whether worker can perform the task T             
    }

    // alternative with instance parameter
    bool CanPerformTask<T>( T task ) where T : Task
    {
        // code to determine whether worker can perform the task passed in
    }
}

このソリューションは、「すべてのタスクをインスタンス化するか、静的メソッドを呼び出す」問題を回避します。

また、組み込みのコレクション クラスの使用を検討してください。キューやスタックなどは、実行をスケジュールするために必要なコードを大幅に簡素化できます。

于 2012-12-28T20:35:58.240 に答える
1

あなたは静的クラスの要点を悪用していると思います。「タスク」クラスは標準である必要があります（静的ではありません）。「Worker」クラスは静的ではないため、複数の「Worker」インスタンスがあることを意味します。このパラダイムを考えると、これらのワーカーにはおそらく同じタスクを割り当てることができます。

「Worker」クラスでは、このプロパティを次のように変更する必要があります。

public ListpossibleTasks;

に

public List _possibleTasks;

おそらく、このプロパティへのパブリックアクセスも必要ありません。必要に応じて「CanPerformThisTask」を変更できます。

于 2012-12-28T20:38:48.390 に答える