játékfejlesztés.hu
FórumGarázsprojectekCikkekSegédletekJf.hu versenyekKapcsolatokEgyebek
Legaktívabb fórumozók:
Asylum:    5440
FZoli:    4892
Kuz:    4455
gaborlabor:    4449
kicsy:    4304
TPG:    3402
monostoria:    3284
DMG:    3172
HomeGnome:    2919
Matzi:    2519

Pretender:    2498
szeki:    2440
Seeting:    2306
Geri:    2185
Orphy:    1893
Joga:    1791
Bacce:    1783
MaNiAc:    1735
ddbwo:    1625
syam:    1491
Frissebbek | [1] > 2 <
nadam - Törzstag | 364 hsz       Online status #103029   2009.01.21 06:29 GMT+1 óra  
Gaborious:
Ismerni kellene a C++-os string megvalósítását, anélkül csak azt tudom mondani, hogy próbálj ki minél több változatot. (meg amúgy is)
Azért a c_str() - es megoldást, amit utoljára írtam próbáld ki. Nem ismerem a C++-os standard string megvalósítását, de ha véletlen függvényhívást csinál az elemelérésből, vagy neadjisten indexhatárokat ellenőriz akkor a c_str() - es megoldás jóval gyorsabb.

A Hash kódot én úgy cachelném, hogy lenne egy saját string osztályom 'MyString' amit pl. a 'string'-ből leörököltetsz, vagy esetleg csak memberként tartalmaz egy igazi 'string'-et. Ebben a MyString-ben kell egy 'unsigned int hash' member, amit 0-ra inicializálnék.

És egy ilyen member functionnel kérném tőle a hash-t:

Kód:
unsigned int getHash()
{
if(hash == 0) hash = calculateHash();
return hash;
}


Ezt hívtam cachelésnek, de asszem lusta elérésnek is hívják talán.
   
dothumour - Tag | 75 hsz       Online status #103027   2009.01.21 06:23 GMT+1 óra  
Idézet
nadam :
Miért 2^6 + 2^16 - 1 az nem 65599? Mit nézek el?


Semmit, én néztem el... << helyett >>-re gondoltam, bocsi.
٩(͡๏̯͡๏)۶

   
Gaborious - Tag | 50 hsz       Online status #103026   2009.01.21 06:18 GMT+1 óra  
Hogyan tudnám cachelni a hash kódot?

// Tényleg most esett le hogy csak 32bites az algo, de a cél a 64 bit volt valszeg elfelejtettem átírni azzá

@nadam
régebben én is próbálkoztam hasonló "gyorsításokkal" de elképedve láttam hogy pl a
profiler a korábbinál több időt jelzett ezen módosítások után
Így pl külön változóba kimenteni a string méretét vmiért "lassította" a dolgot...

Talán azt nem árultam el, hogy nem csak a cikluson belüli számítást kell gyorsítani mert az egy dolog... Maga a fv sokszor hívódik meg így talán hátrányos lehet ha minden fv híváskor kelleténél több változó jön létre.
[Silent Vertigo] { Solarah }
SilentVertigo Honlap
   
nadam - Törzstag | 364 hsz       Online status #103025   2009.01.21 06:06 GMT+1 óra  
Idézet
dothumour :
Bocs, nadam, de szerintem a szorzásos trükköd nem jó.
Egyébként a loop unrollolása (ez hogy van magyarul? A ciklus kifejtése/kibontása?) dobhat rajta sokat.



Miért 2^6 + 2^16 - 1 az nem 65599? Mit nézek el?

Igen, loop unrolling még dobhat rajta.

Szerk.:
Részletesen levezetve:

(hash << 6) + (hash << 16) - hash

= hash * 2^6 + hash * 2 ^ 16 - hash

=hash*(2^6 + 2^16 - 1)

=hash*65599

Ami nagyon régi procikon még nem biztos hogy gyorsabb volt, mert a shifelés annyival gyorsabb volt mint a szorzás, de egy mai procin asszem az integer mul is 1 órajel.

Ezt a hozzászólást nadam módosította (2009.01.21 06:21 GMT+1 óra, ---)
   
dothumour - Tag | 75 hsz       Online status #103024   2009.01.21 06:01 GMT+1 óra  
Bocs, nadam, de szerintem a szorzásos trükköd nem jó.
Egyébként a loop unrollolása (ez hogy van magyarul? A ciklus kifejtése/kibontása?) dobhat rajta sokat.
٩(͡๏̯͡๏)۶

   
nadam - Törzstag | 364 hsz       Online status #103023   2009.01.21 05:54 GMT+1 óra  
dothumour:
megelőztél, amit írtál az már elég optimálisnak tűnik. Talán a szorzásos trükköm hoz egy minimálisat rajta... (nameg érdemes cachelni a hash kódot)
(szvsz asm-ra átírni valamit csak akkor éri meg ha már végképp nincs más optimalizálni való , ami persze csak agyonoptimalizált kóddal esik meg. És szvsz ha átírjuk ASM-ra önmagában nemigen lesz gorsabb, leginkább tényleg csak akkor ha speciális utasításokat használunk, mint az MMX...)

Ezt a hozzászólást nadam módosította (2009.01.21 06:03 GMT+1 óra, ---)
   
nadam - Törzstag | 364 hsz       Online status #103022   2009.01.21 05:51 GMT+1 óra  
Gaborious:
Talán lehet rajta optimalizálni ASM nélkül is:
Így talán gyorsabb egy kicsit:

Kód:
int64 GetHash(const string& key)
{
   int64 hash = 0;
   unsigned int length = key.length();
   for(unsigned int i = 0; i < length; i++)
   {
      hash = key[i] + hash*65599;
   }
   return (hash & 0x7FFFFFFF);
}


32 bitesen biztos, hogy nem jó?
Pl. így:

Kód:
unsigned int GetHash(const string& key)
{
   unsigned int hash = 0;
   unsigned int length = key.length();
   for(unsigned int i = 0; i < length; i++)
   {
      hash = key[i] + hash*65599;
   }
   return hash;
}


Esetleg így még gyorsabb, ki kéne próbálni:

