Lição 3 - Programação de Jogos em ShellScript

A lição 3 também é interessante e fundamental. com o conceito da lição 3 já é possível sair por ai programando algum joguinho. tentei deixar esse assunto o mais simples possível. estarei falando de 2 coisas.

1) Mapas
2) Colisões

Mapas
Para um jogo fazer sucesso é interessante ter um mecanismo de mapa bem simples, que possa até possibilitar ao jogador criar um mapinha para se divertir. no meu exemplo o mapa pode ser desenhado em um simples arquivo de texto.

Colisões
Colisões são praticamente algo que fazem as coisas acontecerem. exemplo, bater o carrinho, levar um tiro, pegar algo, etc...

Vamos começar desenhando um mapa, crie um arquivo com o nome map.layout se quer usar outro nome ok... mas lembre-se disso na parte do código.

Desenhe o que quizer no mapa
Exemplo
nome do arquivo: map.layout
conteúdo:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
X                                                       X
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

tudo que não for uma area em branco será considerado uma parede no joguinho 

agora vamos ao código

nome do arquivo: game.sh

conteudo:

#!/bin/bash

setterm -cursor off

a=0

m=0

n=0

C=0

x=2

y=2

tput cup 0 0

cat map.layout

tput cup $y $x

echo -n "o"

until [ $a = q ];do

read  -n 1 a

clear

cat map.layout

######## Leitura do Teclado ####

if [ $a = a ];then

let "m = x"

let "n = y + 1"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "x = x - 1"

fi

fi

if [ $a = d ];then

let "m = x + 2"

let "n = y + 1"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "x = x + 1"

fi

fi

if [ $a = w ];then

let "m = x + 1"

let "n = y"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "y = y - 1"

fi

fi

if [ $a = s ];then

let "m = x + 1"

let "n = y + 2"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "y = y + 1"

fi

fi

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

tput cup $y $x

echo -n "o"

done

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

clear

setterm -cursor on

echo FIM

Comentários do código

1)

x=2

y=2

#iniciei x e y com o valor 2, para nao começar com o player em uma parede.

2)

tput cup 0 0

cat map.layout

#imprimi o mapa

3)

if [ $a = a ];then

let "m = x"

let "n = y + 1"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "x = x - 1"

fi

fi

# A cada movimento eu verifico no mapa se tem alguma coisa naquela posição.

lembrando que o tput trabalha de 0 até ...

o awk e cut trabalham de 1 até ...

então usei o let com algumas variáveis para adaptar, mesmo assim ficou bem simples e leve.

Anti scans e DDOS no conntrack !

Esses asiáticos desocupados ficam fazendo scan e criando virus horríveis que fazem mais scan... e essa merdas viram DDOS.

Recentemente tenho percebido que muitos pacotes chegam no servidor em portas e ips inutilizados. O número de conexões possíveis  é limitado em 65535 ! e quando o invasor já está dentro com conexões penduradas o iptables não bloqueia até todas serem eliminadas do conntrack... então é bom ficar de olho no conntrack.

O método abaixo previne DDOS, Scans, Virus e muito mais...

É bem simples, basta colocar o conntrack2.sh no crontab (15 em 15 minutos ) ou menos dependendo da exposição...  ele vai enviar o e-mail alertando, e também pode derrubar as conexões killconnections.sh e bloquear o invasor.

Se for utilizar atenção com os detalhes de rede local, no meu caso "10\.1" e se você tiver serviços que recebam mais de 3000 conexões coloque um grep -v também !





conntrack2.sh
-------------------------------------------------------------------------------
#!/bin/bash
N2=3000
cd /root/
cat /proc/net/ip_conntrack | cut -f2 -d"=" | awk {'print $1'} | sort | uniq -c|                                                                                         sort | tail -n 10 | grep -v " 10\.1" > /root/conntrack2.log
cat /root/conntrack2.log
for i in `cat /root/conntrack2.log | awk {'print $2'}`
do
N1=`cat /root/conntrack2.log | grep $i | awk {'print $1'}`
if [ $N1 -gt $N2 ];then
                (:
                    echo 'HELO mail';sleep 1
                    echo 'mail From:<suporte>';
                    echo 'rcpt To:<suporte>';
                    echo 'data';
                    echo 'subject: ' "Tentativa de Invasao";
                    echo 'Sender: <suporte>';
                    echo 'To: <suporte>';
                    echo '';
                    echo "mais de $N2 conexoes do $i Total $N1 conexoes provavel                                                                                         tentativa de invasao";
                    echo `whois $i | grep "owner:"`;
                    echo ".";
                    echo 'quit' ;) | nc mail 25
