DX.COM - Classical Rubber Band Launcher Wooden Pistol Gun (Toy)

Comprei esse produto no DX (www.dx.com) e ele não presta.
A "margarida" de plástico que segura os elásticos é frágil e seus "dentes" acabam arrebentando fácil.
Infelizmente não consigo dar uma reposta (feedback), através do próprio DX.
Então fica o aviso.

Software: AutoHotKey

ATENÇÃO: Use o modo de compatibilidade rodar como administrador.
AutoHotKey é um bom software de automação.
Eu o utilizei para agilizar a transferência de conteúdo de um software para o meu blogger com sucesso.
Segue o básico para quem deseja aprender um pouco sobre ele.

; comentário
^ tecla control

! tecla alt

<^>!:: tecla alt direito / Alt Gr

# tecla win
+ tecla shift

 
 



habilitar em jogos
==================
#NoEnv  ; Recommended for performance and compatibility with future AutoHotkey releases.
; #Warn  ; Enable warnings to assist with detecting common errors.
SetWorkingDir %A_ScriptDir%  ; Ensures a consistent starting directory.
SendMode Play ; Recommended for new scripts due to its superior speed and reliability.
SetKeyDelay, 0, 25, Play

send
====
send - instrução pressionamento de tecla.

copiar (ctrl + c)
send ^c
ou

send, {CTRLDOWN}c{CTRLUP}

colar (ctrl + v)
send ^v
ou
send, {CTRLDOWN}v{CTRLUP}

selecionar tudo (ctrl + t)
send ^t

select all (ctrl + a)
send ^a

salvar (ctrl + b)
send ^b

apagar
send {del}

apagar
send, {Backspace}

 

caracteres especiais, abaixo caracter de exclamação

send, {!}


:: (instrução de evento)
========================
:: - instrução para aguardar pressionamento de teclas, ou seja, evento de teclas.

quando apertar o botão direito do mouse
$RButton::

quando apertar o botão do meio do mouse
$MButton::

quando apertar o botão 4 (mouse com mais de 3 botões)
$XButton1::

quando apertar o botão 5 (mouse com mais de 3 botões)
$XButton2::

quando rolar para cima (mouse)
WheelUp::

quando rolar para baixo(mouse)
WheelDown::

<^>!1::






EXEMPLO DE UM SCRIPT QUE CRIEI
==============================

; win+z - rodar o script abaixo
#z::

; ir para a janela do HelpNDoc
IfWinExist CA.hnd - HelpNDoc Personal Edition 4.1.0.219
{
    WinActivate
}else{
    ;No MsgBox +16 é o ícone de erro
    MsgBox, 16, ERRO!, O HelpNDoc não está aberto!`nOu erro de reconhecimento no script!
    
    ; encerra o script
    return
}

; select all
send ^a

; copiar
send ^c

; ir para o word
IfWinExist arquivo_de_troca.html - Microsoft Word
{
    WinActivate
}else{
    ;No MsgBox +16 é o ícone de erro
    MsgBox, 16, ERRO!, O Word não está aberto!`nOu arquivo_de_troca.html não está aberto nele!`nOu erro de reconhecimento no script!
    
    ; encerra o script
    return
}

; precaução - apaga todo texto - selecionar tudo e apagar
send ^t 
send {del}

; cola o texto do tópico do HelpNDoc
send ^v

; salvar
send ^b

; espera 1 segundo
sleep, 1000

; ir para o notepad++
IfWinExist F:\arquivo_de_troca.html - Notepad++
{
    WinActivate
}else{
    ;No MsgBox +16 é o ícone de erro
    MsgBox, 16, ERRO!, O Notepad++ não está aberto!`nOu arquivo_de_troca.html não está aberto nele!`nOu erro de reconhecimento no script!
    
    ; encerra o script
    return
}

; espera 1 segundo
sleep, 1000

; ir para a mensagem do notepad++
IfWinExist Reload
{
    WinActivate
}else{
    ;No MsgBox +16 é o ícone de erro
    MsgBox, 16, ERRO!, É esperado o notepad++ e sua caixa: 'Do you want to reload it?'
    
    ; encerra o script
    return
}

; responde sim a caixa: 'Do you want to reload it?'
send s

; espera 1 segundo
sleep, 1000

; select all
send ^a

; copiar
send ^c

;No MsgBox +64 é o ícone de informação
MsgBox, 64, Sucesso!, O seu post esta pronto`, agora e so colar :), 5

