Ho l'obbligo di implementare un tipo di IA per un progetto, il problema è che ho problemi a visualizzare come l'IA dovrebbe essere effettivamente implementata.
Essenzialmente, voglio che l'intelligenza artificiale sia la più dinamica possibile. Cioè, se decido in futuro di aggiungere un altro tipo di azione AI (come la chiameremo noi), non ho bisogno di riscrivere la classe usando l'AI o l'AI.
Quello che ho ora, è un'idea molto approssimativa, ma dovrebbe aiutare a chiarire.
public interface IAiAction
{
List<IAiProperty> Properties { get; }
DateTime LastUpdate { get; }
bool Update(Entity e);
}
public interface IAiProperty
{
}
Allora ho qualcosa del tipo:
public class WanderAction : IAiAction
{
private List<IAiProperty> _Properties = new List<IAiProperty>();
public List<IAiProperty> Properties { get { return _Properties; } }
private DateTime _LastUpdate;
public DateTime LastUpdate { get { return _LastUpdate; } }
private Point _WanderTo;
public bool Update(Entity e)
{
// Do stuff here
return true;
}
}
public struct WanderDistance : IAiProperty
{
private Point _Home;
private float _MaxDistance;
public Point Home { get { return _Home; } private set { _Home = value; } }
public float MaxDistance { get { return _MaxDistance; } private set { _MaxDistance = value; } }
public WanderDistance(Point h, float m)
{
_Home = h;
_MaxDistance = m;
}
}
Quindi, nella classe con le azioni:
private List<IAiAction> _AiActions = new List<IAiAction>();
public List<IAiAction> AiActions { get { return _AiActions; } }
public override void Update(Vector2F force)
{
foreach (IAiAction action in AiActions)
action.Update(this);
base.Update(force);
}
Il problema è che questo non si estende bene. Non sono nemmeno sicuro di come sono arrivato a questo livello, perché non ho mai dovuto fare qualcosa del genere prima.
Questo codice non è affatto un requisito. Se qualcuno ha altre idee su come può essere fatto (anche se sono molto distanti da ciò che questo indica), sono pronto a farlo.
Ad esempio, se avessi un IAiAction che doveva determinare ciò che il Entity avrebbe detto a caso, questo lascia molto spazio per farlo. Inoltre, come esempio di WanderAction , devo restituire un Vector2F alla classe chiamante, per aggiungerlo al parametro force del metodo Update(Vector2F) .
Se è necessaria qualche chiarimento oltre a questo, fammi sapere. Questo non ostacola il progetto, ma mi sta causando problemi.
L'unico altro metodo che posso pensare è quello di implementare una sorta di stato che viene trasportato attraverso il programma. Questo sarebbe tecnicamente in grado di soddisfare le mie esigenze, ma sono curioso di sapere se esiste un modo migliore.