# Aplicacao de Truco

# Gere o executavel da seguinte forma:

#
# as -gstabs truco.s -o truco.o
# ld truco.o -lc -dynamic-linker /lib/ld-linux.so.2 -o truco
#
# e execute-o dentro do gdb para testar, fazendo:
#
# gdb ./truco
#
# dentro do gdb crie breakpoints, como por exemplo:
#
# (gdb) b jgjoga <enter>
# (gdb) b cpjoga <enter>
# (gdb) b checalance <enter>
# (gdb) b tratafimmao <enter>
# (gdb) b resetamao <enter>
#
# e ai digite run para rodar e cont para continuar apos cada breakpoint
#
# adicione outros breakpoints que achar util para analisar o codigo

.section .data

texto0: .asciz "\nNumero da Mao: %d\n"

texto1: .asciz "Vira %c(%c)\n"
texto2: .asciz "Computador Jogador\n"
texto3: .asciz "Pontos = %d Pontos = %d\n"
texto4: .asciz "%c(%c) %c(%c) %c(%c) %c(%c) %c(%c) %c(%c)\n"

textocptruco: .asciz "\nCP: Truco? <1> Aceita <2> Corre <3> Seis? "
textocpseis: .asciz "\nCP: Seis? <1> Aceita <2> Corre <3> Nove? "
textocpnove: .asciz "\nCP: Nove? <1> Aceita <2> Corre <3> Doze? "
textocpdoze: .asciz "\nCP: Doze? <1> Aceita <2> Corre? "

textojgtruco: .asciz "\nJG: Truco?\n"

textojgseis: .asciz "\nJG: Seis?\n"
textojgnove: .asciz "\nJG: Nove?\n"
textojgdoze: .asciz "\nJG: Doze?\n"

textocpjoga: .asciz "\nCP Joga!\n"

textojgjoga: .asciz "\nJG Joga!\n"

textocpaceitou: .asciz "\nCP Aceitou!\n"

textojgaceitou: .asciz "\nJG Aceitou!\n"

textocpcorreu: .asciz "\nCP Correu!\n"

textojgcorreu: .asciz "\nJG Correu!\n"

textocpvenceumao: .asciz "\nCP Venceu a Mao!\n"

textojgvenceumao: .asciz "\nJG Venceu a Mao!\n"
textomaoempatou: .asciz "\nMao Empatou: Ninguem Venceu!\n"

textocpvenceulance: .asciz "\nCP Venceu o Lance!\n"

textojgvenceulance: .asciz "\nJG Venceu o Lance!\n"
textolanceempatou: .asciz "\nLance Empatou!\n"

textofimpartida: .asciz "\nFim de Partida!\n"

textocpvenceupartida: .asciz "\nCP Venceu a Partida: %d pontos\n"
textojgvenceupartida: .asciz "\nJG Venceu a Partida: %d pontos\n"

textoprob: .asciz "\Probabilidade = %d\n"

# identificadores das cartas na ordem de poder

# utilizado para identificar o simbolo (caracter) da carta sorteada
idcartas: .int '4','5','6','7','Q','J','K','A','2','3'

# naipes (ouro, espada, copas, paus) das cartas na ordem de poder

# utilizado para identificar o simbolo (caracter) do naipe sorteado
naipes: .int 'O','E','C','P'

# identificadores numericos para computador e jogador

computador: .int 0
jogador: .int 1

# Quanto valem os poderes das cartas

# O poder das cartas sao utilizados para comparacao e identificacao
# de vitoria ou empate
# 4 > 0
# 5 > 1
# 6 > 2
# 7 > 3
# Q > 4
# J > 5
# K > 6
# A > 7
# 2 > 8
# 3 > 9
# Manilha ouro > 10
# Manilha espada > 11
# Manilha copas > 12
# Manilha paus > 13

# registra as cartas, naipes e poderes sorteados das 3 cartas do computador

idcartascp: .int 0,0,0
naipescp: .int 0,0,0
poderescp: .int 0,0,0

