274 lines
8.9 KiB
Plaintext
274 lines
8.9 KiB
Plaintext
module Main where
|
|
|
|
-- mines only on side
|
|
-- build giants
|
|
|
|
import Prelude
|
|
|
|
import Control.Monad.State (State, gets, modify_, runState)
|
|
import Control.MonadZero (guard)
|
|
import Data.Array (any, filter, foldl, head, length, sortBy)
|
|
import Data.Maybe (Maybe(..), fromJust)
|
|
import Data.Tuple (fst, snd)
|
|
import Effect (Effect)
|
|
import Effect.Console (error, log)
|
|
import GameInput (Minion, Site, SiteInfo, ProtoSite, parseInitInput, parseInput)
|
|
import Lib (dist)
|
|
import Partial.Unsafe (unsafePartial)
|
|
|
|
type GameState =
|
|
{ gold :: Int
|
|
, numSites :: Int
|
|
, touchedSite :: Int
|
|
, sites :: Array Site
|
|
, units :: Array Minion
|
|
, leftSide :: Boolean
|
|
}
|
|
|
|
main :: Effect Unit
|
|
main = do
|
|
initInput <- parseInitInput
|
|
error $ show initInput
|
|
loop initInput.numSites initInput.sites Nothing
|
|
|
|
loop :: Int -> Array SiteInfo -> Maybe GameState -> Effect Unit
|
|
loop numSites siteInfo gameState = do
|
|
input <- parseInput numSites
|
|
|
|
-- do we start on the left side of the map?
|
|
let leftSide' = case gameState of
|
|
Just gs -> gs.leftSide
|
|
Nothing -> (queen input.units).x < 500
|
|
|
|
let gameState' =
|
|
{ gold: input.gold
|
|
, numSites
|
|
, touchedSite: input.touchedSite
|
|
, sites: combinedSites input.sites
|
|
, units: input.units
|
|
, leftSide: leftSide'
|
|
}
|
|
|
|
let res = runState loop' gameState'
|
|
let state = snd res
|
|
let val = fst res
|
|
log $ val
|
|
loop state.numSites (toSiteInfo <$> state.sites) (Just state)
|
|
|
|
where
|
|
-- combine sites with siteInfo and old state
|
|
combinedSites :: Array ProtoSite -> Array Site
|
|
combinedSites sites = do
|
|
protoS <- sites
|
|
infoS <- siteInfo
|
|
guard $ protoS.id == infoS.id
|
|
let prevSite = case gameState of
|
|
Just gs -> head $ filter (\s -> s.id == infoS.id) gs.sites
|
|
Nothing -> Nothing
|
|
let mineLvl = case prevSite of
|
|
Just site -> site.mineLvl
|
|
Nothing -> 0
|
|
pure { id: protoS.id
|
|
, gold: protoS.gold
|
|
, maxMineSize: protoS.maxMineSize
|
|
, structureType: protoS.structureType
|
|
, owner: protoS.owner
|
|
, param1: protoS.param1
|
|
, param2: protoS.param2
|
|
, x: infoS.x
|
|
, y: infoS.y
|
|
, radius: infoS.radius
|
|
, mineLvl
|
|
}
|
|
|
|
loop' :: State GameState String
|
|
loop' = do
|
|
ba <- buildAll
|
|
ta <- trainAll
|
|
pure $ ba <> "\n" <> ta
|
|
|
|
buildAll :: State GameState String
|
|
buildAll = do
|
|
sites <- gets _.sites
|
|
units <- gets _.units
|
|
let buildingsCnt = length $ friendlySites sites
|
|
let minesCnt = length $ friendlyMines sites
|
|
if minesCnt < 3
|
|
then buildMines
|
|
else if buildingsCnt < 6
|
|
then case head $ nearFreeSites (queen units) sites of
|
|
Just site -> do
|
|
let typ = if not $ hasArcherBarrack sites then 1
|
|
else if not $ hasKnightsBarrack sites then 0
|
|
else 2
|
|
pure $ build site typ
|
|
Nothing -> avoid
|
|
else if buildingsCnt < 9
|
|
then buildTowers
|
|
else avoid
|
|
|
|
buildTowers :: State GameState String
|
|
buildTowers = do
|
|
leftSide <- gets _.leftSide
|
|
sites <- gets _.sites
|
|
case head $ nearFreeSites (corner leftSide) sites of
|
|
Just site -> pure $ "BUILD " <> show site.id <> " TOWER"
|
|
Nothing -> avoid
|
|
|
|
buildMines :: State GameState String
|
|
buildMines = do
|
|
units <- gets _.units
|
|
sites <- gets _.sites
|
|
case head $ nearNonEmptyMines (queen units) sites of
|
|
Just site -> do
|
|
touched <- gets _.touchedSite
|
|
if touched == -1 || touched /= site.id
|
|
then pure unit
|
|
else modify_ (\s -> s { sites = map (incMineLvl site.id) s.sites })
|
|
pure $ "BUILD " <> show site.id <> " MINE"
|
|
Nothing -> avoid
|
|
where
|
|
incMineLvl :: Int -> Site -> Site
|
|
incMineLvl sId site
|
|
| sId == site.id = site { mineLvl = site.mineLvl + 1 }
|
|
| otherwise = site
|
|
|
|
avoid :: State GameState String
|
|
avoid = do
|
|
sites <- gets _.sites
|
|
nEnemy <- nearestEnemy
|
|
case nEnemy of
|
|
Just enemy -> do
|
|
let site = unsafePartial $ fromJust $ head $
|
|
sortBy (\s1 s2 -> compare (dist enemy s2) (dist enemy s1)) (friendlySites sites)
|
|
pure $ moveToPos site
|
|
Nothing -> pure $ "MOVE 0 0"
|
|
|
|
-- nearest non-queen enemy
|
|
nearestEnemy :: State GameState (Maybe Minion)
|
|
nearestEnemy = do
|
|
units <- gets _.units
|
|
pure $ head $ filter (\u -> isEnemy u) units
|
|
|
|
trainAll :: State GameState String
|
|
trainAll = do
|
|
gold <- gets _.gold
|
|
sites <- gets _.sites
|
|
units <- gets _.units
|
|
|
|
let ownArchers = ownMinions units
|
|
let barrack =if gold > 140
|
|
then
|
|
if length ownArchers < 4 && length (enemyKnights units) /= 0
|
|
then archerBarrack sites
|
|
else if length (enemyTowers sites) > 2
|
|
then giantBarrack sites
|
|
else
|
|
knightBarrack sites
|
|
else []
|
|
pure $ foldl siteToIds "TRAIN" barrack
|
|
where
|
|
siteToIds acc site = acc <> " " <> show site.id
|
|
knightBarrack sites = case head $ knightBarracks sites of
|
|
Just barrack -> [barrack]
|
|
Nothing -> []
|
|
archerBarrack sites = case head $ archerBarracks sites of
|
|
Just barrack -> [barrack]
|
|
Nothing -> []
|
|
giantBarrack sites = case head $ giantBarracks sites of
|
|
Just barrack -> [barrack]
|
|
Nothing -> []
|
|
|
|
build :: forall e. { id :: Int | e } -> Int -> String
|
|
build s typ = "BUILD " <> show s.id <> " BARRACKS-" <> t
|
|
where t | typ == 0 = "KNIGHT"
|
|
| typ == 1 = "ARCHER"
|
|
| otherwise = "GIANT"
|
|
|
|
queen :: Array Minion -> Minion
|
|
queen units = unsafePartial $ fromJust $ head $ filter (\u -> u.unitType == -1 && u.owner == 0) units
|
|
|
|
enemyQueen :: Array Minion -> Minion
|
|
enemyQueen units = unsafePartial $ fromJust $ head $ filter (\u -> u.unitType == -1 && u.owner == 1) units
|
|
|
|
ownMinions :: Array Minion -> Array Minion
|
|
ownMinions = filter isOwn
|
|
|
|
enemyKnights :: Array Minion -> Array Minion
|
|
enemyKnights = filter isEnemy <<< filter isKnight
|
|
|
|
freeSites :: Array Site -> Array Site
|
|
freeSites = filter (\s -> s.owner == -1)
|
|
|
|
friendlySites :: Array Site -> Array Site
|
|
friendlySites = filter (\s -> s.owner == 0)
|
|
|
|
friendlyMines :: Array Site -> Array Site
|
|
friendlyMines sites = filter (\s -> s.structureType == 0) $ friendlySites sites
|
|
|
|
enemyTowers :: Array Site -> Array Site
|
|
enemyTowers = filter isEnemy <<< filter isTower
|
|
|
|
nearSites :: forall a. { x :: Int, y :: Int | a } -> Array Site -> Array Site
|
|
nearSites minion sites = sortBy (compareSiteDist minion) sites
|
|
|
|
nearFreeSites :: forall a. { x :: Int, y :: Int | a } -> Array Site -> Array Site
|
|
nearFreeSites minion sites = sortBy (compareSiteDist minion) (freeSites sites)
|
|
|
|
nearNonEmptyMines :: forall x. { x :: Int, y :: Int | x } -> Array Site -> Array Site
|
|
nearNonEmptyMines minion sites = filter (\s -> s.gold > 20 && s.mineLvl < 5 && s.owner /= 1) $ nearSites minion sites
|
|
|
|
hasKnightsBarrack :: Array Site -> Boolean
|
|
hasKnightsBarrack sites = any (\s -> s.param2 == 0) (friendlySites sites)
|
|
|
|
hasArcherBarrack :: Array Site -> Boolean
|
|
hasArcherBarrack sites = any (\s -> s.param2 == 1) (friendlySites sites)
|
|
|
|
hasGiantsBarrack :: Array Site -> Boolean
|
|
hasGiantsBarrack sites = any (\s -> s.param2 == 2) (friendlySites sites)
|
|
|
|
knightBarracks :: Array Site -> Array Site
|
|
knightBarracks sites = filter (\s -> s.param2 == 0) (friendlySites sites)
|
|
|
|
archerBarracks :: Array Site -> Array Site
|
|
archerBarracks sites = filter (\s -> s.param2 == 1) (friendlySites sites)
|
|
|
|
giantBarracks :: Array Site -> Array Site
|
|
giantBarracks sites = filter (\s -> s.param2 == 2) (friendlySites sites)
|
|
|
|
toSiteInfo :: Site -> SiteInfo
|
|
toSiteInfo s = { id: s.id, x: s.x, y: s.y, radius: s.radius }
|
|
|
|
compareSiteDist :: forall x. { x :: Int, y :: Int | x } -> Site -> Site -> Ordering
|
|
compareSiteDist u s1 s2 = compare (dist s1 u) (dist s2 u)
|
|
|
|
corner :: Boolean -> { x :: Int, y :: Int }
|
|
corner leftSide = if leftSide then { x: 0, y: 0 } else { x: 1920, y: 1000 }
|
|
|
|
isOwn :: forall a. { owner :: Int | a } -> Boolean
|
|
isOwn = owner 0
|
|
|
|
isEnemy :: forall a. { owner :: Int | a } -> Boolean
|
|
isEnemy = owner 1
|
|
|
|
owner :: Int -> forall a. { owner :: Int | a } -> Boolean
|
|
owner oId r = r.owner == oId
|
|
|
|
isKnight :: Minion -> Boolean
|
|
isKnight minion = minion.unitType == 0
|
|
|
|
isArcher :: Minion -> Boolean
|
|
isArcher minion = minion.unitType == 1
|
|
|
|
isGiant :: Minion -> Boolean
|
|
isGiant minion = minion.unitType == 2
|
|
|
|
isTower :: forall a. { structureType :: Int | a } -> Boolean
|
|
isTower s = s.structureType == 1
|
|
|
|
barracks :: Array Site -> Array Site
|
|
barracks sites = filter (\b -> b.structureType == 2) sites
|
|
|
|
moveToPos :: forall e. { x :: Int, y :: Int | e } -> String
|
|
moveToPos p = "MOVE " <> show p.x <> " " <> show p.y
|