Expocol Paula 2024

expocol.sh

#!/usr/bin/env bash
#
# Interpretador de comandos .P de Paula.
#
# Author: John Murowaniecki <[email protected]>
#
#
# shellcheck disable=SC2068

# porpose:SC1090

tput civis

declare LAST_COND
declare RESULTADO
export  RESULTADO



function mostrar() { MOSTRE "${@}"; }
function Mostrar() { MOSTRE "${@}"; }
function MOSTRAR() { MOSTRE "${@}"; }
function mostra () { MOSTRE "${@}"; }
function Mostra () { MOSTRE "${@}"; }
function MOSTRA () { MOSTRE "${@}"; }
function mostre () { MOSTRE "${@}"; }
function Mostre () { MOSTRE "${@}"; }
function MOSTRE () {
    echo -e "${@}" | sed 's,·,\x1b[0;31m·\x1b[0m,g;s,@,\x1b[0;32m@\x1b[0m,' | sed -E 's/(\*)/\x1b[0;33m\1\x1b[0m/g'
}

function POSICAO() {
    VARIÁVEL linha  É "${1}"
    VARIÁVEL coluna É "${2}"

    posicao="${linha}"
    posicao=$(expr "${linha}" \* 81)
    posicao=$(expr "${posicao}" + "${coluna}")

    # echo -e "o que tem na posição ($linha, $coluna)? ${CIDADE:$posicao:1} ($posicao) ${3}"
    echo -en "${CIDADE:$posicao:1}"
}

function MARCA() {
    VARIÁVEL desenho É "${1}"
    VARIÁVEL linha   É "${3}"
    VARIÁVEL coluna  É "${4}"

    posicao=$linha
    posicao=$(expr ${linha} \* 81)
    posicao=$(expr $posicao + $coluna + 1)

    CIDADE="${CIDADE:0:posicao-1}${desenho}${CIDADE:posicao}"
}


# Resulta em um númeo aleatório entre os números informados.
#
# @usage ALEATORIO ENTRE 10 E 12
#
# @param DE  Um número.
# @param ATÉ Outro número.
function aleatorio() { ALEATORIO ${@}; }
function aleatório() { ALEATORIO ${@}; }
function Aleatorio() { ALEATORIO ${@}; }
function Aleatório() { ALEATORIO ${@}; }
function ALEATÓRIO() { ALEATORIO ${@}; }
function ALEATORIO() {
    DE="${2:-0}"
    ATE="${4:-10}"
    RESULTADO="$(shuf -i "${DE}-${ATE}" -n1)"
}



# Ativa ou desativa a exibição do cursor durante a execução do programa.
#
# @usage CUSROR ON       - Mostra cursor na tela.
# @usage CURSOR ESCONDER - Esconde o cursor.
# @usage CURSOR DESATIVA - Esconde o cursor.
#
# @param Opção [ESCONDE ou ESCONDER, OFF, NÃO, DESATIVA ou DESATIVAR] para NÃO EXIBIR o cursor. Utilize qualquer outro valor para exibir.
function cursor() { CURSOR ${@}; }
function Cursor() { CURSOR ${@}; }
function CURSOR() {
    case ${1^^} in
        OFF|NÃO|ESCONDE|DESATIV*) tput civis;;
        *) tput cnorm;
    esac
}



# Limpa a tela, variável ou arquivo.
# Utilize para apagar os dados na tela, variáveis e arquivos antes de imprimir novos.
#
# @param Opção [TELA, ARQUIVO ou VARIÁVEL]
function limpa()  { LIMPA ${@}; }
function Limpa()  { LIMPA ${@}; }
function limpar() { LIMPA ${@}; }
function Limpar() { LIMPA ${@}; }
function LIMPAR() { LIMPA ${@}; }
function LIMPA() {
    case "${1^^}" in
        VAR*) export "${2}"= ;;
        ARQ*) echo -n "" > "${2}";;
        TELA) clear ;;
        *) clear;
    esac
}

# Realiza determinada tarefa ENQUANTO for necessário.
function enquanto() { ENQUANTO ${@}; }
function Enquanto() { ENQUANTO ${@}; }
function ENQUANTO() {
    ORIGEM="${1}"; shift; shift; shift; shift
    LIMITE="${1}"; shift
    INCREMENTADOR=0

    while [ "${INCREMENTADOR}" -lt "${LIMITE}" ]; do
        ${@} && INCREMENTADOR=$(eval "echo $(echo '$'$ORIGEM)")
    done
}