#matar as conexões

killconnections.sh $i

echo $i  >> /root/blacklist.lst

iptables -A INPUT -s $i -j DROP

fi
done

-------------------------------------------------------

killconnections.sh
if [ -z $1 ] ; then
exit
fi
grep -E "^tcp .{10,25}ESTABLISHED src=$1 " /proc/net/ip_conntrack | while read line ; do
S_IP=`echo $line | awk '{print substr($5,5)}'`
S_SOCK=`echo $line | awk '{print substr($7,7)}'`
D_IP=`echo $line | awk '{print substr($6,5)}'`
D_SOCK=`echo $line | awk '{print substr($8,7)}'`
echo "$S_IP:$S_SOCK $D_IP:$D_SOCK"
hping2 $D_IP -R -s $S_SOCK -p $D_SOCK -a $S_IP -k -c 1 >/dev/null 2>/dev/null &
done

Lição 2 - Programação de Jogos em ShellScript

A lição 2 fala sobre movimento, é um assunto muito legal, basicamente o que todos querem saber antes de iniciar a programação de um game.

Alem do movimento tem muita filosofia aqui. então vou tentar explicar todos os detalhes.

Nesse script você pode usar as letras (a,s,w,s) para movimentar a bolinha, e o (q) para sair.

#!/bin/bash

setterm -cursor off

clear

x=0

y=0

a=0

f=0

echo -n "o"

until [ $a = q ];do

read -n 1 a

clear

######## Leitura do Teclado ####

if [ $a = a ];then

let "x = x - 1"

fi

if [ $a = d ];then

let "x = x + 1"

fi

if [ $a = w ];then

let "y = y - 1"

fi

if [ $a = s ];then

let "y = y + 1"

fi

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

##### Movimento da Bolinha #####

f=0

while [ $y -gt $f ];do

echo ""

let "f = f + 1"

done

f=0

while [ $x -gt $f ];do

echo -n " "

let "f = f + 1"

done

echo -n "o"

done

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

clear

setterm -cursor on

echo FIM

OK, agora que você brincou vamos falar sobre o script

setterm -cursor off

Aqui eu desligo o quadrado do cursor de digitação, para que apenas o que eu quero seja exibido.

clear

x=0

y=0

a=0

Apos isso limpo a tela e inicio todas as minhas variáveis com o valor que quero. é importante fazer isso para não haver erros na inicialização.

until [ $a = q ];do

read -n 1 a

clear

Incio o loop, e tem mais uma coisa importante aqui, o read -n1 a, pega apenas a tecla batida, ele não precisa do enter.

Apos isso sigo com o conceito de gráfico x,y que definem onde vou exibir o "o"

E de bônus, eu deveria usar um comando para fazer o sistema imprimir o "o" onde eu quero. mas me imaginei em um sistema ou linguagem onde não teria nem mesmo isso. e montei na marra.

imprimindo o numero de linhas [echo], e imprimindo colunas [echo -n " "] para chegar na posição x,y.

Lição 1 - Programação de Jogos em ShellScript

Estarei postando aqui um tutorial sobre programação de jogos na linguagem ShellScript, claro que ninguém vai lançar jogos em ShellScript mas as lições aqui podem ser empregadas em qualquer outra linguagem, ou programa visto que são usados comandos básicos.

Aos programadores profissionais entendam que nunca fiz curso de programação, então meus métodos são esquisitos mesmo.

Lição 1 - Animações

Uma bela animação na intro pode definir o sucesso de um game, então vejam o exemplo de como fazer animações em ShellScript, isso é ótimo inclusive pra tirar sarro dos colegas.

#!/bin/bash

clear

echo " o"

echo "/|\\"

echo "/ \\"

sleep 1

clear

echo " o"

echo " /|\\"

echo " / \\"

sleep 1

clear

echo " o"

echo " /|\\"

echo " / \\"

Que legal, o bonequinho andou :)

ok ok, inútil mas para salvar o tópico algumas informações do sleep.

1. você pode utilizar sleep 0.5 para esperar meio segundo

2. alem disso existe o comando usleep que trabalha com milissegundos.

