chalkos/haskassonne

Projecto de Laboratórios de Informática I

haskassonne's Issues

Contagem de pontos

NOTA: ideializei isto como um módulo, não precisa de ser um módulo à parte. Sugiro que se faça e depois se forem 2 ou 3 funções simples metem-se noutro modulo em vez de criar um novo.

Deve receber um tabuleiro e ir somando pontos à pontuação actual do jogador.

As regras básicas de contagem estão no enunciado.

O mais fácil é contar um meeple que esteja numa peça tipo B, visto que é só contar o numero de peças à volta.

As cidades são mais complicadas porque é preciso contar um número indeterminado de peças e é preciso verificar a quantidade de meeples que se encontram nessa zona, para saber quem recebe os pontos, ou se recebem os 2.

Os campos são o mais complicado porque é preciso descobrir se estão ou não ligados a cidades e se as cidades estão ou não completas (penso eu).

E deve-se retirar o meeple quando são contados os pontos da zona dele.

Programa next

Verificar se há meeples que devem ser retirados, retira-los e dar as devidas pontuações.

Se o jogo estiver terminado (acabou-se o numero de peças) fazer as pontuações finais, retirar meeples todos e dar um XML.

Se o jogo não estiver terminado gerar uma nova peça.

Criar base para Relatório

Criar a base para relatório, com índice e algumas secções, nem que seja com lorem ipsum.

Programa Play

Ver em que sitio se pode colocar o meeple (ver #4 e #5).

Fazer uma estratégia de colocação da peça e do meeple.

Documentar o código com Haddock

Ir documentando o código à medida que se fazem cenas.

Verificar onde podem ser colocadas as peças

NOTA: ideializei isto como um módulo, não precisa de ser um módulo à parte. Sugiro que se faça e depois se forem 2 ou 3 funções simples metem-se noutro modulo em vez de criar um novo.

Este módulo deve ter uma função principal que recebe um tabuleiro e uma peça e descobre todas as localizações e orientações em que a peça pode estar.

Pode-se usar o datatype Tile do módulo Leitor, mas acho melhor criar um novo, porque se não tem que se preencher localização e meeple na peça que ainda não foi colocada e isso não faz sentido.

Update:
Este módulo também tem que dizer se e onde podem ser colocados meeples.
Cada vez mais esta funcionalidade se relaciona com a #5

Unit tests do Quickcheck

Criar os testes do Quickcheck.

Para isso é suposto criar um novo ficheiro chamado Test<modulo_a_testar>

Esse ficheiro deve ser colocado na pasta src e só deve ser compilado quando se querem fazer testes de quickcheck.

Os testes do QuickCheck só asseguram determinada propriedade.
Aqui (http://book.realworldhaskell.org/read/testing-and-quality-assurance.html) dá para ter uma ideia melhor sobre o que fazem.

As funções dos testes devem começar por "prop_".

Cada ficheiro de testes deve ter uma main deste género:

import Prettify2
import Test.QuickCheck.Batch

options = TestOptions
      { no_of_tests         = 200
      , length_of_tests     = 1
      , debug_tests         = False }

main = do
    runTests "simple" options
        [ run prop_empty_id
        , run prop_char
        , run prop_text
        , run prop_line
        , run prop_double
        ]

    runTests "complex" options
        [ run prop_hcat
        , run prop_puncutate'
        ]

Penso que a parte do HPC é dispensável.

Actualizar a Makefile para suportar novas funcionalidades

É só ir adicionando labels para as novas tarefas e fazer com que

make clean

limpe mesmo todos os ficheiros temporários.

Criar e Testar diferentes ficheiros XML

Criar uma script que testa os vários programas (draw,play,next e paint) com vários XML diferentes.

Já existe um ficheiro 001.xml na pasta test. A ideia é criar mais ficheiros e uma script que os teste a todos ou só a alguns, ou só teste um dos programas...

Essa script deve também fazer uma verificação dos ficheiros xml antes de os testar.
Para isso é fazer a cena do xmllint que está no final do enunciado.

Programa Paint

É uma script que converte cada caracter do ficheiro gerado pelo programa draw num quadrado de pixels.

Os meeples têm de estar assinalados de qualquer forma. De preferência uma forma que dê para distinguir a que jogador pertence o meeple.