hilfe bei emu8086

hallo an alle!
ich bin total neu im gebiet assembler, deswegen wollte ich fragen ob ihr mir helfen könnt. das problem ist folgendes: ich will ein programm schreiben, welches auf der konsole einen kreis zeichnet, ich weis jedoch nicht wie ich anfangen soll. könnt emir bitte jemand helfen? würde sehr dankbar sein!

newguy schrieb:

hallo an alle!
ich bin total neu im gebiet assembler, deswegen wollte ich fragen ob ihr mir helfen könnt. das problem ist folgendes: ich will ein programm schreiben, welches auf der konsole einen kreis zeichnet, ich weis jedoch nicht wie ich anfangen soll. könnt emir bitte jemand helfen? würde sehr dankbar sein!

Anfangen:
Für einen kleinen Kreis würde vermutlich eine Wurzel-Berechnung ausreichen?
Sonst wäre die Berechnung mit Sin/Cos möglicherweise etwas genauer, damit keine Lücken entstehen.

Dirk

volkard

Und dann dieser circle hack d=0.242; x+=d*y; y-=d*x; (früher erschien unter "circle hack" die mathematik dazu, jetzt nicht mehr.( )

Und Bresenham bzw http://en.wikipedia.org/wiki/Midpoint_circle_algorithm

rkhb

Ach, Ihr seid ja gemein. EMU8086 emuliert ganz knallhart einen 8086-Prozessor. Da gibts keine Wurzel und Gleitkommazahlen (FPU).

@newguy: Hier bitte:

#MAKE_COM#    ; emu8086 soll ein COM-Programm herstellen
ORG 100h           ; Beginn des geladenen COM-Programms

        ; DS & ES = CS (eigentlich überflüssig)
        mov ax, cs
        mov ds, ax
        mov es, ax

        ; Achtelkreis: Methode von Horn
        ; http://de.wikipedia.org/wiki/Rasterung_von_Kreisen#Midpoint-Algorithmus
        mov di, OFFSET xy
        mov cx, 0

        loop1:
        mov al, [y]
        mov ah, [x]
        cmp ah, al                      ; x < y ?
        jl endloop1                     ; ja -> Schleifenende
        stosw                           ; x & y in die xy-Tabelle eintragen

        xor ah, ah                       ; // d = 2*y + d + 1
        shl ax, 1
        add ax, [d]
        inc ax
        mov d, ax
        inc [y]

        cmp ax, 0                       ; d > 0 ?
        jle loop1                       ; nein -> continue

        xor dx, dx                       ; // d = d - 2*x + 2
        mov dl, [x]
        shl dx, 1
        sub ax, dx
        add ax, 2
        mov d, ax
        dec [x]

        jmp loop1
        endloop1:

        ; Viertelkreis: zusätzlich gespiegelte Werte vom Achtelkreis
        mov si, di
        loop2:
        sub si, 2
        mov ax, [si]
        xchg al, ah
        stosw
        cmp si, OFFSET xy
        jne loop2
        shl cx, 1

        ; Halbkreis: zusätzlich negierte x-Werte vom Viertelkreis
        mov si, di
        loop3:
        sub si, 2
        mov ax, [si]
        neg ah
        stosw
        cmp si, OFFSET xy
        jne loop3
        shl cx, 1

        ; Vollkreis: zusätzlich negierte y-Werte vom Halbkreis
        mov si, di
        loop4:
        sub si, 2
        mov ax, [si]
        neg al
        stosw
        cmp si, OFFSET xy
        jne loop4
        shl cx, 1

        xor ax, ax
        mov [di], ax

        ; Ausgabe
        mov ax, 0B800h                  ; ES = Video-RAM
        mov es, ax
        mov bl, '*'                     ; BX: Weißer Stern
        mov bh, 0x0F                    ; Vordergrund weiß, Hintergrund schwarz

        ; Mittelpunkt zeichnen
        mov ah, 40                      ; x
        mov al, 12                      ; y
        mov cx, ax                      ; Mittelpunkt merken
        call vec2ofs                    ; Vektor in Offsetadresse umrechnen
        mov es:[di], bx                 ; zeichnen

        ; Kreis zeichnen
        mov si, OFFSET xy               ; Tabellenanfang
        loop5:
        lodsw
        test ax, ax                     ; Tabellenende?
        je endloop5                     ; ja -> Ende
        add al, cl                      ; relativen Vektor zum Mittelpunkt addieren
        add ah, ch
        call vec2ofs                    ; Vektor in Offsetadresse umrechnen
        mov es:[di], bx                 ; zeichnen
        jmp loop5
        endloop5:

        ret                             ; Programmende

        ; Funktion vec2ofs: Umrechnung von Punkten zu Offset im Videoram
        vec2ofs:                        ; Übergabe: al,ah = x,y
        xor dx, dx
        mov dl, ah
        xor ah, ah
        mov ah, 80
        mul ah
        add ax, dx
        mov di, ax
        shl di, 1
        ret

        ; Variablen
        r dw 10
        d dw -10
        x db 10
        y db 0
        xy: dw 00                       ; expandiert nach hinten!

Und nun überleg Dir, ob Du Assembler nicht mit etwas kleineren Brötchen anfangen willst.

viele grüße
ralph

danke für die schnelle antwort! und danke auch für den tipp ich dachte assembler wäre leichter, doch anscheinend habe ich mich gewaltig getäuscht ich werde wohl von ganz ganz unten starten müssen! nochmals danke!