Ping a varios hosts.

d
Visto en The Linux Tips
#!/bin/bash
for i in 192.168.0.{1..10}
do
   ping -c 1 -t 1 "$i" >/dev/null 2>&1 &&
   echo "Ping Status of $i : Success" ||
   echo "Ping Status of $i : Failed"
done
Leer más...

Controlar la cantidad de peticiones de una IP hacia el puerto 80

d
Visto en soyadmin
#!/bin/sh
# Comando que realiza el reastreo
nroconn=`netstat -nap |grep “:80″ | awk ‘{print $5}’ | cut -d: -f1 | sort | uniq -c | sort -n | awk ‘{print $1}’ | tail -1`

# Comando que nos devolverá la ip
ip=`netstat -nap |grep “:80″ | awk ‘{print $5}’ | cut -d: -f1 | sort | uniq -c | sort -n | awk ‘{print $2}’ | tail -1`

# Limite a superar para informar, esto se puede variar según las necesidades de cada server
limite=100
if [ $nroconn -gt $limite ]; then
mensaje=”Atencion! la IP $ip tiene $nroconn conexiones activas”

# Realizamos el whois sobre la IP
infor=`whois $ip | grep country`
whois=`whois $ip`

# Generamos el correo
mailto=”"
cc_to=”"
bcc_to=”"
while read direccion mode
do
if [ -z "$direccion" -o "${direccion:0:1}" = "#" ] ; then continue; fi
if [ "x$mode" = "xcc" -o "x$mode" = "xCC" ] ; then
cc_to=${cc_to:+${cc_to},}$direccion
else
if [ "x$mode" = "xbcc" -o "x$mode" = "xBCC" ] ; then
bcc_to=${bcc_to:+${bcc_to},}$direccion
else
mailto=${mailto:+${mailto},}$direccion
fi
fi

# Llamamos al archivo donde guardamos las direcciones de correo
done <~/emails
mailto=${mailto:-operator}
cc_to=${cc_to:+"-c $cc_to"}
bcc_to=${bcc_to:+"-b $bcc_to"}
mail ${cc_to} ${bcc_to} -s "Alerta OJO Muchas conexiones SERVER: (nombre de servidor)" ${mailto} >&2 <<-EOM
$mensaje
Dicha IP es de: $infor
WHOIS de $ip
$whois
EOM
fi
Leer más...

controla-ancho-de-banda.sh

d
Nombre: controla-ancho-de-banda.sh
Autor: Joaquín E. Naiviat [ joaquinaiviat@yahoo.com.ar ]
Visto en Desde Linux
#    controla-ancho-de-banda.sh
#
#    Copyright 2013 Joaquín E. Naiviat 
#       
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 3 of the License, or
#    (at your option) any later version.
#       
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#       
#    You should have received a copy of the GNU General Public License
#    along with limita_transmission.sh. If not, see .
#
#
# NOMBRE: controla-ancho-de-banda.sh
#
# DESCRIPCIÓN: Controla las velocidades de carga y descarga del programa
# «Transmission» según el consumo de ancho de banda del programa «Firefox».
#
# REQUIERE: los siguientes programas son necesarios para el correcto
# funcionamiento: Transmission, Firefox, Nethogs, awk.
#
# CONSIDERACIONES:Se requiere su ejecución como root para poder iniciar «Nethogs».
#
#
#
#!/bin/bash
 
#Valores por defecto de carga y descarga de transmission-remote
Lim_U=50
Lim_D=75
 
cd /tmp
 
LimitaSubida50(){
        #Evita usar demasiado el comando transmission-remote
        if [ "$Lim_U" -eq "5" ]; then
                su joaquin -c "transmission-remote -u 50"
                Lim_U=50
        fi
}
LimitaSubida5(){
        if [ "$Lim_U" -ne "5" ]; then
                su joaquin -c "transmission-remote -u 5"
                Lim_U=5
        fi
}
LimitaBajadada75(){
        #Evita usar demasiado el comando transmission-remote
        if [ "$Lim_D" -eq "5" ]; then
                su joaquin -c "transmission-remote -d 75"
                Lim_D=75
        fi
}
LimitaBajadada5(){
        if [ "$Lim_D" -ne "5" ]; then
                su joaquin -c "transmission-remote -d 5"
                Lim_D=5
        fi
}
 
Apagar=0
 
DetenerScript(){
# Termina el Script con estado 130 (SIGINT) correctamente
       
        Apagar=1
       
        #Detiene nethogs si está en ejecución
        VERIF_NETHOGS=` ps ax | grep -v grep| grep "nethogs -t"`
        if [ "$?" -eq "0" ]; then
                killall nethogs
        fi
       
        #Borra /tmp/net.lista
        if [ -f /tmp/net.lista ]; then
                rm /tmp/net.lista
        fi
       
        #Restaura valores predeterminados de carga y descarga de transmission-remote
        LimitaSubida50
        LimitaBajadada75
       
        exit 130
}
 
trap DetenerScript INT TERM
 
 
while true;
do
        if [ "$Apagar" -eq "0" ]; then
       
                #Comprueba si transmission está en ejecución antes de iniciar.
                EJEC_TRANSMSSION=`ps -A | grep transmission`
                if [ "$?" -eq "0" ]; then
                       
                        #Inicia torrents si están pausados
                        VERIF_TRANSMISSION=`transmission-remote -tall -i | grep Stopped`
                        if [ "$?" -eq "0" ]; then
                                su joaquin -c "transmission-remote -tall -s"
                        fi
               
                        #Comprueba si firefox está en ejecución antes de iniciar Nethogs.
                        EJEC_FIREFOX=`ps -A | grep firefox`
                        if [ "$?" -eq "0" ]; then
                                #Guarda la salida de nethogs a un archivo «net.lista»
                                nethogs -t > net.lista &
                                sleep 2
                                killall nethogs 
                                       
                                #Lee net.lista y filtra los KB/s enviados y recibidos
                                #KB/s ENVIADOS: $2 RECIBIDOS $3  
                                KB_ENV=`grep firefox net.lista | awk '{print $2}' | awk -F"." '{print $1}'`
                                KB_REC=`grep firefox net.lista | awk '{print $3}' | awk -F"." '{print $1}'`          
 
                                #Controla ancho de banda de transmission según el uso de firefox                                               
                                #Verifica que "$KB_ENV" o "$KB_REC" no den como resultado nada,
                                #para evitar mensajes de error en -gt
                                if [ "$KB_ENV" != "" ]; then
                                        if [ "$KB_ENV" -gt "0" ]; then
                                                LimitaSubida5
                                        else                       
                                                LimitaSubida50
                                        fi     
                                                               
                                else
                                                LimitaSubida50
                                fi
                                                       
                                if [ "$KB_REC" != "" ]; then
                                        if [ "$KB_REC" -gt "3" ]; then
                                                LimitaBajadada5
                                        else
                                                LimitaBajadada75
                                        fi
                                else
                                                LimitaBajadada75
                                fi
                               
                                sleep 5
                        else
                                #Si Firefox está detenido, restaura valores y espera
                                LimitaSubida50
                                LimitaBajadada75
                                sleep 8
                        fi     
                else
                                #Si Transmission está detenido espera
                                sleep 20
                fi
        else
                #Sale del bucle al recibir la señal Apagar=1
                break
        fi     
                       
        done
 
exit 0
Leer más...

ansiweather

d
Nombre: ansiweather
Autor: Frederic Cambus
Más información del script en fcambus
#!/usr/bin/env bash

###############################################################################
#                                                                             #
# AnsiWeather 1.00 (c) by Frederic Cambus 2013                                #
# https://github.com/fcambus/ansiweather                                      #
#                                                                             #
# Created: 2013/08/29                                                         #
# Last Updated: 2013/10/19                                                    #
#                                                                             #
# AnsiWeather is released under the BSD 3-Clause license.                     #
# See LICENSE file for details.                                               #
#                                                                             #
###############################################################################



###[ Configuration options ]###################################################

config_file=~/.ansiweatherrc

function get_config {
        ret=""
        if [ -f $config_file ]
        then
                ret=$(grep $1 $config_file | awk -F\: '{print $2}')
        fi

        if [ "X$ret" = "X" ]
        then
                return 1
        else
                echo $ret
        fi
}

# Location : example "Moscow,RU"
if [ ! -z "$1" ]
then
        location=$1;
else
        location=$(get_config "location" || echo "Moscow,RU")
fi

# System of Units : "metric" or "imperial"
if [ ! -z "$2" ]
then
        units=$2
else
        units=$(get_config "units" || echo "metric")
fi

# Display symbols : "true" or "false" (requires an Unicode capable display)
symbols=$(get_config "symbols" || echo true)


#### [ Colors and characters ]#################################################

background=$(get_config "background" || echo "\033[44m")
text=$(get_config "text" || echo "\033[36;1m")
data=$(get_config "data" || echo "\033[33;1m")
delimiter=$(get_config "delimiter" || echo "\033[35m=>")
dashes=$(get_config "dashes" || echo "\033[34m-")



###[ Unicode Symbols for icons ]###############################################

sun=$(get_config "sun" || echo "\033[33;1m\xe2\x98\x80")
moon=$(get_config "moon" || echo "\033[36m\xe2\x98\xbd")
clouds=$(get_config "clouds" || echo "\033[37;1m\xe2\x98\x81")
rain=$(get_config "rain" || echo "\xe2\x98\x94")
fog=$(get_config "fog" || echo "\xe2\x96\x92")



###[ Fetch Weather data ]######################################################

fetch_cmd=$(get_config "fetch_cmd" || echo "curl -s")

weather=$($fetch_cmd "http://api.openweathermap.org/data/2.5/weather?q=$location\&units=$units")



###[ Process Weather data ]####################################################

city=$(echo $weather | jq -r '.name')
temperature=$(printf '%.0f' $(echo $weather | jq '.main.temp'))
humidity=$(echo $weather | jq '.main.humidity')
pressure=$(echo $weather | jq '.main.pressure')
sky=$(echo $weather | jq -r '.weather[0].main')
sunrise=$(echo $weather | jq '.sys.sunrise')
sunset=$(echo $weather | jq '.sys.sunset')
wind=$(echo $weather | jq '.wind.speed')



###[ Set the period ]##########################################################

now=$(date +%s)

if [ $now -ge $sunset ] || [ $now -le $sunrise ]
then
        period="night"
else
        period="day"
fi



###[ Set the scale ]###########################################################

case $units in
        metric)
                scale="°C"
                speed_unit="m/s"
                pressureUnit="hPa"
                pressure=$(printf '%.0f' $pressure)
                ;;
        imperial)
                scale="°F"
                speed_unit="mph"
                pressureUnit="inHg"
                pressure=$(printf '%.2f' $(echo "$pressure*0.0295" | bc))
                ;;
esac



###[ Set icons ]###############################################################

if [ $symbols = true ]
then
        case $sky in
                Clear)
                        if [ $period = "night" ]
                        then
                                icon="$moon "
                        else
                                icon="$sun  "
                        fi
                        ;;
                Clouds)
                        icon="$clouds  "
                        ;;
                Rain)
                        icon="$rain  "
                        ;;
                Fog)
                        icon="$fog  "
                        ;;
        esac
fi



###[ Display current Weather ]#################################################

echo -e "$background$text Current weather in $city $delimiter$data $temperature $scale $icon$dashes$text Humidity $delimiter$data $humidity % $dashes$text Wind $delimiter$data $wind $speed_unit $dashes$text Pressure $delimiter$data $pressure $pressureUnit \033[0m"

Leer más...

Script para Backup de directorio de correos