; encerra o script

return

CHAMAR UM JOGO DA STEAM
=======================

Run "C:\Program Files (x86)\Steam\Steam.exe" -applaunch 375120




 
FECHAR O SCRIPT AO FECHAR O JOGO
================================
;Nota: Se o nome do arquivo executável contiver espaço, não se deve colocar entre aspas
;-- Exemplo --
;Process, Wait, Culling Of The Cows.exe
;Process, Exist, Culling Of The Cows.exe

Process, Wait, super_star_path.exe
Process, Exist, super_star_path.exe
PID = %ErrorLevel%
Process, WaitClose, %PID%
ExitApp

PULAR MENSAGEM DE INSTÂNCIA
===========================
Toda vez que você modifica o script e tenta rodar, aparece uma mensagem chata se você deseja fechar a instância anterior e rodar a nova. É óbvio que sim. Então adicione essas duas linhas no script.
#NoEnv 
#SingleInstance force      ;Skips the message, "An older instance of this script is already running. Replace it with this instance?"

 

INFORMAR QUE O SCRIPT ESTÁ ESCRITO NA VERSÃO 2.0

================================================

#Requires AutoHotkey v2.0

 

; As instruções de atalho devem estar dentro do bloco { }

<^>!c::
{
    if WinActive("Acesso") = 0 {
         MsgBox "Não detectado"
    }else{
        MsgBox "Detectado"
    }
}
 

; Não é aceito vírgula após o nome da função, Exemplo
 WinActive, "Acesso" ; <= ERRADO

 

FUNÇÕES 

; Se a janela com o título "Acesso" estiver ativa

    if WinActive("Acesso") != 0 {
        MsgBox "Detectado"
        return
    }
 

Desenvolvendo Software

Segue abaixo algumas dicas para se construir um bom software independente da linguagem de programação a utilizar:

·         A tecnologia deve se adaptar ao usuário e não o oposto. Tenha sempre isto em mente.

·         O usuário deve sentir que tem total controle sobre a aplicação. Como por exemplo: sempre cancelar um comando ou desfazer alguma ação. Escolher a fonte, tamanho da fonte, tamanho da janela, posição da janela etc. Aconselho que essas definições, estejam disponíveis no item de menu “Preferências”.

·         Em menus e botões utilize nomes curtos. Não ultrapasse dois níveis de opções nos menus.

·         Vá além do que o usuário ou cliente exige, pois infelizmente e na maioria dos casos, ele não tem uma visão abrangente do assunto. Pesquise, converse e descubra o máximo que puder sobre o assunto. Utilize suas experiências anteriores.

Você não é apenas um programador, ou seja, um digitador de códigos, você agora é um desenvolvedor, pois está envolvido em um projeto e todos seus processos.

Ícones

Abuse da utilização de ícones. Eles ajudam a memorizar um comando ou função. O ícone deve ser coerente com o comando ou função. Utilize ícones com 32-bits de cores, modernos e brilhantes, pois dará impressão de um software também moderno, caso contrário parecerá com um software ultrapassado, mesmo que não seja.

Aparência é importante

Um professor meu dizia: "Um trabalho desleixado é o sinal de uma mente negligente!"

Há muita verdade nisso.

Se não existiu preocupação sequer com a aparência da tela a ser exibida de um modo correto, o que dizer sobre o resto do seu trabalho?

Seu profissionalismo deve ser evidente em cada parte do seu trabalho.

