Changes between Initial Version and Version 1 of AI_Notepad

Timestamp:

Feb 23, 2008, 4:18:58 AM (16 years ago)

Author:

trac

Comment:

--

AI_Notepad

@@ +1 @@
+This development notepad is an organized way to jot down preliminary API decisions. Nothing is finalized. If it doesn't add up, it WILL change.
+[[BR]][[BR]]
+= TODO =
+Decision Tree Generation[[BR]]
+Event Handler[[BR]]
+State Machine[[BR]]
+
+= Mediator =
+Mediators encapsulate how a set of objects interact. We will have a mediator that describes the heirarchy and how the nodes (objects) relate to eachother. A scripter could choose to create his own mediator to change the way the AI "thinks". For example, one could make it so Military interacts directly to Economy and Diplomacy instead of having to go through Commander. The nodes somehow will be responsible for the pieces of the State Machine that pertain to it probably using a chain of responsibility or simply encapsulating it by node which is much more flexible.
+[[BR]][[BR]]
+The interaction between nodes will need handlers to Filter Up and Specify Down the various messages it needs to work with.[[BR]]
+[[BR]]'''Filter Up:'''[[BR]]
+We will need to create objects that can analyze an array of recieved messages and return a more general state/need. When it does that, it also removes the states/needs it used to make the recognition.
+[[BR]]'''Specify Down:'''[[BR]]
+We will also need objects that can intelligently seperate messages into smaller messages.
+== Commander ==
+The Commander node makes sure everything is up to date and creates the strategies the other nodes must accomplish.
+== Economy ==
+The Economy node makes sure the economy is running as smoothly as possible and decides on how to manage civilians based on needs.
+== Diplomacy ==
+The Diplomacy node handles issues that can be categorized as diplomatic and political. The major role of diplomacy is communicating with the AI: Player to AI and AI to AI. The Diplomacy node can send messages to any AI's Commander node. It's the only way to communicate, it should not be possible to directly communicate with other nodes. Player to AI communication could simply be taking notice of all available ways a player can communicate such as signals and chat. The node can then decide what to do with that information.
+
+== Military ==
+The Military node develops military tactics to accomplish goals set by the Commander.
+== Groups ==
+The Groups node is the Flocking logic of the game.
+
+== Units ==
+The Units node is the lowlevel logic for units such as attack, walk, garrison, etc.
+
+= Decision Trees =
+== Constraints ==
+== Learning ==
+The AI can be capable of learning by remembering past experiences. Experiences can be outlined using the route chosen in a Decision Tree. The AI could learn as it plays the game by figuring out which past decisions were more favorable to reach a defined goal.
+
+= State Machine =
+== Game ==
+=== State ===
+string Game.getMap()
+
+Player Game.getPlayers()
+
+Resource Game.getStartingResources()
+
+int Game.getTime()
+
+int Game.getType()
+
+int Game.getStartingPhase()
+
+int Game.getMapSize()
+
+int Game.getBorderTimer()
+
+int Game.getMaxCenters()
+
+int Game.getVisibility()
+
+int Game.getPopCap()
+
+int Game.getDifficulty()
+
+int Game.getVictoryCondition()
+
+bool Game.isOnline()
+
+bool Game.hasTeams()
+
+bool Game.hasTeamsLocked()
+
+bool Game.cheatsEnabled()
+
+bool Game.playerInGame(String player)
+
+bool Game.playerResigned(String player)
+
+int Game.buyingPrice(String resource)
+
+int Game.sellingPrice(String resource)
+
+=== Action ===
+void Game.chatLocalToSelf(String message)
+
+void Game.chatToAllies(String message)
+
+void Game.chatToNeutrals(String message)
+
+void Game.chatToEnemies(String message)
+
+void Game.chatToPlayer(String player, String message)
+
+void Game.tauntLocalToSelf(int tauntID)
+
+void Game.tauntToAllies(String message)
+
+void Game.tauntToNeutrals(String message)
+
+void Game.tauntToEnemies(String message)
+
+void Game.tauntToPlayer(String player, String message)
+
+void !EventHandler.acknowledgeEvent(String eventID, String player)
+
+void !EventHandler.acknowledgeSignal(String signalID, String player)
+
+void !EventHandler.disableTimer(int id)
+
+void !EventHandler.enableTimer(int id, int time)
+
+== Players ==
+=== State ===
+string Player.getCiv()
+
+bool Player.receivedResourceFromPlayer(String resource, String player)
+
+int Player.resourceAmountReceivedFromPlayer(String resource, String player)
+
+int Player.getID()
+
+int Player.getScore()
+
+int Player.getPhase()
+
+int Player.getTimeInAge()
+
+int Player.getCurrentPop()
+
+int Player.getEconomicPop()
+
+int Player.getNonEconomicPop()
+
+Resource Player.getResources()
+
+array Player.getUnits()
+
+array Player.getStructures()
+
+bool Player.isDefeated()
+
+bool Player.canAffordUnit(Type)
+
+bool Player.canAffordBuilding(Type)
+
+bool Player.canAffordTech(Type)
+
+bool Player.canAffordWall()
+
+bool Player.canBuy(Type)
+
+bool Player.canSell(Type)
+
+bool Player.canResearch(Type)
+
+bool Player.canTrain(Type)
+
+bool Player.canBuild(Type)
+
+int Player.getBuyPrice(Type)
+
+int Player.getSellPrice(Type)
+
+int Player.numEnemyBuildingsInTown()
+
+int Player.numEnemyBuildingsOfTypeInTown(Type t)
+
+int Player.wallCompletedPercentage(int perimeter)
+
+int Player.wallInvisblePercentage(int perimeter)
+
+int Player.stanceToward(String player)
+
+=== Action ===
+void Player.tribute(Player, int food, int wood, int stone, int ore)
+
+void Player.resign()
+
+void Player.setStance(Player, int)
+
+void Player.research(Type)
+
+void Player.buy(Type)
+
+void Player.sell(Type)
+
+void Player.declareCentralObject(Type t, Array pos)
+
+void Player.declarePlayerCentralObject(String player, Type t, Array pos)
+
+void Player.build(Type t, int distance)
+
+void Player.buildAtPos(Type t, Array pos)
+
+void Player.buildForward(Type t, String player, int distance)
+
+void Player.buildWall(int distance)
+
+void Player.buildWallAroundPlayer(String player, int distance)
+
+void Player.train(Type unitType)
+
+void Player.trainInBuilding(type unitType, Building b)
+
+void Player.acknowledgeTribute(String resource, String player)
+
+== Resources ==
+=== State ===
+int Resource.getWood()
+
+int Resource.getFood()
+
+int Resource.getStone()
+
+int Resource.getOre()
+
+int Resource.getMinDistance()
+
+== Structures ==
+=== State ===
+array Structure.getWaypoint()
+
+int Structure.getPercentConstructed()
+
+Unit Structure.getLastAttacker()
+
+int Structure.getLastAttacked()
+
+bool Structure.isConstructing()
+
+bool Structure.isConstructed()
+
+bool Structure.isLocked()
+
+bool Structure.isQueued()
+
+bool Structure.isUnderAttack()
+
+=== Action ===
+void Structure.setWaypoint(x, y)
+
+void Structure.train(Unit)
+
+void Structure.cancel(Unit, amount = 1)
+
+void Structure.lock()
+
+void Structure.unlock()
+
+void Structure.delete()
+
+== Units ==
+=== State ===
+array Unit.getPosition()
+
+int Unit.getCurrentHP()
+
+int Unit.getMaxHP()
+
+int Unit.getCrushArmor()
+
+int Unit.getHackArmor()
+
+int Unit.getPierceArmor()
+
+Type Unit.getType()
+
+int Unit.getCurrUP()
+
+int Unit.getNextUP()
+
+Unit Unit.getLastAttacker()
+
+int Unit.getLastAttacked()
+
+bool Unit.isBalanced()
+
+bool Unit.isAggressive()
+
+bool Unit.isDefensive()
+
+bool Unit.isDead()
+
+bool Unit.isIdle()
+
+bool Unit.isRepairing()
+
+bool Unit.isConstructing()
+
+bool Unit.isPatrolling()
+
+bool Unit.isHealing()
+
+bool Unit.isEscorting()
+
+bool Unit.isAttacking()
+
+bool Unit.isGathering()
+
+bool Unit.isGatheringWood()
+
+bool Unit.isGatheringFood()
+
+bool Unit.isGatheringStone()
+
+bool Unit.isGatheringOre()
+
+bool Unit.isGarrisoned()
+
+array Unit.getPosition()
+
+int Unit.getCurrentHP()
+
+int Unit.getMaxHP()
+
+=== Action ===
+void Unit.repair(Structure)
+
+void Unit.patrol(array, array)
+
+void Unit.heal(Unit)
+
+void Unit.escort(Unit)
+
+void Unit.attack(Unit)
+
+void Unit.attackPlayer(Player)
+
+void Unit.gather(Type)
+
+void Unit.move(x, y)
+
+void Unit.garrison(Structure)
+
+void Unit.construct(Type, x, y)
+
+void Unit.buildWall(array, array)
+
+void Unit.delete()
+
+== Entity Filters ==