# registra as cartas, naipes e poderes sorteados das 3 cartas do jogador

idcartasjg: .int 0,0,0
naipesjg: .int 0,0,0
poderesjg: .int 0,0,0

# para conter os enderecos das estruturas anteriores, ora para o computador

# ora para o jogador, de forma que o sorteio de cartas possa servir a um e
# a outro
endidcartas: .int 0
endnaipes: .int 0
endpoderes: .int 0

# controla o uso das 3 cartas do computador e do jogador durante as jogadas

# e durante a impressao na tela. Cartas "fechada/nao jogada" sao mostradas
# com '#' na tela. Cartas "aberta/jogada" sao mostradas com os simbolos
# que possuem. Alem disso, somente as cartas fechadas podem ser sorteadas
# em uma nova jogada.
statuscp: .int 0,0,0 # 0 = fechada/naojogada, 1 = aberta/jogada
statusjg: .int 0,0,0 # 0 = fechada/naojogada, 1 = aberta/jogada
# registra a vira
vira: .int 0,0,0 # idcarta, naipe e poder da carta

# registra a manilha
manilha: .int 0,0 # idcarta e poder da carta

tempo: .int 4

faixageral: .int 40
faixacartas: .int 10
faixanaipes: .int 4
faixapoderes: .int 14

# registra a carta sorteada num alcance de 0 a 39, permitindo verificar se

# determinada carta ja foi sorteada e com isso realizar novo sorteio
sorteadas: .space 40 # 0=nao sorteada 1=sorteada. 1 byte para cada uma

idgcarta: .int 0 # identificador geral da carta

# variaveis auxiliares do sorteio

poder: .int 0
naipe: .int 0
ordemcarta: .int 0

# variaveis para controle dos lances, maos e partida

quemjoga: .int 0 # 0 = computador, 1 = jogador
maodequem: .int 0 # 0 = computador, 1 = jogador
venceumao: .int 3 # 0 = cp, 1 = jg, 2 = empatou, 3 = indefinido
venceupartida: .int 2 # 0 = computador, 1 = jogador, 2 = nao acabou
nrolance: .int 0 # uma mao contem 3 lances (1, 2 e 3)
nrojogada: .int 0 # um lance contem 2 jogadas (1 e 2), uma de cada
# jogador
nrodamao: .int 0 # conta o numero da mao apenas para informacao
fimmao: .int 0 # 0 = continua a mao, 1 = termina a mao
fimpartida: .int 0 # 0 = continua a partida, 1 = termina a partida

pontoscp: .int 0 # registra os pontos do computador

pontosjg: .int 0 # registra os pontos do jogador

podercp: .int 0 # poder da carta corrente jogada pelo computador

poderjg: .int 0 # poder da carta corrente jogada pelo jogador

# marca o nivel do truco (1,3,6,9,12) no primeiro inteiro e quem o originou

# no segundo inteiro. Dessa estrutura sao obtidos os pontos da mao para entregar
# para quem ganhou a mao
niveldamao: .int 1,2 # 0 = cp, 1 = jg, 2 = indefinido

# registra quem ganhou cada um dos 3 lances

statuslances: .int 3,3,3 # 0 = cp, 1 = jg, 2 = empatou, 3 = indefinido

tipod: .asciz "%d"

tipos: .asciz "%s"

retorno: .int 0 # backupeia endereco de retorno

registrador: .int 0 # backupeia registrador

# variaveis auxiliares da divisao e multiplicacao

cem: .int 100
quatro: .int 4
tres: .int 3
dois: .int 2

resp: .int 0

.section .text
.globl _start
_start:

call iniciarand
call sorteiaquemcomeca

volta1:
call sorteiavira
call achamanilha

movl $idcartascp, %eax

movl %eax, endidcartas
movl $naipescp, %eax
movl %eax, endnaipes
movl $poderescp, %eax
movl %eax, endpoderes

call sorteiacartas

movl $idcartasjg, %eax

movl %eax, endidcartas
movl $naipesjg, %eax
movl %eax, endnaipes
movl $poderesjg, %eax
movl %eax, endpoderes

call sorteiacartas
call jogamao

call tratafimmao
call checafimpartida # deve ser chamado antes de resetamao
call resetamao
call alternamaodequem

movl fimpartida, %eax

cmpl $0, %eax
je volta1

call mostrafinal

pushl $0
call exit

# Inicializa a semente de geracao aleatoria usando o tempo/relogio do sistema

iniciarand:

pushl $tempo
call time # o tempo atual será a semente de geração aleatória
pushl tempo
call srand
 addl $8, %esp

ret

# sorteia a carta vira, para posteriormente verificar quais cartas sao manilhas
sorteiavira:

call sortidgcarta

movl $0, %edx

divl faixacartas # %edx/%dl fica com o poder da carta de 0 a 9
# e %eax fica com o naipe de 0 a 3
pushl %eax # backup
pushl %edx # backup
movl $idcartas, %edi
movl %edx, %eax
movl $0, %edx
mull quatro
addl %eax, %edi # posiciona no id da carta
movl $vira, %esi
movl (%edi), %ebx
movl %ebx, (%esi) # guarda a idcarta da vira
popl %edx # restaura
movl %edx, 8(%esi) # guarda o poder da vira

popl %eax # restaura

movl $0, %edx
mull quatro
movl $naipes, %edi
addl %eax, %edi # posiciona no simbolo do naipe
movl (%edi), %ebx
movl %ebx, 4(%esi) # guarda o naipe da vira

ret

achamanilha:

movl $vira, %edi

movl 8(%edi), %eax # poder da vira
incl %eax # calcula poder acima
movl $0, %edx
divl faixacartas # normaliza de 0 a 9 em %edx
# que passa a ser o novo poder da vira
pushl %edx # backup
movl $idcartas, %edi
movl %edx, %eax
movl $0, %edx
mull quatro
addl %eax, %edi
movl $manilha, %esi
movl (%edi), %ebx
movl %ebx, (%esi) # guarda o id da manilha
popl %edx # restaura
movl %edx, 4(%esi) # guarda o poder da manilha

ret

sorteiaquemcomeca:
 call rand
movl $0, %edx
divl dois
movl %edx, quemjoga
movl %edx, maodequem

ret

sorteiacartas:

movl $3, %ecx # conta o total de cartas a ser sorteadas

movl $0, ordemcarta # conta a ordem da carta sorteada > 0, 1 ou 2

volta2:

pushl %ecx

call sortidgcarta # retorna identificacao geral da carta sorteada

# de 0 a 39 em %eax, livre de repeticao
movl $0, %edx
divl faixacartas # %edx fica com o poder base da carta de 0 a 9
# e %eax com o valor do naipe de 0 a 3 -> guarda
movl %edx, poder
movl %eax, naipe

call registracarta
call registranaipe
call registrapoder

incl ordemcarta
popl %ecx
loop volta2

ret

sortidgcarta:

call rand
movl $0, %edx
divl faixageral # %edx fica com o nro da carta de 0 a 39
movl %edx, idgcarta

movl $sorteadas, %edi

addl %edx, %edi
movb (%edi), %al
cmpb $1, %al
je sortidgcarta
movb $1, (%edi)
movl %edx, %eax

ret

registracarta:

movl $idcartas, %edi

movl poder, %eax
movl $0, %edx
mull quatro
addl %eax, %edi # posiciona no vetor de idcartas
 movl endidcartas, %esi

movl ordemcarta, %eax

movl $0, %edx
mull quatro
addl %eax, %esi

movl (%edi), %eax

movl %eax, (%esi) # registra o id da carta

ret

registranaipe:

movl $naipes, %edi

movl naipe, %eax
movl $0, %edx
mull quatro
addl %eax, %edi # posiciona no vetor de naipes
movl endnaipes, %esi

movl ordemcarta, %eax

movl $0, %edx
mull quatro
addl %eax, %esi

movl (%edi), %eax

movl %eax, (%esi) # guarda o naipe (simbolo) da carta

ret

registrapoder:

movl poder, %ebx # poder de base

movl $manilha, %edi
movl 4(%edi), %eax # poder da manilha
cmpl %eax, %ebx
jne cartanormal
# eh manilha -> ajusta poder
movl faixacartas, %ebx # promove o poder da carta
addl naipe, %ebx # promove + agregando numero do naipe

cartanormal:

movl endpoderes, %esi

movl ordemcarta, %eax
movl $0, %edx
mull quatro
addl %eax, %esi
movl %ebx, (%esi)

ret

jogamao:

incl nrodamao

call mostracartas
 volta3:

movl quemjoga, %eax

cmpl $0, %eax
jne jgjoga2

call cpjoga
jmp testafim

jgjoga2:

call jgjoga

testafim:

movl fimmao, %eax

cmpl $1, %eax
jne volta3

# acabou a mao

ret

cpjoga:
pushl $textocpjoga
call printf
addl $4, %esp

call retornaprob
cmpl $1, %eax
jne cpjogaquieto
# reage: truco, seis, nove ou doze

movl niveldamao, %eax

cmpl $1, %eax
je cpchamatruco2
cmpl $3, %eax
je cpanalisaseis # analisa a possibilidade de chamar 6
cmpl $6, %eax
je cpanalisanove # analisa a possibilidade de chamar 9
cmpl $9, %eax
je cpanalisadoze # analisa a possibilidade de chamar 12
# ja esta em 12, joga quieto

cpjogaquieto:
call cpjoga1carta
ret

cpchamatruco2:
call cpchamatruco
ret

cpchamatruco:

pushl $textocptruco
call printf
call getchar # retorna caracter lido em %eax
movl %eax, resp
 call getchar # coleta enter
addl $4, %esp

movl resp, %eax # reestabelece o caracter lido

cmpl $'1', %eax
je jgaceitatruco
cmpl $'2', %eax
je jgcorretruco

jgchamaseis:
pushl $textojgseis
call printf
addl $4, %esp

call retornaprob
cmpl $3, %eax
je cpcorreseis
cmpl $2, %eax
je cpaceitaseis

cpchamanove:
pushl $textocpnove
call printf
call getchar # retorna caracter lido em %eax
movl %eax, resp
call getchar # coleta enter
addl $4, %esp

movl resp, %eax

cmpl $'1', %eax
je jgaceitanove
cmpl $'2', %eax
je jgcorrenove

jgchamadoze:
pushl $textojgdoze
call printf
addl $4, %esp

call retornaprob
cmpl $3, %eax
je cpcorredoze

cpaceitadoze:
pushl $textocpaceitou
call printf
addl $4, %esp

movl $12, niveldamao

movl $niveldamao, %eax
movl $1, 4(%eax) # jogador chamou doze
call cpjoga1carta
ret

cpcorredoze:
pushl $textocpcorreu
call printf
addl $4, %esp
 movl $1, fimmao
movl $1, venceumao
movl pontosjg, %eax
addl $9, %eax
movl %eax, pontosjg
ret

jgaceitanove:
pushl $textojgaceitou
call printf
addl $4, %esp

movl $9, niveldamao

movl $niveldamao, %eax
movl $0, 4(%eax) # computador chamou nove
call cpjoga1carta
ret

jgcorrenove:
pushl $textojgcorreu
call printf
addl $4, %esp

movl $1, fimmao

movl $0, venceumao
movl pontoscp, %eax
addl $6, %eax
movl %eax, pontoscp
ret

cpcorreseis:
pushl $textocpcorreu
call printf
addl $4, %esp

movl $1, fimmao

movl $1, venceumao
movl pontosjg, %eax
addl $3, %eax
movl %eax, pontosjg
ret

cpaceitaseis:
pushl $textocpaceitou
call printf
addl $4, %esp

movl $6, niveldamao

movl $niveldamao, %eax
movl $1, 4(%eax) # jogador chamou seis
call cpjoga1carta
ret

jgaceitatruco:
pushl $textojgaceitou
call printf
addl $4, %esp

movl $3, niveldamao

 movl $niveldamao, %eax
movl $0, 4(%eax) # computador chamou truco
call cpjoga1carta
ret

jgcorretruco:
pushl $textojgcorreu
call printf
addl $4, %esp

movl $1, fimmao

movl $0, venceumao
movl pontoscp, %eax
addl $1, %eax
movl %eax, pontoscp
ret

cpanalisaseis:

movl $niveldamao, %edi

movl 4(%edi), %eax
cmpl $0, %eax
je cpjogaquieto # o proprio computador trucou
call cpchamaseis
ret

cpchamaseis:

pushl $textocpseis
call printf
call getchar # retorna caracter lido em %eax
movl %eax, resp
call getchar # coleta enter
addl $4, %esp

movl resp, %eax

cmpl $'1', %eax
je jgaceitaseis
cmpl $'2', %eax
je jgcorreseis

jgchamanove:
call retornaprob
cmpl $3, %eax
je cpcorrenove
cmpl $2, %eax
je cpaceitanove

cpchamadoze:
pushl $textocpdoze
call printf
call getchar # retorna caracter lido em %eax
movl %eax, resp
call getchar # coleta enter
addl $4, %esp

movl resp, %eax

cmpl $'2', %eax
je jgcorredoze
 jgaceitadoze:
movl $12, niveldamao
movl $niveldamao, %eax
movl $0, 4(%eax) # computador chamou doze
call cpjoga1carta
ret

jgcorredoze:
pushl $textojgcorreu
call printf
addl $4, %esp

movl $1, fimmao

movl $0, venceumao
movl pontoscp, %eax
addl $9, %eax
movl %eax, pontoscp
ret

cpanalisanove:

movl $niveldamao, %edi

movl 4(%edi), %eax
cmpl $0, %eax
# fazer aqui
ret

cpanalisadoze:

movl $niveldamao, %edi

movl 4(%edi), %eax
cmpl $0, %eax
# fazer aqui
ret
jgjoga:
pushl $textojgjoga
call printf
addl $4, %esp
call getchar

# fazer aqui

# apenas para testar

call mostracartas
call checalance
call alternaquemjoga
ret

cpaceitanove:
# fazer aqui
ret

cpcorrenove:
# fazer aqui
ret

jgcorreseis:
# fazer aqui
ret

jgaceitaseis:
# fazer aqui
ret

retornaprob:

call rand
movl $0, %edx
divl cem

cmpl $50, %edx

jl probalta
cmpl $75, %edx
jl probmedia

probbaixa:
movl $3, %eax
jmp contprob

probalta:
movl $1, %eax
jmp contprob

probmedia:
movl $2, %eax

contprob:
pushl %eax
pushl $textoprob
call printf
addl $4, %esp
popl %eax

ret

cpjoga1carta:

call cpescolhecarta # escolhe (0, 1 ou 2) e retorna em %eax

call checalance
call alternaquemjoga
call mostracartas

ret

cpescolhecarta:

call rand
movl $0, %edx
divl tres # %edx esta com o ordem da carta (0, 1 ou 2)

movl $statuscp, %edi

movl %edx, %eax
movl %eax, registrador # backup
movl $0, %edx
mull quatro
 addl %eax, %edi
movl (%edi), %ecx
cmpl $0, %ecx
jne cpescolhecarta
movl $poderescp, %esi
addl %eax, %esi
movl (%esi), %ecx
movl %ecx, podercp
movl $1, (%edi) # alterar status pra ela ser mostrada
movl registrador, %eax # restaura
ret

checalance:
incl nrojogada
movl nrojogada, %eax
cmpl $2, %eax # duas jogadas fecha um lance -> anota situacao
jl fimchecalance

finalizalance:
movl $0, nrojogada
incl nrolance
movl nrolance, %eax
cmpl $3, %eax
jl contchecalance
movl $1, fimmao

contchecalance:
movl podercp, %eax
movl poderjg, %ebx
cmpl %ebx, %eax
jl jgvencelanceatual2
jg cpvencelanceatual2

call empatalanceatual
jmp fimchecalance

jgvencelanceatual2:
call jgvencelanceatual
jmp fimchecalance

cpvencelanceatual2:
call cpvencelanceatual

fimchecalance:
ret

empatalanceatual:
pushl $textolanceempatou
call printf
addl $4, %esp

# primeiro registra o empate

movl $statuslances, %edi
movl nrolance, %eax # vai de 1 a 3
decl %eax # para variar de 0 a 2
movl $0, %edx
mull quatro
addl %eax, %edi
movl $2, (%edi)
 movl nrolance, %eax
cmpl $1, %eax
je fimempatalanceatual # empatou 1o lance -> decide em proximo

# empatou no segundo ou terceiro lance -> checa lances anteriores

checalance1:

movl statuslances, %eax # move o status do lance 1

cmpl $2, %eax
je empatoulance1
cmpl $0, %eax
je cpvenceulance1

jgvenceulance1: # entao jg ganhou a mao

movl $1, fimmao
movl $1, venceumao
addl niveldamao, %eax
addl %eax, pontosjg
jmp fimempatalanceatual

cpvenceulance1: # entao cp ganhou a mao

movl $1, fimmao
movl $0, venceumao
addl niveldamao, %eax
addl %eax, pontoscp
jmp fimempatalanceatual

empatoulance1:
movl nrolance, %eax
cmpl $2, %eax
je fimempatalanceatual # empatou 1o e 2o lances -> decide em proximo

checalance2:
# senao, acabou a mao e lance 2 só pode ter empatado tambem, senao
# já teria definido empatou todos os lances -> pontos pra ninguem

movl $2, venceumao

movl $1, fimmao

fimempatalanceatual:
ret

jgvencelanceatual:
pushl $textojgvenceulance
call printf
addl $4, %esp

# primeiro registra a vitoria do jg

movl $statuslances, %edi
movl nrolance, %eax
decl %eax
movl $0, %edx
mull quatro
addl %eax, %edi
movl $1, (%edi)

movl nrolance, %eax

 cmpl $1, %eax
je fimjgvencelanceatual # 1o lance -> a mao soh comecou

cmpl $2, %eax

je jgchecalance1

# se esta no lance 3, entao jg venceu a mao

movl $1, fimmao
movl $1, venceumao
addl niveldamao, %eax
addl %eax, pontosjg
jmp fimjgvencelanceatual

jgchecalance1:

movl statuslances, %eax # move o status do lance 1

cmpl $0, %eax
je fimjgvencelanceatual # cp venceu lance 1 -> define no proximo

# jg venceu ou empatou o 1o lance -> entao vence a mao

movl $1, fimmao
movl $1, venceumao
addl niveldamao, %eax
addl %eax, pontosjg

fimjgvencelanceatual:
ret

cpvencelanceatual:
pushl $textocpvenceulance
call printf
addl $4, %esp

# primeiro registra a vitoria do cp

movl $statuslances, %edi
movl nrolance, %eax
decl %eax
movl $0, %edx
mull quatro
addl %eax, %edi
movl $0, (%edi)

movl nrolance, %eax

cmpl $1, %eax
je fimcpvencelanceatual # 1o lance -> a mao soh comecou

cmpl $2, %eax

je cpchecalance1

# se esta no lance 3, entao cp venceu a mao

movl $1, fimmao
movl $0, venceumao
addl niveldamao, %eax
addl %eax, pontoscp
jmp fimcpvencelanceatual

cpchecalance1:

movl statuslances, %eax # move o status do lance 1

 cmpl $1, %eax
je fimcpvencelanceatual # jg venceu lance 1 -> define no proximo

# cp venceu ou empatou o 1o lance -> entao vence a mao

movl $1, fimmao
movl $0, venceumao
addl niveldamao, %eax
addl %eax, pontoscp

fimcpvencelanceatual:
ret

alternaquemjoga:

incl quemjoga
movl quemjoga, %eax
movl $0, %edx
divl dois
movl %edx, quemjoga

ret

alternamaodequem:

incl maodequem
movl maodequem, %eax
movl $0, %edx
divl dois
movl %edx, maodequem
movl %edx, quemjoga

ret

mostracartas:

pushl nrodamao
pushl $texto0
call printf
addl $8, %esp

call mostravira

pushl $texto2
call printf
addl $4, %esp

call mostrapontos

movl $idcartasjg, %edi

movl $naipesjg, %esi
movl $statusjg, %edx

call empilhacartas

movl $idcartascp, %edi

movl $naipescp, %esi
movl $statuscp, %edx

call empilhacartas
 pushl $texto4
call printf

addl $52, %esp

ret

# empilha as cartas para serem mostradas

empilhacartas:

popl %ebx
movl %ebx, retorno
movl $3, %ecx

addl $8, %edx

addl $8, %edi
addl $8, %esi

volta4:

movl (%edx), %ebx

cmpl $0, %ebx
jne abrecarta
movl $'#', %eax # carta fechada
pushl %eax
pushl %eax
jmp proximo

abrecarta:

movl (%esi), %eax

pushl %eax
movl (%edi), %eax
pushl %eax

proximo:

subl $4, %edx

subl $4, %edi
subl $4, %esi

loop volta4

pushl retorno

ret

mostravira:

movl $vira, %edi

movl 4(%edi), %eax
pushl %eax
movl (%edi), %eax
pushl %eax

pushl $texto1
call printf
addl $12, %esp
ret

mostrapontos:

pushl pontosjg
pushl pontoscp
pushl $texto3
call printf
addl $12, %esp

ret

tratafimmao:

movl fimmao, %eax

cmpl $0, %eax
je contmao # a mao ainda nao acabou

movl venceumao, %eax

cmpl $0, %eax
je tratacpvenceumao

cmpl $1, %eax

je tratajgvenceumao

tratamaoempatou:

pushl $textomaoempatou
call printf
jmp contmao

tratacpvenceumao:
pushl $textocpvenceumao
call printf
jmp contmao

tratajgvenceumao:
pushl $textojgvenceumao
call printf

contmao:

addl $4, %esp

ret

checafimpartida:

movl pontosjg, %eax

cmpl $12, %eax
jge tratajgvenceu

movl pontoscp, %eax

cmpl $12, %eax
jge tratacpvenceu

# ningum venceu ainda

jmp contpartida
 tratajgvenceu:
movl $12, pontosjg
movl $1, venceupartida
movl $1, fimpartida
jmp contpartida

tratacpvenceu:
movl $12, pontoscp
movl $0, venceupartida
movl $1, fimpartida

contpartida:

ret

resetamao:

# fazer aqui
# cartas sorteadas
# status das cartas do computador e jogador
# status dos lances
# nivel da mao
# variaveis de controle do lance

movl $0, fimmao

movl $0, nrolance
movl $0, nrojogada
movl $3, venceumao

movl $statuslances, %edi

movl $3, (%edi)
movl $3, 4(%edi)
movl $3, 8(%edi)

movl $statuscp, %edi

movl $0, (%edi)
movl $0, 4(%edi)
movl $0, 8(%edi)

movl $statusjg, %edi

movl $0, (%edi)
movl $0, 4(%edi)
movl $0, 8(%edi)

movl $niveldamao, %edi

movl $1, (%edi)
movl $2, 4(%edi)

movl $sorteadas, %edi

movl $10, %ecx

voltaresetamao:
movl $0, (%edi)
addl $4, %edi
loop voltaresetamao

ret
mostrafinal:
pushl $textofimpartida
call printf
movl venceupartida, %eax
cmpl $0, %eax
je cpvenceupartida

jgvenceupartida:
pushl pontosjg
pushl $textojgvenceupartida
call printf

cpvenceupartida:
pushl pontoscp
pushl $textocpvenceupartida
call printf

fimgeral:

addl $12, %esp

ret