Se o que é visto pelo público é de má qualidade, não há razão para acreditar que o trabalho por trás da interface é algo bom.

Muitos de nós desenvolvedores não somos especialistas em desenhar interfaces bonitas e legíveis, então devemos levar em consideração, a contratação de alguém nesta área.

Valide os dados

Valide todos os campos (CNPJ, CPF, I.E., cartão de crédito etc.)

Filtre os dados

Sempre utilize máscara de entrada quando possível.

Evitando entrar caracteres num campo numérico por exemplo.

Impeça a digitação de caracteres especiais como: vírgula, dois pontos, ponto-e-vírgula, travessão, aspas simples, aspas duplas, espaço etc.

Obs.: Nunca armazene na base de dados a máscara de entrada, mas somente os dados. A máscara de entrada serve somente para “guiar os olhos” durante a digitação.

Limite os dados

Se um campo numa tabela cabe apenas 30 caracteres a exemplo, então limite a caixa de texto a 30 caracteres também.

Registro duplicado

Para evitar isto, antes de inserir as informações procure na base de dados e verifique se o registro já existe.

Assistentes e componentes úteis

Abuse dos assistentes segue abaixo alguns exemplos:

Nos formulários inclua a opção classificar e filtrar os dados.

Nos relatórios, também inclua a opção classificar e filtrar os dados.

Nos campos de data sempre inclua um calendário para que o usuário possa consultar uma determinada data facilmente.

Nos campos de caminho do arquivo (path) inclua sempre uma caixa de diálogo para o usuário selecionar o arquivo, evitando assim que ele digite todo o caminho manualmente e eventualmente cometa erros.

No caso do formulário conter campos numéricos e outros que efetuem cálculos, disponibilize uma calculadora para o usuário, pode ser a do próprio Windows, sem problemas. Obs: Disponibilizar uma calculadora para o usuário, não implica em deixar campos sem cálculo automático, deixe essa tarefa por conta do seu programa, poupando tempo e evitando erros por parte do usuário.

Durante o preenchimento de um endereço ou localidade, coloque o campo CEP em primeiro lugar, após o usuário tê-lo preenchido consulte o CEP na base e retorne o estado, endereço, município e bairro automaticamente.

Ao criar um relatório inclua sempre as seguintes funções:

1º Selecionar Impressora.

2º Configurar Impressora.

3º Configurar Página.

4º Uma opção interessante e a de exportar os dados como texto separado por tabulações, geralmente o usuário necessita manipular os dados do relatório em outro aplicativo. O arquivo texto é simples, pequeno (na maioria dos casos) e rápido de ser importado. Outra vantagem e que praticamente todos os softwares do mercado suportam este formato.

5º Opcional. Se possível inclua a opção enviar. Esta opção permite enviar o relatório ou dados utilizando o correio eletrônico (Outlook ou Lotus Notes).

6º Opcional. Habilite o modo estrutura do relatório para o usuário, inclua a opção retornar ao padrão, deixe-o salvar e importar a sua própria estrutura.

Mostre que o software está trabalhando

O usuário deve sempre saber que algo está acontecendo, principalmente numa tarefa demorada que pode consumir alguns minutos para ser executada. Mostre uma ampulheta, ou uma barra de progresso, ou uma barra de status para informar o usuário. Evitando que ele comece a teclar ao acaso para ver se algo acontece. Apenas alguns segundos de inatividade, já faz com que o usuário se sinta frustrado achando que o programa está travado.

Salve

Nunca feche um formulário sem salvar ou execute qualquer outra ação sem salvar os dados ou ao menos perguntar ao usuário se os dados devem ser gravados. Qualquer falha nesse sentido causará receio do usuário a você e ao seu software.

Salve toda a configuração do usuário, mesmo que pequena. (pasta, nome de arquivo, posição das janelas etc.)

Adicione suporte a backup da base de dados e insista para que o usuário faça backups regularmente, através de mensagens de avisos.

Ajuda

