Autore Topic: Generatore Di Frattale  (Letto 2259 volte)

iAN CooG

  • Utente
  • **
  • Post: 1774
    • http://iancoog.altervista.org
  • Gioco Preferito: Turbo Assembler, ActionReplay Monitor, DiskDemon
Generatore Di Frattale
« il: 12 Aprile 2006, 23:48:53 »
 
Codice: [Seleziona]
/* original by StreeTuff/TRSi
   Taken from "Episode 64" demo, hidden part

0 print"{wht}{clr}":dim a(16):forz=0to15:readb:a(z)=b:nextz:poke53280,0:poke53281,0:ti$="000000"
0 forn=0to12:q=(n-12)/10:form=0to39:p=((m-20)/10)-1
0 x=0:y=0:fori=0to50:u=x*x-y*y+p:v=2*x*y+q:if(u*u+v*v)>4thengoto2
0 x=u:y=v:nexti
1 c=(n*40)+m:d=960-(n*40)+m:poke1024+c,160:poke1024+d,160:goto3
2 c=(n*40)+m:d=960-(n*40)+m:i=i and 15:poke1024+c,a(i):poke1024+d,a(i)
3 nextm,n
0 print ti$:end
0 data46,58,45,59,33,47,62,41,66,38,9,8,37,42,35,63

*/

/*
cc65 porting attempt by iAN CooG/HF
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>

#define POKE(x,y) *(unsigned char*)(x) = y

//".:-;!/>)|&IH%*#?"
unsigned char screenchars[]={46,58,45,59,33,47,62,41,66,38,9,8,37,42,35,63};
int c,d,p,q,x,y,u,v,n4;
unsigned char n,m,i,j;
/************************************************************/
int main(void)
/************************************************************/
{
  POKE(646,1);clrscr();
  POKE(0xd018,0x14);

  POKE(0xd020,0);
  POKE(0xd021,0);

  for(n=0;n<=12;++n)
  {
   n4=(n*40);
    q=(n-12);
    for(m=0;m<=39;++m)
    {
      c=1024+n4+m;
      d=1024+960-n4+m;
      p=(m-20)-10; //p=(m-20)-1;
      x=0;y=0;
      for(i=0;i<=50;++i)
      {
 /* provare queste 3 righe anziche' le prossime 3 per un diverso risultato
 le divisioni per potenze di 2 sono piu' ottimizzabili (il compilatore le sostituisce con degli shift)    
        u=((x*x-y*y)/10)+p;
        v=(x*y/5)+q; //v=(2*x*y/10)+q;
        if((u*u+v*v)>1600)
*/
        u=((x*x-y*y)/8)+p;
        v=(x*y/4)+q; //v=(2*x*y/8)+q;
        if((u*u+v*v)>400)
        {
            j=screenchars[i&15];
            POKE(c,j);
            POKE(d,j);
            break;
        }
        else
        {
          x=u;
          y=v;
        }
        POKE(c,160);
        POKE(d,160);
      }

    }
  }


return 0;
}
La difficolta' maggiore e' data dal fatto che CC65 non supporta le variabili float e double, solo interi. Ho cercato quindi di lavorare con valori interi moltiplicati per 10, le divisioni quindi vengono tutte spostate all'ultimo momento, causando approssimazioni evidenti. Pero' il risultato e' apprezzabile.

Sorgenti e binari precompilati per C64 e windows (prompt di msdos) : QUA
-=[]=--- iAN CooG/HVSC^C64Intros ---=[]=-
- http://hvsc.c64.org - http://intros.c64.org -

Cbm

  • Utente
  • **
  • Post: 423
  • Gioco Preferito: Wonderboy
Generatore Di Frattale
« Risposta #1 il: 13 Aprile 2006, 23:47:37 »
 Sei proprio una miniera di iniziative iAN CooG!  :)
Ho lanciato il PRG, è davvero simpatico il risultato. Si tratta di un esperimento o è un primo esempio di qualcosa di più ampio? Pensavo che sarebbe bello che li generasse in maniera causale di volta in volta.

 :ciauz:  
