public override float evaluate(GameState gs) { if (gs.currentPlayer().position == city) return 1; else return 0; }
public static List<TradeAction> getTrades(GameState gs) { List<TradeAction> result = new List<TradeAction>(); City card = gs.currentPlayer().position; List<Player> partners = new List<Player>(); Player trader = null; foreach(Player p in gs.players) { if (p.position == card) { if (p.cards.Contains(card)) { trader = p; } else { partners.Add(p); } } } if(trader == null) return result; foreach(Player p in partners) { result.Add(new TradeAction(trader, p, card)); } return result; }
public override GameState execute(GameState gs) { //does stuff that happens between two turns (after actions) GameState newGS = gs.drawPlayerCards(gs.currentPlayer()); int numInfectionCardsToDraw=0; Map m = newGS.map; //draw x infection cards if(m.infectionRate>=0 && m.infectionRate<3) { numInfectionCardsToDraw = 2; } else if (m.infectionRate >= 3 && m.infectionRate < 5) { numInfectionCardsToDraw = 3; } else if(m.infectionRate >=5 && m.infectionRate<7) { numInfectionCardsToDraw = 4; } newGS = newGS.drawInfectionCards(numInfectionCardsToDraw); newGS.advancePlayer(); return newGS; }
public override GameState execute(GameState gs) { //Debug.Assert(debug_gs == null || debug_gs == gs, "Action used on an unintended gamestate"); Player movedPlayer = new Player(dest, gs.currentPlayer()); GameState result = gs.adjustPlayer(movedPlayer); result.advanceMove(); return result; }
public void initialize() { map = new Map(); atlanta = map.addCity("Atlanta", DiseaseColor.BLUE); newyork = map.addCity("NewYork", DiseaseColor.BLUE); City.makeAdjacent(atlanta, newyork); gs = new GameState(atlanta, map); }
public override GameState execute(GameState current) { Player newPlayer = new Player(card, player); newPlayer = newPlayer.removeCard(card); GameState g = current.adjustPlayer(newPlayer); g.advanceMove(); g = g.recalcBestCardHolder(g, newPlayer, card.color); return g; }
public override GameState execute(GameState gs) { gs = new GameState(gs, gs.map); gs.advancePlayer(); return gs; }
public GameState executeOrDoNothing(Action action, GameState gs) { if (action.isTurnAction()) { return turnAction().execute(gs); } else { return action.execute(gs); } }
public GameState adjustPlayer(Player p) { GameState result = new GameState(this); result.players = new Player[numPlayers]; for (int i = 0; i < numPlayers; i++) { result.players[i] = players[i]; } Debug.Assert(p.playernum < numPlayers); result.players[p.playernum] = p; return result; }
public override GameState execute(GameState gs) { Player newFrom = from.removeCard(card); Player newTo = to.addCard(card); gs = gs.adjustPlayer(newFrom); gs = gs.recalcBestCardHolder(gs, newFrom, card.color); gs = gs.adjustPlayer(newTo); gs = gs.recalcForAddCard(newTo, card); gs.advanceMove(); return gs; }
public override GameState execute(GameState current) { Debug.Assert(debug_gs == null || debug_gs == current, "Action used on an unintended gamestate"); Map newMap = current.map.addStation(position); GameState g = new GameState(current, newMap); player = player.removeCard(position); g.players[g.currentPlayerNum] = player; g.advanceMove(); g = g.recalcBestCardHolder(g, player, position.color); return g; }
public static int getTotalDisease(GameState gs) { int totalDisease = 0; foreach (City c in gs.map.allCities) { totalDisease += gs.map.diseaseLevel(c, DiseaseColor.BLACK); totalDisease += gs.map.diseaseLevel(c, DiseaseColor.BLUE); totalDisease += gs.map.diseaseLevel(c, DiseaseColor.YELLOW); totalDisease += gs.map.diseaseLevel(c, DiseaseColor.ORANGE); } return totalDisease; }
public void moveExecuteTest() { City atlanta = new City("Atlanta", DiseaseColor.BLUE, 0); City newyork = new City("NewYork", DiseaseColor.BLUE, 1); City.makeAdjacent(atlanta, newyork); GameState gs = new GameState(atlanta, null); MoveAction action = new MoveAction(newyork); GameState newGs = action.execute(gs); Assert.AreEqual(newyork, newGs.currentPlayer().position); Assert.AreEqual(atlanta, gs.currentPlayer().position); }
public override float evaluate(GameState gs) { float f = 0; foreach (City c in gs.map.allCities) { if (gs.map.hasStation(c)) { f++; } } return f / 100; }
public static List<CureDiseaseAction> getCureActions(GameState g) { List<CureDiseaseAction> result = new List<CureDiseaseAction>(); if(g.map.hasStation(g.currentPlayer().position)) { foreach(DiseaseColor c in g.currentPlayer().hasCardsToCure()) { if (g.curesFound[(int) c]) continue; result.Add(new CureDiseaseAction(c)); } } return result; }
private GameState(GameState gs) { map = gs.map; players = gs.players; currentPlayerNum = gs.currentPlayerNum; numPlayers = gs.numPlayers; numMoves = gs.numMoves; cpMovesUsed = gs.cpMovesUsed; infectionDeck = gs.infectionDeck; playerDeck = gs.playerDeck; turnAction = gs.turnAction; curesFound = gs.curesFound; bestCardHolder = gs.bestCardHolder; hasEpidemic = gs.hasEpidemic; }
public static float evalGame(GameState gs) { //check the number of nearly outbroken cities float onverge = gs.map.aboutToOutbreak.Count(); float cures = gs.numCures(); int totalDisease = gs.map.numInfectionsInCities; float lotsOfCardsBonus = 0; //fix plz lotsOfCardsBonus /= gs.players.Count(); return 0.5f - (onverge / 20) + (cures / 8) + (float)totalDisease / 100 + lotsOfCardsBonus/8; }
public void epidemicDrawTest() { Map map = new Map(); City atl = map.addCity("Atlanta", DiseaseColor.BLUE); City ny = map.addCity("New York", DiseaseColor.BLUE); City.makeAdjacent(atl, ny); Deck<City> playerDeck = new Deck<City>(map.allCities, false, true); int infectRate; GameState gs = new GameState(atl, map, 1, 4, new Deck<City>(map.allCities), playerDeck); infectRate = gs.map.infectionRate; playerDeck.epidemicCards.Add(1); GameState newGS = new TurnAction().execute(gs); Assert.IsTrue(newGS.map.diseaseLevel(atl, DiseaseColor.BLUE) == 3 || newGS.map.diseaseLevel(ny, DiseaseColor.BLUE) == 3); Assert.AreEqual(infectRate + 1, newGS.map.infectionRate); }
public void epidemicTest() { Map map = new Map(); City atl = map.addCity("Atlanta", DiseaseColor.BLUE); City ny = map.addCity("New York", DiseaseColor.BLUE); City.makeAdjacent(atl,ny); Deck<City> playerDeck = new Deck<City>(map.allCities); int infectRate; GameState gs = new GameState(atl, map, 1, 4, new Deck<City>(map.allCities), playerDeck); infectRate = gs.map.infectionRate; gs.epidemicCard(); Assert.IsTrue(gs.map.diseaseLevel(atl, DiseaseColor.BLUE) == 3 || gs.map.diseaseLevel(ny, DiseaseColor.BLUE) == 3); Assert.AreEqual(infectRate + 1, gs.map.infectionRate); }
public Action bfs_findbest(GameState gs, int depth) { Debug.Assert(depth > 0); float bestEvaluation = -1; List<Pair> initialActions = new List<Pair>(); foreach (Action a in gs.availableActions()) { Pair actionPair = new Pair(); actionPair.initialAction = a; actionPair.resultState = executeOrDoNothing(a,gs); initialActions.Add(actionPair); } Action result = bfs_bestConsequenceReduced(initialActions, depth - 1); //Console.WriteLine("My best action was: " + result.ToString() + " with a score of " + bestEvaluation); return result; }
private float bfs_bestConsequence(GameState gs, int depth) { if (depth == 0) return evaluate(gs); else { float bestEvaluation = -1; List<Action> actions = gs.availableActions(); foreach (Action a in actions) { float currentEvaluation = bfs_bestConsequence(executeOrDoNothing(a, gs), depth - 1); if (bestEvaluation < currentEvaluation) bestEvaluation = currentEvaluation; } return bestEvaluation; } }
public override GameState execute(GameState gs) { Player player = gs.currentPlayer(); int cardsRemoved = 0; foreach (City card in player.cards) { if (cardsRemoved == 5 || (cardsRemoved == 4 && gs.currentPlayer().type == Player.Type.SCIENTIST)) break; if (color == card.color) { player = player.removeCard(card); cardsRemoved++; } } GameState result = gs.cureDisease(color); result = result.adjustPlayer(player); result.advanceMove(); result = result.recalcBestCardHolder(result, gs.currentPlayer(), color); return result; }
public Action bfs_findbest_old(GameState gs, int depth) { Debug.Assert(depth > 0); float bestEvaluation = -1; Action bestAction = null; foreach (Action a in gs.availableActions()) { float currentEvaluation = bfs_bestConsequence(executeOrDoNothing(a, gs), depth - 1); if (bestEvaluation < currentEvaluation) { bestEvaluation = currentEvaluation; bestAction = a; } } // Console.WriteLine("My best action was: " + bestAction.ToString() + " with a score of " + bestEvaluation); return bestAction; }
public void runAction() { Action a; if (gs.currentPlayer().isAI) { a = ev.bfs_findbest(gs, 9); } else { ActionChooser foo = new ActionChooser(gs.availableActions()); foo.ShowDialog(); a = foo.selection; } lastAction = a; gs = a.execute(gs); if (gs.hasEpidemic) { gs.hasEpidemic = false; MessageBox.Show("Epidemic Occured!"); } //throw up some GUI if (gs.hasLost()) { MessageBox.Show("You Lost"); Application.Exit(); } if (gs.hasWon()) { MessageBox.Show("You Won"); Application.Exit(); } }
public GameEngine(Player.Type hType, int difficultyLevel, Boolean allAI) { //initialize infection and player decks and map Map map = initializeCities(); Deck<City> ideck = initializeInfectionDeck(map); //initialize player deck gs = new GameState(atlanta, map, 4, 4, ideck, initializePlayerDeck(map)); gs.map = initializeBoard(map); if (!allAI) { gs.players[0].isAI = false; } foreach (Player p in gs.players) { gs = gs.drawPlayerCards(p, 5); List<City> drawn = gs.playerDeck.mostRecent(5); p.cards.AddRange(drawn); gs = gs.adjustPlayer(p); } List<int> cardLocations = makeEpidemicCards(gs.playerDeck.drawDeck.Count, difficultyLevel); for (int i = 0; i < cardLocations.Count; i++) { cardLocations[i] = cardLocations[i] + gs.playerDeck.cardWeAreOn + 1; } gs.playerDeck.epidemicCards = cardLocations; //ev = new HatesDisease(100); ev = new outbreakHater(true); }
public override float evaluate(GameState gs) { return evalGame(gs); }
public override GameState execute(GameState current) { Debug.Assert(debug_gs == null || debug_gs == current, "Action used on an unintended gamestate"); Map newMap = current.map.removeDisease(position, color); return new GameState(current, newMap); }
public void cureExecuteTest() { Map map = new Map(); City atlanta = map.addCity("Atlanta", DiseaseColor.BLUE); City newyork = map.addCity("NewYork", DiseaseColor.BLUE); City.makeAdjacent(atlanta, newyork); map = map.addDisease(atlanta); GameState gs = new GameState(atlanta, map); CureCityAction action = new CureCityAction(atlanta, DiseaseColor.BLUE); GameState newGs = action.execute(gs); Assert.AreEqual(1, gs.map.diseaseLevel(atlanta, DiseaseColor.BLUE)); Assert.AreEqual(atlanta, newGs.currentPlayer().position); Assert.AreEqual(0, newGs.map.diseaseLevel(atlanta, DiseaseColor.BLUE)); }
public override float evaluate(GameState gs) { return (float)gs.numCures() / 4; }
public GameState doSteps(GameState initial, SearchEvaluate eval, int steps, int depth) { GameState current = initial; for (int i = 0; i < steps; i++) { Action move = eval.bfs_findbest(current, depth); current = move.execute(current); } return current; }