Kód:
unsigned int GetHash(const string& key)
{
   const char* buf = key.c_str();
   unsigned int hash = 0;
   unsigned int length = key.length();
   for(unsigned int i = 0; i < length; i++)
   {
      hash = buf[i] + hash*65599;
   }
   return hash;
}


+Ha lehet és van értelme, akkor cachelném a hash kódot: ha egy stringre egyszer kiszámoltam, akkor már ne kelljen mégegyszer.
   
dothumour - Tag | 75 hsz       Online status #103020   2009.01.21 05:45 GMT+1 óra  
Csak azért kérdezem, mert a 0x7FFFFFFF az 31 bitet enged át szóval 32 elégnek tűnik, teljesen biztos vagy benne, hogy 64-bit kell?

Rákerestem Google-n a "SDBMHash" kifejezésre és ezt az implementációt találtam, itt csak 32 bites...
Kód:
unsigned int SDBMHash(unsigned char *str, unsigned int len)
{
   unsigned int hash = 0;
   unsigned int i    = 0;

   for(i = 0; i < len; str++, i++)
   {
      hash = (*str) + (hash << 6) + (hash << 16) - hash;
   }

   return hash;
}
٩(͡๏̯͡๏)۶

   
Gaborious - Tag | 50 hsz       Online status #103019   2009.01.21 05:35 GMT+1 óra  
int64 kell , az int32 nem elég és preferálnám az mmx kódot (mivel az remélhetőleg gyorsabb)
[Silent Vertigo] { Solarah }
SilentVertigo Honlap
   
dothumour - Tag | 75 hsz       Online status #103018   2009.01.21 05:28 GMT+1 óra  
Gaborious: Biztos kell, hogy int64 legyen a hash? Sima x86 kód vagy MMX kód kell?
٩(͡๏̯͡๏)۶

   
Gaborious - Tag | 50 hsz       Online status #103009   2009.01.21 04:07 GMT+1 óra  
Tudna nekem vki segíteni? Egy kis c++ kódot kéne átültetni asm be ...

Kód:
//SDBMHash
int64 GetHash(const string& key)
{
   
   int64 hash = 0;

   for(unsigned int i = 0; i < key.length(); i++)
   {
      hash = key[i] + (hash << 6) + (hash << 16) - hash;
   }

   return (hash & 0x7FFFFFFF);

}


igazándiból a sebesség miatt kéne átírni asm be...

Előre is köszönöm a segítséget.
[Silent Vertigo] { Solarah }
SilentVertigo Honlap
   
HCodename47 - Törzstag | 231 hsz       Online status #98276   2008.11.03 08:15 GMT+1 óra  
Angolul van, mégis jobban értem, mint a tanár hablatyát! THX!
Maximális tisztelettel: Codename47

-Desktop PC: Intel i5 2.8 Ghz, 8Gb DDR3, ATi HD 5770 (W7 SP1 x64)
-Laptop: Acer Aspire 5112 - AMD Turio64 x2 1.6 Ghz, 3Gb DDR2, ATi Mobility Radeon X1600 (XP SP3 x86)
http://codename47.bayi.hu
   
Asylum - Törzstag | 5440 hsz       Online status #98265   2008.11.03 07:52 GMT+1 óra  
http://www.jegerlehner.ch/intel/IntelCodeTable.pdf

mindenre ottvan, hogy hogyan számolja.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
HCodename47 - Törzstag | 231 hsz       Online status #98224   2008.11.03 00:08 GMT+1 óra  
Üdv,

Igen, így ahogy van volt fenn egy fórumon. És nekem is ez a fő bajom vele, hogy 2 regiszter kellene hozzá... meg hogy én baromira nem tudok ilyen kis lépésekben gondolkodni, mint az asm
Maximális tisztelettel: Codename47

-Desktop PC: Intel i5 2.8 Ghz, 8Gb DDR3, ATi HD 5770 (W7 SP1 x64)
-Laptop: Acer Aspire 5112 - AMD Turio64 x2 1.6 Ghz, 3Gb DDR2, ATi Mobility Radeon X1600 (XP SP3 x86)
http://codename47.bayi.hu
   
Asylum - Törzstag | 5440 hsz       Online status #98218   2008.11.02 17:35 GMT+1 óra  
az a vicc ebben, hogy az x86 regiszterei 4 bájtosak, tehát a quadwordhöz két regisztert is fel kell használni.

a gyökvonásos kódot igy asm kódként vadásztad? mert akkor itt van c++ -ban (érthetöbb)

Kód:
float mysqrt(const float in)
{
    float r = in / 2.0f;

    for( int i = 0; i < PRECISION; i++ )
        r = (r + (in / r)) / 2.0f;

    return r;
}


egyébként babiloni módszernek hivják.
ha esetleg a regiszterek nem lennének elegek, akkor ott a stack.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
HCodename47 - Törzstag | 231 hsz       Online status #98129   2008.11.02 10:05 GMT+1 óra  
Üdv!

Egy kis segítségre lenne szükségem a hozzáértőbbektől. Beadandó feladatnak kaptunk Assembly programozás órán, hogy vonjunk gyököt a neptun kódunkból (aki nem tudja hogy az mi, mondok rá példát: B2QWMP). Ugyebár ebben vannak betűk, de az nem gond, mert ASCII kódként vannak tárolva. Netről vadásztam egy gyökvonásos kódot:

Kód:
TITLE  Negyzetgyokvonas elojel nelkuli egesz szambol
        .MODEL SMALL
        .386
;-------------------------------------------------------------------------
        .CODE                     ;Code szegmens
Sqrt_Dw PROC                      ;Az Sqrt_Dw procedura kezdete
        PUBLIC Sqrt_Dw
        CMP EAX,0                 ;megvizsgalja, hogy  n=0 teljesul-e
        JZ  vege                  ;ha igen, a futas veget er, ha nem, tovabbmegy
        CMP EAX,1                 ;megvizsgalja, hogy n=1 teljesul-e
        JZ  egy                   ;ha igen, az 'egy' kezdetu sorra ugrik, ha nem, tovabbmegy
        MOV EDI,0
        PUSH EBX
        PUSH ECX                  ;Regiszterek mentesenek vege
        MOV EDX,EAX               ;Az eredeti szamot atteszi EDX-be
        BSR ECX,EDX
        SHR CL,1
        MOV EAX,EDX
        SHR EDX,CL