C= - Dal 1985! Lunga vita e prosperità.

iAN CooG

  • Utente
  • **
  • Post: 1774
    • http://iancoog.altervista.org
  • Gioco Preferito: Turbo Assembler, ActionReplay Monitor, DiskDemon
Generatore Di Frattale
« Risposta #2 il: 14 Aprile 2006, 22:17:15 »
 
Citazione
Sei proprio una miniera di iniziative iAN CooG!  :)
si fa quel che si puo' :lol:
Citazione
Ho lanciato il PRG, è davvero simpatico il risultato. Si tratta di un esperimento o è un primo esempio di qualcosa di più ampio?
Non e' altro che un tentativo di porting da basic a C, per cercare di far andare il programma piu' velocemente, e soprattutto, per vedere se riuscivo a fare il tutto utilizzando solo numeri interi anziche' in virgola mobile.
Il noto programma FractInt e' proprio basato su questo modo di calcolare i frattali usando numeri interi.
Citazione
Pensavo che sarebbe bello che li generasse in maniera causale di volta in volta. 
I frattali sono rappresentazioni grafiche di formule matematiche, variandone i parametri varia la figura ottenuta. Mettendo qualche rand() qua e la' dovrebbe essere fattibile. Lascio il compito allo studente volenteroso.

Il compilatore lo trovate su www.cc65.org.
-=[]=--- iAN CooG/HVSC^C64Intros ---=[]=-
- http://hvsc.c64.org - http://intros.c64.org -

djwiper

  • Utente
  • **
  • Post: 197
  • Gioco Preferito: Sim City
Generatore Di Frattale
« Risposta #3 il: 16 Aprile 2006, 11:52:02 »
 Complimenti!

Citazione
Mettendo qualche rand() qua e la' dovrebbe essere fattibile. Lascio il compito allo studente volenteroso.

Premetto che non conosco il c ma voglio provarci lo stesso:

Codice: [Seleziona]
/* original by StreeTuff/TRSi
  Taken from "Episode 64" demo, hidden part

0 print"{wht}{clr}":dim a(16):forz=0to15:readb:a(z)=b:nextz:poke53280,0:poke53281,0:ti$="000000"
0 forn=0to12:q=(n-12)/10:form=0to39:p=((m-20)/10)-1
0 x=0:y=0:fori=0to50:u=x*x-y*y+p:v=2*x*y+q:if(u*u+v*v)>4thengoto2
0 x=u:y=v:nexti
1 c=(n*40)+m:d=960-(n*40)+m:poke1024+c,160:poke1024+d,160:goto3
2 c=(n*40)+m:d=960-(n*40)+m:i=i and 15:poke1024+c,a(i):poke1024+d,a(i)
3 nextm,n
0 print ti$:end
0 data46,58,45,59,33,47,62,41,66,38,9,8,37,42,35,63

*/

/*
cc65 porting attempt by iAN CooG/HF
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
/*
We need <time.h> to initialize the seed
*/
#include <time.h>
#define POKE(x,y) *(unsigned char*)(x) = y

//".:-;!/>)|&IH%*#?"
unsigned char screenchars[]={46,58,45,59,33,47,62,41,66,38,9,8,37,42,35,63};
int c,d,p,q,x,y,u,v,n4,ran_1,ran_2,ran_3;
unsigned char n,m,i,j;
/************************************************************/
int main(void)
/************************************************************/
{
 POKE(646,1);clrscr();
 POKE(0xd018,0x14);

 POKE(0xd020,0);
 POKE(0xd021,0);

 for(n=0;n<=12;++n)
 {
  n4=(n*40);
   q=(n-12);
   for(m=0;m<=39;++m)
   {
     c=1024+n4+m;
     d=1024+960-n4+m;
     p=(m-20)-10; //p=(m-20)-1;
     x=0;y=0;
  
  // Seed is initialized
  srand((unsigned)time(NULL));
  
     for(i=0;i<=50;++i)
     {
    //Three random, positive, number are generated. Ranges can be tweaked
    ran_1 = rand() % 15 + 1;
    ran_2 = rand() % 15 + 1;
    ran_3 = rand() % 2000 + 1;
    
       u=((x*x-y*y)/ran_1)+p;
       v=(x*y/ran_2)+q; //v=(2*x*y/8)+q;
       if((u*u+v*v)>ran_3)
       {
           j=screenchars[i&15];
           POKE(c,j);
           POKE(d,j);
           break;
       }
       else
       {
         x=u;
         y=v;
       }
       POKE(c,160);
       POKE(d,160);
     }

   }
 }


return 0;
}

