Modifier and Type | Field and Description |
---|---|
protected GameState |
GameRunner.state |
Modifier and Type | Method and Description |
---|---|
protected void |
GameRunner.writeState(GameState state) |
Modifier and Type | Field and Description |
---|---|
protected GameState |
AgentPlayer.state |
Modifier and Type | Method and Description |
---|---|
Action |
RandomAgent.doMove(int agentID,
GameState state) |
Action |
Agent.doMove(int agentID,
GameState state)
Standardised interface for game playing agents.
|
Modifier and Type | Method and Description |
---|---|
GameState |
Individual.determinise(GameState state,
int agentID,
Map<Integer,List<Card>> possibleCards,
List<Integer> bindOrder) |
Modifier and Type | Method and Description |
---|---|
GameState |
Individual.determinise(GameState state,
int agentID,
Map<Integer,List<Card>> possibleCards,
List<Integer> bindOrder) |
Action |
RMHC.doMove(int agentID,
GameState state) |
int |
Individual.evaluate(GameState state,
int myID) |
Action |
Individual.getAction(int move,
int agentID,
GameState state) |
double |
Individual.multiEval(GameState state,
int myID) |
Modifier and Type | Method and Description |
---|---|
void |
HatGuessing.applyEffect(GameState state,
GameEvent event) |
Action |
HatGuessing.doMove(int agentID,
GameState state) |
Recommendation |
HatGuessing.doRecommend(int agentID,
GameState state)
Playable: a card that can be successfully played with the current game state.
|
static Action |
Recommendation.encode(Recommendation recommendation,
int myID,
GameState state) |
int |
HatGuessing.getMissingPiece(GameState state,
int whoTold,
int treasureChest) |
int |
HatGuessing.getRecommendationForAHand(int agentToTell,
GameState state)
Gets the integer recommendation for the Hat Guessing algorithm for a single hand
|
boolean |
HatGuessing.isDead(GameState state,
Card card)
Is the card dead by the Hat Guessing definition
|
boolean |
HatGuessing.isIndispensable(GameState state,
Card card)
places a card can be:
1) in the deck (still in deck or our hand)
2) in the discard pile (played incorrectly or discarded cards)
3) on the table (card is no longer needed, a copy was played successfully)
4) another player's hand (our copy is not the only one)
|
boolean |
HatGuessing.isPlayable(GameState state,
Card card)
Is the card playable by the Hat Guessing definition
|
Modifier and Type | Method and Description |
---|---|
Action |
LegalRandom.execute(int playerID,
GameState state) |
static Collection<Action> |
Utils.generateActions(int playerID,
GameState state) |
static Collection<Action> |
Utils.generateSuitableActions(int playerID,
GameState state) |
List<Action> |
BreadthFirstSearch.search(int player,
GameState state) |
Modifier and Type | Method and Description |
---|---|
protected int |
MonteCarloSearch.calculateTreeDepthLimit(GameState state) |
Action |
MonteCarloSearch.doMove(int agentID,
GameState state) |
protected Action |
MonteCarloSearch.selectActionForRollout(GameState state,
int agentID) |
Modifier and Type | Method and Description |
---|---|
protected int |
MCTS.calculateTreeDepthLimit(GameState state) |
Action |
MCTS.doMove(int agentID,
GameState state) |
Action |
MCTSPredictor.doMove(int agentID,
GameState state) |
Action |
NoisyPredictor.doMove(int agentID,
GameState state) |
protected Action |
MCTSPredictor.doSuperMove(int agentID,
GameState state) |
protected MCTSNode |
MCTS.expand(MCTSNode parent,
GameState state) |
boolean |
MCTSNode.fullyExpanded(GameState state) |
boolean |
MCTSNode.fullyExpanded(GameState state,
int nextId) |
Collection<Action> |
MCTSNode.getLegalMoves(GameState state,
int nextId) |
MCTSNode |
MCTSNode.getUCTNode(GameState state) |
protected int |
MCTS.rollout(GameState state,
int agentID,
MCTSNode current) |
protected MCTSNode |
MCTS.select(MCTSNode root,
GameState state,
IterationObject iterationObject) |
protected MCTSNode |
MCTSPredictor.select(MCTSNode root,
GameState state,
IterationObject iterationObject) |
protected Action |
MCTS.selectActionForExpand(GameState state,
MCTSNode node,
int agentID)
Select a new action for the expansion node.
|
protected Action |
MCTSPredictor.selectActionForExpand(GameState state,
MCTSNode node,
int agentID)
Select a new action for the expansion node.
|
protected Action |
MCTSPolicy.selectActionForRollout(GameState state,
int playerID)
Rather than perform a random move, query a policy for one.
|
protected Action |
MCTS.selectActionForRollout(GameState state,
int playerID) |
protected Action |
MCTSPredictor.selectActionForRollout(GameState state,
int agentID) |
Modifier and Type | Method and Description |
---|---|
Action |
RandomAgent.doMove(int agentID,
GameState state) |
Modifier and Type | Method and Description |
---|---|
Action |
TellPlayableCardOuter.execute(int playerID,
GameState state) |
Action |
OsawaDiscard.execute(int playerID,
GameState state) |
Modifier and Type | Method and Description |
---|---|
boolean |
AbstractTellRule.canFire(int playerID,
GameState state) |
default boolean |
Rule.canFire(int playerID,
GameState state) |
boolean |
AbstractRule.canFire(int playerID,
GameState state) |
boolean |
AbstractDiscardRule.canFire(int playerID,
GameState state) |
boolean |
AbstractTellRule.couldFire(int playerID,
GameState state) |
default boolean |
Rule.couldFire(int playerID,
GameState state)
Return true if it is possible this rule could fire, and return false if you can guarantee that it cannot fire.
|
boolean |
AbstractDiscardRule.couldFire(int playerID,
GameState state) |
Action |
ProductionRuleAgent.doDefaultBehaviour(int playerID,
GameState state) |
Action |
ProductionRuleAgent.doMove(int agentID,
GameState state) |
Action |
TellUnknown.execute(int playerID,
GameState state) |
Action |
PlaySafeCard.execute(int playerID,
GameState state) |
Action |
PlayUniquePossibleCard.execute(int playerID,
GameState state) |
Action |
TellAboutOnes.execute(int playerID,
GameState state) |
Action |
TellAnyoneAboutOldestUsefulCard.execute(int playerID,
GameState state) |
Action |
TellDispensable.execute(int playerID,
GameState state) |
Action |
DiscardUnidentifiedCard.execute(int playerID,
GameState state) |
Action |
TellMostInformation.execute(int playerID,
GameState state) |
Action |
TellAnyoneAboutUsefulCard.execute(int playerID,
GameState state) |
Action |
TellAnyoneAboutUselessCard.execute(int playerID,
GameState state) |
Action |
DiscardHighest.execute(int playerID,
GameState state) |
Action |
DiscardSafeCard.execute(int playerID,
GameState state) |
Action |
CompleteTellUsefulCard.execute(int playerID,
GameState state) |
Action |
DiscardUselessCard.execute(int playerID,
GameState state) |
Action |
Rule.execute(int playerID,
GameState state) |
Action |
TellFives.execute(int playerID,
GameState state) |
Action |
DiscardOldestNoInfoFirst.execute(int playerID,
GameState state) |
Action |
DiscardOldestFirst.execute(int playerID,
GameState state) |
Action |
TellIllInformed.execute(int playerID,
GameState state) |
Action |
TryToUnBlock.execute(int playerID,
GameState state) |
Action |
TellIllInformed.getInformingAction(GameState state,
int playerID) |
boolean |
TryToUnBlock.isBlocked(GameState state,
int playerID)
A blocked player is a player who has no safe play or discard move and has no information tokens to tell.
|
static boolean |
PlaySafeCard.isPlayable(Card card,
GameState state) |
Action |
TryToUnBlock.isUnblocking(GameState state,
int playerID)
Can a player cause an information token to become available during their turn?
|
static boolean |
TryToUnBlock.isUsableCard(GameState state,
CardColour colour,
Integer value) |
int |
AbstractRule.selectPlayer(int playerID,
GameState state) |
Modifier and Type | Method and Description |
---|---|
Action |
TellFinesse.execute(int playerID,
GameState state) |
Action |
PlayFinesseTold.execute(int playerID,
GameState state) |
Action |
PlayFinesse.execute(int playerID,
GameState state) |
static int |
PlayFinesse.getNewestCard(GameState state,
int playerID)
This method will return -1 if someone doesn't want us to know what order our cards were delt in.
|
Modifier and Type | Method and Description |
---|---|
static int |
HandUtils.getHighestScorePossible(GameState state,
CardColour colour)
Calculates the maximum possible score obtainable for the given colour
|
static int |
HandUtils.getMinTableValue(GameState state) |
static Integer[] |
HandUtils.getTableScores(GameState state) |
static boolean |
DeckUtils.isDiscardable(Card card,
GameState state) |
static boolean |
DeckUtils.isDiscardable(List<Card> cards,
GameState state) |
static boolean |
HandUtils.isSafeBecauseFiveAlreadyPlayed(GameState state,
CardColour c) |
static boolean |
HandUtils.isSafeBecauseValueLowerThanMinOnTable(GameState state,
Integer value) |
static boolean |
HandUtils.isSafeBecauseValueLowerThanPlayed(GameState state,
CardColour c,
Integer value) |
static boolean |
HandUtils.isSafeToDiscard(GameState state,
CardColour c,
Integer value) |
static boolean |
HandUtils.isSafeToDiscard(GameState state,
int player,
int slot)
Returns true if a given card is safe to discard.
|
static boolean |
HandUtils.isSafeToDiscardHigherThanPossible(GameState state,
CardColour colour,
Integer value)
Returns true if the card is safe to discard because it is higher than what is currently possible for its colour
|
static boolean |
HandUtils.knowsItIsSafeToDiscard(GameState state,
int player,
int slot)
Returns true if a given card is safe to discard.
|
Modifier and Type | Method and Description |
---|---|
Action |
DiscardRandomly.execute(int playerID,
GameState state) |
Action |
PlayProbablySafeCard.execute(int playerID,
GameState state) |
Action |
DiscardLeastLikelyToBeNecessary.execute(int playerID,
GameState state) |
Action |
TellPlayableCard.execute(int playerID,
GameState state) |
Action |
DiscardProbablyUselessCard.execute(int playerID,
GameState state) |
Action |
TellRandomly.execute(int playerID,
GameState state) |
boolean |
PlayProbablySafeCard.isPlayable(Card card,
GameState state) |
Modifier and Type | Method and Description |
---|---|
Action |
PlayIfCertain.execute(int playerID,
GameState state) |
Action |
DiscardIfCertain.execute(int playerID,
GameState state) |
Modifier and Type | Method and Description |
---|---|
boolean |
ConcatRule.canFire(int playerID,
GameState state) |
boolean |
IfRule.canFire(int playerID,
GameState state) |
Action |
ConcatRule.execute(int playerID,
GameState state) |
Action |
IfRule.execute(int playerID,
GameState state) |
Constructor and Description |
---|
IfRule(BiFunction<Integer,GameState,Boolean> predicate,
Rule success) |
IfRule(BiFunction<Integer,GameState,Boolean> predicate,
Rule success,
Rule failure) |
Modifier and Type | Method and Description |
---|---|
Action |
BasicHuman.doMove(int agentID,
GameState state) |
Modifier and Type | Method and Description |
---|---|
void |
BasicGameView.setState(GameState state,
int id) |
abstract void |
GameView.setState(GameState state,
int id) |
protected void |
HumanView.writeState(GameState state) |
Modifier and Type | Field and Description |
---|---|
protected GameState |
InfoComponent.state |
Modifier and Type | Method and Description |
---|---|
Action |
HumanUIAgent.doMove(int agentID,
GameState state) |
void |
PrettyGameView.setState(GameState state,
int id) |
Constructor and Description |
---|
DeckComponent(GameState state) |
DiscardComponent(GameState state) |
HeuristicGameView(GameState state,
int playerID,
HumanUIAgent player) |
InfoComponent(GameState state) |
LifeComponent(GameState state) |
PrettyGameView(GameState state,
int playerID,
HumanUIAgent player) |
TableCard(GameState state,
CardColour colour) |
Modifier and Type | Class and Description |
---|---|
class |
BasicState |
Modifier and Type | Method and Description |
---|---|
GameState |
GameState.getCopy() |
GameState |
BasicState.getCopy() |
Modifier and Type | Method and Description |
---|---|
List<GameEvent> |
Action.apply(int playerID,
GameState state) |
List<GameEvent> |
TellColour.apply(int playerID,
GameState game) |
List<GameEvent> |
PlayCard.apply(int playerID,
GameState game) |
List<GameEvent> |
TellValue.apply(int playerID,
GameState game) |
List<GameEvent> |
DiscardCard.apply(int playerID,
GameState game) |
boolean |
Action.isLegal(int playerID,
GameState state) |
boolean |
TellColour.isLegal(int playerId,
GameState state) |
boolean |
PlayCard.isLegal(int playerID,
GameState state) |
boolean |
TellValue.isLegal(int playerId,
GameState state) |
boolean |
DiscardCard.isLegal(int playerID,
GameState state) |
Modifier and Type | Method and Description |
---|---|
void |
GameEvent.apply(GameState state)
Deprecated.
|
void |
CardPlayed.apply(GameState state,
int myPlayerID) |
void |
CardInfoValue.apply(GameState state,
int myPlayerID) |
void |
CardDiscarded.apply(GameState state,
int myPlayerId) |
void |
CheatEvent.apply(GameState state,
int myPlayerID) |
void |
GameInformation.apply(GameState state,
int myPlayerID) |
void |
CardInfoColour.apply(GameState state,
int myPlayerID) |
abstract void |
GameEvent.apply(GameState state,
int myPlayerID) |
void |
CardDrawn.apply(GameState state,
int myPlayerID) |
void |
CardReceived.apply(GameState state,
int myPlayerID) |
Modifier and Type | Method and Description |
---|---|
static void |
DebugUtils.printDeck(org.slf4j.Logger logger,
GameState state) |
static void |
DebugUtils.printDiscard(org.slf4j.Logger logger,
GameState state) |
static void |
DebugUtils.printHands(org.slf4j.Logger logger,
GameState state) |
static void |
DebugUtils.printState(org.slf4j.Logger logger,
GameState state) |
static void |
DebugUtils.printTable(org.slf4j.Logger logger,
GameState state) |
Copyright © 2017 FOSS Galaxy. All rights reserved.