mehet:  MOV ECX,EAX               ;az eredeti szam ECX-ben
        MOV EAX,EDX               ;EAX regiszterbe betesszuk az an-t
iter:   MOV EBX,EAX               ;a newton-algoritmus kezdete,an EBX-ben
        MOV EAX,ECX               ;az eredeti szam EAX-ban
        MOV EDX,0
        DIV EBX                   ;n osztva an-nel
        ADD EAX,EBX               ;(n/an)+an
        SHR EAX,1                 ;((n/an)+an)/2
        CMP EDI,1
        JNE nincs
        CMP EAX,ESI
        JE ki
        DEC EDI
        MOV ESI,EAX
        JMP nem
nincs:  INC EDI
nem:    CMP EAX,EBX               ;an es a(n+1) osszehasonlitasa
        JNE iter                  ;ha nem egyenlo, ujra fut a ciklus
ki:     MOV EAX,ECX               ;eredeti szam EAX-ba
        MOV EDX,0                 ;EDX nullazasa
        DIV EBX                   ;n mod an
        MOV EAX,EBX               ;an az EAX-ba
        POP ECX                   ;hivas elotti regiszterertekek vissza-
        POP EBX                   ;hozasa a stack-bol
        JMP vege                  ;A procedura vege
egy:    MOV DX,0                  ;ha n=1, x(mod n)=0
vege:   RET                       ;visszateres a hivo procedurahoz

Sqrt_Dw ENDP                      ;Az sqrt procedura vege
;
;****************************************************************************
;*          Sqrt_Dw procedura vege                                          *
;****************************************************************************
        END


De ez dupla szó méretű számból von gyököt, ami 4 bájt, a neptun kód viszont 6 karakter, tehát quadword kéne hozzá. Gondolom nem elég ha a DW-t átírom QW-re... Viszont nem igazán sikerült felfognom amit a tanár magyaráz, így egyedül nem megy a fenti kód átalakítása. Meg mintha hiányos is lenne ... Valaki, ha van egy kis szabadideje pls. segítsen! Előre is köszönöm!
Maximális tisztelettel: Codename47

-Desktop PC: Intel i5 2.8 Ghz, 8Gb DDR3, ATi HD 5770 (W7 SP1 x64)
-Laptop: Acer Aspire 5112 - AMD Turio64 x2 1.6 Ghz, 3Gb DDR2, ATi Mobility Radeon X1600 (XP SP3 x86)
http://codename47.bayi.hu
   
Geri - Törzstag | 2185 hsz       Online status #97146   2008.10.17 09:44 GMT+1 óra  
Megvan félmillió sor?

   
Asylum - Törzstag | 5440 hsz       Online status #97145   2008.10.17 09:39 GMT+1 óra  
de azért imádom, hogy igy látatlanban megmondanak rolam mindent (pl. hogy copyzom a kódokat), mintha csak itt ülne mellettem. A következö az lesz, hogy az enginemet se én irom, hanem a szomszéd Magdi néni...ja bocsánat hiszen az nem is engine...
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Geri - Törzstag | 2185 hsz       Online status #97142   2008.10.17 07:33 GMT+1 óra  
Ne vitatkozz, én is elloptam a végtelentextúra technológiáját 1 évvel azelőtt, hogy kitalálta volna.

   
Asylum - Törzstag | 5440 hsz       Online status #97131   2008.10.16 16:35 GMT+1 óra  
már megbocsáss de magamtól írtam az egészet, a formális nyelvtantól kezdve (merthogy elöször azt kellett beadni, txt formában be is linkeltem valamikor). Egyébként meg honnan copyztam volna monddmérmeg amikor ez egy teljesen spciális nekünk kitalált feladat volt?....
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
newversion - Tag | 197 hsz       Online status #97130   2008.10.16 16:25 GMT+1 óra  
csak mértékkel vágjál fel azzal a koddal, mert te is tudod hogy nagyrészét copyztad
belenéztem a kodba
   
Geri - Törzstag | 2185 hsz       Online status #97122   2008.10.16 14:24 GMT+1 óra  
Nekem anno nagyon tetszett ez a cuccod, Asylum. Azt sajnálom, hogy nem c kompatibilisre írtad, sokra is vihette volna még ez a cucc sztem.

   
Asylum - Törzstag | 5440 hsz       Online status #97121   2008.10.16 13:27 GMT+1 óra  
ha már felvágóskodunk akkor ime egy általam irt (beadando) fordítóprogram ami nasm kódot generál

http://people.inf.elte.hu/asylum/programs/csl.zip

windowsos exe mellékelve van, példakódokkal. A szintaktika hasonlo a C-hez, nemtudom fent van-e még a srác honlapján a specifikáció.
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Joga - Törzstag | 1791 hsz       Online status #97120   2008.10.16 13:01 GMT+1 óra  
Idézet
Asylum :
win32....
linux és nasm. Rengeteg tökjó dolgot tud pl. context stacket; makrókkal lehet definiálni pl. while ciklust is akár. És nagyon egyszerü megtanulni (pl. nincsenek ilyen idiota kulcssavak mint az elözö kodban).

Ha egyszerűségre vágyom, C++, de most itt nem az a lényeg...hanem az élvezet
(ಠ ›ಠ) Stewie!

   
Elf - Törzstag | 932 hsz       Online status #97119   2008.10.16 12:17 GMT+1 óra  
Joga: jópár évvel ezelőtt írtam egy DOS-os scrollert TurboASM-ben (ha jól emléxem). Ha érdekel, letöltheted innen.

WinXP-n ha elindítod, ablakban fog elindulni. Ha látni akarod milyen is valójában, akkor Alt+Enterre rakd teljes képernyősre. Ekkor helyre kell ugrania a színeknek stb.-nek. Remélem hasznos lesz ez a kis program.

Azért berakom ide a forrást is:
Kód:
title Text-mode Scroller

.model small
.286
.stack