Ajuste automático de numero sequencial de canais de MQ

Em primeiro lugar o MQ é um produto muito estável. normalmente a causa do problema não será o MQ, poderá ser maquina, rede, usuario... mas o MQ é um santo ^^

No meu caso costumo utilizar o MQ 5.3 que apesar de ser muito bom não tem nativamente alguns recursos que poderiam ajudar em momentos difíceis.

Se você tem muitos canais de MQ estabelecidos sabe que será trabalhoso restabelecer todos caso alguma desgraça aconteça, ainda mais se for envolver terceiros no processo.

Esse script resolve o caso. ele pega o numero sequencial que a outra ponta espera e sincroniza os canais sozinhos. faz o que um bom analista faria só que muito mais rápido, só depende dos tempos de retryng do mq =)

Obs:

Diretorio: /var/mqm/qmgrs/QMGR/errors

tail -f AMQERR01.LOG |

awk -v teste=0 '{

if ( /AMQ9526:/ )

{

c = $8

channel = substr(c,2,(length(c)-3))

teste = 1

}

if (teste) {

if ( /amqrmtra/ || /amqrfpta/ ) {

system("echo \"STOP CHL("channel")\" > reset")

system("echo \"RESET CHL("channel") SEQNUM("seqnum")\" >> reset")

system("echo \"START CHL("channel")\" >> reset")

system("echo \"END\" >> reset")

system("cat reset | runmqsc QMGR > reset.log")

system("cat reset.log")

teste = 0}

else{if ( $1 ~ /number./ ) {seqnum = $7}}

}

}'

exit

Contingencia com 2 links de Internet

Esse script é bem legal, a principio ele resolve o problema do acesso a internet com 2 links.

Lembrando que não faz balanceamento. seria um modelo active\standby. estamos falando de contingencia qualquer um dos 2 links pode segurar a onda sem depender do outro. lembre-se de contratar os provedores diferentes com terminações diferentes para lugares diferentes.

Exemplo:

LinkA - Fibra - Leste

LinkB - Antena - Sul

Se você só precisa que seus usuários acessem a internet o script já resolve tudo!

mas se precisar ser acessado (website,servidor de email, etc...) existem as opções:

1. Usar 2 servidores de DNS primários um em cada link, que resolvem o nome de acordo com o link que estão alocados.

2. Utilizar um provedor que venda link duplo com terminações distintas.

3. Se tornar um AS com BGP

LINKA = ip do link primario de internet

LINKB = ip do link reserva de internet
RTA=roteador do link primário
RTB=roteador do link secundario

LAN = rede local
mailserver=seu servidor de email
emaildosuporte=email da equipe de suporte

#!/bin/bash

N=`iptables -t nat -nL --line-numbers | grep SNAT| grep LAN | awk {'print $1'}`

DATA=`date`

STATUS=`cat /tmp/internet.status`

echo $N

echo $STATUS

echo $DATA

ping -w 5 -c 1 -I LINKA www.google.com

if [ $? -eq 0 ];then

echo "tudo ok nada a fazer"

if [ $STATUS -eq 1 ];then

echo "LINKA Reativando"

iptables -t nat -R POSTROUTING $N -s LAN -d 0/0 -j SNAT --to LINKA
route delete default gw RTB
route add default gw RTA

echo -n "SUBIU " >> /tmp/caiu.log

echo $DATA >> /tmp/caiu.log

echo 0 > /tmp/internet.status

else

echo "nada a fazer"

fi

else

echo "nao ok virando para LINKB"

iptables -t nat -R POSTROUTING $N -s LAN -d 0/0 -j SNAT --to LINKB

route delete default gw RTA
route add default gw RTB
echo -n "CAIU " >> /tmp/caiu.log

echo $DATA >> /tmp/caiu.log

echo 1 > /tmp/internet.status

(:

echo 'HELO mailserver';sleep 1

echo 'mail From: emaildosuporte';sleep 1

echo 'rcpt To: emaildosuporte';sleep 1

echo 'data';sleep 1

echo 'subject: ' "Atençao Problemas no Link A";sleep 1

echo 'Sender: emaildosuporte';sleep 1

echo 'To: emaildosuporte';sleep 1

echo '';sleep 1

echo "O Link A está fora! "

echo '.';sleep 1

echo 'quit' ;) | nc mailserver 25

fi

#