Compilo con cc65 -t c64 frattale.c

si genera il file frattale.s che contiene il codice assembler... A questo punto non so come compilarlo perchè sia c64asm sia c6502sdk (che ho appena scaricato) mi informano di alcuni errori. In particolare c64asm riporta che:

c64asm c64.s

Error #53 in C64.S at line 4 : Invalid compiler directive
        .fopt           compiler,"cc65 v 2.11.0"

Ho letto la documentazione ma non sono riuscito a venirne a capo. Vorrei sapere se almeno il codice C va bene...

Ciao




 
Ho capito di odiare le firme...

iAN CooG

  • Utente
  • **
  • Post: 1774
    • http://iancoog.altervista.org
  • Gioco Preferito: Turbo Assembler, ActionReplay Monitor, DiskDemon
Generatore Di Frattale
« Risposta #4 il: 16 Aprile 2006, 14:36:49 »
 Ho provato, ma il random seed non e' generato come ci si aspetta,. probabilmente perche' il timer sotto c64 non e' proprio un gioiello :D
Lo sostituirei con la posizione del raster attuale, piu' che sufficiente.
Poi e' altresi' sufficiente generare i 3 valori in cima al programma, non ad ogni iterazione.
Codice: [Seleziona]
int main(void)
{
  //Three random, positive, number are generated. Ranges can be tweaked
  // Seed is initialized
  srand(*(unsigned char*)0xd012); // utilizziamo il raster come seed
  ran_1 = rand() % 15 + 1;
  ran_2 = rand() % 15 + 1;
  ran_3 = rand() % 2000 + 1;
  // stampiamo i valori ottenuti e attendiamo un tasto
  cprintf("%d\r\n%d\r\n%d\r\n",ran_1,ran_2,ran_3);
  while(!kbhit())
    ;
  getchar();

  POKE(646,1);clrscr();
  POKE(0xd018,0x14);

  POKE(0xd020,0);
  POKE(0xd021,0);
  for(n=0;n<=12;++n)
  {
   n4=(n*40);
   q=(n-12);
   for(m=0;m<=39;++m)
   {
    c=1024+n4+m;
    d=1024+960-n4+m;
    p=(m-20)-10; //p=(m-20)-1;
    x=0;y=0;

    for(i=0;i<=50;++i)
    {

     u=((x*x-y*y)/ran_1)+p;
     v=(x*y/ran_2)+q; //v=(2*x*y/8)+q;
     if((u*u+v*v)>ran_3)
     {
       j=screenchars[i&15];
       POKE(c,j);
       POKE(d,j);
       break;
     }
     else
     {
      x=u;
      y=v;
     }
     POKE(c,160);
     POKE(d,160);
    }

   }
  }


  return 0;
}

Per quanto riguarda alla compilazione, CC65 e' una suite di programmi - detta in termine tecnico toolchain - tra cui un compilatore, CC65.EXE, che interpreta il C e genera un sergente ASM (*.s), un Assembler, CA65, che dal ASM genera il file oggetto (*.o), e un linker, LD65, che dai files oggetto e librerie genera finalmente un .prg eseguibile.