;********************************************************************
;********                       ADATOK                       ********
;********************************************************************
.data
      csik       db 219
      csikszin   db 13
      karszam    db 32
      betu       db 16 dup(0)
      bitszam    db 0
      betuszam   dw 0
      elforg     db 0
      szoveg     db ' Assembly text-mode scroller    K‚sz·tette: T·m r Tam s  2000. febru r     '
                 db ' A program 80x25-”s, 16 sz·n karakteres k‚perny”n fut.   '
                 db ' A karakterek adatait a VGA ROM-b˘l olvassa ki, kil‚p‚s ut n '
                 db 'vissza ll·tja az eredeti k‚perny”tartalmat ‚s a sz·npalett t. '
                 db '  Folyamatos mozg s Windows alatt nem ‚rhet” el ‚s a sz·nkezel‚ssel is lehetnek gondok! '
                 db ' Javasolt futtat si k”rnyezet: tiszt n DOS alatt, vagy Win9x alatt a boot-menben '
                 db ' "Csak parancssor"-t v lasztva!     A program a sz”veget a "doll r"-jelig'
                 db ' olvassa, ut nna ism‚tli.   A betk kit”lt”-mint ja a #219-es karakteren'
                 db ' teljes eg‚sz‚ben l that˘: Ű     Kil‚p‚s b rmely billentyre....           $'
      ykoord     db 0
      xkoord     db 79
      kurz_x     db 0
      kurz_y     db 0
      kurz_page  db 0
      original   dw 2000 dup(0)

;                ---1--2--3--4--5--6--7--8--9--10-11-12-13-14-15-16--- szinek fuggoleges sorrendben
      szintabla  db 01,02,03,04,05,06,07,08,09,10,11,12,11,10,09,08
                 db 02,03,04,05,06,07,08,09,10,11,12,11,10,09,08,07
                 db 03,04,05,06,07,08,09,10,11,12,11,10,09,08,07,06
                 db 04,05,06,07,08,09,10,11,12,11,10,09,08,07,06,05
                 db 05,06,07,08,09,10,11,12,11,10,09,08,07,06,05,04
                 db 06,07,08,09,10,11,12,11,10,09,08,07,06,05,04,03
                 db 07,08,09,10,11,12,11,10,09,08,07,06,05,04,03,02
                 db 08,09,10,11,12,11,10,09,08,07,06,05,04,03,02,01,02

      szinpoz    dw 0

      paletta    db  1,63,05,0
                 db  2,63,13,0
                 db  3,63,18,0
                 db  4,63,23,0
                 db  5,63,28,0
                 db 20,63,33,0
                 db  7,63,38,0
                 db 56,63,43,0
                 db 57,63,48,0
                 db 58,63,53,0
                 db 59,63,58,0
                 db 60,63,63,0
                 db 61,0,0,63
                 db 62,0,63,0
                 db 63,0,63,63

;********************************************************************
;********                      FOPROGRAM                     ********
;********************************************************************
.code
start:
       call original_ment   ;az eredeti kepernyotartalmat elmentjuk
       call get_char_xy     ;eltaroljuk a kurzor koordinatait is

       mov ax,_data   ; adatszegemens ds-be
       mov ds,ax
       call keptorles   ;gyors keptorles
       mov betuszam,0   ;kezdeti ertekek nullazasa
       mov szinpoz,0
       call setpaletta  ;uj szinek beallitasa

; ez a kezdeti kepernyo rajzolas....
       mov bl,0        ; a "csikrajzolas"-hoz y koord.=0
       mov cx,13       ; 13*2 sort rajzolunk
@cikl1:
       mov csik,219
       call csikrajzolas       ;meghuzzuk a vizszintes csikot #219-el
       call verticalretrace    ;varunk egy kicsit...
       call verticalretrace
       call verticalretrace
       inc bl                  ;bl-ben az y koordinatat adjuk at a csikrajzolonak!
       mov csik,178            ;a "sotetebb" csikot egy masik karakter adja
       call csikrajzolas       ;ugyanolyan szinnel...
       call verticalretrace
       call verticalretrace
       call verticalretrace
       inc bl
       loop @cikl1

;itt kezdodik a program magja
       mov ykoord,0
@futtat:
       mov cx,13          ;13*2=26 -> a kep 25 karakter magas
@cikl2:
       mov csik,219       ;a kep jobb oldalan 1 karakter szelesen,
       call egykarakter   ;valtakozva megrajzoljuk a hattercsikokat
       inc ykoord
       mov csik,178
       call egykarakter
       inc ykoord
       loop @cikl2        ;egeszen a kep aljaig megyunk
       mov ykoord,0

       call kiirbetu         ;az aktualis betubol 1 oszlopnyit irunk ki
                             ;a kep jobb szelere
       call gorgetes         ;majd elmozditjuk a kepet
       call verticalretrace  ;varunk a raszter-visszafutasra
       mov ax,100h      ;van lenyomott billentyu?
       int 16h
       jz @futtat       ;ha nincs, kezdjuk elolrol

       mov ah,8   ;kiolvassuk a bill. pufferbol a leutott billentyut
       int 21h
       call szinle       ;paletta szineinek elsotetitese
       call _80x25_16    ;normal szoveges uzemmod beallitasa
       call original_vissza   ;az eredeti kepernyotartalmat visszaallitjuk
       call set_char_xy       ;es a kurzor helyet is
       mov ax,4c00h
       int 21h                ;kilepes a programbol...

;********************************************************************
;********                      ELJARASOK                     ********
;********************************************************************
keptorles proc           ;gyors keptorles
       mov ax,0b800h
       mov es,ax
       cld
       mov al,' '        ;kitolto karakter
       mov ah,00000111b  ;es annak szine
       xor di,di
       mov cx,80*25
       rep stosw         ;feltoltjuk a kepernyot
       ret
keptorles endp

csikrajzolas proc          ; be: bl-ben y koordinata, bh-ban a kitolto karakter
      pusha
      xor dx,dx            ; a biztonsag kedveert mindent torlunk
      xor di,di
      mov dl,bl
      xor ax,ax
      mov al,160
      mul dl
      mov dx,ax

      mov ax,0b800h
      mov es,ax
      cld
      mov di,dx
      mov al,csik          ; al-ben a karakter, ah-ban a szine
      mov ah,csikszin
      mov cx,80
      rep stosw            ;meghuzza a csikot
      popa
      ret
csikrajzolas endp