Habilite a ajuda no seu software para quando o usuário pressionar F1 obtenha detalhes sobre o processo em que está utilizando.

Informe na ajuda os processos mais simples. Lembre-se o usuário não é obrigado a adivinhar como seu software funciona, mesmo se tratando de tarefas óbvias.

Efetue a documentação do seu software.

Toda mensagem de erro deve estar no idioma do usuário. O botão de ajuda deve estar disponível sempre, para que o usuário obtenha detalhes do erro, além da solução quando possível.

Treinamento

Não cometa o erro de simplesmente largar o software na mão do usuário.

Para garantir o bom uso do seu software, inclua na venda ou aluguel o valor para treinamento ou suporte.

Faça questão disso. É um item indispensável.

Integração

Integre seu software com outros aplicativos comuns ao usuário como Excel ou Word. Por exemplo, exportar dados para o Excel ou fazer mala direta entre sua base de dados e um documento do Word.

Instalador

Se o seu aplicativo não for do tipo web, crie um instalador para o seu software, nada de pedir ao usuário para criar pastas, manipular arquivos, registrar componentes manualmente, configurar o registro do Windows etc. Crie o instalador e apenas peça para dar dois cliques.

Respeito

Respeite os usuários, eles não são técnicos e nem programadores. Não são obrigados a entenderem termos técnicos ou efetuarem procedimentos deste nível.

Evite piadas como:

- Se o capim mudar de cor, o burro morre de fome.

- É BIOS. Bicho Ignorante Operando o Sistema.

- O problema é a pecinha entre o teclado e o monitor.

etc.

Se todos tivessem as mesmas habilidades, experiência e idéias, a vida não teria diversidade, criatividade e entusiasmo. ;)

A importância do Usuário

Qualquer projeto que você desenvolva tem de envolver usuários. Eles são as pessoas que vão sentar na frente de sua interface por oito horas por dia e decidir se gostam ou não. Se não gostar, não importa o quão eficiente o código seja e quantos milhões foram gastos em desenvolvimento, eles vão encontrar maneiras de sabotá-lo.

Lembre-se: somos apenas desenvolvedores, não importa o quão legal seria ter todo texto roxo sobre um fundo laranja, é o usuário que vai dizer o que é legal e o que não é.

Tolerância a falhas

A aplicação deve ser tolerante a falhas. Usuários cedo ou tarde irão cometer erros. Um único erro não deve derrubar a aplicação. Se não há espaço para erros, os usuários terão medo de experimentar, de descobrir por conta própria como fazer as coisas. Isso retardará o processo de aprendizagem consideravelmente.

Paz e harmonia

Quando a coisa não anda bem, é difícil manter o bom andamento do projeto.

A desavença entre desenvolvedores e testadores; consultoria e cliente etc. infelizmente é frequente. É preciso ter em mente que todos são parceiros e devem trabalhar para um bem comum, deixando determinadas coisas de lado, pois não agregam valor nenhum como:

- Disputa para provar que tem razão.

- Não assumir erros.

- Focar em achar culpados, ao invés de tentar solucionar o problema.

Experiência própria

A consultoria onde trabalhei, responsável por implantar um determinado software, já chegou a perder 3 dias porque o cliente culpava o software de não enviar e-mail e a consultoria dona do software culpava a infra-estrutura do cliente.

A consultoria de software revisou todo software e informou que o produto estava correto e chegou até sugerir determinados testes de rede.

O cliente se recusava a fazer os testes, pois rede era o ramo de atividade deles, eles sabiam o que estavam fazendo e nenhum e-mail foi enviado ao servidor de e-mail deles.

Após uma reunião fervorosa, aceitaram os testes e finalmente começamos a trabalhar juntos para a solução do problema, concluímos então que o e-mail estava sendo barrado pelo antivírus deles, ou seja, era um problema de infraestrutura sim, pois todo firewall e antivírus é responsabilidade do pessoal da infraestrutura. Eles focaram somente na rede, mostrando apenas evidências coletadas dessa. Por ego próprio, acabaram ficando cegos, esquecendo-se de checar outros itens que compõe a rede.

