Add fine-grain grid when selection is active

3 files changed, 38 insertions, 16 deletions

diff --git a/src/Chelleport/Context.hs b/src/Chelleport/Context.hs
index b573975..de5c94b 100644
--- a/src/Chelleport/Context.hs
+++ b/src/Chelleport/Context.hs
@@ -8,7 +8,7 @@ import qualified SDL
 import qualified SDL.Font as TTF
 
 windowOpacity :: CFloat
-windowOpacity = 0.6
+windowOpacity = 0.5
 
 fontSize :: Int
 fontSize = 24
diff --git a/src/Chelleport/Draw.hs b/src/Chelleport/Draw.hs
index 4ee5b31..1c23ee0 100644
--- a/src/Chelleport/Draw.hs
+++ b/src/Chelleport/Draw.hs
@@ -2,6 +2,7 @@ module Chelleport.Draw where
 
 import Chelleport.Types
 import Data.Text (Text)
+import qualified Data.Vector.Storable as Vector
 import Data.Word (Word8)
 import Foreign.C (CInt)
 import qualified SDL
@@ -34,6 +35,9 @@ colorAxisLines = colorAccent
 colorBackground :: SDL.V4 Word8
 colorBackground = SDL.V4 15 12 25 0
 
+colorFineGrainGrid :: SDL.V4 Word8
+colorFineGrainGrid = SDL.V4 55 52 65 100
+
 drawText :: DrawContext -> SDL.V2 CInt -> SDL.V4 Word8 -> Text -> IO (CInt, CInt)
 drawText ctx@(DrawContext {ctxRenderer = renderer}) position color text = do
   surface <- TTF.blended (ctxFont ctx) color text
@@ -64,3 +68,14 @@ drawVerticalLine :: DrawContext -> CInt -> IO ()
 drawVerticalLine ctx@(DrawContext {ctxRenderer = renderer}) x = do
   (SDL.V2 _width height) <- windowSize ctx
   SDL.drawLine renderer (SDL.P $ SDL.V2 x 0) (SDL.P $ SDL.V2 x height)
+
+drawCircle :: DrawContext -> Int -> (CInt, CInt) -> IO ()
+drawCircle (DrawContext {ctxRenderer = renderer}) radius (x, y) = do
+  let renderedPoints = radius * 7
+  let toTheta n = fromIntegral n * (2 * pi) / fromIntegral renderedPoints
+  let toPointOnCircle n =
+        SDL.V2
+          (x + round ((fromIntegral radius :: Float) * cos (toTheta n)))
+          (y + round ((fromIntegral radius :: Float) * sin (toTheta n)))
+  let points = Vector.generate renderedPoints (SDL.P . toPointOnCircle)
+  SDL.drawPoints renderer points
diff --git a/src/Chelleport/View.hs b/src/Chelleport/View.hs
index 1ead214..4956a9f 100644
--- a/src/Chelleport/View.hs
+++ b/src/Chelleport/View.hs
@@ -5,10 +5,9 @@ import Chelleport.Types
 import Chelleport.Utils (intToCInt, isEmpty, isNotEmpty)
 import Control.Monad (forM_, unless, void, when)
 import Data.IORef (modifyIORef', newIORef, readIORef)
-import Data.List (isPrefixOf)
+import Data.List (isPrefixOf, (\\))
 import Data.Maybe (isJust)
 import qualified Data.Text as Text
-import qualified Data.Vector.Storable as Vector
 import Foreign.C (CInt)
 import SDL (($=))
 import qualified SDL
@@ -28,7 +27,7 @@ render state ctx = do
       let px = colIndex * wcell + wcell `div` 2 - 20
       visible <- renderKeySequence ctx (stateKeySequence state) cell (px, py)
       when visible $ do
-        renderTargetPoint ctx (colIndex * wcell + wcell `div` 2, rowIndex * hcell + hcell `div` 2)
+        renderTargetPoints state ctx (rowIndex, colIndex) (wcell, hcell)
 
 renderKeySequence :: DrawContext -> KeySequence -> Cell -> (CInt, CInt) -> IO Bool
 renderKeySequence ctx keySequence cell (px, py) = do
@@ -80,16 +79,24 @@ renderGridLines state ctx@(DrawContext {ctxRenderer = renderer}) = do
   drawHorizontalLine ctx (rows * hcell `div` 2)
   drawVerticalLine ctx (columns * wcell `div` 2)
 
-renderTargetPoint :: DrawContext -> (CInt, CInt) -> IO ()
-renderTargetPoint (DrawContext {ctxRenderer = renderer}) (x, y) = do
-  let renderedPoints = 16
-  let radius = 2.0 :: Double
-  let toTheta n = fromIntegral n * (2 * pi) / fromIntegral renderedPoints
-      toPointOnCircle n =
-        SDL.V2
-          (x + round (radius * cos (toTheta n)))
-          (y + round (radius * sin (toTheta n)))
-  let points = Vector.generate renderedPoints (SDL.P . toPointOnCircle)
+renderTargetPoints :: State -> DrawContext -> (CInt, CInt) -> (CInt, CInt) -> IO ()
+renderTargetPoints state ctx@(DrawContext {ctxRenderer = renderer}) (row, col) (wcell, hcell) = do
+  let (x, y) = (col * wcell + wcell `div` 2, row * hcell + hcell `div` 2)
   SDL.rendererDrawColor renderer $= colorWhite
-  SDL.drawPoints renderer points
-  pure ()
+  drawCircle ctx 2 (x, y)
+  when (stateIsMatched state) $ do
+    SDL.rendererDrawColor renderer $= colorFineGrainGrid
+    forM_ ([-8 .. 8] \\ [0]) $ \n -> do
+      let px = x + n * wcell `div` 16
+      SDL.drawLine renderer (SDL.P $ SDL.V2 px (y - hcell `div` 2)) (SDL.P $ SDL.V2 px (y + hcell `div` 2))
+    forM_ ([-8 .. 8] \\ [0]) $ \n -> do
+      let py = y + n * hcell `div` 16
+      SDL.drawLine renderer (SDL.P $ SDL.V2 (x - wcell `div` 2) py) (SDL.P $ SDL.V2 (x + wcell `div` 2) py)
+
+    SDL.rendererDrawColor renderer $= colorLightGray
+    let lenx = wcell `div` 4
+    let leny = hcell `div` 4
+    SDL.drawLine renderer (SDL.P $ SDL.V2 (x - wcell `div` 4) (y - leny)) (SDL.P $ SDL.V2 (x - wcell `div` 4) (y + leny))
+    SDL.drawLine renderer (SDL.P $ SDL.V2 (x + wcell `div` 4) (y - leny)) (SDL.P $ SDL.V2 (x + wcell `div` 4) (y + leny))
+    SDL.drawLine renderer (SDL.P $ SDL.V2 (x - lenx) (y - hcell `div` 4)) (SDL.P $ SDL.V2 (x + lenx) (y - hcell `div` 4))
+    SDL.drawLine renderer (SDL.P $ SDL.V2 (x - lenx) (y + hcell `div` 4)) (SDL.P $ SDL.V2 (x + lenx) (y + hcell `div` 4))