Un file bat per compilare risolverebbe alla grande. Io ne uso uno fatto da me, ma che richiede 4dos come interprete di comandi. Per command.com si potrebbe fare una cosa del genere (SCRITTO DI GETTO E NON TESTATO!)
Codice: [Seleziona]
set sys=c64
set incp=C:\cc65\include\
set libp=C:\cc65\lib\
set path=C:\cc65\bin;%path%
cc65 -Oirs -T --codesize 500 -t %sys% -I%incp% %1.c
if errorlevel 2 goto end
ca65 %1.s
if errorlevel 2 goto end
if not exist %1.o goto end
LD65 -t %sys%  -o %1.prg %libp%%sys%.o %1.o %libp%%sys%.lib
:end
-=[]=--- iAN CooG/HVSC^C64Intros ---=[]=-
- http://hvsc.c64.org - http://intros.c64.org -

Cbm

  • Utente
  • **
  • Post: 423
  • Gioco Preferito: Wonderboy
Generatore Di Frattale
« Risposta #5 il: 19 Aprile 2006, 15:55:05 »
 Era praticamente da dieci anni che non stendevo un programma, mi hai fatto venire una voglia irrefrenabile; ho bisogno di rinfrescare alcuni concetti e imparare cose nuove, anche perchè il mio manuale d'uso a suo tempo lo ebbi in OLANDESE :doh:  già in giro non si trovava più niente come pubblicazioni e da solo non mi servì a nulla, salvo basarmi su roba del C16, che fu il mio primo computer, ma lì si sfruttavano tutti quei comandi senza preoccuparsi...
Siccome dei frattali conosco abbastanza il concetto, ma non la parte matematica, mi sono divertito arrampicandomi con un pò di fantasia, il listato è parecchio grezzo anche rispetto ai miei standard antichi, a creare un generatore pesudocasuale di falsi frattali. Eccolo qui (il collegamento non è permanente per regolamento del sito che ospita il file). Scusa se lo chiedo approfittando: mi piacerebbe vedere come lo imposteresti tu a titolo di accademia.