d
Visto y más información en Garabatos Linux
#!/bin/bash
HOSTNAME=`hostname`
FECHA=`date +%d%m%Y`
# Lista los Buzones Actuales en Carpeta #
LOG=/home/listado.log
echo "A continuacion se muestra el Listado de Buzones que fueron respaldados. " >>/home/listado.log
echo "Tamaño total del directorio: `du -sh /home/vmail/dominio.com.sv/ `" >> /home/listado.log
cd /home/vmail/dominio.com.sv/
du -sxh * | sort -n >> /home/listado.log
#Titulo del Correo#
SUBJECT="Respaldo de Postfix $HOSTNAME $FECHA"
# Empaquetado#
tar -jcvf /home/BuzonesPostfix/respaldo_correos_$(date +"%d-%m-%Y_%H%M").tar.bz2 /home/vmail/dominio.com.sv/*
#Direcciones de Correo #
EMAIL1="correo1@dominio.com.sv"
EMAIL2="correo2@dominio.com.sv"
## Envio de Correo para Confirmar el Backup ##############
echo "BACKUP DE: " | mail -s "$SUBJECT" "$EMAIL1" -c "$EMAIL2" <$LOG
# Eliminado de Log #
rm /home/listado.log
Leer más...

Iptables Script

d
Visto en The Lone Pole
#!/bin/bash
if [ -z $1 ]; then
        echo "Usage: $0  [reason]";
        exit;
fi

IP=$1
REASON="denied ip"

if [ $# -gt 1 ]; then
        shift;
        REASON=$@
fi

iptables -A INPUT -s ${IP}/32 -j LOG --log-prefix "${REASON} "
iptables -A INPUT -s ${IP}/32 -j DROP

Leer más...

Mario.sh

d
Nombre: Mario.sh
Autores: Doriedson Alves Galdino de Oliveira,Thiago Andre Silva,Vitor Augusto Andrioli
Visto en Mario Bros. Video
#!/bin/bash -i

##################################################################################
#                                                                                #
#    Copyright (C) 2012 Doriedson Alves Galdino de Oliveira                      #
#                       Thiago Andre Silva                                       #
#                       Vitor Augusto Andrioli                                   #
#                                                                                #
#    This program is free software: you can redistribute it and/or modify        #
#    it under the terms of the GNU General Public License as published by        #
#    the Free Software Foundation, either version 3 of the License, or           #
#    (at your option) any later version.                                         #
#                                                                                #
#    This program is distributed in the hope that it will be useful,             #
#    but WITHOUT ANY WARRANTY; without even the implied warranty of              #
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
#    GNU General Public License for more details.                                #
#                                                                                #
#    You should have received a copy of the GNU General Public License           #
#    along with this program.  If not, see .       #
#                                                                                #
##################################################################################

# Autores:
# Doriedson RA 1430431213050
# Thiago Andre RA 1430431213077
# Vitor Augusto RA 1430431213047
# Data: 24/04/2012

# DESCRICAO:
# Jogo do Mario Bros estilo nintendo 8 bits.

# CHANGELOG:

# 2012/05/09 (Doriedson, Vitor, Thiago)
# Eliminada a funcao LoadGame que carregava o mapa da primeira fase em caracters e criada a LoadFase1 para gerar a primeira fase 
# a partir de mapa de caracters menores. 
# Criada funcao MontaCanvas para pegar o tamanho da tela em um mapa de caracters e jogar no buffer

# 2012/05/15 (Doriedson, Vitor, Thiago)
# Adicionada Funcao Splash para mostrar as vidas do personagem e definir abertura de tela
# Adicionada Funcao ColisaoBuraco para relizar colisão com os buracos do cenario
# Adicionada Funcao Dead para relizar animação da morte do personagem
# Adicionada Funcao Play para centralizar as rotinas de execução de audio

# 2012/05/22 (Doriedson, Vitor, Thiago)
# Adicionada Funcao ColisaoBloco
# Adicionada Funcao ColisaoCoin

# 2012/05/29 (Doriedson, Vitor, Thiago)
# Adicionado Inimigo na fase
# Adicionada Funcao ResizeScreen para ajustar o jogo no terminal caso o terminal seja redimensionado
# Alteradas algumas variaveis, inclusive a do jogador, para vetor, para melhorar o calculo de colisao e possivel adicao de cor nos itens da tela como o personagem e as moedas.

# 2012/06/05 (Doriedson, Vitor, Thiago)
# Corrigido bug na funcao LoadFase1 (toda vez que o personagem morre a funcao eh chamada e os vetores fasel[37] [38] e [39] eram incrementados,
# nunca sendo zerados)
# Removido tput clear na funcao resizeScreen para evitar scrolling no terminal e adicionado string com espaços
# Adicionada tela de gameover
# Adicionada funcao para incrementar score e salvar topscore
# Criada funcao MontaMenu, quando mudava o tamanho do terminal não redesenhava e estourava o grafico
# Alterada funcao FPS para controle de uma unica unidade do tempo
# Ajustado movimento do personagem para ficar com mais suavidade
# Retirado desenho das moedas no buffer da fase e criada funcao DrawCoin para desenhar no buffer da tela e realizar animacao
# Criada variavel _edgeScreen para permitir renderizar desenhos que ficam com parte visivel na camera e parte nao visivel
# Corrigido problema de colisao com o inimigo que era avaliado soh o primeiro pois saia da funcao com return e nao avaliava os outros
# Usado -i na frente do /bash/bin inicialamente para importar variaveis como LINES e COLUMNS para nao realizar processos com tput ...
# ...mas foi verificado que é mais lento  do que o comando tput entao permanene pelo motivo de suprir a mensagem de retorno de erro ...
# ...quando a musica de background é morta pelo kill.

# [ FUNCOES ] --------------------------------------------------------------------------------------------------------

_version="1.0" #20120618

# Funcao para pegar tamanho do terminal
function TerminalSize {

 # Cria variavel com altura do terminal em linhas
 local _tmph=`tput lines`

 # Cria variavel com largura do terminal em colunas
 local _tmpw=`tput cols`

 # Verifica se houve mudança no tamando do terminal
 if [ $_tmph -ne $_height ] || [ $_tmpw -ne $_width ]; then

  _height=$_tmph
  _width=$_tmpw

  ResizeScreen

 fi

}

# Funcao para redimensionamento do terminal
function ResizeScreen {

 # Inicializa variavel para definir o meio da tela em largura para economizar recalculo no jogo
 _widthMid=$((_width / 2))

 # Cria variavel para determinar onde começara o desenho da tela subtraindo a altura de desenho do jogo (36 linhas)
 _initY=$((_height - _heightScreen))

 #Cria variaveis para verificar se o terminal eh maior que 80 colunas e centraliza a tela do menu no meio com espaços em volta
 _spaceIni=""
 _spaceFim=""

 if [ $_width -gt 80 ]; then

  _i=$(( (( _width - 80 )) / 2 ))
  _f=$(( (( _width - 80 )) - _i ))
  _spaceIni=`printf "%${_i}s"`
  _spaceFim=`printf "%${_f}s"`
 fi
 
 ((_s= _width*_height))

 _clearScreen=`printf "%${_s}s"`

 # Cria uma variavel com espaços da largura da tela
 _spaceScreen=`printf "%${_width}s"`

 # limpa o topo da tela onde não será usado na screen do jogo
# _screen=""
# for (( _k=0; _k<(_height-_heightScreen); _k++ )); do
  _screen+="$_spaceScreen"
# done

 tput reset
 tput civis
 
 # Configura a cor do fundo da tela
 #tput setab 7

 # Configura a cor da fonte
 #tput setaf 0

 ClearScreen

 _scoreX=$((((_width-80))/2)) # Guarda a Posição do Score na tela de acordo o tamanho do terminal aberto

}

# Função para limpar a tela
function ClearScreen {

 tput cup 0 0
 
 if [ $_color = "on" ]; then
  echo -ne "${_cor[1]}$_clearScreen"
 else
  echo -ne "\E[00;30;47m$_clearScreen"
 fi

 tput cup $_initY 0 # Seta o ponteiro para a linha em que o jogo será desenhado (renderizado)

}

# Função para montar a primeira fase do jogo
function LoadFase1 {
 
 _sizeFase=3000 # Tamanho da fase (largura)
 _btela=`printf "%${_sizeFase}s"` # Variavel com caracter espaço do tamanho da fase para montar o buffer da tela

 _tamQuad=100

 _flagDraw[4]="█          ███" 

 _flagX=2883
 _flagY=6

 # Vetor de localização dos inimigos definindo sua area de movimento
 _enemyX=(0 200 350 500 650 900 1490 1750 2030 2450 2780) 
 _enemyPathIni=(0 150 320 460 610 880 1480 1710 2000 2330 2700)
 _enemyPathFim=(0 250 420 560 710 980 1580 1810 2100 2480 2800)

 # Posicao das moedas no cenario
 _coin=(0 80 190 210 330 350 370 390 410 430 660 800 830 860 890 1010 1080 1150 1240 1260 1280 1370 1390 1410 1480 1500 1520 1540 1590 1650 1720 1810 1830 1850 1870 1890 2260 2290 2320 2350 2410 2540 2570 2600 2630)

 # Posicao dos blocos no cenario
 _bloco=(0 105 135 165 495 525 555 630 690 975 1035 1110 1305 1320 1335 1560 1620 1680 1785 1920 2010 2040 2070 2100 2130 2160 2385 2670 2760 2790)

 # Posicao das nuvens no cenario
 _nuvem=(0 30 220 290 450 580 750 930 1180 1430 1740 1950 2180 2450 2720 2830 2965)

 # Posição dos buracos na fase
 _buraco=(0 280 580 850 1420 1830 2300 2500)

 # Vetor para guardar a posição das monts na tela
 _mont=(0 35 150 210 390 520 740 810 960 1050 1180 1250 1360 1570 1780 1900 2060 2120 2350 2420 2580 2790) 

 _nuvem[0]=${#_nuvem[*]} # Define a quantidade de nuvens no cenario
 _nuvemY=(0) # Posicao em Y da nuvem no cenario
 _nuvemHeight=$_nuvem[0] # Altura da nuvem no cenario

 for (( _k=1; _k<_nuvem[0]; _k++ )); do
  _nuvemY[$_k]=2
 done

 _enemyX[0]=${#_enemyX[*]} # Define a constante da quantidade de (indices no vetor dos) inimigos
 _enemyWidth=16 # Largura do inimigo
 _enemyHeight=(0) # Altura do inimigo eh definido no indice[0] do sprite atual
 _enemyY=(0) # Posição do inimigo no eixo de y definido pelo piso e altura
 _enemyVelocX=(1) # Velocidade do inimigo
 _enemySprite=(0) # Define qual sprite do inimigo sera desenhado
 _enemyDead=(0) # vetor para definir inimigos vivos
 _aniEnemy=(0) # Define sprite de animacao do inimigo

 # Preenche o vetor com a posicao do quadrante dos inimigos
 for ((_k=1; _k<_enemyX[0]; _k++)); do

  _enemyVelocX[$_k]=${_enemyVelocX[0]}
  _enemySprite[$_k]=${_enemySprite[0]}
  _aniEnemy[$_k]=0
  _enemyDead[$_k]=0

 done

 _coin[0]=${#_coin[*]} # Define a constante da quantidade de moedas
 _coinWidth=10 # Largura da moeda
 _coinHeight=5 # Altura da moeda
 _coinY=(9) #posicao da moeda em y
 _coinQ=(0) #vetor para definir o quadrante das moedas
 _coinSprite=(0) #define sprite de animacao das moedas

 #Cria um vetor para o quadrante para checar as colisoes com as moedas
 for ((_k=1; _k<_coin[0]; _k++)); do

  _tmp=$((_coin[_k] / _coinWidth))
  _coinY[$_k]=${_coinY[0]}
  _coinQ[$_tmp]=$_k
  _coinSprite[$_k]=${_coinSprite[0]}

 done


 _blocoWidth=15 #largura do bloco
 _blocoY=8 #posicao do bloco em y
 _blocoHeight=7 #altura do bloco
 _blocoQ=(0) #vetor para definir o quadrante
 _bloco[0]=${#_bloco[*]}

 for ((_k=1; _k<_bloco[0]; _k++)); do

  _tmp=$((_bloco[_k] / _blocoWidth))
  _blocoQ[$_tmp]=$_k

 done

 _montWidth=30 #largura da montanha
 _mont[0]=${#_mont[*]}

 _buraco[0]=${#_buraco[*]}
 _buracoWidth=25

 #buffer da tela
 for (( _k=0; _k<=36; _k++ )); do 
  _fasel[$_k]="$_btela"
 done
 
 #monta o piso da fase no buffer
 _tmp=$((_sizeFase / 10))

 _fasel[37]=""
 _fasel[38]=""
 _fasel[39]=""

 #Coloca o piso na fase
 for (( _k=0; _k<_tmp; _k++ )); do

  _fasel[37]+="${_piso1}"
  _fasel[38]+="${_piso2}"
  _fasel[39]+="${_piso1}"

 done

 #desenha as nuvens no cenario
 for (( _k=1; _k<_nuvem[0]; _k++ )); do
  
  _tmpPos=${_nuvem[$_k]}

  _ind=${_nuvemY[$_k]}

  for (( _l=_ind; _l<(_ind + _nuvemDraw[0]); _l++ )); do

   _tmp0=$(( _l - _ind + 1))   
   _tmp1=${#_nuvemDraw[$_tmp0]}

   _f=$(( _tmpPos + _tmp1  ))

   _fasel[$_l]="${_fasel[$_l]:0:$_tmpPos}${_nuvemDraw[$_tmp0]}${_fasel[$_l]:$_f}"
  done
 done

 #desenha os buracos na fase
# for (( _k=1; _k<_buraco[0]; _k++ )); do
#  
#  _tmpPos=${_buraco[$_k]}
#
#  _f=$(( _tmpPos + 24 ))
#
#  _fasel[37]="${_fasel[37]:0:$_tmpPos}${_buracoDraw}${_fasel[37]:$_f}"
#  _fasel[38]="${_fasel[38]:0:$_tmpPos}${_buracoDraw}${_fasel[38]:$_f}"
#  _fasel[39]="${_fasel[39]:0:$_tmpPos}${_buracoDraw}${_fasel[39]:$_f}"
# done

 #desenha as montanhas no buffer da fase
 for (( _k=1; _k<_mont[0]; _k++ )); do

  _montX=${_mont[$_k]}
  _tmp2=$(( _montX + _montWidth ))
  for (( _l=1; _l<=7; _l++ )); do
   _tmp=$((_l + 29 ))
   _fasel[$_tmp]="${_fasel[$_tmp]:0:$_montX}${_montDraw[$_l]}${_fasel[$_tmp]:$_tmp2}"
  done
 done

 #desenha os blocos na fase
 for (( _k=1; _k<_bloco[0]; _k++ )); do

  _blocoX=${_bloco[$_k]}
  _tmp2=$(( _blocoX + _blocoWidth ))

  _fasel[$((_blocoY))]="${_fasel[$((_blocoY))]:0:$_blocoX}${_blocoDraw[0]}${_fasel[$((_blocoY))]:$_tmp2}"
  _fasel[$((_blocoY+1))]="${_fasel[$((_blocoY+1))]:0:$_blocoX}${_blocoDraw[1]}${_fasel[$((_blocoY+1))]:$_tmp2}"
  _fasel[$((_blocoY+2))]="${_fasel[$((_blocoY+2))]:0:$_blocoX}${_blocoDraw[1]}${_fasel[$((_blocoY+2))]:$_tmp2}"
  _fasel[$((_blocoY+3))]="${_fasel[$((_blocoY+3))]:0:$_blocoX}${_blocoDraw[1]}${_fasel[$((_blocoY+3))]:$_tmp2}"
  _fasel[$((_blocoY+4))]="${_fasel[$((_blocoY+4))]:0:$_blocoX}${_blocoDraw[1]}${_fasel[$((_blocoY+4))]:$_tmp2}"
  _fasel[$((_blocoY+5))]="${_fasel[$((_blocoY+5))]:0:$_blocoX}${_blocoDraw[1]}${_fasel[$((_blocoY+5))]:$_tmp2}"
  _fasel[$((_blocoY+6))]="${_fasel[$((_blocoY+6))]:0:$_blocoX}${_blocoDraw[0]}${_fasel[$((_blocoY+6))]:$_tmp2}"
 done

 #desenha moedas na fase
# for (( _k=1; _k<_coin[0]; _k++ )); do

#  _coinX=${_coin[$_k]}
#  _tmp2=$(( _coinX + _coinWidth ))
#  for (( _l=1; _l<=5; _l++ )); do
#   _tmp=$((_l+8))
#   _fasel[$_tmp]="${_fasel[$_tmp]:0:$_coinX}${_coinDraw[$_l]}${_fasel[$_tmp]:$_tmp2}"
#  done
# done

 #desenha o castelo na fase
 for (( _k=1; _k<=_castle[0]; _k++ )); do

  ((_tmp = _k + 5))
  _tmpL=${#_castle[$_k]}
  _tmpI=$((_sizeFase-120))
  _tmpF=$((_tmpI + _tmpL))

  _fasel[$_tmp]="${_fasel[$_tmp]:0:$_tmpI}${_castle[$_k]}${_fasel[$_tmp]:$_tmpF}"
 done

}

# funcao para desenhar os buracos na fase
function DrawBuraco {

 _ubound=${_buraco[0]}

 for (( _k=1; _k < _ubound; _k++ )); do #laco para verificar cada inimigo

  #verifica se o buraco esta visivel na camera
  if [ $((_buraco[_k] + _buracoWidth)) -ge $_cameraX ] && [ ${_buraco[$_k]} -le $((_cameraX + _width)) ]; then 

   _buracoX=$(( _buraco[_k] + _edgeWidth - _cameraX ))
   _buracoL=$(( _buracoX + _buracoWidth ))

   _tmp=${_canvasC[0]}

   for (( _l=37; _l<40; _l++ )); do
    _canvas[$_l]="${_canvas[$_l]:0:$((_buracoX-2))}${_buracoDraw}${_canvas[$_l]:$((_buracoL+2))}"

    if [ $_color = "on" ]; then
     _tmp=${_canvasC[0]}
     ((_tmp++))
     _canvasC[$_tmp]=${_cor[2]}
     if [ $((_buracoX - _edgeWidth)) -lt 0 ]; then
      _canvasP[$_tmp]=$((_width * _l))
     else
      _canvasP[$_tmp]=$(( (_width * _l) + _buracoX - _edgeWidth ))
     fi
     ((_tmp++))
     _canvasC[$_tmp]=${_cor[3]}
     if [ $((_buracoL - _edgeWidth)) -gt $_width ]; then
      _canvasP[$_tmp]=$(( _width * (_l+1) ))
     else
      _canvasP[$_tmp]=$(( (_width * _l) + _buracoL - _edgeWidth ))
     fi

     _canvasC[0]=$_tmp

    fi

   done


  fi
 done

}

# Funcao para montar o buffer de fundo da tela a partir da cordenada do jogador
function MontaCanvas {

 #Limpa o buffer para posicionar a camera na tela da primeira fase
 #_canvas=""

 #verifica se a posicao do jogador é menor do que o meio do terminal
 if [ $_jogX -lt $_widthMid ]; then

  _cameraX=0 #zera a posicao da camera

 else 
  if [ $_jogX -ge $((_sizeFase - _widthMid)) ]; then #se posicao do jogador passou do meio do terminal

   _cameraX=$((_sizeFase - _width)) #fixa a camera no final da fase

  else

   _cameraX=$((_jogX - _widthMid)) #fixa o jogador no meio da camera
  fi
 fi

 #gera o buffer da tela de acordo com a posicao da camera
  for (( _k=0; _k<_heightScreen; _k++ )); do

  _f=$(( _cameraX + _width -1))

  _canvas[$_k]="${_edgeScreen}${_fasel[$_k]:$_cameraX:$_width}${_edgeScreen}"

 done


}

#Sair do jogo para o terminal
function Sair {

 #Restaura configurações do terminal
 stty $_terminal
 
 #Retorna o ponteiro que pisca na tela
 tput cnorm

 #Volta as cores ao normal
 tput sgr0

 #Limpa a tela
 tput reset

 #Restaura o terminal ao seu padrao 
 #stty sane
 
 # Verifica se ocorreu algum erro e imprime na tela do terminal
 if [ "$_erro" != "" ]; then
  echo -e $_erro
 fi
 
 # termina o programa 
 exit
}

#inicializa as variaveis para comecar o jogo
function InitGame {

 _score=0 #zera o score atual

# _coins=0 #Zera as moedas pega em jogo anterior

 _jogLife=3 #variavel com valor inicial de vidas para o jogo

 Splash #Função para exibir as vidas do jogador
 
}

# funcao para somar score e salvar top score
function Score {

 ((_score+=$1))

 if [ $_score -ge $_topScore ]; then
  _topScore=$_score
  SaveSettings
 fi 

}

#função para salvar configurações quando ocorrer mudanças
function SaveSettings {

 echo "_topScore=$_topScore">.settings
 echo "_sound=$_sound">>.settings
 echo "_color=$_color">>.settings

}
#Função para exibir as vidas do jogador
function Splash {

 #Seta o nome da tela atual(estado do jogo)
 _screenGame="SPLASH"

 LoadColors

 #Registra Coordenadas iniciais do jogador
 _jogX=0
 _jogY=0
 _velocY=0
 _velocX=0

 _jogDead=false #Controla se o jogador morreu

 # guarda qual sprite do personagem sera exibido
 _jogAni=0 #controla a animacao de sprite para dar sensacao mais real do andar
 _jogSprite=0

 #lado do jogador (Sprite) d=direito e=esquerdo
 _jogSide="D"

 #Preenche o buffer com a tela do Splash
 for (( _y=0; _y<12; _y++ )); do

  _canvas[$_y]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"

 done

 _canvas[12]="${_edgeScreen}${_spaceIni}                              █████                                             ${_spaceFim}${_edgeScreen}"
 _canvas[13]="${_edgeScreen}${_spaceIni}                             █░░░░M███                                          ${_spaceFim}${_edgeScreen}"
 _canvas[14]="${_edgeScreen}${_spaceIni}                            █░░░░░░░░░█                                         ${_spaceFim}${_edgeScreen}"
 _canvas[15]="${_edgeScreen}${_spaceIni}                            ███  █ ███                                          ${_spaceFim}${_edgeScreen}"
 _canvas[16]="${_edgeScreen}${_spaceIni}                           █  ██ █    █       X     0${_jogLife}                          ${_spaceFim}${_edgeScreen}"
 _canvas[17]="${_edgeScreen}${_spaceIni}                           █  ██  █   █                                         ${_spaceFim}${_edgeScreen}"
 _canvas[18]="${_edgeScreen}${_spaceIni}                            ██   █████                                          ${_spaceFim}${_edgeScreen}"
 _canvas[19]="${_edgeScreen}${_spaceIni}                             ██     █                                           ${_spaceFim}${_edgeScreen}"
 _canvas[20]="${_edgeScreen}${_spaceIni}                               █████                                            ${_spaceFim}${_edgeScreen}"

 for (( _y=21; _y<_heightScreen; _y++ )); do

  _canvas[$_y]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"

 done
 
 Render #chama função Render

 LoadFase1 #Carrega a tela da primeira fase para o buffer

 sleep 1 #adormece o script por 1 segundos

 #Toca som de fundo tema 
 Play "background"

 #Seta o nome da tela atual(posicao no jogo)
 _screenGame="GAME"

 _timeIni=$SECONDS #set variavel com tempo de segundo do sistema para controlar tempo no jogo
}

# função para desenha gameover na tela
function GameOver {

 # seta que o jogo na tela de game over
 _screenGame="GAMEOVER"

 LoadColors

 #Preenche o buffer com a tela do Splash
 for (( _y=0; _y<13; _y++ )); do

  _canvas[$_y]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"

 done

 #desenho do gameover

 _canvas[13]="${_edgeScreen}$_spaceIni  ████    ████   ██   ██  ██████           ████   ██  ██  ██████  █████     ██  $_spaceFim${_edgeScreen}" 
 _canvas[14]="${_edgeScreen}$_spaceIni ██      ██  ██  ███ ███  ██              ██  ██  ██  ██  ██      ██  ██    ██  $_spaceFim${_edgeScreen}" 
 _canvas[15]="${_edgeScreen}$_spaceIni ██ ███  ██████  ██ █ ██  ████            ██  ██  ██  ██  ████    █████     ██  $_spaceFim${_edgeScreen}" 
 _canvas[16]="${_edgeScreen}$_spaceIni ██  ██  ██  ██  ██   ██  ██              ██  ██   ████   ██      ██  ██        $_spaceFim${_edgeScreen}"   
 _canvas[17]="${_edgeScreen}$_spaceIni  ████   ██  ██  ██   ██  ██████           ████     ██    ██████  ██  ██    ██  $_spaceFim${_edgeScreen}"  


 for (( _y=18; _y<_heightScreen; _y++ )); do

  _canvas[$_y]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"

 done

 Render #chama função Render

 sleep 4 #adormece o script por segundos

 LoadMenu
}

# função para desenhar a tela de GameWin
function GameWin {

 # seta que o jogo na tela de game over
 _screenGame="GAMEWIN"

 LoadColors

 #Preenche o buffer com a tela do Splash
 for (( _y=0; _y<10; _y++ )); do

  _canvas[$_y]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"

 done

 #desenho do fim do jogo WIN

_canvas[10]="${_edgeScreen}${_spaceIni}      █████    ████   █████    ████   █████   ██████  ██  ██   ████     ██      ${_spaceFim}${_edgeScreen}" 
_canvas[11]="${_edgeScreen}${_spaceIni}      ██  ██  ██  ██  ██  ██  ██  ██  ██  ██  ██      ███ ██  ██        ██      ${_spaceFim}${_edgeScreen}" 
_canvas[12]="${_edgeScreen}${_spaceIni}      █████   ██████  █████   ██████  █████   ████    ██ ███   ████     ██      ${_spaceFim}${_edgeScreen}" 
_canvas[13]="${_edgeScreen}${_spaceIni}      ██      ██  ██  ██  ██  ██  ██  ██  ██  ██      ██  ██      ██            ${_spaceFim}${_edgeScreen}"   
_canvas[14]="${_edgeScreen}${_spaceIni}      ██      ██  ██  ██  ██  ██  ██  █████   ██████  ██  ██   ████     ██      ${_spaceFim}${_edgeScreen}"  
_canvas[15]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[16]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[17]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[18]="${_edgeScreen}${_spaceIni} TRABALHO EM SHELL SCRIPT                                                      ${_spaceFim}${_edgeScreen}"
_canvas[19]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[20]="${_edgeScreen}${_spaceIni} FATEC CARAPICUIBA                                                             ${_spaceFim}${_edgeScreen}"
_canvas[21]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[22]="${_edgeScreen}${_spaceIni} DISCIPLINA LSO (LABORATORIO DE SISTEMAS OPERACIONAIS)                         ${_spaceFim}${_edgeScreen}"
_canvas[23]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[24]="${_edgeScreen}${_spaceIni} PROF. RUBENS                                                                  ${_spaceFim}${_edgeScreen}"
_canvas[25]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[26]="${_edgeScreen}${_spaceIni} ALUNO DORIEDSON ALVES GALDINO DE OLIVEIRA                                     ${_spaceFim}${_edgeScreen}"
_canvas[27]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[28]="${_edgeScreen}${_spaceIni} ALUNO VITOR AUGUSTO ANDRIOLI                                                  ${_spaceFim}${_edgeScreen}"
_canvas[29]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"
_canvas[30]="${_edgeScreen}${_spaceIni} ALUNO THIAGO ANDRE SILVA                                                      ${_spaceFim}${_edgeScreen}"
_canvas[31]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"


 for (( _y=32; _y<_heightScreen; _y++ )); do

  _canvas[$_y]="${_edgeScreen}${_spaceScreen}${_edgeScreen}"

 done

 Render #chama função Render

 sleep 4 #adormece o script por segundos

 read -n1

 LoadMenu
}

#Carrega a tela do menu para o buffer
function LoadMenu {

 if [ $_musicId ]; then
  Stop $_musicId #Mata o processo da musica de fundo
 fi

 #Seta o nome da tela atual(posicao no jogo)
 _screenGame="MENU"

}

#monta tela do menu no canvas
function MontaMenu {

 #Limpa o buffer para preencher com a tela do menu
 #_canvas=""

 #Preenche o buffer com a tela menu
 for (( _y=0; _y<26; _y++ )); do
  
  _canvas[$_y]="${_edgeScreen}${_spaceIni}${_menu[$_y]}${_spaceFim}${_edgeScreen}"

 done

 _tmpi=$((36+12-${#_topScore}))
 _canvas[26]="${_edgeScreen}${_spaceIni}${_menu[26]:0:$_tmpi}${_topScore}${_menu[26]:60}${_spaceFim}${_edgeScreen}"

 for (( _y=27; _y<_heightScreen; _y++ )); do
  
  _canvas[$_y]="${_edgeScreen}${_spaceIni}${_menu[$_y]}${_spaceFim}${_edgeScreen}"

 done

}

function LoadColors {

 if [ $_color = "off" ]; then
  return
 fi

 # vetor para guardar as cores do cenario
 _canvasC=(0) #guarda a cor
 _canvasP=(0) #guarda a posicao da cor

 _tmp=0

 ((_tmp++))
 _canvasC[$_tmp]=${_cor[1]}
 _canvasP[$_tmp]=0

 ((_tmp++))
 _canvasC[$_tmp]=${_cor[2]}
 _canvasP[$_tmp]=$((_width * 2))

 case $_screenGame in

 "MENU")
  _tmp2=${#_spaceIni}
  for ((_k=5; _k<18; _k++)); do
   ((_tmp++))
   _canvasC[$_tmp]=${_cor[0]}
   _canvasP[$_tmp]=$(((_width * _k) + _tmp2 + 15))
   ((_tmp++))
   _canvasC[$_tmp]=${_cor[2]}
   _canvasP[$_tmp]=$(((_width * _k) + _tmp2 + 65))
  done

  ((_tmp++))
  _canvasC[$_tmp]=${_cor[3]}
  _canvasP[$_tmp]=$((_width * 37))
  ;;

 "GAME"|"DEAD"|"WIN"|"WINPOINT") 
  ((_tmp++))
  _canvasC[$_tmp]=${_cor[3]}
  _canvasP[$_tmp]=$((_width * 37))
  ;;

 esac

 _canvasC[0]=$_tmp

}

#Desenha o Jogador no buffer da tela
function DrawJogador {

 #Calcula a posição inicial do desenho do jogador no buffer da tela
 _tmpJogX=$((_jogX - (_cameraX - _edgeWidth)))
 _tmpIni=1

 if [ $((_jogY + _jogHeight -1)) -gt 39 ]; then
  _tmpJogHeight=$(( 40 - _jogY ))
 elif [ $_jogY -lt 0 ]; then
  _tmpJogHeight=$(( _jogHeight + _jogY ))
  _tmpIni=$((-_jogY +1))
 else
  _tmpJogHeight=$_jogHeight
 fi

 #Laço para desenhar o jogador
 for (( _l=_tmpIni; _l<=_tmpJogHeight; _l++ )); do

  #Pega pŕoxima variável(linha) do desenho do jogador
  _tmp="_mario${_jogSide}${_jogSprite}[$_l]"

  #Lê o valor da variável como nome de outro variavel
  _tmp="${!_tmp}"

  #Calcula o tamanho restante da buffer da tela para recorte
  _tmpf=$((_tmpJogX+${#_tmp}))

  #Desenha a linha do personagem no buffer da tela
  #_screen="${_screen:0:$_posIniJog}${_tmp}${_screen:$_resto}"
  _tmpJogY=$(( _jogY+_l-1))  
  _canvas[$_tmpJogY]="${_canvas[$_tmpJogY]:0:$_tmpJogX}${_tmp}${_canvas[$_tmpJogY]:$_tmpf}"

 done
}

#função para desenhar o score no topo do buffer da tela
function DrawScore {

 # Gera novo buffer para tela
 #_screen="$_canvas"
 
 #posicao das linhas temporariamente
 _tmp=0

 #posiciona e imprime o title score
 #_screen="${_screen:0:$_tmp}${_spaceIni}${_scoreTitle0}${_spaceFim}${_screen:$((_tmp + _width))}"
 _canvas[0]="${_edgeScreen}${_spaceIni}${_scoreTitle0}${_spaceFim}${_edgeScreen}"

 _tmpScore=${#_score}
 _tmpScorei=$((11 - _tmpScore))

 _tmpCoin=${#_coins}
 _tmpCoini=$((21 - _tmpCoin))

 _tmpTime=${#_time}
 _tmpTimei=$(( 37 - _tmpTime ))

 ((_tmp+=_width))
 _canvas[1]="${_edgeScreen}${_spaceIni}${_scoreTitle1:0:$_tmpScorei}${_score}${_scoreTitle1:11:${_tmpCoini}}${_coins}${_scoreTitle1:32:$_tmpTimei}${_time}${_scoreTitle1:69}${_spaceFim}${_edgeScreen}"

 # gera o texto que exibe o fps e posiciona na tela
 _texto="[s]sound:$_sound [c]color:$_color LPS:$_lps"

# _i=$((39 * _width))
 _l=${#_texto}

 # posiciona e imprime o texto fps na _screen
 _pos=$((39))
 _canvas[$_pos]="${_edgeScreen}${_texto}${_canvas[$_pos]:$((_l + _edgeWidth))}${_edgeScreen}"

}

#Desenha o buffer no terminal
function Render {
 
 # se jogo esta em andamento chama função para montar o buffer da tela de acordo a posição da camera na fase 
 case $_screenGame in
 
 "GAME"|"DEAD"|"WIN"|"WINPOINT")
  MontaCanvas;;

 "MENU")
  MontaMenu;;

 esac


 case $_screenGame in

  "SPLASH"|"GAMEOVER"|"GAMEWIN")
   DrawScore #desenha o score no topo da tela
   ;;

  "MENU")
   DrawScore #desenha o score no topo da tela
   _temp=0 #variavel nao utilizada para nao deixar o case vazio
   ;;

  "GAME"|"DEAD"|"WIN"|"WINPOINT")
   DrawBuraco #desenha buracos na fase
   DrawScore #desenha o score no topo da tela
   DrawCoin #desenha as moedas se existir
   DrawEnemy #desenha o inimigo se existir
   DrawFlag #desenha a bandeira do mastro
   DrawJogador #Desenha o jogador
   ;;

 esac

 _screen=""

 for (( _k=0; _k<_heightScreen; _k++ )); do
  _canvas[$_k]="${_canvas[$_k]:$_edgeWidth:$_width}"
  _screen+="${_canvas[$_k]}"
 done

 if [ $_color = "on" ]; then

#echo "${_canvasC[*]}"

  BubbleSort

#  QuickSort 1 ${_canvasC[0]}


#  _tmpSize=$(( _width * _height / 10 ))

#  for (( _k=_tmpSize; _k>0; _k-- )); do
#   if [ ! -z ${_canvasP[$_k]} ]; then
    #_screen="${_screen:0:${_canvasP[$_k]}}${_canvasC[$_k]}${_screen:${_canvasP[$_k]}}"
#   fi
#  done

  for (( _k=_canvasC[0]; _k>0; _k-- )); do
   _screen="${_screen:0:${_canvasP[$_k]}}${_canvasC[$_k]}${_screen:${_canvasP[$_k]}}"
  done
 fi

 #Desenha a cena atual do jogo no terminal
 echo -ne "$_screen" 

 tput cup $_initY 0 #Posiciona o ponteiro na tela para desenhar o buffer 

}

function QuickSort {

 local _ini=$1
 local _fim=$2
 local _pivo=${_canvasP[$(( (_ini + _fim ) / 2 ))]}

 while [ $_ini -lt $_fim ]; do

  while [ ${_canvasP[$_ini]} -lt $_pivo ]; do
   ((_ini++))
  done

  while [ ${_canvasP[$_fim]} -gt $_pivo ]; do
   ((_fim--))
  done

  if [ $_ini -le $_fim ]; then
   local _aux=${_canvasP[$_ini]}
   _canvasP[$_ini]=${_canvasP[$_fim]}
   _canvasP[$_fim]=$_aux

   local _aux=${_canvasC[$_ini]}
   _canvasC[$_ini]=${_canvasC[$_fim]}
   _canvasC[$_fim]=$_aux

   ((_ini++))
   ((_fim--))
  fi

  if [ $_fim -gt $1 ]; then
   QuickSort $1 $_fim
  fi

  if [ $_ini -lt $2 ]; then
   QuickSort $_ini $2
  fi
 done

}

#ordena o vetor de cores da menor posicao para maior
function BubbleSort {

 for (( _k=(_canvasC[0]); _k>1; _k-- )); do

  for (( _l=1; _l<_k; _l++ )); do
   
   (( _tmp= _l + 1 ))


   if [ $((_canvasP[$_l])) -gt $((_canvasP[$_tmp])) ]; then

    _tmpV=${_canvasP[$_tmp]} 
    _canvasP[$_tmp]=${_canvasP[$_l]} 
    _canvasP[$_l]=$_tmpV

    _tmpC=${_canvasC[$_tmp]} 
    _canvasC[$_tmp]=${_canvasC[$_l]} 
    _canvasC[$_l]=$_tmpC

   fi

  done

 done

}

# funcao para desenhar as moedas
function DrawCoin {

 ((_tmp1=_cameraX / _coinWidth))
 ((_tmp2=(_cameraX + _width) / _coinWidth))

 for (( _k=_tmp1; _k<=_tmp2; _k++)); do

  _tmpCoin=${_coinQ[$_k]} #pega a posicao do indice do vetor das moedas se existir


  if [ $_k -eq 0 ] || [ -z $_tmpCoin ]; then #verifica se o indíce do quadrante não é zero e se existe moeda no quadrante
   continue
  else

   _coinX=${_coin[$_tmpCoin]} #pega a posicao x da moeda

   if [ $_coinX -gt 0 ]; then #se existir moeda desenha ela

    ((_coinX-=(_cameraX-_edgeWidth)))

    ((_coinSprite[_tmpCoin]++))

    if [ ${_coinSprite[$_tmpCoin]} -eq 6 ]; then
     _coinSprite[$_tmpCoin]=0
    fi

    ((_tmpSp=_coinSprite[_tmpCoin]/2))

    #Laço para desenhar a moeda
    for (( _l=1; _l<=_coinHeight; _l++ )); do

     #Pega pŕoxima variável(linha) do desenho do jogador
     _tmpS="_coinDraw${_tmpSp}[$_l]"

     #Lê o valor da variável como nome de outro variavel
     _tmpS="${!_tmpS}"

     #Calcula o tamanho restante da buffer da tela para recorte
     _tmpf=$((_coinX + _coinWidth))

     #Desenha a linha da coin no buffer da tela
     _tmpCoinY=$(( _coinY[_tmpCoin] + _l -1))  

     _canvas[$_tmpCoinY]="${_canvas[$_tmpCoinY]:0:$_coinX}${_tmpS}${_canvas[$_tmpCoinY]:$_tmpf}"

     if [ $_color = "on" ]; then

      _tmp=${_canvasC[0]}
      ((_tmp++))
      _canvasC[$_tmp]=${_cor[4]}

      if [ $((_coinX - _edgeWidth)) -lt 0 ]; then
       _canvasP[$_tmp]=$((_width * _tmpCoinY))
      else
       _canvasP[$_tmp]=$(( (_width * _tmpCoinY) + _coinX - _edgeWidth ))
      fi

      ((_tmp++))
      _canvasC[$_tmp]=${_cor[2]}
      if [ $((_tmpf - _edgeWidth)) -gt $_width ]; then
       _canvasP[$_tmp]=$(( _width * (_tmpCoinY+1) ))
      else
       _canvasP[$_tmp]=$(( (_width * _tmpCoinY) + _tmpf - _edgeWidth ))
      fi

      _canvasC[0]=$_tmp

     fi

    done

   fi
  fi

 done

}

# funcao para desenhar a bandeira no mastro
function DrawFlag {

 if [ $_flagX -lt $(( _cameraX + _width )) ]; then

  for (( _k=1; _k<=_flagDraw[0]; _k++ )); do

   #Calcula o tamanho restante da buffer da tela para recorte
   _tmpL=${#_flagDraw[$_k]}
   _tmpY=$(( _flagY + _k -1 ))
   _tmpX=$(( _flagX - _cameraX + _edgeWidth ))
   _tmpF=$(( _tmpX + _tmpL ))


   #Desenha a linha do inimigo no buffer da tela
   _canvas[$_tmpY]="${_canvas[$_tmpY]:0:$_tmpX}${_flagDraw[$_k]}${_canvas[$_tmpY]:$_tmpF}"

  done

  
 
 fi

}

#função para desenhar o inimigo se existir
function DrawEnemy {

 _ubound=${_enemyX[0]}

 for (( _k=1; _k < _ubound; _k++ )); do #laco para verificar cada inimigo

  #verifica se o path do inimigo esta visivel na camera
  if [ $((_enemyX[_k] + _enemyWidth)) -ge $_cameraX ] && [ ${_enemyX[$_k]} -le $((_cameraX + _width)) ] && [ ${_enemySprite[$_k]} -le 6 ]; then 

   _tmpY="_gompa${_enemySprite[$_k]}[0]" #Pega o sprite do inimigo
   _tmpY="${!_tmpY}"

   #Calcula a posição inicial do desenho do inimigo no buffer da tela
   _tmpEnemyY=$((_enemyY[_k])) #$((37 - _tmpY))
   _tmpEnemyX=$(( _enemyX[_k] - (_cameraX - _edgeWidth)))

   #Laço para desenhar o inimigo
   for (( _l=1; _l<=_tmpY; _l++ )); do

    _tmpE="_gompa${_enemySprite[$_k]}[$_l]" #Pega o sprite do inimigo
    _tmpE="${!_tmpE}"

    #Calcula o tamanho restante da buffer da tela para recorte
    _tmpL=${#_tmpE}
    _tmpf=$(( _tmpEnemyX + _tmpL ))

    #Desenha a linha do inimigo no buffer da tela
    _canvas[$_tmpEnemyY]="${_canvas[$_tmpEnemyY]:0:$_tmpEnemyX}${_tmpE}${_canvas[$_tmpEnemyY]:$_tmpf}"

    #Muda a posição inicial de plotagem para a próxima linha do inimigo
    ((_tmpEnemyY++))
   done
  fi
 done

}

#Função para ouvir o teclado
function ListenKey {

 # ouve as teclas pressionadas pelo teclado
 _key=$(dd bs=3 count=1 2>/dev/null) 

#read -n1 -t 0.001 _key

 # eliminar os caracters especias de quando as setas direcionais forem pressionadas
# while [ "$_key" = "^" ] || [ "$_key" = "[" ]; do

#  read -n1 -t 0.001 _key
# done

 #Verifica as teclas pressionadas
 case $_key in

 $KEY_ENTER) #tecla ENTER
  case $_screenGame in

  "MENU")
   InitGame;; #Inicia o jogo

  esac
  ;;


 $KEY_ESC) #tecla ESC  
  case $_screenGame in

  "MENU")
   Sair ;; #Termina o programa

  "GAME")
   LoadMenu;; #Carrega a tela de menu

  esac
  ;;
 
 $KEY_UP) #Seta para cima
  case $_screenGame in

  "GAME")
   #_clearBuffer=true
   #Verifica se velocidade de y é = 0 e se o personagem esta no piso entao libera para pulo
   if [ $_velocY -eq 0 ] && [ $((_jogY+_jogHeight)) -eq $((_piso)) ]; then
    Play "jump" #Toca audio do pulo
    #_jogSprite=2 #Sprite do jogador pulando
    ((_velocY=-6)) #Define velocidade do pulo
   fi
   ;;
  esac
  ;;

 $KEY_RIGHT) # Pressionado a seta para direita 
  case $_screenGame in

  "GAME")
   #_clearBuffer=true
   #_jogSide=d #lado do jogador a desenhar
   ((_velocX=4)) #Velocidade do jogador em X
   ;;
  esac
  ;;

 $KEY_LEFT) # Pressionado a seta para esquerda
  case $_screenGame in

  "GAME")
   #_clearBuffer=true
   #_jogSide=e #lado do jogador a desenhar
   ((_velocX=-4)) #velocidade do jogador em X
   ;;
  esac
  ;;

 "s")
  if [ $_sound = "off" ] ; then
   _sound="on"

   if [ $_screenGame = "GAME" ]; then
    Play "background"
   fi
  else
   _sound="off"

   if [  $_musicId ]; then
    Stop $_musicId #para o processo da musica de fundo
   fi
  fi
  SaveSettings
  ;;

 "c")
  if [ $_color = "on" ]; then  
   _color="off"
  else
   _color="on"
  fi
  SaveSettings
  ClearScreen
  ;;

 esac

 
 #Se for capturado alguma tecla antes entao limpa o buffer para caso de segurar a tecla pressionada 
 #if [ $_clearBuffer = true ] ; then
 # read -n100 -t0.001 _discard
 # _clearBuffer=false
 #fi
}

#Função para verificar quantos loops por segundo o jogo está conseguindo rodar
function FPS {
 # incrementa 1 na variável quadros 
 ((_quadros++))

 # Guarda o nanosegundo atual do relógio do sistema 
 _tempo2N=$((10#`date +%N`))
 
 # verifica se passou 1 segundo desde o início da contagem e coloca os quadros contados na
 # variável _fps para exibição posteriormente
# if [ $((SECONDS - _tempoS)) -gt 0 ] ; then


  #Guarda o segundo atual desde quando o terminal foi aberto 
#  _tempoS=$SECONDS


# fi
 
 #Calcula a diferenca entre agora e a ultima leitura em nanosegundo
 _tmp=$((_tempo2N-_tempoN))

 #corrige a diferenca pra positivo se for negativo a cada segundo que se passa
 if [ $_tmp -lt 0 ]; then
  ((_tmp+=1000000000))


  if [ $_quadroRender -gt 5 ]; then  
   #Atualiza a taxa de quadros por segundo
   _lps=$_quadros
   _fps=$_quadroRender

   #Zera o contador de quadros para comecar novamente
   _quadros=0

   _quadroRender=0


  fi

 fi

 #a cada 1 decimo de segundo libera para cálculo de movimento do personagem e cenario
 if [ $_tmp -ge 100000000 ]; then
  ((_quadroRender++))

  _tempoN=$_tempo2N
  _next=true

  TerminalSize

  case $_screenGame in

  "GAME") #opção para reduzir um segundo no relógio de tempo do jogo
 
   _time=$(( _timeGame - (( SECONDS - _timeIni )) ))

   if [ $_time -eq 30 ]; then
    if [ $_quadroRender -eq 5 ]; then
     Play "timewarning"
    fi

   elif [ $_time -eq 27 ]; then
    if [ $_quadroRender -eq 5 ]; then
     Play "background"
    fi

   elif [ $_time -eq 0 ]; then # se tempo acabou o personagem morre
 
    Dead "time"
    _velocY=-5
    _jogSprite=0
    _jogSide="F"

   fi
   ;;
  esac

 fi
}


#Funcao para calcular o movimento do jogador
function Jogador {

 case $_screenGame in

 "WINPOINT")
  if [ $_time -gt 0 ]; then
   Score 10
   ((_time--))
   Play "point"
  else
   GameWin
  fi
  ;;

 "WIN")

  # Controla o movimento na vertical(pulo) e faz colisao com o piso do cenario
  if [ $_velocY -ne 0 ] || [ $((_jogY - 1 + _jogHeight)) -ne $((_piso - 1)) ]; then 

   _jogSprite="2"
   ((_velocY+=_gravidade)) #incremento de velocidade pela gravidade
   ((_jogY+=_velocY)) #incremento de posição vertical do personagem pela velocidade
   ((_flagY=_jogY))
   #verifica se o personagem atravessou o piso
   if [ $((_jogY - 1 + _jogHeight)) -ge $((_piso)) ]; then
    _jogAni=0
    _jogSprite="0"
    ((_jogY=_piso - _jogHeight)) #nao houve colisao entao posiciona o personagem no piso
    _velocY=0 #zera a velocidade de y
    Play "worldcleared"
   fi
  elif [ $_jogX -lt 2927 ]; then
   ((_jogX++))
   #Animacao do Personagem
   ((_jogAni++))

   if [ $_jogAni -eq 2 ]; then
    _jogSprite=0
    _jogAni=0
   else
    _jogSprite=1
   fi
  else
   _jogX=3001
   _screenGame="WINPOINT"
  fi
  ;;

 "GAME"|"DEAD") # se jogo em fase ou personagem morto processa movimento do personagem
  if [ $_jogDead = true ]; then
   ((_velocY+=_gravidade))
   ((_jogY+=_velocY))
   if [ $_jogY -gt 50 ]; then
    if [ $_jogLife -eq 0 ]; then # se acabou as vidas do personagem termina jogo e volta para o menu principal
     sleep 1
     GameOver
    else # se não mostra vidas restante do jogador
     sleep 2
     Splash
    fi
   fi

   return
  fi

  # Controla o movimento na horizontal do personagem e faz colisao com os limites do cenario
  if [ $_velocX -ne 0 ]; then 
   
   if [ $_velocX -gt 0 ]; then
    ((_jogX+=4)) # =_velocX)) #Movimenta o Personagem
   else
    ((_jogX-=4))
   fi
   if [ $_velocX -lt 0 ]; then

    _jogSide="E"

    #Colisao com o comeco e o fim da fase
    if [ $_jogX -lt 0 ]; then
     _jogX=0
    fi
    
    #se personagem toca o piso a velocidade do persogem em x sofre alteração
    if [ $_velocY -eq 0 ]; then
     ((_velocX++))
    fi

   else
    #determina o sprite da posicao que o personagem anda
    _jogSide="D"

    #colisao  com o fim do cenario
    if [ $_jogX -gt $((_sizeFase - _jogWidth)) ]; then
     _jogX=$((_sizeFase - _jogWidth))
    fi

    #se personagem toca o piso a velocidade do persogem em x sofre alteração
    if [ $_velocY -eq 0 ]; then
     ((_velocX--))
    fi


   fi
    
   #Animacao do Personagem
   ((_jogAni++))

   if [ $_jogAni -eq 2 ]; then
    _jogSprite=0
    _jogAni=0
   else
    _jogSprite=1
   fi
  else
   _jogAni=0
   _jogSprite=0
  fi 

  # Controla o movimento na vertical(pulo) e faz colisao com o piso do cenario
  if [ $_velocY -ne 0 ] || [ $((_jogY - 1 + _jogHeight)) -ne $((_piso - 1)) ]; then 

   _jogSprite="2"
   ((_velocY+=_gravidade)) #incremento de velocidade pela gravidade
   ((_jogY+=_velocY)) #incremento de posição vertical do personagem pela velocidade

   #verifica se o personagem atravessou o piso
   if [ $((_jogY - 1 + _jogHeight)) -ge $((_piso)) ]; then
    _jogAni=0
    _jogSprite="0"

    ColisaoBuraco # Verifica se houve colisao com buraco
    if [ $? -eq 0 ]; then
     ((_jogY=_piso - _jogHeight)) #nao houve colisao entao posiciona o personagem no piso
     _velocY=0 #zera a velocidade de y
    fi

   fi
  else
   ColisaoBuraco # Verifica se houve colisao com buraco
 
  fi

 ;;

 esac

 if [ $_screenGame = "GAME" ]; then
  
  #verifica qual sentido o personagem está andando para dar prioridade a colisao do bloco da esquerda ou direita quando colidir com dois
  if [ $_jogSide = "D" ]; then
   _tmp2=$(( _jogX / _blocoWidth ))
   _tmp1=$(( ((_jogX+15)) / _blocoWidth ))
  else
   _tmp1=$(( _jogX / _blocoWidth ))
   _tmp2=$(( ((_jogX+15)) / _blocoWidth ))
  fi

  ColisaoBloco $_tmp1 #verifica se houve colisao com o primeiro quadrante
  if [ $? -eq 0 ]; then #se nao houve
   ColisaoBloco $_tmp2 #verifica se houve colisao com o segundo quadrante
  fi
  
  #verifica colisao com as moedas, como a largura do personagem equivale a 3 moedas por isso 3 testes
  ColisaoCoin $(( _jogX / _coinWidth ))
  ColisaoCoin $(( ((_jogX + 8)) / _coinWidth ))
  ColisaoCoin $(( ((_jogX + 15)) / _coinWidth ))

  ColisaoEnemy
  ColisaoMastro

 fi


}

function ColisaoMastro {

 if [ $((_jogX + _jogWidth)) -gt 2880 ]; then

  _screenGame="WIN"
  Play "flagpole"
  _flagY=$_jogY  
  _velocY=0
  _tmp=$(( ((21 - $_jogY) * 330) + 50 ))

  _tmpL=${#_tmp}
  ((_tmpL+=2))

  _flagDraw[4]="${_flagDraw[4]:0:2}$_tmp${_flagDraw[4]:$_tmpL}"  

  Score $_tmp
  _jogX=$(( 2883 - _jogWidth))
 fi

}

#funcao colisao inimigo
function ColisaoEnemy {

 #_firstQ=$(( _cameraX / _tamQuad )) #pega o primeiro quadrante
 _ubound=${_enemyX[0]}

 for (( _k=1; _k<_ubound; _k++ )); do #laco para verificar cada inimigo

  #verifica se o path do inimigo esta visivel na camera
  if [ ${_enemyPathIni[$_k]} -lt $((_cameraX + _width)) ] && [ ${_enemyPathFim[$_k]} -gt $_cameraX ] && [ ${_enemySprite[$_k]} -lt 3 ]; then 
   if [ $_jogX -gt $((_enemyX[_k] + _enemyWidth -1)) ]; then #personagem esta do lado direito do inimigo
    _tmp=0 

   elif [ $_jogY -gt $((_enemyY[_k] + _enemyHeight[_k] -1)) ]; then #personagem esta do lado de baixo do inimigo
    _tmp=0

   elif [ $((_jogX + _jogWidth -1)) -lt ${_enemyX[$_k]} ]; then #personagem esta do lado esquerdo do inimigo
    _tmp=0

   elif [ $((_jogY + _jogHeight -1)) -lt ${_enemyY[$_k]} ]; then #personagem esta do lado de cima do inimigo
    _tmp=0

   #A partir daqui houve colisao
   #Próximo if verifica se a colisão foi lateral entao o personagem morre
   elif [ $((_jogY + _jogHeight -1 - _velocY)) -lt ${_enemyY[$_k]} ]; then
    Play "enemy"
    Score 100    
    _jogY=$((_enemyY[_k] - _jogHeight)) 
    _velocY=-3
    _enemySprite[$_k]=2
    _enemyDead[$_k]=1
    return 1 #retorna que houve colisao
   else
    Dead "enemy"
    _velocY=-5
    _jogSprite=0
    if [ $_jogSide = "D" ]; then
     ((_jogX=_enemyX[_k] - _jogWidth))
    else
     ((_jogX=_enemyX[_k] + _enemyWidth))
    fi
    _jogSide="F"
    return 1 #retorna que houve colisao
   fi

   
  fi
 done

}

#funcao para colisao com moedas
function ColisaoCoin {

 _tmpQ=$1 #recebe o quadrante para teste

 _tmp=${_coinQ[$_tmpQ]} #pega a posicao do indice do vetor das moedas se existir

 if [ $_tmpQ -eq 0 ] || [ -z $_tmp ]; then #verifica se o indíce do quadrante não é zero e se existe moeda no quadrante
  return
 fi

 _coinX=${_coin[$_tmp]} #pega a posicao x da moeda

 if [ $_coinX -gt 0 ]; then #se existir moeda checar colisao

  if [ $_jogX -gt $((_coinX + _coinWidth)) ]; then #personagem esta do lado direito da moeda
   return 0 #retorna que nao houve colisao
  fi

  if [ $((_jogY)) -gt $((_coinY[_tmp] + _coinHeight)) ]; then #personagem esta do lado de baixo da moeda
   return 0 #retorna que nao houve colisao
  fi

  if [ $((_jogX + 15)) -lt $_coinX ]; then #personagem esta do lado esquerdo da moeda
   return 0 #retorna que nao houve colisao
  fi

  if [ $((_jogY+_jogHeight)) -lt ${_coinY[$_tmp]} ]; then #personagem esta do lado de cima da moeda
   return 0 #retorna que nao houve colisao
  fi

  Play "coin" #toca o som da moeda
  _coin[$_tmp]=0 #tira a moeda do vetor
  GetCoin #chama funcao para fazer contagem de ponto da moeda    

  _tmp2=$(( _coinX + _coinWidth )) #pega a posicao do final da moeda

#  for (( _k=9; _k<=13; _k++ )); do #limpa o desenho da moeda no buffer da fase

#   _fasel[$_k]="${_fasel[$_k]:0:$_coinX}${_coinClear}${_fasel[$_k]:$_tmp2}"

#  done

  return 1 #retorna que houve colisao
 fi

}

#funcao para contagem de pontos da moeda
function GetCoin {

 ((_coins++)) #incrementa ponto da moeda
 Score 200 #incrementa ponto do score

 if [ $_coins -gt 99 ]; then #verifica se moedas chegou a 100 para converter em vida

  ((_coins-=100)) #subtrai 100 moedas do contador
  Play "up" #toca som de ganho de vida
  ((_jogLife++)) #incrementa 1 na variavel vida
 fi

}

#funcao para colisao do bloco
function ColisaoBloco {

 _tmpQ=$1 #recebe a posicao do quadrante
 
 _tmp=${_blocoQ[$_tmpQ]} #recebe a posicao do indice do bloco se existir

 if [ $_tmpQ -eq 0 ] || [ -z $_tmp ]; then #verifica se o indíce do quadrante não é zero e se existe bloco no quadrante
  return 0 #retorna que nao houve colisao
 fi

 _blocoX=${_bloco[$_tmp]} #pega a posicao x do bloco

 if [ $_blocoX -gt 0 ]; then #se existir bloco checar colisao

  if [ $_jogX -gt $((_blocoX -1 + _blocoWidth)) ]; then #personagem esta do lado direito do bloco
   return 0 #retorna que nao houve colisao
  fi

  if [ $((_jogY)) -gt $((_blocoY -1 + _blocoHeight)) ]; then #personagem esta do lado de baixo do bloco
   return 0 #retorna que nao houve colisao
  fi

  if [ $((_jogX -1 + _jogWidth)) -lt $_blocoX ]; then #personagem esta do lado esquerdo do bloco
   return 0 #retorna que nao houve colisao
  fi

  if [ $((_jogY -1 + _jogHeight)) -lt $_blocoY ]; then #personagem esta do lado de cima do bloco
   return 0 #retorna que nao houve colisao
  fi

  #A partir daqui houve colisao
  #Próximo if verifica se a colisão foi lateral para não quebrar o bloco
  if [ $((_jogY - _velocY)) -lt $((_blocoY -1 + _blocoHeight)) ]; then

   if [ $_jogSide = "D" ]; then # se não houve colisao posiciona o jogador ao lado do bloco
    _jogX=$((_blocoX - 16))
   else
    _jogX=$((_blocoX + _blocoWidth))
   fi
   _velocX=0
   return 1

  fi

  Play "bloco" #som do bloco quebrando
  Score 50 #incrementa score   
  _bloco[$_tmp]=0 #Limpa o bloco do vetor
  _jogY=$((_blocoY + _blocoHeight)) #posiciona o jogador abaixo do bloco
  _velocY=$((- _velocY)) #incrementa a velocidade de y


  _tmp2=$(( _blocoX + _blocoWidth )) #variavel para definir final do desenho do bloco (limpar)

  for (( _k=_blocoY; _k<(_blocoY+_blocoHeight); _k++ )); do #limpa o desenho do bloco do buffer da fase
   _fasel[$_k]="${_fasel[$_k]:0:$_blocoX}${_blocoClear}${_fasel[$_k]:$_tmp2}"
  done

  return 1 #retorna que houve colisao
 fi

}

#Funcao para detectar colisao do personagem com buracos na fase
function ColisaoBuraco {

 for (( _k=1; _k<_buraco[0]; _k++ )); do

  _buracoX=${_buraco[$_k]}

  if [ $((_jogX + (_jogWidth/2))) -gt $((_buracoX+2)) ] && [ $((_jogX + (_jogWidth/2))) -lt $((_buracoX + 2 + _buracoWidth )) ]; then #se houve colisão então mata personagem

   _jogX=$((_buracoX + 2 +(_buracoWidth/2) - (_jogWidth/2) ))
   Dead "buraco"

   return 1 #houve colisao
  fi

 done
 return 0 #nao houve colisao
}

#Função para matar o personagem definindo trilha sonora e tipo de animação do personagem
function Dead {

 #Define que o jogo está na passagem de morte do personagem
 _screenGame="DEAD"

 ((_jogLife--)) #Subtrai um vida do personagem
 
 if [ $_jogLife = 0 ]; then #se zerou as vidas do jogador toca audio fim de jogo
  Play "gameover"
 else #se não toca audio de perda de vida
  Play "die"
 fi 

 _jogDead=true #define variavel verdadeira para rotina de animação da morte do personagem

 ((_velocY+=_gravidade)) #Atualaiza velocidade de queda do personagem
}

#Função para parar a musica
function Stop {

 kill -9 $1 1 2>/dev/null

}


#Função para tocar os audios
function Play {

 if [ $_sound = "off" ]; then
  return
 fi

 case $1 in #Seleciona qual audio deve ser tocado

  "worldcleared")
   canberra-gtk-play --file="worldcleared.ogg" 1 2>/dev/null&
   ;;

  "flagpole")
   if [ $_musicId ]; then
    Stop $_musicId #Mata o processo da musica de fundo
   fi
   canberra-gtk-play --file="flagpole.ogg" 1 2>/dev/null&
   ;;

  "timewarning")
   if [ $_musicId ]; then
    Stop $_musicId #Mata o processo da musica de fundo
   fi
   canberra-gtk-play --file="timewarning.ogg" 1 2>/dev/null&
   ;;

  "gameover")
   if [ $_musicId ]; then
    Stop $_musicId #Mata o processo da musica de fundo
   fi
   canberra-gtk-play --file="gameover.ogg" 1 2>/dev/null&
   ;;

  "die")
   if [ $_musicId ]; then
    Stop $_musicId #Mata o processo da musica de fundo
   fi
   canberra-gtk-play --file="die.ogg" 1 2>/dev/null&
   ;;

  "background")
   if [ $_musicId ]; then
    Stop $_musicId #Mata o processo da musica de fundo
   fi

   canberra-gtk-play -l 99 -V 0 --file="world1-1.ogg" 1 2>/dev/null & _musicId="$!"
   #Guarda o id do processo da musica para parar quando for preciso
   ;;

  "jump")
   canberra-gtk-play --file="jump.ogg" 1 2>/dev/null&;;

  "bloco")
   canberra-gtk-play --file="brick.ogg" 1 2>/dev/null&;;

  "point")
   canberra-gtk-play --file="coin.ogg" 1 2>/dev/null&;;

  "coin")
   canberra-gtk-play --file="coin.ogg" 1 2>/dev/null&;;

  "up")
   canberra-gtk-play --file="up.ogg" 1 2>/dev/null&;;

  "enemy")
   canberra-gtk-play --file="stomp.ogg" 1 2>/dev/null&;;
 esac

}

function MoveEnemy {

 case $_screenGame in

 "GAME") # se jogo em fase processa movimento do inimigo

  #_firstQ=$(( _cameraX / _tamQuad )) #pega o primeiro quadrante
  _ubound=${_enemyX[0]}

  for (( _k=1; _k<_ubound; _k++ )); do #laco para verificar cada inimigo

   #verifica se o path do inimigo esta visivel na camera
   if [ ${_enemyPathIni[$_k]} -lt $((_cameraX + _width)) ] && [ ${_enemyPathFim[$_k]} -gt $_cameraX ] && [ ${_enemySprite[$_k]} -lt 6 ]; then 

    #((_aniEnemy[_k]++))

    #Animacao do inimigo
    case ${_enemySprite[$_k]} in
    0)
     ChangeSpriteEnemy $_k
     _enemySprite[$_k]=1
     _aniEnemy=1

     ;;
    1) 
     ChangeSpriteEnemy $_k
     ((_enemySprite[_k]+=_aniEnemy))
     ;;
    2)
     if [ ${_enemyDead[$_k]} -eq 1 ]; then
      _enemySprite[$_k]=3
     else
      ChangeSpriteEnemy $_k
      _enemySprite[$_k]=1
      _aniEnemy=-1
     fi
     ;;
    3)
     _enemySprite[$_k]=4;;
    4)
     _enemySprite[$_k]=5;;
    5)
     _enemySprite[$_k]=6;;
    esac 

   fi


   _enemyHeight[$_k]="_gompa${_enemySprite[$_k]}[0]" 
   _enemyHeight[$_k]=${!_enemyHeight[$_k]}
   _enemyY[$_k]=$((_piso - _enemyHeight[$_k]))

  done
  
 esac
}

function ChangeSpriteEnemy {

 _k=$1

# if [ ${_aniEnemy[$_k]} -eq 2 ]; then
  ((_enemyX[_k]+=_enemyVelocX[_k])) #Movimenta o inimigo

  if [ $(( _enemyX[_k] + enemyWidth )) -gt $(( _enemyPathFim[_k] )) ] || [ ${_enemyX[$_k]} -lt ${_enemyPathIni[$_k]} ]; then
   (( _enemyVelocX[_k]=-_enemyVelocX[_k] ))
  fi


  _aniEnemy[$_k]=0
# fi


}

# [ INICIO SCRIPT ] ----------------------------------------------------------------------------------------------------------

# Carrega as configurações salva
. .settings

# Mapa do score no topo da tela
_scoreTitle0="     MARIO                                   WORLD               TIME           "
_scoreTitle1="     000000                 @x00              1-1                 000           "


# Mapa de caracters do jogador mario e das montanhas de fundo

_montDraw[0]=7
_montDraw[1]="              ████████              "
_montDraw[2]="          ████        ████          "
_montDraw[3]="        ██                ██        "
_montDraw[4]="      ██           ██ ░░░░  ██      "
_montDraw[5]="    ██           ██       ░░  ██    "
_montDraw[6]="  ██                        ░░  ██  "
_montDraw[7]="██                            ░░  ██"

# Mapa de caracters do Menu do jogo
 _menu[0]="                                                                                "
 _menu[1]="                                                                                "
 _menu[2]="                                                                                "
 _menu[3]="                                                                                "
 _menu[4]="                                                                                "
 _menu[5]="               @                                                @               "
 _menu[6]="                    ██   ██   ████   █████   ██████   ████                      "
 _menu[7]="                    ███ ███  ██  ██  ██  ██    ██    ██  ██                     "
 _menu[8]="                    ██ █ ██  ██████  █████     ██    ██  ██                     "
 _menu[9]="                    ██   ██  ██  ██  ██  ██    ██    ██  ██                     "
_menu[10]="                    ██   ██  ██  ██  ██  ██  ██████   ████                      "
_menu[11]="                                                                                "
_menu[12]="                     █████   █████    ████    ████                              "
_menu[13]="                     ██  ██  ██  ██  ██  ██  ██                                 "
_menu[14]="                     █████   █████   ██  ██   ████                              "
_menu[15]="                     ██  ██  ██  ██  ██  ██      ██  ██                         "
_menu[16]="                     █████   ██  ██   ████    ████   ██                         "
_menu[17]="               @                                                @               "
_menu[18]="                                           2012 FATEC CARAPICUIBA               "
_menu[19]="                                                                                "
_menu[20]="                                                                                "
_menu[21]="                                                                                "
_menu[22]="                                                                                "
_menu[23]="                    P R E S S   E N T E R   T O   S T A R T                     "
_menu[24]="                                                                                "
_menu[25]="                                                                                "
_menu[26]="                                TOP - 0000000000                                "
_menu[27]="                                                                                "
_menu[28]="                                                                                "
_menu[29]="                                                                                "
_menu[30]="              ████████                                                          "
_menu[31]="          ████        ████                              █     █     █           "
_menu[32]="        ██                ██                           █ █   █ █   █ █          "
_menu[33]="      ██           ██ ░░░░  ██                        █   █ █   █ █   █         "
_menu[34]="    ██           ██       ░░  ██                     █     █     █     █        "
_menu[35]="  ██                        ░░  ██                  █                   █       "
_menu[36]="██                            ░░  ██               █                     █      "
_menu[37]="░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░"
_menu[38]="█░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░█"
_menu[39]="░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░░░░░██░░░░"

_flagDraw[0]=7
_flagDraw[1]="████"
_flagDraw[2]="█   ████"
_flagDraw[3]="█       ███"
_flagDraw[4]="█          ███"
_flagDraw[5]="█       ███"
_flagDraw[6]="█   ████"
_flagDraw[7]="████"

_castle[0]=31
 _castle[1]="  @@@"
 _castle[2]=" @@@@@                           ___     ___     ___     __     ___     ___     ___"
 _castle[3]="  @@@                           |░░░|   |░░░|   |░░░|   |░░|   |░░░|   |░░░|   |░░░|"
 _castle[4]="  | |                           |░░░|   |░░░|   |░░░|   |░░|   |░░░|   |░░░|   |░░░|"
 _castle[5]="  | |                           |░░|░░░░|░░░░|░░░░|░░░░|░░░|░░░░|░░░░|░░░░|░░░░|░░░|"
 _castle[6]="  | |                           |░░░░|░░░░|░░░░|░░░░|░░░░|░░░|░░░░|░░░░|░░░░|░░░░|░|"
 _castle[7]="  | |                           |░░|░░░░|██████░░░|░░░░|░░░|░░░░|░░░░██████░░░░|░░░|"
 _castle[8]="  | |                           |░░░░|░░░██████|░░░░|░░░░|░░░|░░░░|░░██████░|░░░░|░|"
 _castle[9]="  | |                           |░░|░░░░|██████░░░|░░░░|░░░|░░░░|░░░░██████░░░░|░░░|"
_castle[10]="  | |                           |░░░░|░░░██████|░░░░|░░░░|░░░|░░░░|░░██████░|░░░░|░|"
_castle[11]="  | |                           |░░|░░░░|██████░░░|░░░░|░░░|░░░░|░░░░██████░░░░|░░░|"
_castle[12]="  | |                 __     ___|░░░░___░██████|░░░░░___░░░░___░░░░░_██████░___░░░░|___     __"
_castle[13]="  | |                |░░|   |░░░|░░░|░░░|███|░░░|░░░|░░░|░░|░░░|░░░|░░░|███|░░░|░░░|░░░|   |░░|"
_castle[14]="  | |                |░░|   |░░░|░░░|░░░|░░░|░░░|░░░|░░░|░░|░░░|░░░|░░░|░░░|░░░|░░░|░░░|   |░░|"
_castle[15]="  | |                |░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░|"
_castle[16]="  | |                |░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░|"
_castle[17]="  | |                |░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░████████░░|░░░░|░░░░|░░░░|░░░░░░|░░░░|░░|"
_castle[18]="  | |                |░|░░░░|░░░░|░░░░|░░░░|░░░░|░░░████████████░░░|░░░░|░░░░|░░░░|░░░░|░░░░|░|"
_castle[19]="  | |                |░░░|░░░░|░░░░|░░░░|░░░░|░░░░|██████████████░░░░|░░░░|░░░░|░░░░░░|░░░░|░░|"
_castle[20]="  | |                |░|░░░░|░░░░|░░░░|░░░░|░░░░|░████████████████░|░░░░|░░░░|░░░░|░░░░|░░░░|░|"
_castle[21]="  | |                |░░░|░░░░|░░░░|░░░░|░░░░|░░░██████████████████░░|░░░░|░░░░|░░░░|░░░░|░░░░|"
_castle[22]="  | |                |░|░░░░|░░░░|░░░░|░░░░|░░░░████████████████████░░░░|░░░░|░░░░|░░░░|░░░░|░|"
_castle[23]="  | |                |░░░|░░░░|░░░░|░░░░|░░░░|░░████████████████████░|░░░░|░░░░|░░░░|░░░░|░░░░|"
_castle[24]="  | |                |░|░░░░|░░░░|░░░░|░░░░|░░░░████████████████████░░░░|░░░░|░░░░|░░░░|░░░░|░|"
_castle[25]="  | |                |░░░|░░░░|░░░░|░░░░|░░░░|░░████████████████████░|░░░░|░░░░|░░░░|░░░░|░░░░|"
_castle[26]="  | |                |░|░░░░|░░░░|░░░░|░░░░|░░░░████████████████████░░░░|░░░░|░░░░|░░░░|░░░░|░|"
_castle[27]="  | |                |░░░|░░░░|░░░░|░░░░|░░░░|░░████████████████████░|░░░░|░░░░|░░░░|░░░░|░░░░|"
_castle[28]="  | |                |░|░░░░|░░░░|░░░░|░░░░|░░░░████████████████████░░░░|░░░░|░░░░|░░░░|░░░░|░|"
_castle[29]=" _| |_               |░░░|░░░░|░░░░|░░░░|░░░░|░░████████████████████░|░░░░|░░░░|░░░░|░░░░|░░░░|"
_castle[30]="|░░░░░|              |░|░░░░|░░░░|░░░░|░░░░|░░░░████████████████████░░░░|░░░░|░░░░|░░░░|░░░░|░|"
_castle[31]="|░░░░░|              |░░░|░░░░|░░░░|░░░░|░░░░|░░████████████████████░|░░░░|░░░░|░░░░|░░░░|░░░░|"

_marioD0[0]=16
 _marioD0[1]=""
 _marioD0[2]="   █████"
 _marioD0[3]='  █░░░░M███'
 _marioD0[4]=' █░░░░░░░░░█'
 _marioD0[5]=' ███  █ ███'
 _marioD0[6]='█  ██ █    █'
 _marioD0[7]='█  ██  █   █'
 _marioD0[8]=' ██   █████'
 _marioD0[9]='  ██     █'
_marioD0[10]=' █░░██░░█'
_marioD0[11]='█░░░░██░░█'
_marioD0[12]='█░░░░█████'
_marioD0[13]=' █   ██ ██'
_marioD0[14]=' █  ░░░███'
_marioD0[15]='  █░░░░░█'
_marioD0[16]='   █████'

_marioE0[0]=16
 _marioE0[1]=""
 _marioE0[2]='    █████'
 _marioE0[3]=' ███M░░░░█'
 _marioE0[4]='█░░░░░░░░░█'
 _marioE0[5]=' ███ █  ███'
 _marioE0[6]='█    █ ██  █'
 _marioE0[7]='█   █  ██  █'
 _marioE0[8]=' █████   ██'
 _marioE0[9]='  █     ██'
_marioE0[10]='   █░░██░░█'
_marioE0[11]='  █░░██░░░░█'
_marioE0[12]='  █████░░░░█'
_marioE0[13]='  ██ ██   █'
_marioE0[14]='  ███░░░  █'
_marioE0[15]='   █░░░░░█'
_marioE0[16]='    █████'

_marioD1[0]=16
 _marioD1[1]='     █████'
 _marioD1[2]='    █░░░░M███'
 _marioD1[3]='   █░░░░░░░░░█'
 _marioD1[4]='   ███  █ ███'
 _marioD1[5]='  █  ██ █    █'
 _marioD1[6]='  █  ██  █   █'
 _marioD1[7]='   ██   █████'
 _marioD1[8]='   ███     █'
 _marioD1[9]=' ██░░░██░░███'
_marioD1[10]='█  ░░░░██░░█░█'
_marioD1[11]='█   ░░██████░ █'
_marioD1[12]=' █  ████ ██ █ █'
_marioD1[13]='  █████████░░█'
_marioD1[14]=' █░░██████░░░█'
_marioD1[15]=' █░░░█  █░░░█'
_marioD1[16]='  ███    ███'

_marioE1[0]=16
 _marioE1[1]='     █████'
 _marioE1[2]='  ███M░░░░█'
 _marioE1[3]=' █░░░░░░░░░█'
 _marioE1[4]='  ███ █  ███'
 _marioE1[5]=' █    █ ██  █'
 _marioE1[6]=' █   █  ██  █'
 _marioE1[7]='  █████   ██'
 _marioE1[8]='   █     ███'
 _marioE1[9]='  ███░░██░░░██'
_marioE1[10]=' █░█░░██░░░░  █'
_marioE1[11]='█ ░██████░░   █'
_marioE1[12]='█ █ ██ ████  █'
_marioE1[13]=' █░░█████████'
_marioE1[14]=' █░░░██████░░█'
_marioE1[15]='  █░░░█  █░░░█'
_marioE1[16]='   ███    ███'

_marioF0[0]=16
 _marioF0[1]='    ███████'
 _marioF0[2]='  ██░░░M░░░██'
 _marioF0[3]=' █░░░░███░░░░█'
 _marioF0[4]='  ███████████'
 _marioF0[5]=' █   █   █   █'
 _marioF0[6]='██    ░░░    ██'
 _marioF0[7]=' █ █████████ █'
 _marioF0[8]='█ █   █░█   ██'
 _marioF0[9]='█  ██ █░█ ██  █'
_marioF0[10]=' █ █░█████░░ █ █'
_marioF0[11]='  █░░░░░░░░█████'
_marioF0[12]=' ████░░░░░█░░░█'
_marioF0[13]='█░░░░█░░░█░░░░█'
_marioF0[14]=' █░░░░█████░░░█'
_marioF0[15]='  █░░░█    ███'
_marioF0[16]='   ███'

_marioD2[0]=16
 _marioD2[1]='     █████  ███'
 _marioD2[2]='    █░░░░M██   █'
 _marioD2[3]='   █░░░░░░░░█  █'
 _marioD2[4]='   ███  █ ███░█'
 _marioD2[5]='  █  ██ █    ░█'
 _marioD2[6]='  █  ██  █   ░█'
 _marioD2[7]='   ██   ██████'
 _marioD2[8]='    ██      ░█'
 _marioD2[9]='  █░░░█░░░█░█'
_marioD2[10]=' ███░░░█░░░████'
_marioD2[11]='█   █░░█ ██ █░░█'
_marioD2[12]='█   █░██████░░░█'
_marioD2[13]=' █░█████████░░█'
_marioD2[14]='█░░░████████░░█'
_marioD2[15]='█░░██████   ██'
_marioD2[16]=' ██ ███'

_marioE2[0]=16
 _marioE2[1]=' ███  █████'
 _marioE2[2]='█   ██M░░░░█'
 _marioE2[3]='█  █░░░░░░░░█'
 _marioE2[4]=' █░███ █  ███'
 _marioE2[5]=' █░    █ ██  █'
 _marioE2[6]=' █░   █  ██  █'
 _marioE2[7]='  ██████   ██'
 _marioE2[8]='  █░      ██'
 _marioE2[9]='   █░█░░░█░░░█'
_marioE2[10]=' ████░░░█░░░███'
_marioE2[11]='█░░█ ██ █░░█   █'
_marioE2[12]='█░░░██████░█   █'
_marioE2[13]=' █░░█████████░█'
_marioE2[14]=' █░░████████░░░█'
_marioE2[15]='  ██   ██████░░█'
_marioE2[16]='         ███ ██'



_marioD00=13
 _marioD01="    █████"
 _marioD02='   █░░░░M███'
 _marioD03='  █░░░░░░░░░█'
 _marioD04='  ███  █ ███'
 _marioD05=' █  ██ █    █'
 _marioD06=' █  ██  █   █'
 _marioD07='  ██   █████'
 _marioD08='   ██     █'
 _marioD09='  █   ██ ██'
_marioD010='  █  ░░░███'
_marioD011='   █░░░░░█'
_marioD012='    █████'

_marioE00=13
 _marioE01='     █████'
 _marioE02='  ███M░░░░█'
 _marioE03=' █░░░░░░░░░█'
 _marioE04='  ███ █  ███'
 _marioE05=' █    █ ██  █'
 _marioE06=' █   █  ██  █'
 _marioE07='  █████   ██'
 _marioE08='   █     ██'
 _marioE09='   ██ ██   █'
_marioE010='   ███░░░  █'
_marioE011='    █░░░░░█'
_marioE012='     █████'

_marioD10=13
 _marioD11='     █████'
 _marioD12='    █░░░░M███'
 _marioD13='   █░░░░░░░░░█'
 _marioD14='   ███  █ ███'
 _marioD15='  █  ██ █    █'
 _marioD16='  █  ██  █   █'
 _marioD17='   ██   █████'
 _marioD18='   ███     █'
 _marioD19='  █ ████ ██ █'
_marioD110='  █████████░░█'
_marioD111=' █░░██████░░░█'
_marioD112=' █░░░█  █░░░█'
_marioD113='  ███    ███'

_marioE10=13
 _marioE11='     █████'
 _marioE12='  ███M░░░░█'
 _marioE13=' █░░░░░░░░░█'
 _marioE14='  ███ █  ███'
 _marioE15=' █    █ ██  █'
 _marioE16=' █   █  ██  █'
 _marioE17='  █████   ██'
 _marioE18='   █     ███'
 _marioE19='  █ ██ ████ █'
_marioE110=' █░░█████████'
_marioE111=' █░░░██████░░█'
_marioE112='  █░░░█  █░░░█'
_marioE113='   ███    ███'

_marioD20=13
 _marioD21='     █████  ███'
 _marioD22='    █░░░░M██   █'
 _marioD23='   █░░░░░░░░█  █'
 _marioD24='   ███  █ ███░█'
 _marioD25='  █  ██ █    ░█'
 _marioD26='  █  ██  █   ░█'
 _marioD27='   ██   ██████'
 _marioD28='    ██      ░█'
 _marioD29='   ██████░░░█'
_marioD210='  █████████░░█'
_marioD211=' █░░███████░░█'
_marioD212='█░░██████  ██'
_marioD213=' ██ ███'

_marioE20=13
 _marioE21=' ███  █████'
 _marioE22='█   ██M░░░░█'
 _marioE23='█  █░░░░░░░░█'
 _marioE24=' █░███ █  ███'
 _marioE25=' █░    █ ██  █'
 _marioE26=' █░   █  ██  █'
 _marioE27='  ██████   ██'
 _marioE28='  █░      ██'
 _marioE29='   █░░░██████'
_marioE210='  █░░█████████'
_marioE211='  █░░███████░░█'
_marioE212='   ██   █████░░█'
_marioE213='         ███ ██'

_gompa0[0]=10                                 
 _gompa0[1]="       ████"
 _gompa0[2]="   ██████████"
 _gompa0[3]="  ███ >████< █"
 _gompa0[4]=" ████ █ ██ █ ██"
 _gompa0[5]="█████   ██   ███"
 _gompa0[6]=" ██████████████"
 _gompa0[7]="  █████░░░░███"
 _gompa0[8]="  ███░░░░░░ "
 _gompa0[9]="  ████░░░░██"
_gompa0[10]="   ████░░██"

_gompa1[0]=10
 _gompa1[1]="      ████"
 _gompa1[2]="   ██████████"
 _gompa1[3]="  ██ >████< ██"
 _gompa1[4]=" ███ █ ██ █ ███"
 _gompa1[5]="████   ██   ████"
 _gompa1[6]=" ██████████████"
 _gompa1[7]="  ████░░░░████"
 _gompa1[8]="     ░░░░░░"
 _gompa1[9]="   ██░░░░░░██"
_gompa1[10]="    ██░░░░██"

_gompa2[0]=10
 _gompa2[1]="     ████"
 _gompa2[2]="   ██████████"
 _gompa2[3]="  █ >████< ███"
 _gompa2[4]=" ██ █ ██ █ ████"
 _gompa2[5]="███   ██   █████"
 _gompa2[6]=" ██████████████"
 _gompa2[7]="  ███░░░░████"
 _gompa2[8]="     ░░░░░░███"
 _gompa2[9]="    ██░░░░████"
_gompa2[10]="     ██░░████"

_gompa3[0]=8                                   
 _gompa3[1]="    ████████"
 _gompa3[2]=" ███ >████< ███"
 _gompa3[3]="████ █ ██ █ ████"
 _gompa3[4]="████   ██   ████"
 _gompa3[5]=" █████░░░░█████"
 _gompa3[6]="     ░░░░░░"
 _gompa3[7]="   ███░░░░███"
 _gompa3[8]="    ███░░███"

_gompa3[0]=5                                                                   
 _gompa3[1]="   ████████████"
 _gompa3[2]=" ████ >████< ████"
 _gompa3[3]="█████ █ ██ █ █████"
 _gompa3[4]="   ███░░░░░░███"
 _gompa3[5]="    ███░░░░███"
 
_gompa4[0]=3                                                                   
 _gompa4[1]="   ████████████"
 _gompa4[2]="█████ █ ██ █ █████"
 _gompa4[3]="    ███░░░░███"

_nuvemDraw[0]=13
 _nuvemDraw[1]="               ███████"
 _nuvemDraw[2]="             ██       ██" 
 _nuvemDraw[3]="           ██           ██"
 _nuvemDraw[4]="          █     █   █  ░  █"
 _nuvemDraw[5]="      ████      █   █   ░  ████"
 _nuvemDraw[6]="   ███                  ░      ███"
 _nuvemDraw[7]=" ██                          ░   █"
 _nuvemDraw[8]=" █                          ░    █"
 _nuvemDraw[9]=" ██   ░░░░            ░    ░░ ███"
_nuvemDraw[10]="   ███   ░░░░     ░    ░░░░░  █"
_nuvemDraw[11]="      ████  ░░░░░░  ██      ██"
_nuvemDraw[12]="          ██      ██  ██████"
_nuvemDraw[13]="            ██████"


_coinDraw0[0]=5
_coinDraw0[1]="    @@    "
_coinDraw0[2]="  @@  @@  "
_coinDraw0[3]=" @  @@  @ "
_coinDraw0[4]="  @@  @@  "
_coinDraw0[5]="    @@    "

_coinDrawC[1]=${_cor[4]}
_coinDrawC[2]=${_cor[4]}
_coinDrawC[3]=${_cor[4]}
_coinDrawC[4]=${_cor[4]}
_coinDrawC[5]=${_cor[4]}

_coinDraw1[0]=5
_coinDraw1[1]="    @@    "
_coinDraw1[2]="   @  @   "
_coinDraw1[3]="  @ @@ @  "
_coinDraw1[4]="   @  @   "
_coinDraw1[5]="    @@    "

_coinDraw2[0]=5
_coinDraw2[1]="    @@    "
_coinDraw2[2]="    @@    "
_coinDraw2[3]="    @@    "
_coinDraw2[4]="    @@    "
_coinDraw2[5]="    @@    "

# Cria o mapa de caracters para o piso
_piso1='░░░░██░░░░'
_piso2='█░░░░░░░░█'

_buracoDraw="██                         ██" # Variavel para desenhar o buraco na fase

# Buffer de desenho do Bloco
_blocoDraw[0]="███████████████"
_blocoDraw[1]="█░░░░░░░░░░░░░█"
_blocoClear="               "

#Inicializa as variaveis existentes no programa
#Salva as configurações atuais do terminal
_terminal=$(stty -g)

# -echo Desliga o que eh digitado na tela
# -icanon desliga o modo canonico
# min 0 minimo de caracters a esperar para fazer leitura
#-icrnl converte o caracter new line[enter] para carrier return para ser detectado em _ListenKey
stty -echo -icanon -icrnl min 0 #time 0

# Desliga o cursor piscante na tela
tput civis

# Define constantes para as Teclas de controle seremm detectadas no _ListenKey
KEY_ENTER=$(printf '\x0d')
KEY_BACKSPACE=$(printf '\x08')
KEY_ESC=$(printf '\x1b')
KEY_UP=$(echo -ne '\e[A')
KEY_LEFT=$(echo -ne '\e[D')
KEY_RIGHT=$(echo -ne '\e[C')
KEY_DOWN=$(echo -ne '\e[B')

if [ $TERM = "linux" ]; then
 _cor[0]="\E[00;37;41m" # logo
 _cor[1]="\E[00;37;46m" # Title
 _cor[2]="\E[00;30;46m" # ceu
 _cor[3]="\E[00;31;42m" # piso
 _cor[4]="\E[00;33;46m" # amarelo para coin
 _cor[5]="\E[00;36;46m" # invisible
else
 _cor[0]="\E[01;37;41m" # logo
 _cor[1]="\E[01;37;46m" # Title
 _cor[2]="\E[02;30;46m" # ceu
 _cor[3]="\E[02;31;42m" # piso
 _cor[4]="\E[01;33;46m" # amarelo para coin
 _cor[5]="\E[00;36;46m" # invisible
fi

#definicao minima de Largura e Altura da tela do jogo em linhas por colunas
_heightScreen=40
_widthScreen=80

# Inicializa variaveis de controle de tempo
#_tempoS=$SECONDS #((10#`date +%S`)) Define o tempo inicial com os segundos desde quando o terminal foi aberto
_tempoN=0
_tempo2N=0

#Controla quantos eventos por segundo devem ocorrer
_next=false

# inicializa variavel para posicao da camera no cenario
_cameraX=0

# inicializa variavel para definir a largura da fase em caracters
_sizeFase=0

#Cores possíveis no terminal
# 0 preto
# 1 vermelho
# 2 verde
# 3 amarelo
# 4 azul escuro
# 5 cinza
# 6 azul claro
# 7 branco

_edgeWidth=30
_edgeScreen=`printf "%${_edgeWidth}s"` # Variavel para permitir renderizar desenhos que ficam com parte visivel na camera e parte nao visivel

_width=0
_height=0

TerminalSize

_score=0 #Variavel para guardar o score atual do jogo
_coins=0 #Variavel para as moedas capturadas no jogo
_world="1-1" #Nivel atual do jogo
_timeGame=300 #Define quanto tempo terá a fase
_timeIni=0 #Guarda o tempo em segundos do inicio do jogo
_time=0 #Tempo atual do jogo em segundos

#Carrega a tela do menu no buffer
LoadMenu

_jogAni=0 #Controla a animacao de sprite para dar sensacao mais real do andar
# guarda qual sprite do personagem sera exibido
_jogSprite=0

#qual lado do jogador (d=direito e=esquerdo) será exibido
_jogSide="D"

_jogHeight=16
_jogWidth=16

# Coordenadas iniciais do jogador x,y e velocidade em x e y
_jogX=0
_jogY=0
_velocY=0
_velocX=0

# define se o jogado morreu
_jogDead=false

#Variavel que guarda as vidas do personagem
_jogLife=0

#Define a tela atual do Jogo se esta: no menu, no jogo ou em pausa no jogo
_screenGame="MENU"

# Fisica do Jogo
_gravidade=1

# Coordenada da posicao do piso no cenario para colisao do personagem
_piso=37

# Variaveis de controle de calculo e exibicao de quadros por segundo do jogo (velocidade do jogo)
_quadroRender=0
_quadros=0
_lps=0 #loops por segundo
_fps=0 #frames por segundo

#Variavel para controle de limpeza do buffer do teclado: ver Function ListenKey
_clearBuffer=false


# Verifica se há linhas suficientes para desenha o jogo no terminal
# caso contrário gera um erro, termina o programa e exibe mensagem para o usuario
if [ $_height -lt $_heightScreen ] || [ $_width -lt $_widthScreen ]; then
 _erro="Terminal deve ter no mínimo $_heightScreen linhas x $_widthScreen colunas!\nEncontrado $_height linhas x $_width colunas."
 Sair
fi

ClearScreen

tput cup $(( _initY + 12 )) 0

echo "$_spaceIni    Copyright (C) 2012 Doriedson Alves Galdino de Oliveira                      "
echo "$_spaceIni                       Thiago Andre Silva                                       "
echo "$_spaceIni                       Vitor Augusto Andrioli                                   "
echo "                                                                                "
echo "$_spaceIni    This program is free software: you can redistribute it and/or modify        "
echo "$_spaceIni    it under the terms of the GNU General Public License as published by        "
echo "$_spaceIni    the Free Software Foundation, either version 3 of the License, or           "
echo "$_spaceIni    (at your option) any later version.                                         "
echo "$_spaceIni                                                                                "
echo "$_spaceIni    This program is distributed in the hope that it will be useful,             "
echo "$_spaceIni    but WITHOUT ANY WARRANTY; without even the implied warranty of              "
echo "$_spaceIni    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               "
echo "$_spaceIni    GNU General Public License for more details.                                "
echo "                                                                                "
echo "$_spaceIni    You should have received a copy of the GNU General Public License           "
echo "$_spaceIni    along with this program.  If not, see .       "

read -n1

ClearScreen

# guarda o nanosegundo atual do relógio do sistema, aqui foi usado 10# para conversão de base
# pois quando o segundo chega a 08 dá erro com cálculos por que o bash entende que o número
# é octadecimal e como o sistema octadecimal vai até o 7, entao gera um erro, por isso precisamos
# forçar o entendimento para a base decimal com 10#
_tempoN=$((10#`date +%N`))


# [ TIME LINE ] --------------------------------------------------------------------------------------------------------------------

# loop do jogo (Time Line)
while true; do

 FPS #Atualiza a taxa de quadros por segundo
 
 ListenKey #Houve o Teclado

 if [ $_next = true ]; then
  LoadColors #Carrega as cores de fundo

  MoveEnemy #Calcula movimento do inimigo  

  Jogador #Calcula Coordenadas do Jogador

  Render #Renderiza o jogo no terminal
 fi

 _next=false #Controle para quando poderá calcular o próximo quadro do jogo

done

Leer más...

cp_p.sh

d
Nombre: cp_p.sh
Visto en Chris-Lamb
#!/bin/sh
cp_p()
{
   strace -q -ewrite cp -- "${1}" "${2}" 2>&1 \
      | awk '{
        count += $NF
            if (count % 10 == 0) {
               percent = count / total_size * 100
               printf "%3d%% [", percent
               for (i=0;i<=percent;i++)
                  printf "="
               printf ">"
               for (i=percent;i<100;i++)
                  printf " "
               printf "]\r"
            }
         }
         END { print "" }' total_size=$(stat -c '%s' "${1}") count=0

Leer más...

Script para eliminar virus de dispositivos USB

d
Autor: KZKG^Gaara
Visto en Desde Linux
#!/bin/bash
#
# -*- ENCODING: UTF-8 -*-
# Este programa es software libre. Puede redistribuirlo y/o
# modificarlo bajo los términos de la Licencia Pública General
# de GNU según es publicada por la Free Software Foundation,
# bien de la versión 2 de dicha Licencia o bien (según su
# elección) de cualquier versión posterior.
#
# Si usted hace alguna modificación en esta aplicación,
# deberá siempre mencionar al autor original de la misma.
#
# Copyleft 2013, DesdeLinux.net {Ciudad Habana, Cuba}.
# Autor: KZKG^Gaara  

CONTROL=0
WAITTIME=20
WORKFOLDER="$HOME/script-antireggeaton"

while [ $CONTROL=0 ] ; do
 for SHIT in `cat $WORKFOLDER/filtro.lst` ; do
  find /media/ -iname *$SHIT* -exec rm -rfv {} \; >> $WORKFOLDER/shit-deleted.log
 done
 sleep $WAITTIME
done

exit 0
Leer más...

Script Full Backup

d
Autor: GhosTi
Visto en Blog of Sysadmins
#!/bin/bash
 
 
 
TAR=$(which tar)
TEE=$(which tee)
 
ARGS=2
 
if [ $# -ne $ARGS ]
then
echo “Usage: “$0” file dir”
echo ” file: backup file name”
echo ” dir: path to backup”
exit
fi
 
APP=$0 #app name
FILE=$1“_full.tgz” #backup file
FILE_OLD=$FILE“~” #file backuped before remove
DIR=$2 #path
 
LOG_DIR=/var/log
LOG_FILE=$LOG_DIR“/”${APP##*\/}“.log” #remuevo de APP lo que este antes de la ultima /
 
TODAY=`date “+%Y-%m-%d %a”`
echo $TODAY” *** Backup full *** “ | $TEE -a $LOG_FILE
 
if [ ! -d $DIR ]
then
echo “ERROR: path “$DIR” not exist” | $TEE -a $LOG_FILE
exit
fi
 
#Realizo backup del backup
echo “Rotating files…” | $TEE -a $LOG_FILE
 
if [ -f $FILE ];
then
#cp -v $FILE $FILE_OLD | $TEE -a $LOG_FILE
rm -v $FILE | $TEE -a $LOG_FILE
fi
 
echo “Making backup…” | $TEE -a $LOG_FILE
#Realizo el backup
$TAR -chzf $FILE $DIR | $TEE -a $LOG_FILE
 
if [ $? == 0 ]
then
echo “Backup successfull!”
else
echo “ERROR: error making backup :-( “
fi
Leer más...

Script Backup Incremental.

d
Autor: GhosTi
Visto en Blog of Sysadmins
#!/bin/sh
TAR=$(which tar)
TEE=$(which tee)
 
 
 
ARGS=2
 
if [ $# -ne $ARGS ]
 
then
echo “Usage: “$0” file dir”
echo ” file: backup file name”
echo ” dir: path to backup”
exit
fi
 
APP=$0 #app name
FILE=$1“_incremental.tgz” #backup file
FILE_FULL=$1“_full.tgz” #backup full
FILE_OLD=$FILE“~” #file backuped before remove
DIR=$2 #path
 
LOG_DIR=/var/log
LOG_FILE=$LOG_DIR“/”${APP##*\/}“.log” #remuevo de APP lo que este antes de la ultima /
 
TODAY=`date “+%Y-%m-%d %a”`
echo $TODAY” *** Backup incremental ***” | $TEE -a $LOG_FILE
 
if [ ! -d $DIR ]
then
echo “ERROR: path “$DIR” not exist” | $TEE -a $LOG_FILE
exit
fi
 
# Reviso si existe el backup full
if [ ! -f $FILE_FULL ];
then
echo “ERROR: full backup “$FILE_FULL” not exist!” | $TEE -a $LOG_FILE
exit
fi
 
#Realizo backup del backup
 
echo “Rotating files…” | $TEE $LOG_FILE
 
if [ -f $FILE ];
 
then
#cp -v $FILE $FILE_OLD | $TEE $LOG_FILE
rm -v $FILE | $TEE $LOG_FILE
fi
 
#Realizo el backup
DATE_FULL=“`date \”+%Y-%m-%d %H:%M\” -r “$FILE_FULL“`”
echo “Full backupe created: “$DATE_FULL | $TEE $LOG_FILE
 
echo “Making backup…” | $TEE $LOG_FILE
$TAR -chzf $FILE –newer-mtime=“$DATE_FULL” $DIR | $TEE -a $LOG_FILE
 
if [ $? == 0 ]
then
echo “Backup successfull!”
else
echo “ERROR: error making backup :-( “
fi
Leer más...

DB Version Updater

d
Nombre: DB Version Updater
Autor: Eduardo Cuomo [ eduardo.cuomo.ar@gmail.com ]
Descripción: Script to keep the version of the database model updated, using a simple Linux script.
Más información del Script en reduardo7
#!/bin/bash

# Execute Queries for update.
#
# SQL Query File name format: [version number (BIGINT)][ |-|.|_|,|#|\|][Query description][.sql]
#
# For more help, execute this file into a Terminal without parameters.
#
# Eduardo Cuomo | eduardo.cuomo.ar@gmail.com


# Test if running with "bash" interpreter
if [ "$BASH" = "" ] ; then
    # Run with "bash"
    bash "$0" $@
    exit $?
fi

# DB config
DB_USER="USER"
DB_PASS="PASS"
DB_NAME="DB_NAME"
DB_HOST="localhost"
DB_TABLE="DB_VERSION"
DB_CHARSET="latin1"
DB_PORT="3306"


# DB status
DB_STATUS_EXECUTING="EXECUTING"
DB_STATUS_EXECUTED="EXECUTED"
DB_STATUS_ERROR="ERROR"

# Arguments
ARG_UPDATE="update"
ARG_CREATE="create"
ARG_MARK_UPDATED="mark-updated"

# File format
CHAR_SEP="\ \-\_\,\|\#"
CHAR_SEP_P="\ \-\_\,\|\#\."
FILE_NAME_FORMAT="[version number (BIGINT)][${CHAR_SEP_P}][Query description][.sql]"

# Vars
CURRENT_DIR="$(printf '%q' "$(pwd)")"
DIR_NAME="$(dirname "$(printf '%q' "$(readlink -f "$(printf '%q' "$0")")")")"
result=""
br="
"

# Exit
function ex() {
 echo
 echo "cd $CURRENT_DIR"
 cd $CURRENT_DIR
 echo
 exit $1
}

# Escape String
function escape_string() {
 result=$(printf '%q' "$1")
}

# echo
function e() {
 echo "| $1"
}

# echo line
function e_l() {
 let fillsize=80
 fill="+"
 while [ "$fillsize" -gt "0" ] ; do
  fill="${fill}-" # fill with underscores to work on
  let fillsize=${fillsize}-1
 done
 echo $fill
}

# echo exit
function e_e() {
 e "$1"
 e_l
 ex 1
}

# Show help
function show_help() {
 escape_string "$0"
 script="$result"
 e "Help (this):"
 e " # bash $script"
 e " # bash $script --help"
 e
 e
 e "To use rollback on error, tables must be transactional (InnoDB)."
 e "Use next query to set as InnoDB tables:"
 e "    ALTER TABLE \`TABLE_NAME\` ENGINE = INNODB;"
 e
 e
 e "The SQL files names must have the next format:"
 e " ${FILE_NAME_FORMAT}"
 e "File name examples:"
 e " 0001. Query description.sql"
 e " 0002 - Query description 2.sqL"
 e " 3 Query description 3.Sql"
 e " 04, Query description 4.sQl"
 e " 05_Query description 5.SQL"
 e " 20100617-Query description with date as version number.sql"
 e " 201006170105#Query description with date and time as version number.sql"
 e " 00017|Other Query description.sql"
 e " 00017#Other Query description.sql"
 e
 e
 e "Usage: bash $script [OPTIONS] ACTION [EXTRA]"
 e
 e "OPTION:"
 e "-u, --user     Set DB user name to use."
 e "               Using: '$DB_USER'"
 e "-p, --pass     Set DB password to use."
 e "               Using: '$DB_PASS'"
 e "-d, --db       Set DB name to use."
 e "               Using: '$DB_NAME'"
 e "-h, --host     Set DB host to use."
 e "               Using: '$DB_HOST'"
 e "-P, --port     Set DB host port to use."
 e "               Using: '$DB_PORT'"
 e "--help         This help."
 e
 e "ACTION:"
 e "$ARG_UPDATE         Execute update."
 e "               NOTE: Transaction rollback on MySQL error."
 e "$ARG_CREATE         Create a SQL file to mark all files as executed."
 e "               Uses:"
 e "                 # bash $script $ARG_CREATE [OUT FILE NAME]"
 e "                 # bash $script $ARG_CREATE \"out_file_name.sql\""
 e "                 # bash $script $ARG_CREATE \"0. Mark executed to version X.sql\""
 e "               TIP: You can use version '0' to execute before others already executed files."
 e "$ARG_MARK_UPDATED   Mark all files as executed without execute files."
 e_e
}

# Begin
echo
echo "cd $DIR_NAME"
echo
e ":: DB Updater ::"
cd $DIR_NAME
e_l

# No parameters
if [ $# -eq 0 ] ; then
 show_help
fi

# Options
TMP=`getopt --name="$0" -a --longoptions=user:,pass:,db:,host:,port:,help -o u:,p:,d:,h:,P -- $@`
if [ $? -ne 0 ] ; then
 # Invalid option
 e
 e "Error! Invalid parameters!"
 e
 show_help
fi
eval set -- $TMP

until [ $1 == -- ]; do
 case $1 in
  -u|--user)
   DB_USER=$2
   ;;
  -p|--pass)
   DB_PASS=$2
   ;;
  -d|--db)
   DB_NAME=$2
   ;;
  -h|--host)
   DB_HOST=$2
   ;;
  -P|--port)
   DB_PORT=$2
   ;;
  --help)
   show_help
   ;;
 esac
 shift # move the arg list to the next option or '--'
done
shift # remove the '--', now $1 positioned at first argument if any

# Query: Execute query
function q_e() {
 query=$1
 mysql -h ${DB_HOST} -u ${DB_USER} -p${DB_PASS} -P ${DB_PORT} ${DB_NAME} -e "${query}"
 return $?
}

# Read version from file name
function read_version() {
 result=$(echo "$1" | sed "s/[${CHAR_SEP_P}].*$//" | sed "s/^0*//g")
 if [[ "$result" = "" ]] ; then
  result=0
 fi
 # Check integer
 if [[ $result =~ ^[^0-9]+$ ]] ; then
  e "File name format:"
  e " ${FILE_NAME_FORMAT}"
  e_e "The file '$1' not contains a Version number as start name."
 fi
}