Escrito por Wellington Gomes dos Santos.

Campo Minado em Linguagem C - Minesweeper in C

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define TECLA_ESC 27       // o código da tecla ESC é 27
#define OCULTAR 0
#define REVELAR 1
#define PERDEU 0           
#define GANHOU 2           
#define DIMENSAO 5         
#define INDICE_FINAL 24    // índice final do vetor
#define TOTAL_ELEMENTOS 25 // total de elementos

/* Tabuleiro é de 5 x 5, então temos 25 células
   30% das células devem conter minas, então 30% de 25 é 7,5 arredondando temos 8 minas. */
#define TOTAL_MINAS 8

/* Vetor com 25 elementos representando tabuleiro, índice de 0 a 24
   Guarda se a posição possui ou não minas. 
   Onde:
   0 - não existe mina
   1 - sim, existe uma mina nesta posição
*/       
int tabuleiroMina[TOTAL_ELEMENTOS];    

/* Vetor com 25 elementos representando tabuleiro, índice de 0 a 24
   Guarda se o usuário já jogou em determinada posição.
   Onde:
   0 - não jogou
   1 - sim, já jogou nesta posição do tabuleiro
*/    
int tabuleiroJogada[TOTAL_ELEMENTOS];    

/* PROTÓTIPO DAS FUNÇÕES */
void limparTabuleiro();
void espalharMinas();
void desenharTabuleiro();
int contarMinas(int posicao);
int converte(char *pos);
int jogar(char *pos);
int ganhou();
int pecaDireita(int posicao);
int bordaDireita(int posicao);
int pecaEsquerda(int posicao);
int bordaEsquerda(int posicao);
int pecaSuperior(int posicao);
int bordaSuperior(int posicao);
int pecaInferior(int posicao);
int bordaInferior(int posicao);
int pecaSuperiorEsquerda(int posicao);
int pecaSuperiorDireita(int posicao);
int pecaInferiorEsquerda(int posicao);
int pecaInferiorDireita(int posicao);
int inteiro(float numerador, float denominador);


int main(int argc, char *argv[])
{
    
    /* Variável para pegar a tecla digitada */
    int tecla;
    
    /* Variável para pegar a posição que o usuário quer jogar*/    
    char posicao[4]; 
    
    /* Retorno do processamento da jogada */
    int resposta;
    
    //A função srand inicializa a função que irá retornar um número aleatório. 
    srand ( time(NULL) );
    
    do{
        /* Limpa a tela */
        system("cls");
        
        printf("****************************************************\n");        
        printf("****************************************************\n");        
        printf("***          UNIVERSIDADE ESTACIO UNIRADIAL      ***\n");
        printf("*** Wellington Gomes dos Santos                  ***\n");
        printf("*** topictree.app.br                         ***\n");
        printf("****************************************************\n");        
        printf("****************************************************\n");        
        printf("\n \n \n \n");
        printf("Pressione qualquer tecla para iniciar o jogo\n");
        printf("Pressione ESC para terminar\n");
        
        /* obtém código da tecla digitada */
        tecla = getch();
        
        /* Se apertou ESC */
        if (tecla == TECLA_ESC){
            /* Sai do programa */
            exit(0);
        }
        
        limparTabuleiro();
        
        espalharMinas();
        
        do{
            /* Limpa a tela */
            system("cls");
            
            //desenha o tabuleiro sem revelar as minas
            desenharTabuleiro(OCULTAR);
            
            //TESTE - REMOVA O COMENTÁRIO ABAIXO E VEJA A RESPOSTA DO JOGO, ÚTIL PARA TESTAR QUANDO GANHA
            //desenharTabuleiro(REVELAR);
            
            printf("\nDigite 'sair' para desistir e encerrar o jogo.");
            printf("\nOu escolha a linha e a coluna: ");
            scanf("%s", posicao);
            
            /* Se digitou "sair" */
            if (strcmp(posicao, "sair") == 0){
                /* Sai do programa */
                exit(0);
            }
            
            resposta = jogar(posicao);

            switch (resposta){
                   
                case PERDEU: 
                    //desenha o tabuleiro revelando as minas
                    desenharTabuleiro(1);
                    
                    printf("\nGAME OVER\n");
                    system("PAUSE");
                     
                    break;
                    
                case GANHOU:
                    //desenha o tabuleiro revelando as minas
                    desenharTabuleiro(1);

                    printf("\nPARABENS, VOCE COMPLETOU O JOGO\n");
                    system("PAUSE");       
                    
                    break;
            }
                                
        /* Enquanto não perder o jogo ou ganhar, continua */          
        } while ( (resposta != PERDEU) && (resposta != GANHOU) );
    
    /* Só sai quando o comando exit(0) for executado */  
    } while (1);
    
    return 0;
}