function entao() { ENTAO ${@}; }
function então() { ENTAO ${@}; }
function Entao() { ENTAO ${@}; }
function Então() { ENTAO ${@}; }
function ENTÃO() { ENTAO ${@}; }
function ENTAO() {
    echo "${LAST_COND} ${@}"
    exit 1
    [ "${LAST_COND}" ] && ${@}
}

function senão() { SENAO ${@}; }
function senao() { SENAO ${@}; }
function Senão() { SENAO ${@}; }
function Senao() { SENAO ${@}; }
function SENÃO() { SENAO ${@}; }
function SENAO() {
    [ ! "${LAST_COND}" ] && ${@}
}

# Soma dois ou mais números e armazena o $RESULTADO.
function ADICIONAR() { SOMA ${@}; }
function ADICIONA () { SOMA ${@}; }
function ADICIONE () { SOMA ${@}; }
function ADICAO   () { SOMA ${@}; }
function SOMAR    () { SOMA ${@}; }
function SOME     () { SOMA ${@}; }
function SOMA     () {
    total=
    for numero in ${@}
    do  numero=${numero//[!0-9]/}
        numero=${numero:-0}
        total=$((total + numero))
    done
    export RESULTADO=${total}
    ESCREVE ${RESULTADO}
}

# Subtrai dois ou mais números e armazena o $RESULTADO.
function SUBTRACAO() { DIMINUI ${@}; }
function SUBTRAIR () { DIMINUI ${@}; }
function DIMINUIR () { DIMINUI ${@}; }
function SUBTRAI  () { DIMINUI ${@}; }
function DIMINUA  () { DIMINUI ${@}; }
function DIMINUI  () {
    total=$1; shift
    for numero in ${@}
    do  numero=${numero//[!0-9]/}
        numero=${numero:-0}
        total=$((total - numero))
    done
    export RESULTADO=${total}
    ESCREVE ${RESULTADO}
}

function multiplicou() { MULTIPLICA ${@}; }
function multiplicar() { MULTIPLICA ${@}; }
function multiplique() { MULTIPLICA ${@}; }
function Multiplicou() { MULTIPLICA ${@}; }
function Multiplicar() { MULTIPLICA ${@}; }
function Multiplique() { MULTIPLICA ${@}; }
function MULTIPLICOU() { MULTIPLICA ${@}; }
function MULTIPLICAR() { MULTIPLICA ${@}; }
function MULTIPLIQUE() { MULTIPLICA ${@}; }
function multiplica () { MULTIPLICA ${@}; }
function Multiplica () { MULTIPLICA ${@}; }
function MULTIPLICA () {
    export RESULTADO=$(( "${1}" * "${2}" ))
}

function dividiu() { DIVIDE ${@}; }
function Dividiu() { DIVIDE ${@}; }
function DIVIDIU() { DIVIDE ${@}; }
function divider() { DIVIDE ${@}; }
function Divider() { DIVIDE ${@}; }
function DIVIDER() { DIVIDE ${@}; }
function divida () { DIVIDE ${@}; }
function Divida () { DIVIDE ${@}; }
function DIVIDA () { DIVIDE ${@}; }
function divide () { DIVIDE ${@}; }
function Divide () { DIVIDE ${@}; }
function DIVIDE () {
    RESULTADO="$(( "${1}" / "${2}" ))"
    export RESULTADO
}

function repetir() { REPETE ${@}; }
function Repetir() { REPETE ${@}; }
function REPETIR() { REPETE ${@}; }
function repita () { REPETE ${@}; }
function Repita () { REPETE ${@}; }
function REPITA () { REPETE ${@}; }
function repete () { REPETE ${@}; }
function Repete () { REPETE ${@}; }
function REPETE () {
    vezes=$1; shift; shift
    for x in $(seq "${vezes}")
    do ${@} "${x}"
    done
}

function variável() { VARIAVEL ${@}; }
function variavel() { VARIAVEL ${@}; }
function Variável() { VARIAVEL ${@}; }
function Variavel() { VARIAVEL ${@}; }
function VARIÁVEL() { VARIAVEL ${@}; }
function VARIAVEL() {
    variavel="${1}"; shift
    [[ "${1^^} ${2^^ }" == "DEVE SER" ]] \
    && { shift; shift; } \
    || { shift; }
    export "${variavel}"="${*}"
}

function MAPA() {
    [[ "${1^^}" == "DA" ]] && shift;
    variavel="${1}"; shift
    [[ "${1^^} ${2^^ }" == "DEVE SER" ]] \
    && { shift; shift; } \
    || { shift; }
    export "${variavel}"="${*}"
}

function escrevendo() { ESCREVE ${@}; }
function escrever  () { ESCREVE ${@}; }
function escreve   () { ESCREVE ${@}; }
function Escrevendo() { ESCREVE ${@}; }
function Escrever  () { ESCREVE ${@}; }
function Escreve   () { ESCREVE ${@}; }
function ESCREVENDO() { ESCREVE ${@}; }
function ESCREVER  () { ESCREVE ${@}; }
function ESCREVE   () {
    echo -en "\n  ${*}\n"
    sleep .5
}

function retorna() { RETORNA ${@}; }
function Retorna() { RETORNA ${@}; }
function RETORNA() {
    echo -en "${@}"
}

function perguntar() { PERGUNTE ${@}; }
function pergunta () { PERGUNTE ${@}; }
function pergunte () { PERGUNTE ${@}; }
function Perguntar() { PERGUNTE ${@}; }
function Pergunta () { PERGUNTE ${@}; }
function Pergunte () { PERGUNTE ${@}; }
function PERGUNTAR() { PERGUNTE ${@}; }
function PERGUNTA () { PERGUNTE ${@}; }
function PERGUNTE () {
    echo -en "\e[1m   "
    read -r "${1}"
    echo -en "\e[0m"
}

function LETRA() {
    read -n1 "${1}"
}

function ESPERAR() { espere ${@}; }
function ESPERA () { espere ${@}; }
function ESPERE () {
    sleep "${1:-3}"
}

function se() { SE ${@}; }
function Se() { SE ${@}; }
function SE() {
    variavel="${1}"; shift

    while [ $# ]
    do  case "${1^^}" in
            É|FOR) shift; logica=-eq; tipo=A;;
            IGUAL) shift; logica=-eq; tipo=A;;
            MAIOR) shift; logica=-gt; tipo=A;;
            MENOR) shift; logica=-lt; tipo=A;;
            VAZIO) shift; valor=""""; tipo=A; valueSet=true;;
            QUE) shift;;
            DO|Q*) shift;;
            ENTÃO) shift; valor="${previous}"; valueSet=true; execute=true; break;;
            *) break
        esac
        previous="${1}"
    done

    [ -z "${valueSet}" ] && {
        valor="${1}"; shift; shift
    }

    re='^[0-9]+$'
    if ! [[ $variavel =~ $re ]]
    then tipo='S'
    fi

    case "${tipo}" in
        S) [[ "${variavel}" == "${valor}"  ]] && ret=0 || ret=1;;
        A) case "${logica}" in
        -eq) [ "${variavel}" -eq "${valor}" ] && ret=0 || ret=1;;
        -gt) [ "${variavel}" -gt "${valor}" ] && ret=0 || ret=1;;
        -lt) [ "${variavel}" -lt "${valor}" ] && ret=0 || ret=1;;
        esac
    esac

    [ "${ret}" -eq 0 ] && ${@}


    LAST_COND="${ret}"
    return $ret
}

function PROCESSAR() { ITERA ${@}; }
function PROCESSA()  { ITERA ${@}; }
function ITERAR()    { ITERA ${@}; }
function ITERA() {
    FUNCAO="${1}"; shift; shift
    for valor in ${@}
    do "${FUNCAO}" "${valor}"
    done
}

function executar() { ${@}; }
function executa () { ${@}; }
function execute () { ${@}; }
function Executar() { ${@}; }
function Executa () { ${@}; }
function Execute () { ${@}; }
function EXECUTAR() { ${@}; }
function EXECUTA () { ${@}; }
function EXECUTE () {
    ${@}
}

function saia() { SAIR ${@}; }
function Saia() { SAIR ${@}; }
function SAIA() { SAIR ${@}; }
function sair() { SAIR ${@}; }
function Sair() { SAIR ${@}; }
function SAIR() {
    exit "${@}"
}

function PARAMETROS() {
    echo "${*} ${LAST_COND}"
}

[ "${SHELL}" != "pdpaula" ] && {
    [ "${#}" -lt 1 ] && {
        export PSX="${PS1}"
        export SHELLOLD="${SHELL}"
        export SHELL=pdpaula

        /usr/bin/env bash --noprofile --rcfile "$(readlink "$(which pdpaula)")"

        export PS1="${PSX}"
        export SHELL="${SHELLOLD}"
    }
} || {
    export PS1="> "
    tput cnorm
    get=source
    for f in "${@}"
    do  [ -f "${f}" ] && \
        $get "${f}"
    done
}

echo -en "\e[0m\n"
tput cnorm


#
# ###############################################################################
#

VARIÁVEL DIRECOES DEVE SER "wasd"
VARIÁVEL MENSAGEM DEVE SER "Bem vindo!"
VARIÁVEL MOVIMENTO É 0

MAPA DA CIDADE É "\
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░                                                                              ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░                                                                              ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░                                                                              ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ▓▓▓▓▓▓ ░
░                                                                              ░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
"

LIMITE=(13 78)

MARCA "A" EM  1  1
MARCA "B" EM  5 78
MARCA "C" EM 11 50


RASTRO=( )
POSICAO=(1 2)



function DIRIGIR() {
    LIMPAR
    MOSTRA "${CIDADE} (${POSICAO[0]},${POSICAO[1]}) já andamos ${MOVIMENTO} metros."
    MOSTRA "${MENSAGEM} "
    MOSTRA -n "Aperte Q para sair e ${DIRECOES} para andar : ${DIRECAO}"
    LETRA DIRECAO

    SE $DIRECAO FOR IGUAL "w" ENTÃO VARIÁVEL CAMINHO É "CIMA"
    SE $DIRECAO FOR IGUAL "a" ENTÃO VARIÁVEL CAMINHO É "ESQUERDA"
    SE $DIRECAO FOR IGUAL "s" ENTÃO VARIÁVEL CAMINHO É "BAIXO"
    SE $DIRECAO FOR IGUAL "d" ENTÃO VARIÁVEL CAMINHO É "DIREITA"

    MOVIMENTA_PARA "${CAMINHO}"

    DIRIGIR # Para continuar dirigindo
}



function MOVIMENTA_PARA() {
    RASTRO=(${POSICAO[0]} ${POSICAO[1]})
    declare -i linha=${POSICAO[0]}
    declare -i coluna=${POSICAO[1]}

    VARIÁVEL MENSAGEM É "Movendo para ${1}.\\a"
    VARIÁVEL MOVIMENTO É $(expr $MOVIMENTO + 1)

    case "${1}" in
        CIMA) linha+=-1;;
        BAIXO) linha+=1;;
        DIREITA) coluna+=1;;
        ESQUERDA) coluna+=-1;;
    esac

    #
    # Agora precisamos nos certificar de que estamos caminhando dentro
    # do nosso mapa.
    #
    # Onde o mapa começa:
    SE $linha  FOR MENOR QUE          1   ENTÃO VARIÁVEL linha É 1
    SE $linha  FOR MAIOR QUE ${LIMITE[0]} ENTÃO VARIÁVEL linha É ${LIMITE[0]}
    #
    # E onde o mapa termina:
    SE $coluna FOR MENOR QUE          1   ENTÃO VARIÁVEL coluna É 1
    SE $coluna FOR MAIOR QUE ${LIMITE[1]} ENTÃO VARIÁVEL coluna É ${LIMITE[1]}

    POSICAO=(${linha} ${coluna})

    function OBSTACULO_ENCONTRADO() {
        VARIÁVEL MENSAGEM É "Obstáculo encontrado. Não posso ir além. \a"
        POSICAO=(${RASTRO[0]} ${RASTRO[1]}) # Voltando para posição anterior.
    }

    SE $(POSICAO ${POSICAO[0]} ${POSICAO[1]}) FOR IGUAL "▓" ENTÃO OBSTACULO_ENCONTRADO

    MARCA "·"  EM ${RASTRO[0]}  ${RASTRO[1]}
    MARCA "@" EM ${POSICAO[0]} ${POSICAO[1]} # 🚗
}

DIRIGIR