# Read description from file name
function read_description() {
 result=$(echo "$1" | sed "s/[^\d${CHAR_SEP_P}]*//" | sed "s/\.sql.*$//i" | sed "s/^[${CHAR_SEP_P}]*//g")
}

# Create table if not exists
function create_table() {
 q_e "CREATE TABLE IF NOT EXISTS \`${DB_TABLE}\` (\`version\` BIGINT NOT NULL, \`description\` varchar(255) NOT NULL, \`file_name\` varchar(255) NOT NULL, \`executed_date\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, \`status\` VARCHAR(10) NOT NULL DEFAULT '${DB_STATUS_EXECUTING}' COMMENT '${DB_STATUS_EXECUTING}; ${DB_STATUS_EXECUTED}; ${DB_STATUS_ERROR}', PRIMARY KEY (\`version\`)) ENGINE=InnoDB DEFAULT CHARSET=latin1"
    if [ $? -ne 0 ]; then
        e_e "[ERROR CODE 7001] QUERY ERROR! mysql exit code: $?"
    fi
 e "Connected to ${DB_USER}@${DB_HOST}.${DB_NAME}"
 e_l
}

# Read file data
file_name=""
file_nameq=""
version=""
versionq=""
desc=""
descq=""
function read_file_data() {
 file_name="$1"
 # File name
 escape_string "$file_name" ; file_nameq=$result
 e "File:         $file_name"
 # Version
 read_version "$file_name" ; version=$result
 escape_string $version ; versionq=$result
 e "Version:      $version"
 # Description
 read_description "$file_name" ; desc=$result
 escape_string "$desc" ; descq=$result
 e "Description:  $desc"
}