void limparTabuleiro(){         
    int a;
    for (a = 0; a <= INDICE_FINAL; a++){
        tabuleiroMina[a] = 0;
        tabuleiroJogada[a] = 0;
    }         
}


void espalharMinas(){
    int pos;
    int totalMinas = 0;
    
    do {
        //número aleatório de 0 a 4
        pos = rand() % TOTAL_ELEMENTOS;        
        
        //Se não existe mina ainda
        if (tabuleiroMina[pos] == 0){
            
            //marca que agora tem uma mina nesta posição
            tabuleiroMina[pos] = 1;
            
            //mais uma mina foi adicionada
            totalMinas++;
        }
    
    //enquanto não tiver 8 minas continua
    } while(totalMinas != TOTAL_MINAS);    
}

/* O jogo normalmente só deve mostrar as posições já jogadas
   Onde
     0 - não revelar o jogo
     1 - revelar o jogo
*/
void desenharTabuleiro(int revelar){
    int a;
    int contador = 0;
    int minasRedor;
    
    char letras[] = "ABCDE";
    int letra = 0;
    
    /* SÓ DEVE MOSTRAR POSIÇÕES JÁ JOGADAS */
    
    printf("\n  01234 \n");
    
    for (a = 0; a <= INDICE_FINAL; a++){
        
        if (contador == 0){
            printf("%c ", letras[letra]);
            
            //próxima letra da linha
            letra++;
        }
        
        contador++;
            
        //Se não é para revelar o jogo
        if (revelar == 0){
                    
            //Se posição não foi escolhida
            if (tabuleiroJogada[a] == 0){
                                   
                //oculta
                printf("?");
            }else{
                //verifica e mostra quantas minas tem ao redor da posição
                minasRedor = contarMinas(a);
                printf("%d", minasRedor);
            }
            
        }else{ // Se é para revelar o jogo
            
            //Se tem mina
            if (tabuleiroMina[a] == 1){
                printf("*");
            }else{
                //mostra quantas minas tem ao redor da posição
                minasRedor = contarMinas(a);
                printf("%d", minasRedor);                  
            }
        
        } // end if
        
        //quebra linha a cada cinco 
        if (contador == DIMENSAO){
             printf("\n");
             
             //reinicia contador
             contador = 0;
        }
        
    } //end for
     
    printf("\n");
}


