void Player_Random::getMoves(GameState & state, const MoveArray & moves, std::vector<Move> & moveVec) { for (size_t u(0); u<moves.numUnits(); u++) { moveVec.push_back(moves.getMove(u, rand() % moves.numMoves(u))); } }
const bool AlphaBeta::pruneMove(GameState & state, const IDType & playerToMove, const MoveArray & moves, const MoveTuple & tuple) const { IDType enemy(getEnemy(playerToMove)); // damage assigned to each enemy unit so far int hpRemaining[Search::Constants::Max_Units]; for (IDType u(0); u<state.numUnits(enemy); ++u) { hpRemaining[u] = state.getUnit(enemy,u).currentHP(); } // for each unit in the tuple for (size_t u(0); u<moves.numUnits(); u++) { // get its move const Move & m(moves.getTupleMove(tuple, u)); if (m.type() == MoveTypes::ATTACK) { // if the target unit has already been killed then return prune if (hpRemaining[m.index()] <= 0) { return true; } hpRemaining[m.index()] -= state.getUnit(playerToMove, u).damage(); } } return false; }
void UnitScriptData::calculateMoves(const IDType & player, MoveArray & moves, GameState & state, std::vector<Action> & moveVec) { // generate all script moves for this player at this state and store them in allScriptMoves for (size_t scriptIndex(0); scriptIndex<_scriptVec[player].size(); ++scriptIndex) { // get the associated player pointer const PlayerPtr & pp = getPlayerPtr(player, scriptIndex); // get the actual script we are working with const IDType actualScript = getScript(player, scriptIndex); // generate the moves inside the appropriate vector getMoves(player, actualScript).clear(); pp->getMoves(state, moves, getMoves(player, actualScript)); } // for each unit the player has to move, populate the move vector with the appropriate script move for (size_t unitIndex(0); unitIndex < moves.numUnits(); ++unitIndex) { // the unit from the state const Unit & unit = state.getUnit(player, unitIndex); // the move it would choose to do based on its associated script preference Action unitMove = getMove(player, unitIndex, getUnitScript(unit)); // put the unit into the move vector moveVec.push_back(unitMove); } }
void Player_NOKDPS::getMoves(GameState & state, const MoveArray & moves, std::vector<UnitAction> & moveVec) { moveVec.clear(); IDType enemy(state.getEnemy(_playerID)); Array<int, Constants::Max_Units> hpRemaining; for (IDType u(0); u<state.numUnits(enemy); ++u) { hpRemaining[u] = state.getUnit(enemy,u).currentHP(); } for (IDType u(0); u<moves.numUnits(); ++u) { bool foundUnitAction (false); size_t actionMoveIndex (0); double actionHighestDPS (0); size_t closestMoveIndex (0); unsigned long long closestMoveDist (std::numeric_limits<unsigned long long>::max()); const Unit & ourUnit (state.getUnit(_playerID, u)); const Unit & closestUnit(ourUnit.canHeal() ? state.getClosestOurUnit(_playerID, u) : ourUnit.type().isDetector() ? state.getClosestEnemyUnit(_playerID, u, false):state.getClosestEnemyUnit(_playerID, u, true)); for (size_t m(0); m<moves.numMoves(u); ++m) { const UnitAction move (moves.getMove(u, m)); if ((move.type() == UnitActionTypes::ATTACK) && (hpRemaining[move._moveIndex] > 0)) { const Unit & target (state.getUnit(state.getEnemy(move.player()), move._moveIndex)); double dpsHPValue = (target.dpf() / hpRemaining[move._moveIndex]); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundUnitAction = true; } if (move._moveIndex >= state.numUnits(enemy)) { int e = enemy; int pl = _playerID; printf("wtf\n"); } } else if (move.type() == UnitActionTypes::HEAL) { const Unit & target (state.getUnit(move.player(), move._moveIndex)); double dpsHPValue = (target.dpf() / hpRemaining[move._moveIndex]); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundUnitAction = true; } } else if (move.type() == UnitActionTypes::RELOAD) { if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { closestMoveIndex = m; break; } } else if (move.type() == UnitActionTypes::MOVE) { Position ourDest (ourUnit.x() + Constants::Move_Dir[move._moveIndex][0], ourUnit.y() + Constants::Move_Dir[move._moveIndex][1]); size_t dist (closestUnit.getDistanceSqToPosition(ourDest, state.getTime())); if (dist < closestMoveDist) { closestMoveDist = dist; closestMoveIndex = m; } } } size_t bestMoveIndex(foundUnitAction ? actionMoveIndex : closestMoveIndex); UnitAction theMove(moves.getMove(u, actionMoveIndex)); if (theMove.type() == UnitActionTypes::ATTACK) { hpRemaining[theMove.index()] -= state.getUnit(_playerID, theMove.unit()).damage(); } moveVec.push_back(moves.getMove(u, bestMoveIndex)); } }
const MoveTuple Player_AttackClosest::getMoveTuple(GameState & state, const MoveArray & moves) { MoveTuple tuple(0); for (IDType u(0); u<moves.numUnits(); ++u) { bool foundAction (false); size_t actionMoveIndex (0); size_t closestMoveIndex (0); unsigned long long actionDistance (std::numeric_limits<unsigned long long>::max()); unsigned long long closestMoveDist (std::numeric_limits<unsigned long long>::max()); const Unit & ourUnit (state.getUnit(_playerID, u)); const Unit & closestUnit (ourUnit.canHeal() ? state.getClosestOurUnit(_playerID, u) : state.getClosestEnemyUnit(_playerID, u)); for (size_t m(0); m<moves.numMoves(u); ++m) { const Move move (moves.getMove(u, m)); if (move.type() == MoveTypes::ATTACK) { const Unit & target (state.getUnit(state.getEnemy(move.player()), move._moveIndex)); size_t dist (ourUnit.distSq(target, state.getTime())); if (dist < actionDistance) { actionDistance = dist; actionMoveIndex = m; foundAction = true; } } if (move.type() == MoveTypes::HEAL) { const Unit & target (state.getUnit(move.player(), move._moveIndex)); size_t dist (ourUnit.distSq(target, state.getTime())); if (dist < actionDistance) { actionDistance = dist; actionMoveIndex = m; foundAction = true; } } else if (move.type() == MoveTypes::RELOAD) { if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { closestMoveIndex = m; break; } } else if (move.type() == MoveTypes::MOVE) { Position ourDest (ourUnit.x() + Search::Constants::Move_Dir[move._moveIndex][0], ourUnit.y() + Search::Constants::Move_Dir[move._moveIndex][1]); size_t dist (closestUnit.distSq(ourDest, state.getTime())); if (dist < closestMoveDist) { closestMoveDist = dist; closestMoveIndex = m; } } } size_t bestMoveIndex(foundAction ? actionMoveIndex : closestMoveIndex); tuple += bestMoveIndex * moves.getProduct(u); } return tuple; }
void Player_KiterDPS::getMoves(GameState & state, const MoveArray & moves, std::vector<Move> & moveVec) { for (IDType u(0); u<moves.numUnits(); ++u) { bool foundAction (false); IDType actionMoveIndex (0); IDType furthestMoveIndex (0); size_t furthestMoveDist (0); IDType closestMoveIndex (0); double actionHighestDPS (0); unsigned long long closestMoveDist (std::numeric_limits<unsigned long long>::max()); const Unit & ourUnit (state.getUnit(_playerID, u)); const Unit & closestUnit (ourUnit.canHeal() ? state.getClosestOurUnit(_playerID, u) : state.getClosestEnemyUnit(_playerID, u)); for (IDType m(0); m<moves.numMoves(u); ++m) { const Move move (moves.getMove(u, m)); if (move.type() == MoveTypes::ATTACK) { const Unit & target (state.getUnit(state.getEnemy(move.player()), move._moveIndex)); double dpsHPValue (target.dpf() / target.currentHP()); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundAction = true; } } else if (move.type() == MoveTypes::HEAL) { const Unit & target (state.getUnit(move.player(), move._moveIndex)); double dpsHPValue (target.dpf() / target.currentHP()); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundAction = true; } } else if (move.type() == MoveTypes::MOVE) { Position ourDest (ourUnit.x() + Search::Constants::Move_Dir[move._moveIndex][0], ourUnit.y() + Search::Constants::Move_Dir[move._moveIndex][1]); size_t dist (closestUnit.distSq(ourDest, state.getTime())); if (dist > furthestMoveDist) { furthestMoveDist = dist; furthestMoveIndex = m; } if (dist < closestMoveDist) { closestMoveDist = dist; closestMoveIndex = m; } } } // the move we will be returning size_t bestMoveIndex(0); // if we have an attack move we will use that one if (foundAction) { bestMoveIndex = actionMoveIndex; } // otherwise use the closest move to the opponent else { // if we are in attack range of the unit, back up if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { bestMoveIndex = furthestMoveIndex; } // otherwise get back into the fight else { bestMoveIndex = closestMoveIndex; } } moveVec.push_back(moves.getMove(u, bestMoveIndex)); } }
// TODO: UNTESTED const MoveTuple Player_Kiter::getMoveTuple(GameState & state, const MoveArray & moves) { // the tuple, we will generate this on the fly MoveTuple tuple(0); for (IDType u(0); u<moves.numUnits(); ++u) { bool foundAction (false); IDType actionMoveIndex (0); IDType furthestMoveIndex (0); size_t furthestMoveDist (0); IDType closestMoveIndex (0); int actionDistance (std::numeric_limits<int>::max()); unsigned long long closestMoveDist (std::numeric_limits<unsigned long long>::max()); const Unit & ourUnit (state.getUnit(_playerID, u)); const Unit & closestUnit (ourUnit.canHeal() ? state.getClosestOurUnit(_playerID, u) : state.getClosestEnemyUnit(_playerID, u)); for (IDType m(0); m<moves.numMoves(u); ++m) { const Move move (moves.getMove(u, m)); if (move.type() == MoveTypes::ATTACK) { const Unit & target (state.getUnit(state.getEnemy(move.player()), move._moveIndex)); PositionType dist (ourUnit.distSq(target, state.getTime())); if (dist < actionDistance) { actionDistance = dist; actionMoveIndex = m; foundAction = true; } } else if (move.type() == MoveTypes::HEAL) { const Unit & target (state.getUnit(move.player(), move._moveIndex)); PositionType dist (ourUnit.distSq(target, state.getTime())); if (dist < actionDistance) { actionDistance = dist; actionMoveIndex = m; foundAction = true; } } else if (move.type() == MoveTypes::MOVE) { Position ourDest (ourUnit.x() + Search::Constants::Move_Dir[move._moveIndex][0], ourUnit.y() + Search::Constants::Move_Dir[move._moveIndex][1]); size_t dist (closestUnit.distSq(ourDest, state.getTime())); if (dist > furthestMoveDist) { furthestMoveDist = dist; furthestMoveIndex = m; } if (dist < closestMoveDist) { closestMoveDist = dist; closestMoveIndex = m; } } } // the move we will be returning size_t bestMoveIndex(0); // if we have an attack move we will use that one if (foundAction) { bestMoveIndex = actionMoveIndex; } // otherwise use the closest move to the opponent else { // if we are in attack range of the unit, back up if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { bestMoveIndex = furthestMoveIndex; } // otherwise get back into the fight else { bestMoveIndex = closestMoveIndex; } } // update the tuple calculation tuple += bestMoveIndex * moves.getProduct(u); } return tuple; }
const MoveTuple Player_NOK_AttackDPS::getMoveTuple(GameState & state, const MoveArray & moves) { MoveTuple tuple(0); IDType player(moves.getMove(0,0).player()); IDType enemy(state.getEnemy(player)); Array<int, Search::Constants::Max_Units> hpRemaining; if (state.numUnits(enemy) > Search::Constants::Max_Units) { hpRemaining.resize(state.numUnits(enemy)); } for (IDType u(0); u<state.numUnits(enemy); ++u) { hpRemaining[u] = state.getUnit(enemy,u).currentHP(); } for (IDType u(0); u<moves.numUnits(); ++u) { bool foundAction (false); size_t actionMoveIndex (0); double actionHighestDPS (0); size_t closestMoveIndex (0); unsigned long long closestMoveDist (std::numeric_limits<unsigned long long>::max()); const Unit & ourUnit (state.getUnit(_playerID, u)); const Unit & closestUnit (ourUnit.canHeal() ? state.getClosestOurUnit(_playerID, u) : state.getClosestEnemyUnit(_playerID, u)); for (size_t m(0); m<moves.numMoves(u); ++m) { const Move move (moves.getMove(u, m)); if ((move.type() == MoveTypes::ATTACK) && (hpRemaining[move._moveIndex] > 0)) { const Unit & target (state.getUnit(state.getEnemy(move.player()), move._moveIndex)); double dpsHPValue = (target.dpf() / hpRemaining[move._moveIndex]); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundAction = true; } } else if (move.type() == MoveTypes::HEAL) { const Unit & target (state.getUnit(move.player(), move._moveIndex)); double dpsHPValue = (target.dpf() / hpRemaining[move._moveIndex]); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundAction = true; } } else if (move.type() == MoveTypes::RELOAD) { if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { closestMoveIndex = m; break; } } else if (move.type() == MoveTypes::MOVE) { Position ourDest (ourUnit.x() + Search::Constants::Move_Dir[move._moveIndex][0], ourUnit.y() + Search::Constants::Move_Dir[move._moveIndex][1]); size_t dist (closestUnit.distSq(ourDest, state.getTime())); if (dist < closestMoveDist) { closestMoveDist = dist; closestMoveIndex = m; } } } size_t bestMoveIndex(foundAction ? actionMoveIndex : closestMoveIndex); Move theMove(moves.getMove(u, actionMoveIndex)); if (theMove.type() == MoveTypes::ATTACK) { hpRemaining[theMove.index()] -= state.getUnit(player, theMove.unit()).damage(); } tuple += bestMoveIndex * moves.getProduct(u); } return tuple; }
void Player_AttackDPS::getMoves(GameState & state, const MoveArray & moves, std::vector<Move> & moveVec) { for (IDType u(0); u<moves.numUnits(); ++u) { bool foundAction (false); size_t actionMoveIndex (0); size_t closestMoveIndex (0); double actionHighestDPS (0); unsigned long long closestMoveDist (std::numeric_limits<unsigned long long>::max()); const Unit & ourUnit (state.getUnit(_playerID, u)); const Unit & closestUnit (ourUnit.canHeal() ? state.getClosestOurUnit(_playerID, u) : state.getClosestEnemyUnit(_playerID, u)); for (size_t m(0); m<moves.numMoves(u); ++m) { const Move move (moves.getMove(u, m)); if (move.type() == MoveTypes::ATTACK) { const Unit & target (state.getUnit(state.getEnemy(move.player()), move._moveIndex)); double dpsHPValue = (target.dpf() / target.currentHP()); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundAction = true; } } if (move.type() == MoveTypes::HEAL) { const Unit & target (state.getUnit(move.player(), move._moveIndex)); double dpsHPValue = (target.dpf() / target.currentHP()); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundAction = true; } } else if (move.type() == MoveTypes::RELOAD) { if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { closestMoveIndex = m; break; } } else if (move.type() == MoveTypes::MOVE) { Position ourDest (ourUnit.x() + Search::Constants::Move_Dir[move._moveIndex][0], ourUnit.y() + Search::Constants::Move_Dir[move._moveIndex][1]); size_t dist (closestUnit.distSq(ourDest, state.getTime())); if (dist < closestMoveDist) { closestMoveDist = dist; closestMoveIndex = m; } } } size_t bestMoveIndex(foundAction ? actionMoveIndex : closestMoveIndex); moveVec.push_back(moves.getMove(u, bestMoveIndex)); } }
void Player_AttackClosest::getMoves(const GameState & state, const MoveArray & moves, std::vector<UnitAction> & moveVec) { moveVec.clear(); for (IDType u(0); u<moves.numUnits(); ++u) { bool foundUnitAction (false); size_t actionMoveIndex (0); size_t closestMoveIndex (0); unsigned long long actionDistance (std::numeric_limits<unsigned long long>::max()); unsigned long long closestMoveDist (std::numeric_limits<unsigned long long>::max()); const Unit & ourUnit (state.getUnit(_playerID, u)); const Unit & closestUnit (ourUnit.canHeal() ? state.getClosestOurUnit(_playerID, u) : state.getClosestEnemyUnit(_playerID, u)); for (size_t m(0); m<moves.numMoves(u); ++m) { const UnitAction move (moves.getMove(u, m)); if (move.type() == UnitActionTypes::ATTACK) { const Unit & target (state.getUnit(state.getEnemy(move.player()), move._moveIndex)); size_t dist (ourUnit.getDistanceSqToUnit(target, state.getTime())); if (dist < actionDistance) { actionDistance = dist; actionMoveIndex = m; foundUnitAction = true; } } if (move.type() == UnitActionTypes::HEAL) { const Unit & target (state.getUnit(move.player(), move._moveIndex)); size_t dist (ourUnit.getDistanceSqToUnit(target, state.getTime())); if (dist < actionDistance) { actionDistance = dist; actionMoveIndex = m; foundUnitAction = true; } } else if (move.type() == UnitActionTypes::RELOAD) { if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { closestMoveIndex = m; break; } } else if (move.type() == UnitActionTypes::MOVE) { Position ourDest (ourUnit.x() + Constants::Move_Dir[move._moveIndex][0], ourUnit.y() + Constants::Move_Dir[move._moveIndex][1]); size_t dist (closestUnit.getDistanceSqToPosition(ourDest, state.getTime())); if (dist < closestMoveDist) { closestMoveDist = dist; closestMoveIndex = m; } } } size_t bestMoveIndex(foundUnitAction ? actionMoveIndex : closestMoveIndex); moveVec.push_back(moves.getMove(u, bestMoveIndex)); } }
void Player_Kiter_NOKDPS::getMoves(GameState & state, const MoveArray & moves, std::vector<Action> & moveVec) { moveVec.clear(); IDType enemy(state.getEnemy(_playerID)); Array<int, Constants::Max_Units> hpRemaining; for (IDType u(0); u<state.numUnits(enemy); ++u) { hpRemaining[u] = state.getUnit(enemy,u).currentHP(); } for (IDType u(0); u<moves.numUnits(); ++u) { bool foundAction (false); size_t actionMoveIndex (0); IDType furthestMoveIndex (0); size_t furthestMoveDist (0); double actionHighestDPS (0); size_t closestMoveIndex (0); unsigned long long closestMoveDist (std::numeric_limits<unsigned long long>::max()); const Unit & ourUnit (state.getUnit(_playerID, u)); const Unit & closestUnit (ourUnit.canHeal() ? state.getClosestOurUnit(_playerID, u) : state.getClosestEnemyUnit(_playerID, u)); for (size_t m(0); m<moves.numMoves(u); ++m) { const Action move (moves.getMove(u, m)); if ((move.type() == ActionTypes::ATTACK) && (hpRemaining[move.index()] > 0)) { const Unit & target (state.getUnit(state.getEnemy(move.player()), move.index())); double dpsHPValue = (target.dpf() / hpRemaining[move.index()]); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundAction = true; } if (move.index() >= state.numUnits(enemy)) { int e = enemy; int pl = _playerID; printf("wtf\n"); } } else if (move.type() == ActionTypes::HEAL) { const Unit & target (state.getUnit(move.player(), move.index())); double dpsHPValue = (target.dpf() / hpRemaining[move.index()]); if (dpsHPValue > actionHighestDPS) { actionHighestDPS = dpsHPValue; actionMoveIndex = m; foundAction = true; } } else if (move.type() == ActionTypes::RELOAD) { if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { closestMoveIndex = m; break; } } else if (move.type() == ActionTypes::MOVE) { Position ourDest (ourUnit.x() + Constants::Move_Dir[move.index()][0], ourUnit.y() + Constants::Move_Dir[move.index()][1]); size_t dist (closestUnit.getDistanceSqToPosition(ourDest, state.getTime())); if (dist > furthestMoveDist) { furthestMoveDist = dist; furthestMoveIndex = m; } if (dist < closestMoveDist) { closestMoveDist = dist; closestMoveIndex = m; } } } size_t bestMoveIndex(0); // if we have an attack move we will use that one if (foundAction) { bestMoveIndex = actionMoveIndex; } // otherwise use the closest move to the opponent else { // if we are in attack range of the unit, back up if (ourUnit.canAttackTarget(closestUnit, state.getTime())) { bestMoveIndex = furthestMoveIndex; } // otherwise get back into the fight else { bestMoveIndex = closestMoveIndex; } } Action theMove(moves.getMove(u, actionMoveIndex)); if (theMove.type() == ActionTypes::ATTACK) { hpRemaining[theMove.index()] -= state.getUnit(_playerID, theMove.unit()).damage(); } moveVec.push_back(moves.getMove(u, bestMoveIndex)); } }