# Update DB
if [ "$1" = "${ARG_UPDATE}" ] ; then
 # Update
 e "Updating DB ${DB_HOST}@${DB_NAME}..."
 e_l

 # Create table if not exists
 create_table

 # Begin
 for file in *.sql ; do
  if [[ "$file" =~ ^[0-9]+[${CHAR_SEP_P}]+.+\.[sS][qQ][lL]$ ]] ; then
   read_file_data "$file"

   # Check
   q_e "DELETE FROM \`${DB_TABLE}\` WHERE \`version\` = ${version} AND \`status\` = '${DB_STATUS_ERROR}'"
   q_e "INSERT INTO \`${DB_TABLE}\` (\`version\`, \`description\`, \`file_name\`, \`status\`) VALUES (${version}, '$descq', '$file_nameq', '${DB_STATUS_EXECUTING}')" &> /dev/null

   if [ $? -ne 0 ]; then
    # Already executed
    e "* Already executed."
   else
    e "* Executing update..."
    # Prepare query
    update_query=$(cat "$file")
    update_query="SET SQL_MODE=\"NO_AUTO_VALUE_ON_ZERO\"; SET AUTOCOMMIT=0; START TRANSACTION;
-- BEGIN UPDATE

$update_query ;

-- END UPDATE
COMMIT;"
    query_executed="UPDATE \`${DB_TABLE}\` SET \`status\` = '${DB_STATUS_EXECUTED}' WHERE \`version\` = ${version}"
    # Execute query file
    #mysql -h ${DB_HOST} -u ${DB_USER} -p${DB_PASS} -P ${DB_PORT} --default-character-set=${DB_CHARSET} ${DB_NAME} < "$file"
    mysql -h ${DB_HOST} -u ${DB_USER} -p${DB_PASS} -P ${DB_PORT} --default-character-set=${DB_CHARSET} ${DB_NAME} <<< "$update_query"
    exc=$?
    if [ $exc -ne 0 ]; then
     e
     q_e "UPDATE \`${DB_TABLE}\` SET \`status\` = '${DB_STATUS_ERROR}' WHERE \`version\` = ${version}"
     e "[ERROR CODE 7003] QUERY ERROR! mysql exit code: $exc"
     e "QUERY:${br}${br}$update_query${br}"
     e
     e "Mark this script as executed:"
     e_e "${query_executed};"
    fi
    # Ok
    q_e "$query_executed"
    e "Query executed!"
   fi
   e_l
  fi
 done

 # Finish!
 e "DB ${DB_HOST}@${DB_NAME} updated!"
 e_l

 echo
 echo
 echo "Finish!"
 ex 0