/* conta quantas minas tem ao redor de uma posição */
int contarMinas(int posicao){
    
    int contador = 0;
    int peca = 0;
    
    //Se a peça não estiver na borda direita
    if ( !bordaDireita(posicao) ){
        
        //obtém a posicao da peça a sua direita
        peca = pecaDireita(posicao);
        
        //se for uma mina
        if ( tabuleiroMina[peca] == 1){
            contador++;
        } 
    }
    
    //Se a peça não estiver na borda esquerda
    if ( !bordaEsquerda(posicao) ){
        
        //obtém a posicao da peça a sua esquerda
        peca = pecaEsquerda(posicao);
        
        //se for uma mina
        if ( tabuleiroMina[peca] == 1){
            contador++;
        } 
    }
    
    //Se a peça não estiver na borda superior
    if ( !bordaSuperior(posicao) ){
        
        //obtém a posicao da peça superior
        peca = pecaSuperior(posicao);
        
        //se for uma mina
        if ( tabuleiroMina[peca] == 1){
            contador++;
        } 
    }
    
    //Se a peça não estiver na borda inferior
    if ( !bordaInferior(posicao) ){
        
        //obtém a posicao da peça inferior
        peca = pecaInferior(posicao);
        
        //se for uma mina
        if ( tabuleiroMina[peca] == 1){
            contador++;
        } 
    }
        
    /* DIAGONAIS */
            
    //Se a peça não estiver na borda superior ou na borda esquerda
    if ( !bordaSuperior(posicao) && !bordaEsquerda(posicao) ){
        
        //obtém a posicao da peça superior esquerda
        peca = pecaSuperiorEsquerda(posicao);
        
        //se for uma mina
        if ( tabuleiroMina[peca] == 1){
            contador++;
        } 
    }
        
    //Se a peça não estiver na borda superior ou na borda direita
    if ( !bordaSuperior(posicao) && !bordaDireita(posicao) ){
        
        //obtém a posicao da peça superior direita
        peca = pecaSuperiorDireita(posicao);
        
        //se for uma mina
        if ( tabuleiroMina[peca] == 1){
            contador++;
        } 
    }
    
    //Se a peça não estiver na borda inferior esquerda
    if ( !bordaInferior(posicao) && !bordaEsquerda(posicao) ){
        
        //obtém a posicao da peça inferior esquerda
        peca = pecaInferiorEsquerda(posicao);
        
        //se for uma mina
        if ( tabuleiroMina[peca] == 1){
            contador++;
        } 
    }
    
    //Se a peça não estiver na borda inferior direita
    if ( !bordaInferior(posicao) && !bordaDireita(posicao) ){
        
        //obtém a posicao da peça inferior direita
        peca = pecaInferiorDireita(posicao);
        
        //se for uma mina
        if ( tabuleiroMina[peca] == 1){
            contador++;
        } 
    }
    
    return contador;
}


/* Converte caractere (char) para posição válida na matriz, ou seja, um número de 0 a 4
Onde:
  A = 0    
  B = 1    
  C = 2    
  D = 3    
  E = 4    
*/
int converte(char *pos){
    
    int pos1;
    int pos2;
    
    //converte para maiúsculo
    pos[0] = toupper(pos[0]);    
    
    //converte letra para número
    if (pos[0] == 'A'){
        pos1 = 0;
        
    }else if (pos[0] == 'B'){
        pos1 = 1;
        
    }else if (pos[0] == 'C'){
        pos1 = 2;
        
    }else if (pos[0] == 'D'){
        pos1 = 3;
        
    }else if (pos[0] == 'E'){
        pos1 = 4;
    }
    
    //converte posição de matriz, para posição sequencial
    if (pos[1] == '0'){
        pos2 = 5;
        
    }else if (pos[1] == '1'){
        pos2 = 4;
        
    }else if (pos[1] == '2'){
        pos2 = 3;
        
    }else if (pos[1] == '3'){
        pos2 = 2;
        
    }else if (pos[1] == '4'){
        pos2 = 1;
    }
    
    /* converte posição de matriz, para posição sequencial 
       exemplo [2][0] (linha 3, coluna 3) para 10
       lembrando que o índice começa em zero
    */
    return (pos1 * DIMENSAO) + (DIMENSAO - pos2);    
}