egykarakter proc     ;egy karakter rajzolasa (xkoord,ykoord) helyre.
                     ;csik = a kiiratando karakter,   csikszin = ez pedig a szine
            pusha
            mov     ax,_data              ;a ds regiszter beallitasa
            mov     ds,ax
            mov     ax,0b800h             ;ax-ben a dos-kepernyo cime
            mov     es,ax
            mov     al,byte ptr [ykoord]  ;kiszamitjuk a pontos
            mov     bl,160                ;memoriacimet a koordinatakbol
            mul     bl                    ;ami di-be kerul
            mov     di,ax
            mov     al,byte ptr [xkoord]
            mov     bl,2
            mul     bl
            add     di,ax
            mov     al,csik      ;al-be a betu kodjat ah-ba
            mov     ah,csikszin  ;pedig a szinkodot tolti.
            mov     es:[di],ax   ;az es:di altal mutatott helyen megjeniti a karaktert
            popa
            ret
egykarakter endp

gorgetes proc          ;a kepernyo tartalmat 1 karakterrel balra tolja
    push  ds           ;forras: VGA-kartya programozasa c. konyv
    push  es
    mov   ax,0b800h
    mov   ds,ax
    mov   es,ax
    cld
    mov   ax,0
    mov   bx,0
    mov   ax,23    ;csak 23 karakter magasan
    sub   ax,0
    inc   ax
    mov   dx,79    ;79 karakter szelessegben
    sub   dx,0
@cik:
    mov   cx,dx
    mov   di,bx
    mov   si,bx
    add   si,2
    add   bx,160
    rep movsw
    mov   si,0h
    mov   es:[di],si
    dec   ax
    jnz   @cik
    pop   es
    pop   ds
    ret
gorgetes endp

verticalretrace proc     ;varakozas raszter-visszafutasra
        pusha
        mov dx,03dah
@1:     in al,dx
        test al,8
        jz @1
@2:     in al,dx
        test al,8
        jnz @2
        popa
        ret
verticalretrace endp

charset_eng proc             ;a VGA-ROM-ban levo karakterkeszlet
            mov dx,03ceh     ;elereset engedelyezi, 0a000h-tol talalhato
            mov ax,0406h     ;ott ahol egyebkent a 320*200-as mod
            out dx,ax        ;bitterkepe is
            mov dx,03c4h     ;forras: VGA-kartya programozasa c. konyv
            mov ax,0402h
            out dx,ax
            mov ax,0704h
            out dx,ax
            mov dx,03ceh
            mov ax,0204h
            out dx,ax
            mov ax,0005h
            out dx,ax
            ret
charset_eng endp

charset_vissza proc         ;a karakterkeszlet eleres tiltasa,
            mov dx,03ceh    ;visszaall a megszokott allapot 0b800h szoveges, 0a000h lowres grafikus
            mov ax,0e06h    ;forras: VGA-kartya programozasa c. konyv
            out dx,ax
            mov ax,0004h
            out dx,ax
            mov ax,1005h
            out dx,ax
            mov dx,03c4h
            mov ax,0302h
            out dx,ax
            mov ax,0304h
            out dx,ax
            ret
charset_vissza endp

karakter_adat proc       ;az aktualis betu hexa adatait a "betu" tombbe masolja
       xor di,di         ;tovabbi feldolgozasig
       call charset_eng
       mov ax,0a000h
       mov es,ax
       xor di,di
       xor ax,ax
       mov cx,32       ;a VGA-ROM-ban minden betu 8*32 pixeles helyen tarolodik
       mov al,karszam
       mul cx
       mov di,ax       ;karszam*32 pixel -> es:[di] a karakter adat 1. sora!

       lea si,betu
       mov cx,16       ;az alap betutipus csak 8*16 pixeles
@masolcikl:
       mov al,es:[di]  ;a betu adatait eltaroljuk, hogy aztan lehessen bitenkent
       mov ds:[si],al  ;forgatni
       inc di
       inc si
       loop @masolcikl
       call charset_vissza    ;charset-eleres tiltasa
       ret
karakter_adat endp

kiirbetu proc           ; az aktualis betu 1 pixelnyi oszlopat irja ki
         mov ax,_data   ; a 80.-ik oszlopba
         mov ds,ax
         lea si,betu
         mov ax,0b800h
         mov es,ax
         xor di,di
         xor ax,ax
         xor cx,cx
         mov cl,2
         mov al,elforg    ;ennyi bitet forgattuk el eddig az aktualis betut
         mul cx
         mov di,ax
         mov cx,0            ;16 pixel magassagig nezzuk csak
@egeszbetu:
         mov al,ds:[si]      ;a kovetkezo sor a "betu"-bol, annak hexa adata
         push cx
         mov cx,8            ;1 sor szelessege 8 pixel
@egypixelsor:
         cmp szinpoz,128     ;8*16 pixel = 128 <- ennyi byte-os a paletta, ha
                             ;a szamlalo tullepne a szinpalettan, akkor nullazzuk
         jne @szinkiolvas
         mov szinpoz,0
@szinkiolvas:
         push si
         mov bx,0            ;betu pixelenek a szine tablazatbol
         lea si,szintabla
         mov bx,szinpoz      ; a szintabla-ban a szinpoz mutatja a karakter szinet
         add si,bx
         mov bh,ds:[si]      ; bh-ban a kiirando karakter szine, bl-ben pedig
                             ; vagy #219 vagy #32
         inc szinpoz         ; a kovetkezo karakternek mar uj szine lesz a szintabla alapjan
         pop si
         clc
         shl al,1       ;balra forgatunk egyet
         jc @vanpixel   ;megnezzuk, hogy a kovetkezo bit 1-es-e
         mov bl,' '     ;ezt tul. keppen nem is irjuk ki-> a betu igy atlatszo...
                        ;ha kiirnank, akkor letakarna a hatteret! igy itt nincs "mov es:[di+958],bx"
         jmp @tovabb
@vanpixel:
         mov bl,'Ű'
         mov es:[di+958],bx       ;kiirjuk a kepre  158+(5*160)
                                  ; 158=a kepernyo 80.oszlopa, 160=1 sor hossza byte-ban
                                  ; 5*160=fentrol az 5. sorban, +158=a sor utolso karaktere