fi

# Mark all files as executed without execute files
if [ "$1" = "${ARG_MARK_UPDATED}" ] ; then
 # Update
 e "Marking as updated DB ${DB_HOST}@${DB_NAME}..."
 e_l

 # Create table if not exists
 create_table

 # Begin
 for file in *.sql ; do
  if [[ "$file" =~ ^[0-9]+[${CHAR_SEP_P}]+.+\.[sS][qQ][lL]$ ]] ; then
   read_file_data "$file"

   # Check
   q_e "DELETE FROM \`${DB_TABLE}\` WHERE \`version\` = ${version} AND \`status\` = '${DB_STATUS_ERROR}'"
   q_e "INSERT INTO \`${DB_TABLE}\` (\`version\`, \`description\`, \`file_name\`, \`status\`) VALUES (${version}, '$descq', '$file_nameq', '${DB_STATUS_EXECUTING}')" &> /dev/null

   if [ $? -ne 0 ]; then
    # Already executed
    e "* Already executed."
   else
    # Mark as executed
    e "* Marking as updated..."
    query_executed="UPDATE \`${DB_TABLE}\` SET \`status\` = '${DB_STATUS_EXECUTED}' WHERE \`version\` = ${version}"
    q_e "$query_executed"
    e "Query executed!"
   fi
   e_l
  fi
 done

 # Finish!
 e "DB ${DB_HOST}@${DB_NAME} marked as updated!"
 e_l

 echo
 echo
 echo "Finish!"
 ex 0
fi

# Create start status file
if [ "$1" = "${ARG_CREATE}" ] ; then
 if [ $# -eq 2 ] ; then
  file_out="$2"
  e "Creating '$file_out' file..."
  e_l

  # Create out file
  echo "INSERT INTO \`${DB_TABLE}\` (\`version\`, \`description\`, \`file_name\`, \`status\`) VALUES" > "$file_out"
  flag=1

  for file in *.sql ; do
   if [[ "$file" =~ ^[0-9]+[${CHAR_SEP_P}]+.+\.[sS][qQ][lL]$ ]] ; then
    if [ "$file" != "$file_out" ] ; then
     read_file_data "$file"

     query=$(echo "(${versionq}, '${descq}', '${file_nameq}', '${DB_STATUS_EXECUTED}')")

     # Add query
     if [ $flag -ne 1 ] ; then
      query=", $query"
     else
      flag=0
     fi
     echo "$query" >> "$file_out"

     e_l
    fi
   fi
  done

  echo ";" >> "$file_out"

  # End
  e "'$file_out' file created!"
  e_l

  echo
  echo
  echo "Finish!"
  ex 0
 fi
fi

# Invalid ACTION
e "INVALID ACTION!"
e_l
show_help
Leer más...