Per finire una domanda imperdonabile sul codice...  :stordita:
Citazione da: "iAN CooG/HF"
[CODE]
/* original by StreeTuff/TRSi
   Taken from "Episode 64" demo, hidden part

0 print"{wht}{clr}":dim a(16):forz=0to15:readb:a(z)=b:nextz:poke53280,0:poke53281,0:ti$="000000"
0 forn=0to12:q=(n-12)/10:form=0to39:p=((m-20)/10)-1
0 x=0:y=0:fori=0to50:u=x*x-y*y+p:v=2*x*y+q:if(u*u+v*v)>4thengoto2
0 x=u:y=v:nexti
1 c=(n*40)+m:d=960-(n*40)+m:poke1024+c,160:poke1024+d,160:goto3
2 c=(n*40)+m:d=960-(n*40)+m:i=i and 15:poke1024+c,a(i):poke1024+d,a(i)
3 nextm,n
0 print ti$:end
0 data46,58,45,59,33,47,62,41,66,38,9,8,37,42,35,63
........
Non capisco come sono ordinate le righe, mi sento spaesato, sembrano basic ma non sono numerate in maniera standard. Come mai?

Saluti.
C= - Dal 1985! Lunga vita e prosperità.

djwiper

  • Utente
  • **
  • Post: 197
  • Gioco Preferito: Sim City
Generatore Di Frattale
« Risposta #6 il: 19 Aprile 2006, 17:29:32 »
 Ian, è da due giorni che sbatto e credo di dover bussare alla tua porta: il file bat funziona alla perfezione ma non riesco a capire dove posso reperire le librerie o, in altre parole, i files che vanno in C:\cc65\lib\

L'archivio che ho scaricato non ha nè la directory lib nè la directory bin e in assenza di quelle non riesco  a generare il .prg

EDIT:
ftp://ftp.musoftware.de/pub/uz/cc65/cc65-c64-2.11.0-1.zip, eccole qui...

Comunque i valori che mi restituisce sono sempre 6,2,1257 con WinVice appena avviato. Basta però una interazione grafica (tipo un poke 53281,x) e qualche carattere digitato che il frattale cambia forma! Credo che questo sia normale perchè effettuando un drag and drop su vice nel momento in cui viene lanciato il programma il raster si trova sempre allo stesso punto. (credo eh! Parlo di raster senza sapere cosa sia pertanto concedetemi un margine d'errore)

Per ovviare a questo "inconveniente" ho effettuato una modifica facendo in modo che sia l'utente, inconsapevolemente, a decidere il numero variabile. Ecco il codice:

Codice: [Seleziona]
/* original by StreeTuff/TRSi
 Taken from "Episode 64" demo, hidden part

cc65 porting attempt by iAN CooG/HF
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#define POKE(x,y) *(unsigned char*)(x) = y

// ".:-;!/>)|&IH%*#?"
unsigned char screenchars[]={46,58,45,59,33,47,62,41,66,38,9,8,37,42,35,63};
int c,d,p,q,x,y,u,v,n4,ran_1,ran_2,ran_3;
unsigned char n,m,i,j;

int main(void)
{
 
 // Let some time passes by, while raster is "changing" its value.
 printf ("Hit RETURN to start the demo");
 while(!kbhit())
 ;
 getchar();
 
 // Three random, positive, nonzero number are generated. Ranges can be tweaked
 // Seed is initialized using read-raster address.
 srand(*(unsigned char*)0xd012);
 ran_1 = rand() % 15 + 1;
 ran_2 = rand() % 15 + 1;
 ran_3 = rand() % 2000 + 1;
 POKE(646,1);clrscr();
 POKE(0xd018,0x14);

 POKE(0xd020,0);
 POKE(0xd021,0);
 for(n=0;n<=12;++n)
 {
  n4=(n*40);
  q=(n-12);
  for(m=0;m<=39;++m)
  {
   c=1024+n4+m;
   d=1024+960-n4+m;
   p=(m-20)-10;
   x=0;y=0;
  
   for(i=0;i<=50;++i)
   {
    u=((x*x-y*y)/ran_1)+p;
    v=(x*y/ran_2)+q; //v=(2*x*y/8)+q;
    if((u*u+v*v)>ran_3)
    {
      j=screenchars[i&15];
      POKE(c,j);
      POKE(d,j);
      break;
    }
    else
    {
     x=u;
     y=v;
    }
    POKE(c,160);
    POKE(d,160);
   }
  }
 }
 return 0;
}

e per finire ecco la versione colorata...

Codice: [Seleziona]
/* original by StreeTuff/TRSi
 Taken from "Episode 64" demo, hidden part

cc65 porting attempt by iAN CooG/HF
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#define POKE(x,y) *(unsigned char*)(x) = y

// ".:-;!/>)|&IH%*#?"
unsigned char screenchars[]={46,58,45,59,33,47,62,41,66,38,9,8,37,42,35,63};
int c,d,p,q,x,y,u,v,n4,ran_1,ran_2,ran_3,mem_loc1,mem_loc2;
unsigned char n,m,i,j;

int main(void)
{
 
 // Let some time passes by, while raster is "changing" its value.
 printf ("Hit RETURN to start the demo");
 while(!kbhit())
  ;
 getchar();
 
 // Three random, positive, nonzero number are generated. Ranges can be tweaked
 // Seed is initialized using read-raster address.
 srand(*(unsigned char*)0xd012);
 ran_1 = rand() % 15 + 1;
 ran_2 = rand() % 15 + 1;
 ran_3 = rand() % 2000 + 1;
 POKE(646,1);clrscr();
 POKE(0xd018,0x14);

 POKE(0xd020,0);
 POKE(0xd021,0);
 for(n=0;n<=12;++n)
 {
  n4=(n*40);
  q=(n-12);
  for(m=0;m<=39;++m)
  {
   c=1024+n4+m;
   d=1024+960-n4+m;
   p=(m-20)-10;
   x=0;y=0;
  
   for(i=0;i<=50;++i)
   {
    u=((x*x-y*y)/ran_1)+p;
    v=(x*y/ran_2)+q; //v=(2*x*y/8)+q;
    // ran_1 = rand() % 15 + 1; // Use this for random color
ran_1 = q-(m+q); // Or else use this for really fractalized color

mem_loc1 = 0xd800+n4+m;
mem_loc2 = 0xd800+960-n4+m;

if((u*u+v*v)>ran_3)
    {
      j=screenchars[i&15];
      // Character is located into memory-matrix
   POKE(c,j);
      POKE(d,j);
   // Color is located into memory-matrix.
   POKE(mem_loc1,ran_1);
   POKE(mem_loc2,ran_1);
      break;
    }
    else
    {
     x=u;
     y=v;
    }
// Character is located into memory-matrix
    POKE(c,160);
    POKE(d,160);
// Color is located into memory-matrix
POKE(mem_loc1,ran_1);
POKE(mem_loc2,ran_1);
   }
  }
 }
 return 0;
}

 :ciauz:  
Ho capito di odiare le firme...

iAN CooG

  • Utente
  • **
  • Post: 1774
    • http://iancoog.altervista.org
  • Gioco Preferito: Turbo Assembler, ActionReplay Monitor, DiskDemon
Generatore Di Frattale
« Risposta #7 il: 19 Aprile 2006, 21:41:28 »
 CBM: Ho scaricato il file e lo guardero' piu' tardi.
Per quanto riguarda la numerazione, si tratta di un prg basic elaborato con Exobasic, tool compreso in Exomizer, che serve per ottimizzare i programmi basic rendendoli comprimibili al massimo. Una della tante ottimizzazioni che puo' fare e' proprio quella di azzerare i numeri di linea non referenziati da nessun salto goto/gosub, e rinumerando solo quelle che hanno un riferimento.
Al basic del c64 non importa come sono numerate, in fase di run, ma solo durante l'inserimento e modifica del programma, per poterle riordinare in caso di inserimento tra 2 righe esistenti, o appenderla in caso il numero di linea sia superiore all'ultimo numero riga gia' presente.
In fase di run ogni riga viene eseguita in sequenza, seguendo i link alla linea successiva, necessitando del numero di riga solo in occasione dei salti goto/gosub.
-=[]=--- iAN CooG/HVSC^C64Intros ---=[]=-
- http://hvsc.c64.org - http://intros.c64.org -

iAN CooG

  • Utente
  • **
  • Post: 1774
    • http://iancoog.altervista.org
  • Gioco Preferito: Turbo Assembler, ActionReplay Monitor, DiskDemon
Generatore Di Frattale
« Risposta #8 il: 19 Aprile 2006, 21:49:54 »
 Djwiper: La configurazione di cc65 non e' delle piu' facili, purtroppo. Spero che ora tu sia operativo :)
Citazione
Comunque i valori che mi restituisce sono sempre 6,2,1257 con WinVice appena avviato.
Appena avviato non puoi farci niente, in un emulatore.
Il clock e' sempre a 0, il raster e' sempre a 0 e il tempo impiegato per caricare e' sempre lo stesso (a parita' di bytes da caricare/posizione nel disco/etc) quindi il seed iniziale e' PER FORZA sempre uguale.
Perdi un po' di tempo premendo un tasto prima del load, o prima del run, o comunque nel programma ma prima della srand().
Dopo un run e' cmq sempre random, perche' appunto il tempo per dare un nuovo run e' sempre sufficientemente variabile, a meno che tu non riesca a digitarlo in un paio di cicli di clock :P
Poi provero' le tue modifiche, ma ad occhio mi sembra tutto ok, potresti mettere le 2
mem_loc1 = 0xd800+n4+m;
mem_loc2 = 0xd800+960-n4+m;
fuori dall ciclo della "i", tanto variano solo in base a "n" e "m", e quindi le ricalcoli inutilmente ad ogni iterazione della "i"  
-=[]=--- iAN CooG/HVSC^C64Intros ---=[]=-
- http://hvsc.c64.org - http://intros.c64.org -

djwiper

  • Utente
  • **
  • Post: 197
  • Gioco Preferito: Sim City
Generatore Di Frattale
« Risposta #9 il: 19 Aprile 2006, 22:24:56 »
 
Citazione
La configurazione di cc65 non e' delle piu' facili, purtroppo. Spero che ora tu sia operativo :)
Si, ora lo sono... compila che è una bellezza!

Citazione
potresti mettere le 2
mem_loc1 = 0xd800+n4+m;
mem_loc2 = 0xd800+960-n4+m;
fuori dall ciclo della "i",
Giusto...
Ho capito di odiare le firme...

Cbm

  • Utente
  • **
  • Post: 423
  • Gioco Preferito: Wonderboy
Generatore Di Frattale
« Risposta #10 il: 21 Aprile 2006, 22:36:23 »
Citazione da: "iAN CooG/HF"
Per quanto riguarda la numerazione, si tratta di un prg basic elaborato con Exobasic...
...
Al basic del c64 non importa come sono numerate, in fase di run, ma solo durante l'inserimento e modifica del programma
 
Ti ringrazio per il chiarimento, sulla "sequenzialità" ricordavo qualcosa, ma non capivo poi come poter battere il listato in quelle condizioni, quindi credevo si trattasse di qualcosa non standard. Comunque ora è chiaro.
Per curiosità ho poi battuto il listato rinumerandolo e cambiato i goto interessati, ed infatti gira bene. Certo che a differenza di quello convertito, va anche troppo lento, ma solo quando deve stampare a schermo i quadratini bianchi; con gli altri caratteri la velocità di calcolo si equivale, infatti sostituendo il quadrato con altro carattere, la velocità si normalizza nel suo complesso. Come si spiega questa differenza tra caratteri, tutti a bassa risoluzione? Non riesco a capirne il perchè.
C= - Dal 1985! Lunga vita e prosperità.

iAN CooG

  • Utente
  • **
  • Post: 1774
    • http://iancoog.altervista.org
  • Gioco Preferito: Turbo Assembler, ActionReplay Monitor, DiskDemon
Generatore Di Frattale
« Risposta #11 il: 22 Aprile 2006, 17:07:18 »
 
Citazione
solo quando deve stampare a schermo i quadratini bianchi;
Perche' quelli vengono stampati quando ha finito le iterazioni di "i", quindi ci impiega piu' tempo
Citazione
con gli altri caratteri la velocità di calcolo si equivale, infatti sostituendo il quadrato con altro carattere, la velocità si normalizza nel suo complesso. Come si spiega questa differenza tra caratteri, tutti a bassa risoluzione? Non riesco a capirne il perchè.
impossibile, stampare un carattere piuttosto che un altro e' irrilevante, tanto piu' che qua si tratta solo di pokes nella memoria video.
Mostra il codice modificato.
-=[]=--- iAN CooG/HVSC^C64Intros ---=[]=-
- http://hvsc.c64.org - http://intros.c64.org -

djwiper

  • Utente
  • **
  • Post: 197
  • Gioco Preferito: Sim City
Generatore Di Frattale
« Risposta #12 il: 22 Aprile 2006, 17:15:24 »
 Credo intendesse dire "se al posto del quadrato i cicli generano un altro carattere la velocità si normalizza".

Come ha giustamente detto Ian CooG il quadrato viene "scelto" soltanto in ultima istanza e già mille e passa cicli di clock a carattere sono pesantucci per il commodore :)
Ho capito di odiare le firme...

Cbm

  • Utente
  • **
  • Post: 423
  • Gioco Preferito: Wonderboy
Generatore Di Frattale
« Risposta #13 il: 22 Aprile 2006, 20:40:52 »
Citazione da: "iAN CooG/HF"
Citazione
Come si spiega questa differenza tra caratteri, tutti a bassa risoluzione? Non riesco a capirne il perchè.
impossibile
Come non detto... infatti è impossibile... solo che ieri ero di corsa e mi era sfuggito il banale perchè. In compenso il caso mi è servito da incentivo per capire la logica del programma più a fondo.
Nel modificare il poke dello spazio (160) avevo inavvertitamente battuto il tasto 1 modificando il carattere adiacente della riga di sopra, che guarda caso era quella dell'iterazione di I, per cui il ciclo si era abbassato da 50 a 10... e l'ho notato ora ricontrollando passo a passo il listato. Scusate davvero... invece di caratteri ho generato confusione in voi...
 
C= - Dal 1985! Lunga vita e prosperità.