0votos

Mostrar Movimiento de Piezas de Ajedrez en Haskell

por josejuan hace 4 años

Una.

Se deben de mostrar los movimientos posibles de cada pieza del ajedrez con un asterisco (*). El usuario introducirá las coordenadas de la pieza y el programa le mostrará los movimientos posibles a partir de la coordenada introducida.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import Data.Maybe 
 
data PieceType  = King  | Queen | Rook | NightK | Bishop | Pawn deriving (Read, Eq, Enum) 
 
-- Una pieza a cadena 
instance Show PieceType where 
  show x = case x of 
             King   -> "♔" 
             Queen  -> "♕" 
             Rook   -> "♖" 
             NightK -> "♘" 
             Bishop -> "♗" 
             Pawn   -> "♙" 
 
-- Una casilla del tablero a cadena 
showC (x, y) | odd x == odd y = "⛆" 
             | otherwise      = "☐" 
 
-- Mete un dato (si puede) en una celda 
onBoard :: (Int, Int) -> a -> Maybe a 
onBoard (x, y) a | x >= 1 && x <= 8 && y >= 1 && y <= 8 = Just a 
                 | otherwise                            = Nothing 
 
-- Extiende un camino en una dirección, sólo uno o muchos 
tracePath :: ((Int, Int), Bool) -> (Int, Int) -> [(Int, Int)] 
tracePath ((xo, yo), one) (dx, dy) = catMaybes [onBoard p p | i <- [1.. if one then 1 else 8] 
                                                           , let p = (xo + i * dx, yo + i * dy) ] 
 
-- Una cruz 
crossPaths :: ((Int, Int), Bool) -> [(Int, Int)] 
crossPaths q = concatMap (tracePath q) [(1,0),(-1,0),(0,1),(0,-1)] 
 
-- Un aspa 
bladePaths :: ((Int, Int), Bool) -> [(Int, Int)] 
bladePaths q = concatMap (tracePath q) [(1,1),(1,-1),(-1,1),(-1,-1)] 
 
-- Todas las posiciones de movimiento de una pieza 
getPaths :: PieceType -> (Int, Int) -> [(Int, Int)] 
getPaths q p@(x, y) = 
  case q of 
    King   -> crossPaths (p, True) 
    Queen  -> crossPaths (p, False) ++ bladePaths (p, False) 
    Rook   -> crossPaths (p, False) 
    NightK -> catMaybes [onBoard p p | a <- [-1,1], b <- [-1,1], (u, v) <- [(1,2),(2,1)], let p = (x + a * u, y + b * v)] 
    Bishop -> bladePaths (p, False) 
    Pawn   -> catMaybes [onBoard (x, y + 1) (x, y + 1)] 
 
-- Genera un tablero con los movimientos de una pieza en una posición dada 
showPaths :: PieceType -> (Int, Int) -> [String] 
showPaths p q = 
  let paths = q: getPaths p q 
  in  map (concatMap (\c -> if c `elem` paths then show p else showC c)) [[(x, y) | x <- [1..8]] | y <- [8,7..1]] 
 
 
 
 
 
 
{-- 
 
  Por ejemplo, para mostrar todas las fichas en una posición centrada podría hacerse desde interactivo: 
   
  *Main> let tres = mapM_ putStrLn . foldl (zipWith (\a b -> a ++ " " ++ b)) (repeat "") . map (flip showPaths (4, 4)) 
  *Main> tres [King, Queen, Rook] >> putStrLn "" >> tres [NightK, Bishop, Pawn] 
   ☐⛆☐⛆☐⛆☐⛆ ☐⛆☐♕☐⛆☐♕ ☐⛆☐♖☐⛆☐⛆ 
   ⛆☐⛆☐⛆☐⛆☐ ♕☐⛆♕⛆☐♕☐ ⛆☐⛆♖⛆☐⛆☐ 
   ☐⛆☐⛆☐⛆☐⛆ ☐♕☐♕☐♕☐⛆ ☐⛆☐♖☐⛆☐⛆ 
   ⛆☐⛆♔⛆☐⛆☐ ⛆☐♕♕♕☐⛆☐ ⛆☐⛆♖⛆☐⛆☐ 
   ☐⛆♔♔♔⛆☐⛆ ♕♕♕♕♕♕♕♕ ♖♖♖♖♖♖♖♖ 
   ⛆☐⛆♔⛆☐⛆☐ ⛆☐♕♕♕☐⛆☐ ⛆☐⛆♖⛆☐⛆☐ 
   ☐⛆☐⛆☐⛆☐⛆ ☐♕☐♕☐♕☐⛆ ☐⛆☐♖☐⛆☐⛆ 
   ⛆☐⛆☐⛆☐⛆☐ ♕☐⛆♕⛆☐♕☐ ⛆☐⛆♖⛆☐⛆☐ 
   
   ☐⛆☐⛆☐⛆☐⛆ ☐⛆☐⛆☐⛆☐♗ ☐⛆☐⛆☐⛆☐⛆ 
   ⛆☐⛆☐⛆☐⛆☐ ♗☐⛆☐⛆☐♗☐ ⛆☐⛆☐⛆☐⛆☐ 
   ☐⛆♘⛆♘⛆☐⛆ ☐♗☐⛆☐♗☐⛆ ☐⛆☐⛆☐⛆☐⛆ 
   ⛆♘⛆☐⛆♘⛆☐ ⛆☐♗☐♗☐⛆☐ ⛆☐⛆♙⛆☐⛆☐ 
   ☐⛆☐♘☐⛆☐⛆ ☐⛆☐♗☐⛆☐⛆ ☐⛆☐♙☐⛆☐⛆ 
   ⛆♘⛆☐⛆♘⛆☐ ⛆☐♗☐♗☐⛆☐ ⛆☐⛆☐⛆☐⛆☐ 
   ☐⛆♘⛆♘⛆☐⛆ ☐♗☐⛆☐♗☐⛆ ☐⛆☐⛆☐⛆☐⛆ 
   ⛆☐⛆☐⛆☐⛆☐ ♗☐⛆☐⛆☐♗☐ ⛆☐⛆☐⛆☐⛆☐ 
                   
--} 

Comenta la solución

Tienes que identificarte para poder publicar tu comentario.