@tovabb:
         mov ds:[si],al   ;az elforgatott betu adatait visszairjuk a "betu" tombbe
                          ;igy legkozelebb is csak 1-et kell rajta forgatni
         pop cx
         push ax
         xor di,di             ;kiszamoljuk az uj sor helyet a kepernyon
         mov ax,160
         mul cx
         add di,ax
         pop ax

         inc si                ;a "betu" hexa kodjain egyet lepunk, a kovetkezo sorra
         inc cx                ;a sor szamat is noveljuk
         cmp cx,16             ;16 sor van a betuben, vegig ert mar?
         jnz @egeszbetu        ; ha meg nem, akkor vissza

          inc elforg          ;noveljuk az elforgatottsag szamat
          mov al,elforg
          mov ah,0ah          ;1 betu 8 pixelen tarolodik a ROM-ban,
                              ;de 9 pixel szelesen jeleni meg. Mi 10-et forgatunk, igy nem
                              ;folynak annyira ossze a betuk. Nem baj, ha tul sokat forgatunk,
                              ;mert SHL-nel 0-s bitek lepnek be, azok nem jelennek meg a kepen.
          cmp al,ah
          jne @kilep

          mov al,0           ;ha uj betu jon, azt mindenestol be kell allitani!
          mov elforg,al
          inc betuszam
@ujbetukereses:
          lea si,szoveg    ;szoveg a memoriaban: ds:[si]-tol kezdve
          xor ax,ax
          mov ax,betuszam  ;a kiiratando karakter sorszama a szovegben
          add si,ax
          mov al,ds:[si]
          mov karszam,al
          cmp al,36             ;ha $ akkor a szoveg elejere all
          jne @ujbetu
          mov betuszam,0
          dec si
          jmp @ujbetukereses
@ujbetu:
       mov szinpoz,0
          call karakter_adat    ;ha uj betu van, annak adataivel
                                ;feltoltjuk "betu" tombot
@kilep:
         ret
kiirbetu endp

setcolor proc               ;1 szin beallitasa
        mov ax,_data
        mov ds,ax
        mov dx,3c8h
        mov al,ds:[si]     ;si-ben lesz az atalitando szin szama
        out dx,al
        inc dx
        mov al,ds:[si+1]   ;R osszetevo
        out dx,al
        mov al,ds:[si+2]   ;G osszetevo
        out dx,al
        mov al,ds:[si+3]   ;B osszetevo
        out dx,al
        ret
setcolor endp

setpaletta proc
        pusha
        mov si, offset [paletta]
        mov cx,16       ; mind a 16 szint beallitjuk
@szinbe:
        call setcolor
        inc si           ;1 szin 4 byte-ot foglal a "paletta"-ban
        inc si           ;ezert ennyit kell rajta leptetni
        inc si           ;minden szin beallitasahoz
        inc si
        loop @szinbe
        popa
        ret
setpaletta endp

_80x25_16 proc      ;80*25-os szoveges mod beallitasa, a szinpalettat
        mov ax,3    ;is helyre rakja
        int 10h
        ret
_80x25_16 endp

szinle proc          ; a szinek elsotetitese
       mov ax,_data
       mov ds,ax
       mov cx, 63        ;63 fokozatban
@szineken:
       lea si,paletta    ;minden adatot a "paletta"-bol veszunk
       push cx
       mov cx,16         ;mind a 16 szint
@halvcikl:
       mov bl,ds:[si]    ;bl-ben a szin szama
       xor ax,ax
       mov al,ds:[si+1]  ;al-be az R osszetevo
       cmp al,0
       je @tov1          ;ha 0 akkor tovabb
       dec al            ; ha nem, csokkentjuk es visszairjuk
       mov ds:[si+1],al
@tov1:
       xor ax,ax
       mov al,ds:[si+2]  ;al-be az G osszetevo
       cmp al,0
       je @tov2          ;ha 0 akkor tovabb
       dec al            ; ha nem, csokkentjuk es visszairjuk
       mov ds:[si+2],al
@tov2:
       xor ax,ax
       mov al,ds:[si+3]  ;al-be az B osszetevo
       cmp al,0
       je @tov3          ;ha 0 akkor tovabb
       dec al            ; ha nem, csokkentjuk es visszairjuk
       mov ds:[si+3],al
@tov3:
       inc si            ;tovabblepunk a kovetkezo szin cimere (si=si+4 byte)
       inc si
       inc si
       inc si
       loop @halvcikl
       call verticalretrace   ;varunk egy kicsit, hogy lassuk is az effektet...
       call setpaletta        ;beallitjuk az uj szineket, amik most is
                              ;a "paletta"-ban vannak
       pop cx
       loop @szineken
       ret
szinle endp

original_ment proc       ;az eredeti kepernyo tartalmat eltaroljuk
       mov ax,0b800h     ;egyszeru adatmasolas...
       mov es,ax
       xor di,di
       mov ax,_data
       mov ds,ax
       lea si,original
       mov cx,2000
@elmentcikl:
       mov bx,es:[di]
       mov ds:[si],bx
       inc di
       inc di
       inc si
       inc si
       loop @elmentcikl
       ret
original_ment endp

original_vissza proc     ;az elmentett kepet ujra megjelenitjuk
       mov ax,0b800h
       mov es,ax
       xor di,di
       mov ax,_data
       mov ds,ax
       lea si,original
       mov cx,2000
@elmentcikl2:
       mov bx,ds:[si]
       mov es:[di],bx
       inc di
       inc di
       inc si
       inc si
       loop @elmentcikl2
       ret
original_vissza endp

get_char_xy proc         ;a kurzor poziciot is elmentjuk
       mov ah,0fh        ;forras: SWAG
       int 10h
       mov kurz_page,bh
       mov ah,03h
       int 10h
       mov kurz_x,dl
       mov kurz_y,dh
       ret
get_char_xy endp

set_char_xy proc       ;a kurzor poziciot ujra beallitjuk
       xor ax,ax       ;forras: SWAG
       xor bx,bx
       mov ah,02h
       mov bh,kurz_page
       mov dl, kurz_x
       mov dh, kurz_y
       int 10h
       ret
set_char_xy endp

end start             ; program vege...
I, Robot
1. A robotnak nem szabad kárt okoznia emberi lényben.
2. A robot engedelmeskedni tartozik az emberi lények utasításainak.
3. A robot tartozik saját védelméről gondoskodni.
   