/* Retorno:
    0 - jogada marcada, uma mina e fim de jogo 
    1 - jogada marcada, sem mina e jogo continua
    2 - jogada marcada, descobriu todas as minas
*/
int jogar(char *pos){
    
    /* converte as coordenadas (Ex: A1) para uma posição válida (Ex: 0) */
    int posicao = converte(pos);
        
    /* Marca onde o usuário jogou */
    tabuleiroJogada[posicao] = 1;
    
    /* Se tem uma mina */
    if (tabuleiroMina[posicao] == 1){
        /* fim do jogo */
        return 0;
    }
    
    /* Se não ganhou */    
    if ( ganhou() == 0 ){
        //continua
        return 1;
    }else{
        //parabéns
        return 2;
    }
}


/* Verifica se o usuário ganhou o jogo 
    0 - não ganhou
    1 - sim, ganhou o jogo
*/
int ganhou(){
    int a;
    int contador = 0;
    
    /* jogo tem 25 posições e 8 minas, então deve fazer 17 jogadas para vencer */
    int jogadasVencer = TOTAL_ELEMENTOS - TOTAL_MINAS;
    
    for (a = 0; a <= INDICE_FINAL; a++){
        if (tabuleiroJogada[a] == 1){
            contador++;
        }
    }
    
    if (contador == jogadasVencer){
        return 1;
    }else{
        return 0;
    }
}


/* Retorna a posição da peça que está a direita */
int pecaDireita(int posicao){
    return posicao + 1;
}

/* Verifica se o número pertence a borda direita 
   Onde:
   0 - não   
   1 - sim, essa posição pertence a borda direita
*/
int bordaDireita(int posicao){
    if ( inteiro(posicao + 1, DIMENSAO) ){
        return 1;
    } else {
        return 0;
    }
}


/* Retorna a posição da peça que está a esquerda */
int pecaEsquerda(int posicao){
    return posicao - 1;
}

/* Verifica se o número pertence a borda esquerda
   Onde:
   0 - não
   1 - sim, essa posição pertence a borda esquerda
*/
int bordaEsquerda(int posicao){
    if ( inteiro(posicao, DIMENSAO) ){
        return 1;
    } else {
        return 0;
    }    
}


/* Retorna a posição da peça que está a cima */
int pecaSuperior(int posicao){
    return posicao - DIMENSAO;
}

/* Verifica se o número pertence a borda superior
   Onde:
   0 - não
   1 - sim, essa posição pertence a borda superior
*/
int bordaSuperior(int posicao){
    if ( posicao < DIMENSAO ){
        return 1;
    } else {
        return 0;
    }    
}


/* Retorna a posição da peça que está a baixo */
int pecaInferior(int posicao){
    return posicao + DIMENSAO;
}

/* Verifica se o número pertence a borda inferior
   Onde:
   0 - não
   1 - sim, essa posição pertence a borda inferior
*/
int bordaInferior(int posicao){
        
    //ultima peça da borda inferior
    int ultima = (DIMENSAO * DIMENSAO) - 1;
    
    //primeira peça da borda inferior
    int primeira = (DIMENSAO * DIMENSAO) - DIMENSAO;

    if ( (posicao >= primeira) && (posicao <= ultima) ){
        return 1;
    } else {
        return 0;
    }    
}


/* Retorna a posição da peça que está na parte superior esquerda */
int pecaSuperiorEsquerda(int posicao){
    return posicao - DIMENSAO - 1;
}

/* Retorna a posição da peça que está na parte superior direita */
int pecaSuperiorDireita(int posicao){
    return posicao - DIMENSAO + 1;
}

/* Retorna a posição da peça que está na parte inferior esquerda */
int pecaInferiorEsquerda(int posicao){
    return posicao + DIMENSAO - 1;
}

/* Retorna a posição da peça que está na parte inferior direita */
int pecaInferiorDireita(int posicao){
    return posicao + DIMENSAO + 1;
}

/* Verifica se um número é inteiro
   Onde retorna:
   0 - não   
   1 - sim, este número é inteiro
*/
int inteiro(float numerador, float denominador){
    //fmod - retorna a parte fracionária, ou seja, se a parte fracionária é zero, então é um inteiro
    if ( fmod(numerador, denominador) == 0 ){
         return 1;
    } else {
         return 0;
    }
}