Question

作为背景，我正在开发一款增量游戏，而我遇到一个关于通常中产阶级的奇怪困境，这就是这种情况。

我有3个类：Engine，EngineList和Resources。引擎“产生”某种类型的资源，EngineList（显然）持有并处理不同引擎的列表。资源是管理所有资源的单例。资源包含单个私有静态EngineList，以及其他资源类型的其他变量。 Other类实际上仅访问Resources，如果它们访问EngineList，则将通过Resources。

参考资料中有关引擎的许多调用只是与EngineList相同的确切函数的调用。例如：

public float getEnergyCost(string id)
{
    return energyEngines.getCost(id);
}

public int getEnergyAmount(string id)
{
    return energyEngines.getNum(id);        
}

...而且EngineList唯一的实例将来自资源。

问题在于EngineList仍然还有其他作业。（在我看来）更适合将所有一种资源类型的生产者聚集在一起的工作，而不是处理所有资源类型的工作。（例如，这些步骤包括汇总引擎的总生产率，存储所有引擎ID的const等）

一种TL; DR：

现在，在为Other类调用这些方法时，Resources在某种程度上是中间人，但是EngineList仍然有其他工作（最终是与Resources不同的总体工作）。现在，这就是我所理解的选项。

将EngineList的功能吸收到资源中
使EngineList为Resources的子类（尽管我不确定这是否会使问题有所不同）
使EngineList成为一个单例（而不是作为Resources的私有静态变量），并让Resources和Other类直接访问它
保持现状

虽然我不确定什么是合适的，但这里显然有异味，但我不知道确切的含义。最终的问题是如何处理这样的半中间人情况，为什么？

示例代码：

public class Engines {

//does enginey things

}

EngineList又名EnergyEngines

public class EnergyEngines {

    public const string STOMPER_ID = "Stompers";
    public const string JUMPER_ID = "Jumpers";

    Dictionary<string, Engine> engines;

    float productionSum;

    public EnergyEngines()
    {
        productionSum = 0;
        engines = new Dictionary<string, Engine>();
        engines.Add(STOMPER_ID, new Engine(STOMPER_ID, .15f, 1f, 1.3f));
        engines.Add(JUMPER_ID, new Engine(JUMPER_ID, 10f, 2.7f, 5f));
    }

    public float ProductionSum
    {
        get { return productionSum; }
    }


    public bool tryPurchase(string id)
    {
        Engine e = engines[id];
        if (e != null)
        {
            if(e.NextCost <= Resources.Res.Energy+.01f)
            {
                Resources.Res.Energy -= e.NextCost;
                e.Amount++;
                recalculateProduction();
                return true;
            }
        }
        return false;
    }

    void recalculateProduction()
    {
        productionSum = 0;
        foreach (Engine e in engines.Values)
        {
            productionSum += e.TotalProduction;
        }
    }

    public float getCost(string id)
    {
        Engine e = engines[id];
        if (e != null)
        {
            return e.NextCost;
        }
        return float.MaxValue;
    }

    public int getNum(string id)
    {
        Engine e = engines[id];
        if (e != null)
        {
            return e.Amount;
        }
        return -1;
    }
}

资源：

public class Resources : MonoBehaviour
{
    const int playerIncrement = 1;

    private static Resources instance;

    public static Resources Res { get { return instance; } }

    private static EnergyEngines energyEngines;

    public float Energy { get; set; }

    Resources()
    {
        Energy = 0;
        energyEngines = new EnergyEngines();

    }

    // Use this for initialization
    void Awake()
    {
        if (instance == null)
        {
            instance = this;
        }    
    }

    void FixedUpdate()
    {
        Energy += energyEngines.ProductionSum * Time.fixedDeltaTime;
    }

    void Update()
    {
        HUDManager.Hud.updateEnergyText();
    }

    public void tapEnergy()
    {
        Energy += playerIncrement;
    }

    public bool tryEnergyPurchase(string type)
    {

        if (energyEngines.tryPurchase(type))
        {
            HUDManager.Hud.updateWorkerInfo();
            return true;
        }
        return false;
    }

    public float getCost(string id)
    {
        return energyEngines.getCost(id);
    }

    public int getAmount(string id)
    {
        return energyEngines.getNum(id);        
    }

    // ... other things with other resources,

}

半中等情况应该如何处理？

一种TL; DR：

0 个答案: