# Nikola Rebraca

# Y*RESX/8 + X/8

.section .data
RESX = 80   # horizontalna rezolucija, mora biti deljiva sa 8
RESY = 25   # vertikalna rezolucija
bitmap: .fill RESX*RESY/8,1,0   # video memorija
printnew: .ascii "\n\n\n\n\0"   # pomoćni stringovi za iscrtavanje video memorije
printdot:   .ascii "#\0"
printspc:   .ascii ".\0"
printx: .ascii "    X1=\0"      # dodatni string za ispis ispod bitmape
printx_len = .-printx

printy: .ascii "    Y1=\0"
printy_len = .-printy

str_x:	.fill	5, 1, 0
x_len =	5
str_y:	.fill	5, 1, 0
y_len =	5

x:	.long	1
y:	.long	1

smerx:	.long	1
smery:	.long	1

max_x:	.long	RESX-1
max_y:	.long	RESY-1

pomeraj: .long	0

# konstanta za generisanje pauze prilikom iscrtavanja, treba je prilagoditi
# sopstvenom računaru, ukoliko je animacija previše brza ili spora
PAUZA = 0x10000000

.section .text
.globl main

main:
    #orb $0x80, bitmap+RESX*RESY/8/3     # iscrtavanje tačke na sredini ekrana

    # glavna petlja programa

	#postavljanje okvira
okvir_gore:
	movl	$bitmap,	%ecx
	movb	$255,		%bl
	movl	$RESX/8,	%edx
ok_g:
	cmpl	$0,		%edx
	je	okvir_dole
	movb	%bl,		(%ecx)
	decl	%edx
	incl	%ecx
	jmp	ok_g
okvir_dole:
	movl	$bitmap,	%ecx
	addl	$8*30,		%ecx
	movl	$RESX/8,	%edx
ok_d:
	cmpl	$0,		%edx
	je	okvir_levo
	movb	%bl,		(%ecx)
	decl	%edx
	incl	%ecx
	jmp	ok_d
okvir_levo:
	movl	$bitmap,	%ecx
	movb	$128,		%bl
	movl	%ecx,		%edx
	addl	$8*30,		%edx
ok_l:
	addl	$10,		%ecx
	cmpl	%edx,		%ecx
	je	okvir_desno
	movb	%bl,		(%ecx)
	jmp	ok_l
okvir_desno:
	movl	$bitmap,	%ecx
	addl	$9,		%ecx
	movb	$1,		%bl
	movl	%ecx,		%edx
	addl	$8*30,		%edx
ok_de:
	addl	$10,		%ecx
	cmpl	%edx,		%ecx
	je	koory
	movb	%bl,		(%ecx)
	jmp	ok_de

koory:
	movl	smery,		%eax
	cmpl	$0,		%eax
	jle	negaty

	movl	y,		%eax
	incl	%eax
	incl	%eax
	cmpl	max_y,		%eax	#da li je stigao do kraja dole?
	je	dno

	incl	y
	jmp	koorx
negaty:
	movl	y,		%eax
	decl	%eax
	decl	%eax
	cmpl	$0,		%eax	#da li je stigao do kraja gore?
	je	vrh
	decl	y
	jmp	koorx
dno:
	negl	smery
	incl	y
	jmp	koorx
vrh:
	negl	smery
	decl	y
	jmp	koorx

koorx:
	movl	smerx,		%eax
	cmpl	$0,		%eax
	jle	negatx

	movl	x,		%eax
	incl	%eax
	incl	%eax
	cmpl	max_x,		%eax	#da li je stigao do kraja desno?
	je	desno
	incl	x

	jmp	petljica
negatx:
	movl	x,		%eax
	decl	%eax
	decl	%eax
	cmpl	$0,		%eax	#da li je stigao do kraja levo?
	je	levo
	decl	x
	jmp	petljica
desno:
	negl	smerx
	incl	x
	jmp	petljica
levo:
	negl	smerx
	decl	x
	jmp	petljica

	#namestanje odgovarajuceg bita za stampanje
petljica:
	movl	$8,		%edi
	movb	$1,		%bl
	movl	x,		%eax
	xorl	%edx,		%edx
	divl	%edi

	cmpl	$7,		%edx	#maska za ostatak 7 je 0x01
	je	maska

	rorb	$1,		%bl	#maska za ostatak 0 je 0x10
stelovanje:
	cmpl	$0,		%edx
	je	maska

	rorb	$1,		%bl

	decl	%edx

	jmp	stelovanje
#cuva okvir sa strane
maska:
	movl	$8,		%edi
	cmpl	x,		%edi
	jg	mask
	movl	$71,		%esi
	cmpl	x,		%esi
	jl	mas
	jmp	petlja
mas:
	orb	$1,		%bl
	jmp	petlja
mask:
	orb	$0x80,		%bl

	#namestanje odgovarajuceg bajta za stampanje
petlja:
	movl	$RESX,		%eax
	mull	y
	movl	$8,		%edi
	divl	%edi
	movl	%eax,		pomeraj

	movl	x,		%eax
	divl	%edi
	addl	%eax,		pomeraj

	movl	$bitmap,	%ecx
	addl	pomeraj,	%ecx

	movb	%bl,		(%ecx)	#postavi tacku za stampanje

	pushl	%ecx

    call printbitmap                    # iscrtavanje bitmape

	pushl	$str_x
	pushl	x
	call	broj_u_string
	addl	$8,		%esp

    movl $4, %eax                       # ispis poruke
    movl $1, %ebx
    movl $printx, %ecx
    movl $printx_len, %edx
    int $0x80

	movl	$4,		%eax
	movl	$1,		%ebx
	movl	$str_x,		%ecx
	movl	$x_len,		%edx
	int	$0x80

	pushl	$str_y
	pushl	y
	call	broj_u_string
	addl	$8,		%esp

	movl	$4,		%eax
	movl	$1,		%ebx
	movl	$printy,	%ecx
	movl	$printy_len,	%edx
	int	$0x80

	movl	$4,		%eax
	movl	$1,		%ebx
	movl	$str_y,		%ecx
	movl	$y_len,		%edx
	int	$0x80

#brisanje prethodno odstampane tacke

	popl	%ecx
brisi:
	movb	$0,		%bl

	movl	$8,		%edi
	cmpl	x,		%edi
	jg	obr
	movl	$71,		%esi
	cmpl	x,		%esi
	jl	br
	jmp	obrisi
br:
	orb	$0x01,		%bl
	jmp	obrisi
obr:
	orb	$0x80,		%bl
obrisi:
	andb	%bl,		(%ecx)

    # na kraju glavne petlje programa se pravi pauza
    # kako bi uzastopna iscrtavanja ekrana dala animaciju
    movl $PAUZA, %eax

pauza:
    decl %eax
    jnz pauza
    jmp koory          # izlaz iz programa je CTRL+C !!!

    movl $1, %eax
    movl $0, %ebx
    int $0x80

#void broj_u_string()
#potprogram koji pretvara broj u string, heksadecimalni zapis

broj_u_string:
	pushl	%ebp
	movl	%esp,		%ebp
	pushl	%ebx

	movl	12(%ebp),	%ecx	#adresa stringa
	movl	8(%ebp),	%eax	#broj
	xorl	%edx,		%edx
	movl	$16,		%ebx

	movl	$0,		(%ecx)

	cmpl	$0,		%eax
	jne	konvert

	movb	$'0',		%dl
	movb	%dl,		(%ecx)
	jmp	kraj
konvert:
	cmpl	$0,		%eax
	je	na_kraj
	xorl	%edx,		%edx
	divl	%ebx
	cmpl	$10,		%edx
	jge	slovo

	addb	$'0',		%dl
	movb	%dl,		(%ecx)
	incl	%ecx
	jmp	konvert
slovo:
	addb	$55,		%dl
	movb	%dl,		(%ecx)
	incl	%ecx
	jmp	konvert

na_kraj:
	movl	12(%ebp),	%ecx
	movl	%ecx,		%edx
navig:
	cmpb	$0,		(%edx)
	je	obrni
	incl	%edx
	jmp	navig

obrni:
	movb	(%edx),		%bl
	movb	(%ecx),		%bh
	movb	%bh,		(%edx)
	movb	%bl,		(%ecx)

	cmpl	%ecx,		%edx
	jle	kraj
	incl	%ecx
	decl	%edx
	jmp	obrni

kraj:
	popl	%ebx
	popl	%ebp
	ret


# void printbitmap()
# Potprogram koji iscrtava trenutni izgled monohromatskog ekrana
# Svaka uključena tačka se ispisuje kao karakter "printdot".
printbitmap:
    pushl %ebp
    movl %esp, %ebp
    pushl %ebx
    pushl %esi
    pushl %edi

    movl $RESX, %esi    # brojač X koordinate
    movl $RESY, %edi    # brojač Y koordinate
    movl $4, %eax       # ispis 4 newline-a
    movl $1, %ebx
    movl $printnew, %ecx
    movl $4, %edx
    int $0x80

    movl $bitmap, %edx  # pokazivač za prolazak kroz bitmapu

print_petlja1:
    movb (%edx), %bl    # 8 tačaka za ispis
    movb $8, %bh        # brojač tačaka

print_petlja2:
    movl $printspc, %ecx
    shlb $1, %bl        # da li se ispisuje tačka ili praznina?
    jnc print_ispis
    movl $printdot, %ecx
print_ispis:
    pushl %edx          # ispis tačke ili praznine
    pushl %ebx
    movl $4, %eax
    movl $1, %ebx
    movl $1, %edx
    int $0x80
    popl %ebx
    popl %edx

    decb %bh            # da li je ispisano 8 tačaka?
    jnz print_petlja2
    incl %edx           # prelazak na sledećih 8 tačaka
    subl $8, %esi       # da li je ispisan ceo red?
    jnz print_petlja1

    movl $RESX, %esi    # priprema brojača X koordinate za ispis sledećeg reda
    pushl %edx          # ispis jednog newline-a
    pushl %ebx
    movl $4, %eax
    movl $1, %ebx
    movl $printnew, %ecx
    movl $1, %edx
    int $0x80
    popl %ebx
    popl %edx

    decl %edi           # da li su ispisani svi redovi?
    jnz print_petlja1

    popl %edi           # vraćanje sačuvanih registara i završetak
    popl %esi
    popl %ebx
    movl %ebp, %esp
    popl %ebp
    ret