Asylum - Törzstag | 5440 hsz       Online status #97118   2008.10.16 11:42 GMT+1 óra  
win32....
linux és nasm. Rengeteg tökjó dolgot tud pl. context stacket; makrókkal lehet definiálni pl. while ciklust is akár. És nagyon egyszerü megtanulni (pl. nincsenek ilyen idiota kulcssavak mint az elözö kodban).
C++ fordítóval és macival alszom
http://darthasylum.blog.hu/
   
Joga - Törzstag | 1791 hsz       Online status #97116   2008.10.16 10:27 GMT+1 óra  
Lenne egy kis probléma...Gondoltam egyet, és írtam egy COM programot, ami kiír 80x25 'A' betűt, ezzel csak egy gond van, hogy nem csinálja meg( TASM )
Kód:
.486
program segment para use16 'muhahahahaaaa'
assume cs: program, ds: program, ss:program

org 100h
start:

mov sp, 0fffeh

mov ax, 3
int 10h

mov cx, 80

cim1:
push cx
mov cx, 25

cim2:
mov ax, 09h
mov dx, offset string
int 21h
loop cim2

pop cx
loop cim1

xor ax, ax
int 16h
ret


string db 'A$'

program ends
END start

Csupán egy képernyőtörlést tapasztaltam, és vége is lett a futásnak...Pedig azért többet kéne csinálnia

Szerk.: próbáltam kiszedni a veremkezelést, meg a ciklust, de úgy sem írt ki semmit

Mégegy Szerk.: Téves riasztás, rájöttem, az a gond, hogy ax-be írtam ah helyett a 09h-t
(ಠ ›ಠ) Stewie!

   
ShAdeVampirE - Törzstag | 1313 hsz       Online status #65783   2007.08.04 05:09 GMT+1 óra  
MASM a leg elterjedtebb ha win32 assemblyzni szeretnél.
   
WToma - Szerkesztő | 635 hsz       Online status #65780   2007.08.04 04:02 GMT+1 óra  
Marcell: a már korábban említett prog.hu-n van asm tutorial. windows alatt van nasm, masm, radASM (bár lehet hogy ez csak IDE). nyilván van még más is, régen assemblyztem...
Ez nem bug, hanem feature!
http://sohivatal.uw.hu
   
Marcell101 - Tag | 1 hsz       Online status #65775   2007.08.04 03:17 GMT+1 óra  
Nem Tud vki egy könnyen használható Windowsos Assemblert.
Azon kívül egy magyar oldalt ami ezzel foglalkozik.

   
Joga - Törzstag | 1791 hsz       Online status #41855   2006.12.23 07:26 GMT+1 óra  
Ja csak egy pillantást vetettem rá.
(ಠ ›ಠ) Stewie!

   
nagyy - Törzstag | 248 hsz       Online status #41854   2006.12.23 07:07 GMT+1 óra  
Igen, többnyire konstansok, kivéve az X-et. Ha jól értelmezem, akkor úgy működik, hogy kiszámol egy nagyon nagy számot, és a túlcsordulást használja fel, mintha random szám lenne. Az pedig a paramétertől függően eléggé nagy szórással változik, köszönhetően a képletnek.
Nemrégiben végigcsináltam azt a tutorial-t, ami a mellékelt linken érhető el, és akkor ezt a függvényt használtam a random számok generálására, és ott tökéletesen működött. Ha gondolod próbáld ki C++ -ban, működni fog.
   
Joga - Törzstag | 1791 hsz       Online status #41848   2006.12.23 06:07 GMT+1 óra  
Kössz!

Idézet
beast :
Sztem prog.hu-n keress rá, mert ezt már ott kérdezték 66milliárdan!


Annyi ember nincsen.(Ki tudja, talán egy másik dimenzióban)

Egyébként nagyy. A függvényedben csak konstansok vannak, ez így nem biztos, hogy jó lesz
(ಠ ›ಠ) Stewie!

   
beast - Törzstag | 1241 hsz       Online status #41685   2006.12.21 11:36 GMT+1 óra  
Sztem prog.hu-n keress rá, mert ezt már ott kérdezték 66milliárdan!

   
gaborlabor - Moderátor | 4449 hsz       Online status #41680   2006.12.21 11:10 GMT+1 óra  
assemblyt nem vágom, de azt tudom, hogy a pascal a számítógép órája szerint generál "véletlen" számokat. szal ha le tudod kérdezni a biostól a rendszeridőt, akkor azt addig csűröd-csavarod ameddig megfelelő tartománybeli számot nem kapsz.

   
nagyy - Törzstag | 248 hsz       Online status #41629   2006.12.21 09:46 GMT+1 óra  
Eddig nem igazán foglalkoztam a témával, de amennyire tudom, nincs külön utasítás, amivel véletlen számot lehetne generálni. Inkább úgy szokták megoldani, hogy kitalálnak valami nagyon egzotikus képletet, ami a paraméterétől függően visszaad egy "véletlen" számot. Például az alábbi függvénnyel lehet véletlen számokat generálni -1.0 és 1.0 közé.

Kód:
  function IntNoise(32-bit integer: x)

    x = (x<<13) ^ x;
    return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 7fffffff) / 1073741824.0);   

  end IntNoise function


Az algoritmus egyébként innen való: http://freespace.virgin.net/hugo.elias/models/m_perlin.htm , még mielőtt valaki megijjedne, hogy az én agyamban születnek meg ilyenek.

Szóval a lényeg, hogy keresni kell vmi tetszőleges függvényt, amivel random számot lehet generálni, majd azt le kellene kódolni assembly utasításokkal. Szerintem.
   
Joga - Törzstag | 1791 hsz       Online status #41508   2006.12.20 10:04 GMT+1 óra  
Látom már régen írtak ide, de lenne egy kérdésem: Hogyan lehet véletlenszámot generálni? Vagy van valami fájl-otok, amiben benne van?
(ಠ ›ಠ) Stewie!

   
ShAdeVampirE - Guests | hsz       Online status #6023   2006.01.10 23:10 GMT+1 óra  
Pontosítok: vagyis azt is tud használni, ha kihasználod

