TODO.md

TODO

• Remove electron requirement.
• Add ESlint
• Separate renderer logic from data and models.
• Switch plugins to being ES modules.
• Re-do plugin system to remove 'priority' and rely on dependencies directly.
• Get AI players to move units.
• Convert all raw data files to JS classes.
• Re-do world generation.
• Remove reliance on augmenting Engine directly.
• Work on city build list.
• Combat.
• When building World, ensure there are enough starting squares.
• Add user-definable rulesets.
• Non-human players.
• Write tests.
• Fix map tiling.
• City Improvements/Wonders.
• Control city improvement costs via Rules.
• Control unit base stats via Rules.
• Fix AI bug with NavalTransports.
• More civilizations.
• Reorganise all existing plugins to extract self-contained entities (perhaps so they they are testable?)
• Fix AI bug where they always trend north-east. Maybe this is just masked - but seems less problematic.
• Add science.
• Add 'trade' tile yield.
• Break all plugins into core (parent classes/interfaces/rules) and base (implementations).
• Change terrain specials to be augments instead of specific terrain types - this would allow rivers as they are in Civ 2+
• Governments.
• Replace all unit stats (and maybe costs etc) with Yields
• Add trade rates to control how much of a city's yield is tax/science/etc
• Convert science to trade rate
• Add tax trade rate
• Look at the benefit of creating a single entity registry with helper methods like .is(...). - const [entity] = Registry.getBy(...) is sufficient for this.
• Obseletion mechanism (primarily units, but potentially anything...) - Covered by research with an extra criteria check.
• Add Modifiers to Yields with either a priority field, or a Queue of some sort.
• Add Science and Gold multipliers (Library, Marketplace, etc)
• Add maintenance costs
• Re-do tile yields to calculate Gold/Science immediately, rather than via events.
• Add luxuries trade rate
• City Happiness.
• Convert terrain improvements availableOn into Rules.
• Write more tests.
• Replace Tile#improvements with Registry.
• Move buildProgress and the entire build mechanism into a value object instead of a property.
• Replace the rest of the .improvements with Registry pattern
• Add ability to spend gold on city build items.
• Move foodStorage into a value object instead of a property.
• Add pathing mechanisms (A*?)
• Add version checking to plugin system. - negated when moving to using npm modules.
• Fix bug where AI wasn't attacking other units
• Change the way events and rules are triggered to make testing feasible. This could be main script in package.json.
• Fix bug when AI is using NavalTransport - unit testing the AI might be a good way to do this... (Game hangs)
• Set pathing data for target in SimpleAIPlayer.
• Convert DelayedAction to use Rules.
• Fix bug where units will continually fire NoOrders when on the coast - this seems to be resolved as part of the fixes applied to SimpleAIPlayer during testing/pathing addition.
• Handle Unit#transport somehow. Perhaps this needs to be a Registry to avoid adding it to Unit?
• Implement Priority for Rules to aid processing Trade.
• Add wonders.
• Add wealth. - not civ 1 - delay
• Add build-queue. - not civ 1 - delay
• Break base-civilizations into individual plugins.
• Break base-unit into individual plugins.
• Break base-city-improvements into individual plugins.
• Fix bug where SimpleAIPlayer can't perform an action for a unit.
• Convert Notificaiton#when to use Rules.
• Add Zulu, Egyptian, Chinese, Mongol civilizations for Civ1 compatibility.
• Break base-wonder into individual plugins.
• Add Sleep action definition Rules.
• Add Pillage unit action.
• Add goody huts
• Ensure Engine is passed to plugins in read-only mode, but expose events system.
• Convert to TypeScript? - There's no run-time system to handle this at the moment, look into again later... Alongside the "compiler"
• Add PlayerMap classes that only see what the Player has discovered and track the state (improvements, cities, etc) - perhaps this is a concern of a Client?
• Consider PlayerActionRegistry returning a PlayerAction entity that can be processed or dismissed. Sub-class with Mandatory... and Optional... PlayerActions which can be optionally skipped in the Player#takeTurn loop. - Used Rules but, implemented.
• Abstract World class to allow implementation of hexes rather than squares and other world generators.
• Renderer interface - I imagine this to be a separate application that has this repo as a dependency. - Look at NodeGUI - need a canvas or something similar to be implemented. Or wait for Electron to adopt Node 14...
• Break the engine into it's own core-engine repo.
• Input management (keyboard/mouse) - tied to renderer?
• i18n/l10n.
• Remote network players.
• Even more civilizations.
• Difficulties.
• Add optional dependencies to plugins.
• Human players - this is likely dependent on a renderer, although perhaps make it playable within a TTY?
• Write more tests.
• Feature parity with Civilization.
• Add more units.
• Add more city improvements.
• Add Barbarians.
• Look at modular AI info for plugin Unit providing data/weightings on what to do with the unit?
• Add starter technologies - need to read why Civ allocates these and set up Rules within base-science.
• Consider building a 'compiler' that can build a static version of the game including all rules that would run better and consider the current state as 'dev' mode.
• Add diplomacy
• Add leader traits
• Modify AI to adjust trade rates
• Add load and save methods to World - need to consider the available plugins when saving/loading - mandating the exact plugins seems too much, but need to consider this before working on this functionality.
• Replace Tile#features with Registry pattern - not sure on how useful this is, since it'll necessitate a refactor in World#build/Generator.
• Add ability to sell CityImprovements.
• Add Caravan and Diplomat and correctly exclude these from city:costs. (Diplomatic type of Unit?)
• (Eventually) Convert all plugins to individual packages on npm so that plugin packs can be provided that combine a bunch of plugins to match the functionality of a desired Civ game.
• Add AI routine to avoid civil disorder.
• Add benefits to 'we love the leader' day.
• Break SimpleAIPlayer down into smaller routines.
• Investigate why units STILL trend north-east.
• Make Player#civilization use methods instead of bare properties.
• Make Civilization and leader choice a bit better - add Leader class and use Player#setCivilization or something.
• Add rules to wake enemy units that are Sleeping when moving within their visible range.
• Add effects for GreatWall.
• Add revolution delay in changing governments.
• Add effects for Pyramids.
• Add more variance in the worlds that are generated again - no islands appear to be generated no matter the settings used.
• Fix any tests that rely on global instances.
• Break base-terrain into individual base-terrain-x plugins and incorporate movementCosts.
• Add Negotiation to core-diplomacy.
• Add more Interactions and use this data to inform AI decisions on trusting another player.
• Convert activate, disband, etc from methods to Actions for Units.
• Add Corruption yield.
• Fix units having Fortified applied loads of times.
• Add GoTo action for Units.
• Add provider to Yields.