------------------------------------------------
([url="http://shadevampire.uw.hu">ShAdeVampirE otthona a neten...[/url])

   
ShAdeVampirE - Guests | hsz       Online status #6022   2006.01.10 23:09 GMT+1 óra  
A kérdés akkor vetődött fel bennem, amikor olvastam egy Architektúrákról szóló könyvet, amiben végigvették 8080-tól a gépeket, de a teszteket már Pentium II-esen írták, és ott említették, hogy csak régebben kellettek szegbens regiszterek, PII már tömb alapú, 1db memória szegmenst használ.

------------------------------------------------
([url="http://shadevampire.uw.hu">ShAdeVampirE otthona a neten...[/url])

   
damaniac82 - Guests | hsz       Online status #6021   2006.01.10 11:54 GMT+1 óra  
"Az ellen nem véd..."

Mondom, hogy részemről már rég volt...

------------------------------------------------------------
[url=http://maniac.iceglow.com> OpenGL Tutorials & iNSANEX DevBlog[/url]

   
nagyy - Guests | hsz       Online status #6020   2006.01.10 09:57 GMT+1 óra  
Védett módban viszont a szegmens regiszterek funkciója is megváltozik, mivel ott már nem 64k-s szegmensekből áll a memória. Ekkor az ES, DS regiszterekben un. szelektorokat tárolnak. Ha jól emlékszem, ezek a szelektorok valójában egy hivatkozást tárolnak a különféle descriptor táblákra (van pl.: GDT = global descriptor table, LDT = local descriptor table (ezt a multitasknál használják), IDT = interrupt descriptor table). Ezekben a táblákban olyan rekordok találhatók, amikkel leírható, hogy pl a memória bizonyos területén miket tudunk végezni. (pl.: írható, olvasható, hol kezdődik a mem tartomány, stb.)

Azt, hogy mikor melyik descriptor bejegyzés van használatban, a szegmens regiszterekben állíthatjuk be.

nagyy

   
Dzsó - Guests | hsz       Online status #6019   2006.01.10 09:53 GMT+1 óra  
Én a Watcom Assembler-re esküszöm


Code::Blocks rulez!

   
KergeDelfin - Guests | hsz       Online status #6018   2006.01.10 09:21 GMT+1 óra  
Turbo Assembler, vagy Macro Assembler, ha dos alatt akarsz programozni, akkor ezek a legjobbak


   
damaniac82 - Guests | hsz       Online status #6017   2006.01.10 08:41 GMT+1 óra  
Szegmenseket specifikálsz velük. Nem tudom, Win32 Asm alatt ez hogy van, de DOS alatt anno szegmentált memóriát kellet ASM-ben használni. Egy átlagos .EXE proginál volt egy kód (CS - Code Segment Register) egy adat (DS - Data Segment Register), valamint egy extra (ES - Extra Segment Register). Ez utóbbit általában az ember beállította a videomemóriára rövid úton, s mindjárt tudott a monitorról is olvasni, lecserélni a színeket egy karakteren, etc... Na de ezt most nem lényeg. Szóval a szegmentált címzés azért kellett, mert a 16 bites gépeken a legnagyobb érték ami egy regiszterbe belefért, az az 64K volt. Tehát, két lehetőséged volt:

1) 64K memóriát használsz össz-vissz, mert ennyit bírsz címezni
2) Amennyi memóriád van, azt felosztod 64K-s darabokra és a szegmens regiszterrel mondod meg, hogy melyik szegmensben dolgozol (mert ugy pl. 1 mega memória már nem 1-2 szegmens...) Így pl az aktuálisan futó utasítás kezdő címe a CS:IP-volt (CS. szegmensen belül az IP. utasítás). Az már más kérdés, hogy a legtöbb assemblerben, ha jól tudom, nem is volt olyan hogy IP regiszter. Legalábbis nem bírtad direktbe elérni...

Na, kb ilyesmi lenne a lényegük. Ill ez volt régen, de cirka 5 éve assembly-ztem utoljára...

------------------------------------------------------------
[url=http://maniac.iceglow.com> OpenGL Tutorials & iNSANEX DevBlog[/url]

   
ShAdeVampirE - Guests | hsz       Online status #6016   2006.01.10 08:08 GMT+1 óra  
Mire jók a szegmens regiszterek?

------------------------------------------------
([url="http://shadevampire.uw.hu">ShAdeVampirE otthona a neten...[/url])

   
Hacker - Guests | hsz       Online status #6015   2005.09.05 09:52 GMT+1 óra  
Igen ez a RadASM egész jó (így első ránézésre). Köszi a tippet és megnézem mire megyek vele .

Programozz ne háborúzz!!!

   
WToma - Guests | hsz       Online status #6014   2005.09.05 09:20 GMT+1 óra  
RadASM? Nekem bejött bár nem sokat progiztam asm-ben
Toma

"Ez nem bug, hanem feature!"

   
Hacker - Guests | hsz       Online status #6013   2005.09.05 07:39 GMT+1 óra  
Letöltöttem de van egy kis bajom. Én nagyon kezdő vagyok és amit a fordítóba írtam DOS-os programot azt nem fordította le! Már a .MODEL small-nál elakadt. Leszedtem a Flat Assembly for DOS-t is, de az meg el se indul.

Programozz ne háborúzz!!!

   
pocokman - Guests | hsz       Online status #6012   2005.09.04 11:44 GMT+1 óra  
Idézet
Hacker írta:
Bár nemtudom hogy hányan programoztok Assembly-ben de lenne egy kérdésem. Tudna valaki ajánlani egy jó Assembler-t, mert Turbo Pascal-ban nem nagyon tudom használni.

Programozz ne háborúzz!!!
Én flat assemblert használok, nézz el ide:
http://flatassembler.net/docs.php?article=manual
Nekem nagyon bejön, f?leg arra használom hogy libraryba irjak asm eljárásokat, amiket linkelek a c-projekthez.


   
Hacker - Guests | hsz       Online status #6011   2005.09.04 11:10 GMT+1 óra  
Bár nemtudom hogy hányan programoztok Assembly-ben de lenne egy kérdésem. Tudna valaki ajánlani egy jó Assembler-t, mert Turbo Pascal-ban nem nagyon tudom használni.

Programozz ne háborúzz!!!

   
Frissebbek | [1] > 2 <