home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / misc / zxam16b.lha / ZXAM Spectrum / ZXAM_Spectrum.DOCesp < prev    next >
Encoding:
Text File  |  1995-01-28  |  67.4 KB  |  1,482 lines
  1. ›[0m›[0 p
  2.                           ›[0;1;33;40mZXAM SPECTRUM EMULATOR v1.6b›[0m
  3.            © 1993-95 WareSoft  Todos los derechos reservados
  4.            Programado por Antonio J. Pomar Rosselló
  5.  
  6.  
  7.  
  8.  
  9. ›[0;1mDISTRIBUCION›[0m
  10.  
  11.    Este  programa  es SHAREWARE. Esto sigifica que tienes un mes de tiempo para
  12. probarlo,  y  si  te  gusta  deberías mandar 15 US$ (unas 2000 pts) al autor. A
  13. cambio  recibirás  la  última versión disponible (probablemente la versión 128k
  14. estará  disponible  para marzo de 1995). Con esta contribución estás asegurando
  15. el desarrollo y mejora posterior del emulador. Gracias por adelantado.
  16.  
  17.    Esta  versión  SHAREWARE  puede  circular libremente siempre que se incluyan
  18. todos  los  ficheros asociados al programa. Está prohibido utilizar el programa
  19. para  fines comerciales, o sea que solo se pueden cargar los gastos normales de
  20. copia  y envio que se cargan habitualmente en las librerias de Dominio Público.
  21. También puedes meterlo en BBS o incluirlo en discos de revista.
  22.  
  23.    El paquete completo de distribución comprende:
  24.  
  25.     ZXAM_SpectrumAGA       Este es el programa ejecutable (con icono).
  26.     ZXAM_SpectrumAGA_FASTER       El mismo, pero versión rápida (con icono).
  27.     ZXAM_SpectrumOCS_ECS       Versión para OCS/ECS (con icono).
  28.     ZXAM_SpectrumOCS_ECS_FAST  Versión rápida para ECS/OCS (con icono).
  29.     ZXAM_Spectrum.DOCesp       El texto que lees ahora (con icono).
  30.     ZXAM_Spectrum.DOCeng       Traducción a inglés de este DOC (con icono).
  31.     LEEME!!               Notas de distribución (con icono).
  32.     README!!           Lo mismo, pero en inglés (con icono).
  33.     INTERFACE.IFF           Esquema del interface de cinta (con icono).
  34.     DIGIT_INTERFACE.IFF       Digitalización de mi interface (con icono).
  35.     powerpacker.library       Necesaria para cargar ficheros comprimidos.
  36.  
  37.    El autor  del  programa  no acepta ninguna  responsabilidad    sobre cualquier
  38. perjuicio  que puede  suponer el uso  o abuso del  programa,  ni ofrece ninguna
  39. garantia  sobre el programa y sus capacidades. Tampoco se garantiza  nada sobre
  40. la precisión  o  estilo   literario  de  este  documento  ni  se acepta ninguna
  41. responsabilidad sobre las consecuencias que puede acarrear su lectura.  Tampoco
  42. acepta ninguna responsabilidad sobre cualquier  consecuencia que puede tener la
  43. realización o uso del interface de cassette.  Esta prohibido montar y vender el
  44. interface  para sacar un provecho económico.
  45.  
  46.    Se reconocen  todas las marcas registradas, marcas  comerciales y Copyrights
  47. de los productos mencionados en este documento.
  48.  
  49.    Por lo que he podido leer en el DOC    del  Spectrum  Emulator  v1.7  la  casa
  50. AMSTRAD,  que  posee  ahora los derechos sobre los componentes del Spectrum, ha
  51. dado permiso especial a los autores de emuladores para poder distribuir la  ROM
  52. del  Spectrum  original. De todas formas el Copyright sobre la ROM sigue siendo
  53. de AMSTRAD.
  54.  
  55.    La  pantalla  KeysHelp.iff ha sido incluida con el permiso del autor (Mikael
  56. Ostergren) para ayudar a localizar teclas en el spectrum 48k.
  57.  
  58.    La powerpacker.library es © Nico François.
  59.  
  60.    El Sinclair ZX Spectrum Emulator es © Peter McGavin.
  61.  
  62.    El Sinclair ZX Spectrum Emulator "Z80" es © Gerton Lunter.
  63.  
  64.    El emulador ZX Spectrum (SPEC386) es © Pedro Gimeno.
  65.  
  66.  
  67.  
  68.  
  69. ›[0;1mREQUERIMIENTOS›[0m
  70.  
  71.    Este programa necesita WorkBench 3.0 (o sea, versión 39), los chips gráficos
  72. AGA  y  un  microprocesador  68020,  o  versiones  superiores (en el caso de la
  73. versión  OCS/ECS  se  necesita  solo 68020 y WB 2.04 o superiores). En resumen,
  74. necesita  un  Amiga 1200 como mínimo. Además necesita la powerpacker.library en
  75. libs: o en el mismo directorio del programa.
  76.  
  77.    Por  otro  lado, para los requesters de ficheros se usa la libreria standard
  78. del  sistema  'asl.library'.  Esta  libreria  tiene  el  problema  de releer el
  79. directorio  cada  vez  que abre el requester, con lo que puede ser desesperante
  80. cargar  ficheros  desde disquete, o cuando en el disco duro hay muchos ficheros
  81. (como  en  mi  caso,  que  son  400).  Para  evitar esto lo mejor seria usar la
  82. reqtools.library,  ya que su requester tiene un buffer que evita tener que leer
  83. el  directorio  cada  vez,  pero  debido  a graves problemas técnicos aún no he
  84. podido  implementarlo.  Mientras  tanto  la  mejor  opción  es usar el programa
  85. RTPatch,  de Nico François, que parchea las librerias asl/req/arp para que usen
  86. el  requester  de  la reqtools. Así, además, todos los demás programas que usen
  87. asl/req/arp  usarán  dicho  requester,  que  es mucho mejor que los originales.
  88. Curiosamente  con  RTPatch 1.3 (que es el parche que yo uso) el buffer funciona
  89. perfectamente,  pero  con  el  ReqChange 3.0 (otro parche que se supone hace lo
  90. mismo) el buffer no funciona.
  91.  
  92.    ¿Que  tiene  de  AGA  el  emulador?:  Pues   usa   algunas   de  las  nuevas
  93. posibilidades  específicas  de  los  chips AGA para la conversión  de pixels  y
  94. colores de la pantalla del Spectrum, para adaptarla a los bitplanos  del Amiga.
  95.  
  96.    Como verás, ya hay incluida con el paquete una versión OCS/ECS del emulador.
  97. Esta versión necesita 68020+ y WorkBench 2.04+.  Los chips gráficos pueden  ser
  98. OCS/ECS/AGA indistintamente. Esta versión es de prueba.  Si hay algún problema,
  99. no  dudes  en  comunicármelo  (yo no puedo  probarla  completamente  por que no
  100. dispongo de  ningún ordenador OCS/ECS con 68020+).  La versión  OCS/ECS  usa un
  101. sistema  de  conversión de pantalla más lento que la versión AGA (se nota sobre
  102. todo  en  juegos como el Uridium). Aún así, en muchos casos la diferencia no es
  103. apreciable.  Las  únicas  cosas  que  posee  el  AGA  y  el  OCS/ECS  no, es la
  104. posibilidad  de funcionar en monocromo/color y el FLASH de colores (substituido
  105. por un INVERSE).
  106.  
  107.    Algo muy importante es la memoria FAST de 32 bits. El emulador funciona bién
  108. sobre memoria CHIP, pero si hay memoria FAST 32 bits disponible  el  incremento
  109. de  velocidad puede ser impresionante. Por lo que yo he podido saber la adición
  110. de FAST al Amiga 1200 incrementa la velocidad  de  proceso  al    219%  (más  del
  111. doble).  Esto  se  debe  a  la    constante lucha entre el procesador y los chips
  112. gráficos  para acceder    a la memoria CHIP,  y al sistema de  SLOTs que usan los
  113. chips gráficos para asignar el    tiempo de uso  de la memoria CHIP entre éstos y
  114. el procesador. Debido al sistema de SLOTs un Amiga 4000/030 sin FAST solo va un
  115. 15% mas rápido    que un Amiga 1200  sin FAST.  Por otro    lado la  velocidad  del
  116. emulador depende mucho del programa de Spectrum que se esté ejecutando.
  117.  
  118.  
  119.  
  120.  
  121. ›[0;1mINTRODUCCION›[0m
  122.  
  123.    Como habrás deducido de forma inmediata este  programa  tiene  como    función
  124. principal  (y  única)  la  de  emular  un  Sinclair  ZX  Spectrum  48k, con sus
  125. entrañables atributos y su sonido de 1 bit (lagrimilla...).
  126.  
  127.    Notarás que el emulador está en inglés, pero cualquiera que    haya  usado  un
  128. Spectrum antes sabrá lo que significa LOAD, SAVE, POKE, etc...
  129.  
  130.  
  131.  
  132.  
  133. ›[0;1mFORMATOS DE PROGRAMA›[0m
  134.  
  135.    Antes de poder comprender la función de algunos de los gadgets  y  ToolTypes
  136. del  programa  debemos    discutir  algo sobre formatos de programas de Spectrum.
  137. Actualmente hay varios emuladores de Spectrum 48k para    diferentes  ordenadores
  138. (Amiga,  PC,  Atari, etc...) y cada uno de estos emuladores graba los programas
  139. en disco en un formato de fichero diferente. Esto significa que para poder usar
  140. programas grabados con un emulador en otro debes  disponer  de    algún  tipo  de
  141. utilidad que convierta los programas de un formato a otro (yo hice uno en BASIC
  142. compilado  para  pasar programas Spectrum de PC a Amiga). Este emulador intenta
  143. evitar la necesidad de conversor admitiendo cargar y grabar directamente varios
  144. formatos en vez de tener un solo formato propio. Asi también se puede  usar  el
  145. emulador como conversor de formatos, si surge la necesidad.
  146.  
  147.    De  momento hay implementados cuatro formatos (los únicos que conozco) a los
  148. que he llamado provisionalmente PC, MIRAGE, Z80 y KGB, y que son:
  149.  
  150.      PC: Este formato proviene del emulador de Spectrum para PC programado
  151.      por Pedro Gimeno. El ejecutable se llama SPEC386.EXE y la versión que
  152.      he usado (yo no tengo PC) es la 0.99D ß. Supongo que a estas  alturas
  153.      debe haber una versión mas completa en circulación (creo recordar que
  154.      este  emulador ya tiene unos años).  Necesita un 386DX a 25MHz con un
  155.      caché de 256Kb para acercarse a la velocidad del Spectrum real. Estos
  156.      ficheros se reconocen por que ocupan 49190 bytes en el disco y suelen
  157.      llevar la extensión .SP al final del nombre.
  158.  
  159.      MIRAGE:  Este  es el  formato  del  Spectrum  Emulator  1.7  de Peter
  160.      McGavin.  Es  un  emulador  para AMIGAs  sin  chips AGA. Los ficheros
  161.      se reconocen  por que ocupan 49179 bytes y suelen llevar la extensión
  162.      .snapshot,  aunque yo  prefiero  cambiarsela  por .mirage para evitar
  163.      confusiones, ya que son muchos los emuladores que usan esa extensión.
  164.      Hay que notar que hasta  la  versión 1.6 del Spectrum  Emulator  este
  165.      formato no guardaba el color actual del borde,  por lo que  al cargar
  166.      ficheros  de  formato pre-1.6  el  borde  arrancará  en  negro.  Para
  167.      arreglar  esto  puedes  regrabar  en  dicho  formato,  ya que el ZXAM
  168.      utiliza el formato moderno, que almacena el borde correctamente. Este
  169.      formato también lo usan los emuladores  (para PC) VGASPEC (*.SNA,  no
  170.      sé el autor) y JPP (*.SP, de Arnt Gulbrandsen).
  171.  
  172.      Z80: este formato (implementado a partir de la versión 1.6) es el que
  173.      usa  el  emulador  de  Spectrum  (para PC)  'Z80'  de  G.A.Lunter. El
  174.      emulador admite la carga de ficheros .Z80 de formato antiguo (versión
  175.      1.45 del Z80) y moderno (versión 2.01  del Z80),  siempre que  sea un
  176.      fichero de Spectrum 48k.  En caso  de que sea  128k o  necesite de la
  177.      emulación de interface I o cualquier  otro hardware no soportado  por
  178.      el ZXAM,  el fichero será  rechazado como  desconocido.  Este formato
  179.      solo está disponible para cargar, pero no para grabar.
  180.  
  181.      KGB: este fomato  (implementado también a  partir de la versión 1.6b)
  182.      es   el   del    viejo   emulador   KGB    para   Amiga.   Se   puede
  183.      reconocer  por que  el tamaño  es siempre  49486 bytes.  No se  quien
  184.      es el autor de dicho emulador (la versión que yo tengo no incluye DOC
  185.      ni nada parecido)  ni si aún se usa  debido a que es incompatible con
  186.      la versión 2.0 y  superiores del sistema operativo.  Este fomato está
  187.      disponible solo para cargar.
  188.  
  189.    En todos los casos el emulador  admite que los  programas estén  comprimidos
  190. con powerpacker.
  191.  
  192.    Hay  que  notar  que  el  emulador  no usa NUNCA la extensión del nombre del
  193. fichero  para  identificar  su  formato.  En  vez  de eso se hacen una serie de
  194. comprobaciones  en la estructura del fichero para reconocerlo. Si quieres poner
  195. otra  extensión a un fichero, puedes hacerlo sin que ello afecte la posibilidad
  196. de  cargarlo  en  el  emulador.  Eso  si,  tienes que añadir esa extensión a la
  197. plantilla  (tooltype  PATTERN  en  el  icono  del  emulador)  del  requester de
  198. ficheros, ya que si no esos ficheros no aparecerán el él.
  199.  
  200.    Además de estos formatos hay otro, el llamado .TAP, que no es un snapshot en
  201. si  mismo  si  no que es una serie de cabeceras y bloques de datos unidos en un
  202. solo  fichero.  Junto  al  emulador  hay  un  script ARexx que puedes usar para
  203. descomponer  un  fichero  .TAP en la serie del .header y .bytes que contiene, y
  204. poder cargar así dichos bloques con la opción de LOAD desde disco.
  205.  
  206.    En caso de que tengas información sobre otros formatos de otros  emuladores,
  207. aunque    sean de otros ordenadores, solo tienes que mandarme un disco con varios
  208. programas en ese formato y la información de que dispones. Procuraré incluir en
  209. la proxima  versión del emulador  la posibilidad de usar dicho formato.  Es MUY
  210. importante  que me mandes algún programa grabado en ese formato, si no no podré
  211. probar la carga en dicho formato.
  212.  
  213.  
  214.  
  215.  
  216. ›[0;1mARRANQUE DEL PROGRAMA›[0m
  217.  
  218.    El programa está pensado para arrancar desde WorkBench ya que  las  opciones
  219. se  leen del icono del programa. De todas formas, si lo arrancas desde el SHELL
  220. el programa buscará el icono en el mismo directorio del ejecutable, para cargar
  221. dichas opciones. Además, se "despegará" de la ventana del SHELL.
  222.  
  223.    Si hay algún problema al arrancar el programa, éste    lo  comunicará    con  un
  224. requester y volverá al sistema operativo.
  225.  
  226.    Las ToolTypes ("Tipos Herramientas" en WB3.0 en castellano)    que  se  pueden
  227. meter en el icono son:
  228.  
  229.     PATTERN=    Le  indicamos  el  pattern   (plantilla)  para    el
  230.             requester  de ficheros.  Este pattern es un filtro
  231.             que especifica    que ficheros  deben  mostrarse    en
  232.             dicho requester.  Consulta el manual del ordenador
  233.             sobre el uso de plantillas de fichero.
  234.  
  235.     LOADPATH=    Indica en  que    directorio  queremos  que  se abra
  236.             inicialmente el requester de  cargar. Esto es útil
  237.             para  dirigirlo al directorio del disco duro donde
  238.             guardas normalmente los programas de Spectrum y no
  239.             tener que meter cada vez el path (yo tengo  en  el
  240.             disco   duro   un   directorio   con   232  juegos
  241.             comprimidos [4.7 Megas]).
  242.  
  243.     SAVEPATH=    Indica en  que    directorio  queremos  que  se abra
  244.             inicialmente el requester de  grabar.
  245.  
  246.     DEFFORMAT=    Indica el  formato por    defecto usado  para grabar
  247.             los  programas  de  Spectrum  (formato PC, MIRAGE,
  248.             PC_PP  y  MIRAGE_PP).  De  todas  formas se  puede 
  249.             cambiar  el  formato  usado  mediante los  gadgets
  250.             adecuados de la ventana de control.
  251.             
  252.     REXXPATH=    Indicamos  el directorio donde  se debe  abrir  el
  253.             requester  para  seleccionar  scripts  ARexx.   El
  254.             nombre de los scripts debe acabar en '.zxam'.
  255.     
  256.     ROMFILE=    Indicamos  la  ROM  a  cargar,   substituyendo  la
  257.             interna  del  emulador  (la original  del Spectrum
  258.             48k).  La   ROM   puede   estar   comprimida   con
  259.             powerpacker. CUIDADO  con  las  ROM  extrañas  por
  260.             que   pueden   provocar   incompatibilidades   con
  261.             algunos  juegos (no es culpa mia ;-)
  262.             
  263.     PRERUN=        Fija una linea de comandos AmigaDOS  para ejecutar
  264.             justo antes de arrancar la emulación. Por ejemplo,
  265.             con "PRERUN=cpu nocache noburst" se  desactivarian
  266.             los  cachés y el  burst del  procesador.  Antes de
  267.             ejecutar  la linea  PRERUN el  emulador  guarda el
  268.             estado de  los  cachés  y  los  restaura al volver
  269.             de  la  emulación (con la tecla HELP), justo antes
  270.             de  ejecutar  la  linea POSTRUN.  De esta forma se
  271.             puede poner un comando  que  desactive  los cachés
  272.             en el momento de emular sin  que en  el  WorkBench
  273.             tengamos que tener los cachés desactivados.
  274.  
  275.     POSTRUN=    Fija  una  linea  de  comandos a ejecutar justo al
  276.             salir de la emulación (con la tecla HELP).
  277.  
  278.     LOADMODE=    Fija el modo de la rutina  LOAD de la ROM  (TAPE o
  279.                         DISK).
  280.  
  281.     SAVEMODE=    Fija el modo de la  rutina SAVE de  la ROM  (TAPE,
  282.                         DISK o DISK_PP para que se compriman los  datos al
  283.                         grabar.
  284.  
  285.  
  286.  
  287.  
  288. ›[0;1mVENTANA DEL PROGRAMA›[0m
  289.  
  290.    Si has arrancado el programa verás que abre una ventana en el WorkBench  con
  291. los  gadgets  de  cargar,  grabar,  poke, etc. Los gadgets que tienen una letra
  292. subrayada (TODOS) significa que si pulsas la tecla correpondiente a dicha letra
  293. es como si pulsaras el gadget con el ratón.
  294.  
  295.    Las funciones de los gadgets son las siguientes:
  296.  
  297.    Load  Program  .-   Abre  el  requester  de    ficheros  para     que  puedas
  298.      seleccionar el programa  que  quieres  cargar.  El  emulador  detectará
  299.      automáticamente  en  que  formato    está  el  programa, por lo que no es
  300.      necesario especificarle nada. IMPORTANTE: los programas de Spectrum  se
  301.      pueden  comprimir    con  el programa PowerPacker, y se descomprimirán al
  302.      cargarlos. Así nos ahorramos un montón de espacio en disco (en un disco
  303.      de 880k suelen caber unos 45 programas una vez  comprimidos).  Una  vez
  304.      cargado se verá el nombre del fichero en el recuadro "Loaded File" y el
  305.      formato  en  que  está  en  el recuadro "Format". Si intentas cargar un
  306.      fichero que no es un programa de Spectrum lo único que puede  pasar  es
  307.      que  se borre el contenido anterior de la memoria del Spectrum. Hay que
  308.      notar que el emulador YA es  capaz  de  cargar  programas    directamente
  309.      desde  cinta (V1.3 ß),  pero debes montar  el interface  descrito en la
  310.      pantalla  INTERFACE.IFF.  A partir de la  versión 1.5  la  ventana  del
  311.      emulador es una AppWindow, o sea, puedes tirar dentro los iconos de los
  312.      ficheros a cargar. Si lo que metes es un cajón o un disco, se abrirá el
  313.      requester de ficheros en dicho cajón/disco.
  314.  
  315.    Reload.-  Vuelve a cargar de disco el  programa de Spectrum    que  aparece
  316.      en la ventana "Loaded File", sin abrir el requester de ficheros.
  317.  
  318.    Save program.-  Graba la memoria del  Spectrum en el formato indicado por
  319.      los  gadgets  de  la  derecha  (recuadro  "SAVE FORMAT").
  320.  
  321.    POKE.- Es facil imaginarselo, ¿no?.
  322.  
  323.    Recuadro "Save Format".- En este recuadro hay 4 gadgets que determinan el
  324.      formato  en  el que se grabará la memoria del Spectrum si seleccionamos
  325.      el gadget "Save Program". Los formatos son MIRAGE y PC, y sus versiones
  326.      comprimidas con powerpacker, MIRAGE_PP y PC_PP.
  327.  
  328.    RUN.- Arranca el Spectrum.  En el momento  de arrancar  se  desactiva  la
  329.      multitarea  y  el    emulador toma el control de la máquina. He preferido
  330.      desactivar la multitarea por que no me parece necesaria en  el  momento
  331.      de  usar  un Spectrum  y para que el emulador tenga aspecto de Spectrum
  332.      de verdad. Más adelante se explica como volver al WorkBench.
  333.  
  334.    Reset & RUN.- Lo mismo que RUN pero forzando un RESET del Spectrum.
  335.  
  336.    Run ARexx.-  Abre un requester de ficheros para elegir el  script ARexx a
  337.      ejecutar.  Se abrirá en el path fijado por la  ToolType REXXPATH.  Solo
  338.      se mostrarán los ficheros con la extensión '.zxam'.
  339.  
  340.    Abort ARexx.- Es un gadget que está totalmente bajo el control del script
  341.      en cuanto a activarlo/desactivarlo y leerlo periodicamente. El emulador
  342.      simplemente informa al script  de que ha sido pulsado y es  éste el que
  343.      debe decidir lo que debe hacer.
  344.  
  345.  
  346.  
  347.  
  348. ›[0;1mMENUS Y TECLADO›[0m
  349.  
  350.    Todos los gadgets que tienen una letra subrayada significa que  pulsando  la
  351. tecla  correspondiente    a  esa    letra  es  como  si  pulsáramos  el gadget, sin
  352. necesidad de tocar el ratón para nada.    También  tenemos  la  tecla  HELP,  que
  353. mostrará  el  requester  de 'About...', la tecla ESCAPE, con la que salimos del
  354. programa, y la tecla TAB, que  selecciona  el  primer  gadget  numérico  de  la
  355. ventana  para  poder  modificarlo  sin    tener  que seleccionarlo  con el ratón.
  356. Mientras estás modificando un gadget numérico puedes pulsar TAB para  pasar  al
  357. siguiente gadget numérico, o Shift+TAB para pasar al anterior.
  358.  
  359.    Por otro lado está el menú del programa, aunque todo lo que está en el  menú
  360. se  puede hacer desde teclado o pulsando los gadgets adecuados. Esta ahí por si
  361. se quisiera usar el programa sin el teclado, ya que  la  opcion  'About...'  no
  362. tiene gadget asociado en la pantalla (es una función importante...).
  363.  
  364.    A  partir  de  la  versión  1.6 se ha añadido el menu "Options" en el que se
  365. puede  seleccionar  hacia  donde desviar los comandos LOAD y SAVE de la ROM del
  366. Spectrum,  para poder grabar ficheros de datos del BASIC, o cargar fases en los
  367. juegos  multicarga,  directamente  del disco. La opción Disk Crunched significa
  368. que   al   grabar   los   datos   será   comprimidos   automáticamente  con  la
  369. powerpacker.library.
  370.  
  371.  
  372.  
  373.  
  374. ›[0;1mTECLADO EN EL SPECTRUM›[0m
  375.  
  376.    Cuando el Spectrum está en marcha el teclado equivale al de un Spectrum 48k,
  377. aunque he configurado algunas teclas especiales:
  378.  
  379.      <-   Borra un caracter (Shift+0)
  380.      Ctrl Equivale a pulsar Caps+Symbol, o sea, pasa a modo E (extendido)
  381.      Alt  Equivale a Symbol Shift
  382.      Del  Equivale a Shift+1 (Edit)
  383.      Help Vuelve al WorkBench
  384.      Esc  Reset
  385.      F1   Conmuta entre modo color o blanco y negro. En ordenadores sin memoria
  386.       FAST el conflicto existente entre  el procesador y los chips AGA para
  387.       acceder a la memoria CHIP frena el procesador. Si necesitas el máximo
  388.       de  velocidad  puedes poner  el emulador  en blanco  y negro,  con lo
  389.       que se acelerará un 10%, aproximadamente.  Además el sonido irá MUCHO
  390.       mejor.
  391.      F2   En modo Blanco y Negro invierte la imagen.
  392.      F6   Arranca el transfer (el programa se graba en cinta listo para ser
  393.           cargado en un Spectrum real o en el propio emulador).
  394.      Cursores  Equivalen a los cursores del Spectrum original (Shift+5 6 7 8).
  395.      ,      (tecla a la derecha de la M) equivale a la coma (Symbol+N)
  396.      .      (2ª tecla a la derecha de la M) equivale al punto (Symbol+M)
  397.      ´      (3ª tecla a la derecha de la M) equivale a las comillas (Symbol+P)
  398.      Ñ      (tecla a la derecha de la L) equivale a dos puntos (Symbol+Z)
  399.      ;      (2ª tecla a la derecha de la L) equivale al punto y coma (Symbol+O)
  400.  
  401.    El keypad funciona completo.
  402.  
  403.    El joystick Kempston se emula con el de Amiga.
  404.  
  405.    Debo decir que seguramente más de un  usuario  de  Amiga  1200  notará  algo
  406. extraño en el teclado, y es que no se pueden pulsar al mismo tiempo 2 teclas en
  407. la misma linea. Esto significa que si pulsas, por ejemplo, la P y la Q al mismo
  408. tiempo      el  emulador    creerá    que  no  tienes  pulsada  ninguna  tecla.  Este
  409. comportamiento no se debe a un fallo en el emulador si no  a  una  "curiosidad"
  410. bastante molesta del teclado del Amiga 1200 (al menos del alemán, que es el que
  411. yo tengo).
  412.  
  413.  
  414.  
  415.  
  416. ›[0;1mEMULACION›[0m
  417.  
  418. Detalles puntuales de la versión completa (FULL):
  419.  
  420.     - La ROM del Spectrum 48k original está en el ejecutable, en vez
  421.       de venir en un fichero separado, por comodidad.
  422.     - El registro R es correctamente emulado.
  423.     - En el registro F no se emulan los 2 bits no utilizados, y se
  424.       emulan parcialmente los bit N y H.
  425.     - La emulación del BCD es prácticamente completa.
  426.     - Se emulan todas las instrucciones "secretas" del Z80.
  427.     - El modo 0 de interrupciones se emula como el modo 1 (RST $38).
  428.     - No hay NMI (¿para que lo quiero?).
  429.     - El borde es de tipo lento, debido a que está implementado en la
  430.       copperlist. Esto significa que, de momento, no se vén las rayas
  431.       al hacer SAVE a cinta, pero el comando BORDER funciona
  432.       correctamente.
  433.     - Las instrucciones de transferencia funcionan a nivel 32 bits.
  434.     - Se puede conmutar (con F1) en modo blanco y negro o color para
  435.       acelerar el emulador en ordenadores sin memoria FAST.
  436.     - FLASH perfectamente emulado.
  437.     - El sonido se emula a nivel de la instrucción OUT. Se emulan los
  438.       2 bits del spectrum (el del altavoz y el de cassette) en un solo
  439.       canal del Amiga.
  440.     - El joystick Kempston se emula a nivel de la instrucción IN.
  441.     - La sincronización con el barrido de la pantalla es solo parcial.
  442.       Por eso algunos programas parpadearán (de momento).
  443.     - La pantalla del Spectrum se abre en PAL con 15KHz de barrido
  444.       horizontal, o sea que no se puede usar el emulador con monitores
  445.       tipo VGA, aunque si se puede usar con monitores MultiSync, con
  446.       el Commodore 1084, el Philips 8833 y con cualquier televisor.
  447.       No hay parches que valgan.
  448.     - La pantalla es compatible genlock.
  449.     - El emulador funciona correctamente aunque VBR no sea 0.
  450.    >>>>>>>>> Añadido para 1.3 ß <<<<<<<<<
  451.     - Carga de cinta, por parche (en realidad parchecillo) en la ROM.
  452.     - Graba hacia cinta en TIEMPO REAL, o sea, es la emulación Z80 la
  453.       que manda los impulsos a la salida de audio. Incluso en 1200 sin
  454.       memoria FAST.
  455.     - El borde es "casi" real (ya no es de tipo lento).
  456.    >>>>>>>>> Añadido para 1.3b ß <<<<<<<<<
  457.     - El emulador incorpora un transfer a cinta, para pasar a cinta los
  458.       programas que tengas en disco.
  459.    >>>>>>>>> Añadido para 1.6 <<<<<<<<<
  460.         - Se puede desviar las rutinas LOAD y SAVE de la ROM para que carguen
  461.           o graben sobre disco.
  462.       
  463.     Notas sobre versión FAST (v1.3 ß):
  464.     - No emula BCD. Esto significa que el BASIC no imprimirá correctamente
  465.       los numeros, y que algunos juegos no imprimirán bién la puntuación.
  466.     - Las temporizaciones son menos precisas, lo que puede suponer que
  467.       algunos juegos se comporten de una forma "peculiar".
  468.     - No se emula el registro R.
  469.     - La salida de audio no está estabilizada, por lo que el SAVE a cinta
  470.       no funciona.
  471.     - El borde es de tipo lento.
  472.     - No hay LOAD de cinta.
  473.         (en realidad la versión FAST es solo PARA JUGAR!!)
  474.     - La diferencia de velocidad entre la versión FULL y la FAST es de
  475.       entre un 5% y un 10% (depende del juego). La verdad es que prefiero
  476.       usar la versión FULL en mi 1200 para tener la emulación lo más
  477.       completa posible.
  478.  
  479.  
  480.  
  481.  
  482. ›[0;1mPUERTO AREXX›[0m
  483.  
  484.    A partir de la versión 1.4 ß el emulador tiene un puerto ARexx.  Este puerto
  485. es ideal para crear scripts que permitan soportar nuevos  formatos,  ensamblar,
  486. desensamblar,  hacer pokeadores,  y cualquier cosa que se te ocurra.  El puerto
  487. tiene  el nombre 'ZXAM_REXX',  aunque solo usarás  el nombre para  comprobar si
  488. el emulador está presente, como verás más abajo.
  489.  
  490.    Junto con el emulador encontrarás scripts de ejemplo para cargar formatos de
  491. snapshot,  para  grabar  la  pantalla del Spectrum como IFF, para conversión de
  492. formatos en bloque, para listar el programa BASIC que pueda haber en la memoria
  493. del  Spectrum,  para  sacar  la  ROM  del Spectrum del emulador, por si quieres
  494. modificarla  por alguna razón, para desensamblar la memoria del spectrum y para
  495. descomponer  ficheros .TAP. La mayoria de estos scripts son simples ejemplos de
  496. uso  de  las  funciones que incorpora el ZXAM. Una muestra de las posibilidades
  497. del  puerto  ARexx es el script Monitor.zxam (hecho por Leonardo Cocaña Galán),
  498. que  es  un  simple  desensamblador  que te permite 'hurgar' por las tripas del
  499. Spectrum.  Es solo un principio, que mejorandolo puede llegar a ser un completo
  500. desensamblador/monitor de C/M. Algunos de los scripts usan algunos comandos del
  501. sistema  operativo  (como requestchoice o multiview). Es caso de no disponer de
  502. estos, deberás modificar los scripts para que usen los que tengas.
  503.  
  504.    El puerto ARexx del emulador tiene una peculiaridad, y es que es un Function
  505. Host,  no un Command Host.  Traducido al 'cristiano' significa que lo que tiene
  506. el  emulador no  son comandos,  sino funciones.  De esta forma  no es necesario
  507. hacer ADDRESS ZXAM_REXX o OPTIONS RESULTS al principio de los scripts.  Además,
  508. así se pueden usar las funciones directamente dentro de expresiones.  La  única
  509. regla  es que los parámetros  se entregan entre paréntesis, y que las funciones
  510. sin parámetros  necesitan un  paréntesis  vacio tras ellas.  Además,  al ser un
  511. function host, todas las funciones del emulador empiezan por ZXAM,  para evitar
  512. conflictos con nombres de funciones de otros host o librerias.  Los nombres son
  513. independientes  de mayúculas/minúsculas. Las funciones sin parámetros se pueden
  514. ejecutar como comandos (ADDRESS...).
  515.  
  516.    Las 56 funciones implementadas en la versión 1.6b (39.21) son:
  517.  
  518.  
  519. ZXAMGetReg:  Toma el valor de un registro del Z80 de 8 o 16 bits. Mirar sección
  520. 'Registros' para los registros soportados. El parámetro opcional 'formato' fija
  521. el formato en que debe darse el valor devuelto ('h' para hexadecimal y 'd' para
  522. decimal). El formato por defecto es decimal.
  523.  
  524. formato:    valor = ZXAMGetReg( nombre registro , [formato] )
  525.             
  526. -------------------------------------------------------------------------------
  527.             
  528. ZXAMSetReg: Mete un valor de 8 o 16 bits en un registro del Z80.  Mirar sección
  529. 'Registros' para más detalles.
  530.     
  531. formato:    ZXAMSetReg( nombre registro , valor )
  532.             
  533. -------------------------------------------------------------------------------            
  534.  
  535. ZXAMPeek: Lee un byte de la dirección dada de la memoria del Spectrum.
  536.  
  537. formato:    valor = ZXAMPeek( direccion spectrum )
  538.  
  539. -------------------------------------------------------------------------------
  540.  
  541. ZXAMPoke: Escribe un byte en la memoria del Spectrum.        
  542.  
  543. formato:    ZXAMPoke( direccion spectrum , valor 8 bits )
  544.  
  545. -------------------------------------------------------------------------------
  546.  
  547. ZXAMDPeek: Lee un valor de 16 bits de la memoria del Spectrum en formato Z80, o
  548. sea, el byte menos significativo está primero.
  549.  
  550. formato:    valor = ZXAMDPeek( direccion spectrum )
  551.  
  552. -------------------------------------------------------------------------------
  553.  
  554. ZXAMDpoke:  Escribe un valor de 16 bits en la memoria del Spectrum.  Lo escribe
  555. en formato Z80, o sea, el byte menos significativo se coloca primero.
  556.  
  557. formato:    ZXAMDPoke( direccion spectrum , valor 16 bits )
  558.  
  559. -------------------------------------------------------------------------------
  560.  
  561. ZXAMGetMem: Lee un trozo  de memoria de la  dirección y  el tamaño  dados  y lo
  562. entrega como cadena.
  563.  
  564. formato:    cadena = ZXAMGetMem( direccion spectrum , tamaño )
  565.  
  566. -------------------------------------------------------------------------------
  567.  
  568. ZXAMPutMem: Coloca la cadena dada en la dirección especificada de la memoria de
  569. Spectrum. La cadena suele ser una secuencia de bytes, no un texto.
  570.  
  571. formato:    ZXAMPutMem( direccion spectrum , cadena )
  572.  
  573. -------------------------------------------------------------------------------
  574.  
  575. ZXAMFindByte:  Busca el byte a  partir de la  dirección dada.  Si llega al tope
  576. superior de la  memoria del Spectrum sin encontrarlo, entregará -1.  En caso de
  577. encontrarlo, entrega la dirección donde se encuentra el byte.
  578.  
  579. formato:    direccion = ZXAMFindByte( direccion spectrum , byte_a_buscar )
  580.  
  581. -------------------------------------------------------------------------------
  582.  
  583. ZXAMRun: Arranca la emulación (simple, ¿no?).
  584.     
  585. formato:    ZXAMRun()
  586.  
  587. -------------------------------------------------------------------------------
  588.  
  589. ZXAMQuit: Provoca la salida del emulador (como cerrar la ventana del emulador).
  590.  
  591. formato:    ZXAMQuit()
  592.  
  593. -------------------------------------------------------------------------------
  594.     
  595. ZXAMppLoadFile:  Carga  un  fichero  a  través de la  powerpacker.library  y lo
  596. entrega descomprimido  en forma de cadena.  Si el fichero no estaba comprimido,
  597. se cargará igual.
  598.  
  599. formato:    bloque = ZXAMppLoadFile( path_y_nombre )
  600.  
  601. -------------------------------------------------------------------------------
  602.  
  603. ZXAMppSaveFile:  Salva  un  bloque  de bytes  a disco,  comprimiéndolo  con  la
  604. powerpacker.library.  En caso  de no  querer  comprimir el  fichero,  usar  los
  605. comandos del ARexx para acceso a ficheros.
  606.  
  607. formato:    ZXAMppSaveFile( path_y_nombre , bloque )
  608.  
  609. -------------------------------------------------------------------------------
  610.  
  611. ZXAMLoadRequester:  Abre el requester de LOAD  del emulador.  El título es para
  612. colocar  en la parte  superior del requester.  El path (opcional)  fija en  que
  613. directorio debe abrirse el requester.  En caso de no entregar  path se usará el
  614. último que se usó con el requester. Si 'path_y_nombre' está vacio significa que
  615. se ha pulsado el CANCEL.
  616.  
  617. formato:    path_y_nombre = ZXAMLoadRequester( titulo , [path] )
  618.  
  619. -------------------------------------------------------------------------------
  620.  
  621. ZXAMSaveRequester:  Abre el requester de SAVE del emulador.  El título  es para
  622. colocar  en la parte  superior del requester.  El path (opcional)  fija  en que
  623. directorio debe abrirse el requester. En caso de no entregar  path se  usará el
  624. último que se usó con el requester. Si 'nombre_y_path' está vacio significa que
  625. se ha pulsado el CANCEL.
  626.  
  627. formato:    path_y_nombre = ZXAMSaveRequester( titulo , [path] )
  628.  
  629. -------------------------------------------------------------------------------
  630.  
  631. ZXAMNameFormat:  Coloca las cadenas entregadas en las  casillas 'Loaded File' y
  632. 'Format' de la ventana del emulador.
  633.  
  634. formato:    ZXAMNameFormat( nombre , formato )
  635.  
  636. -------------------------------------------------------------------------------
  637.  
  638. ZXAMActName: Entrega el nombre contenido en la casilla 'Loaded file'. Si no hay
  639. nombre, entregará una cadena vacia.
  640.  
  641. formato:    nombre = ZXAMActName()
  642.  
  643. -------------------------------------------------------------------------------
  644.  
  645. ZXAMActLoadPath: Entrega el último path utilizado en el requester de LOAD.
  646.  
  647. formato:    path = ZXAMActLoadPath()
  648.  
  649. -------------------------------------------------------------------------------
  650.  
  651. ZXAMActSavePath: Entrega el último path utilizado en el requester de SAVE.
  652.  
  653. formato:    path = ZXAMActSavePath()
  654.  
  655. -------------------------------------------------------------------------------
  656.     
  657. ZXAMActFormat:  Entrega el nombre de formato contenido en  la casilla 'Format'.
  658. Si no hay formato, entregará una cadena vacía.
  659.  
  660. formato:    formato = ZXAMActFormat()
  661.  
  662. -------------------------------------------------------------------------------
  663.  
  664. ZXAMActSaveFormat: Entrega el nombre del actual formato seleccionado para save.
  665. Puede ser  PC, MIRAGE,  PC_PP y MIRAGE_PP  (los dos últimos son los comprimidos
  666. con powerpacker.library).
  667.  
  668. formato:    formato = ZXAMActSaveFormat()
  669.  
  670. -------------------------------------------------------------------------------
  671.  
  672. ZXAMProgVersion:  Entrega  la  versión  interna del programa.  En el caso de la
  673. versión 1.5,  entrega la versión interna  '39.16'.  Sirve por si se quiere usar
  674. una  función  ARexx  que  solo  está  presente  a  partir de cierta versión del
  675. emulador  (para saber la versión a la que aparece uns función, mira la HISTORIA
  676. al final de este DOC).
  677.  
  678. formato:    version = ZXAMProgVersion()
  679.  
  680. -------------------------------------------------------------------------------
  681.  
  682. ZXAMSaveFormat:  Selecciona un formato para SAVE. Puede ser PC, MIRAGE, PC_PP o
  683. MIRAGE_PP.
  684.  
  685. formato:    ZXAMSaveFormat( nombreformato )
  686.  
  687. -------------------------------------------------------------------------------
  688.  
  689. ZXAMParseLoaded:  Coge el bloque entregado e intenta reconocerlo como snapshot.
  690. Si  es  de formato conocido (PC, MIRAGE, Z80 o KGB, SIN comprimir) colocará los
  691. registros  y  la  memoria  a  los  valores  de acuerdo al snapshot. A la salida
  692. entrega  el  nombre  del  formato  del bloque (PC, MIRAGE, Z80 o KGB). Si no ha
  693. podido  reconocer  el  formato  no  modificará nada (ni registros ni memoria) y
  694. entregará una cadena vacia como nombre de formato.
  695.  
  696. formato:    formato = ZXAMParseLoaded( bloque )
  697.  
  698. -------------------------------------------------------------------------------
  699.  
  700. ZXAMParseToSave:  Entrega la  memoria y los  registros del  Spectrum  colocados
  701. según el formato seleccionado para SAVE (SIN comprimir).
  702.  
  703. formato:    bloque = ZXAMParseToSave()
  704.  
  705. -------------------------------------------------------------------------------
  706.  
  707. ZXAMJoinPathName: Une el path y el nombre entregados.
  708.  
  709. formato:    nombrecompleto = ZXAMJoinPathName( path , nombre )
  710.  
  711. -------------------------------------------------------------------------------
  712.  
  713. ZXAMGetScr:  Entrega la pantalla actual del Spectrum en  formato de 4 bitplanos
  714. entrelazados, listo para grabar en una estructura IFF ILBM.
  715.  
  716. formato:    bloque = ZXAMGetScr()
  717.  
  718. -------------------------------------------------------------------------------
  719.  
  720. ZXAMClearNameFormat: Borra las casillas 'Loaded file' y 'Format'.
  721.  
  722. formato:    ZXAMClearNameFormat()
  723.  
  724. -------------------------------------------------------------------------------
  725.  
  726. ZXAMLoadPath: Modifica el path para requester de LOAD sin abrirlo.
  727.  
  728. formato:    ZXAMLoadPath( path )
  729.  
  730. -------------------------------------------------------------------------------
  731.  
  732. ZXAMSavePath: Modifica el path para requester de SAVE sin abrirlo.
  733.  
  734. formato:    ZXAMSavePath( path )
  735.  
  736. -------------------------------------------------------------------------------
  737.  
  738. ZXAMFilePart: Entrega el nombre del fichero de un path completo.
  739.  
  740. formato:    nombre = ZXAMFilePart( path_y_nombre )
  741.  
  742. -------------------------------------------------------------------------------
  743.  
  744. ZXAMPathPart: Entrega el path (sin el nombre del fichero) de un path completo.
  745.  
  746. formato:    path = ZXAMPathPart( path_y_nombre )
  747.  
  748. -------------------------------------------------------------------------------
  749.  
  750. ZXAMPreRun: Modifica la linea de comandos PRERUN.
  751.  
  752. formato:    ZXAMPreRun( linea_de_comandos )
  753.  
  754. -------------------------------------------------------------------------------
  755.  
  756. ZXAMActPreRun: Entrega la actual linea de comandos PRERUN.
  757.  
  758. formato:    linea_de_comandos = ZXAMActPreRun()
  759.  
  760. -------------------------------------------------------------------------------
  761.  
  762. ZXAMPostRun: Modifica la linea de comandos POSTRUN.
  763.  
  764. formato:    ZXAMPostRun( linea_de_comandos )
  765.  
  766. -------------------------------------------------------------------------------
  767.  
  768. ZXAMActPostRun: Entrega la actual linea de comandos POSTRUN.
  769.  
  770. formato:    linea_de_comandos = ZXAMActPostRun()
  771.  
  772. -------------------------------------------------------------------------------
  773.  
  774. ZXAMPattern: Modifica el pattern para los requesters de ficheros.
  775.  
  776. formato:    ZXAMPattern( pattern )
  777.  
  778. -------------------------------------------------------------------------------
  779.  
  780. ZXAMActPattern: Entrega el pattern actual para los requesters de ficheros.
  781.  
  782. formato:    pattern = ZXAMActPattern()
  783.  
  784. -------------------------------------------------------------------------------
  785.  
  786. ZXAMBASICToken:   Entrega   el  token  expandido  correspondiente  al  caracter
  787. entregado,  o  sea, traduce el caracter según la tabla de caracteres y palabras
  788. claves  (tokens)  del  Spectrum.  Por  ejemplo  ZXAMBASICToken('ff'x) entregará
  789. 'COPY'. Todos los caracteres del 0 al 255 son traducidos.
  790.  
  791. formato:    cadena = ZXAMBASICToken( caracter )
  792.  
  793. -------------------------------------------------------------------------------
  794.  
  795. ZXAMReadAbort: Entrega un 0 o un 1, indicando si se ha pulsado el gadget 'Abort
  796. ARexx'.
  797.  
  798. formato:    pulsado = ZXAMReadAbort()
  799.  
  800. -------------------------------------------------------------------------------
  801.  
  802. ZXAMClearAbort: Borra (a 0) el indicador de que se ha pulsado 'Abort ARexx'.
  803.  
  804. formato:    ZXAMClearAbort()
  805.  
  806. -------------------------------------------------------------------------------
  807.  
  808. ZXAMNoReload:  Desactiva  el  gadget  "Reload".  Esto debe hacerse cuando hemos
  809. dejado  modificada  la caja 'Loaded File', indicando asi que al pulsar 'Reload'
  810. no se cargará lo que aparece en dicha caja.
  811.  
  812. formato:    ZXAMNoReload()
  813.  
  814. -------------------------------------------------------------------------------
  815.  
  816. ZXAMEnableAbort:  Activa  el gadget 'Abort ARexx'. Esto debe hacerse si quieres
  817. leer  el  gadget  desde  el  script  (al  arrancar  el  script  el  gadget está
  818. desactivado por defecto).
  819.  
  820. formato:    ZXAMEnableAbort()
  821.  
  822. -------------------------------------------------------------------------------
  823.  
  824. ZXAMDisableAbort: Desactiva el gadget 'Abort ARexx'. Si no vas a leer el gadget
  825. debes  desactivarlo,  para  evitar que el usuario intente interrumpir el script
  826. inutilmente.
  827.  
  828. formato:    ZXAMDisableAbort()
  829.  
  830. -------------------------------------------------------------------------------
  831.  
  832. ZXAMDisassemble: Desensambla la instrucción de la dirección dada, entregando a
  833.                  la salida una cadena con el formato:
  834.         - 1 caracter ASCII que indica el numero de bytes que ocupa
  835.                   la instrucción (para incrementar la dirección entregada y
  836.                   saber así la dirección de la siguiente). Este caracter debe
  837.                   ser eliminado de la cadena antes de imprimirla en pantalla
  838.                   o impresora.
  839.                 - el resto de la cadena es un desensamblado en en habitual
  840.                   formato 'dirección+codigo objeto+mnemonico'. En el caso de
  841.                   que la instrucción desensamblada fuera un salto relativo
  842.                   (JR, DJNZ, etc...) se añadirá al final de la linea un
  843.                   comentario que indicará la dirección destino del salto.
  844.                   Las instrucciones ilegales se representarán como '---'.
  845.  
  846.                 El parametro opcional "formato" determina el formato en que
  847.                 se imprimen las direcciones/datos. Si es 'H' se imprimirán
  848.                 en hexadecimal, y si es 'D' se imprimirán en decimal. Si no
  849.                 se entrega este parámetro, se imprimirá en hexadecimal
  850.  
  851. formato:    ZXAMDisassemble( direccion , [formato] )
  852.  
  853. -------------------------------------------------------------------------------
  854.  
  855. ZXAMLoadMode:  Indica  el  modo  del  parche LOAD (o sea, controla el menu LOAD
  856. MODE). Se le entrega el modo deseado ('TAPE' o 'DISK').
  857.  
  858. formato:    ZXAMLoadMode( modo )
  859.  
  860. -------------------------------------------------------------------------------
  861.  
  862. ZXAMSaveMode:  Indica  el  modo  del  parche SAVE (o sea, controla el menu SAVE
  863. MODE). Se le entrega el modo deseado ('TAPE', 'DISK' o 'DISK_PP').
  864.  
  865. formato:    ZXAMSaveMode( modo )
  866.  
  867. -------------------------------------------------------------------------------
  868.  
  869. ZXAMActLoadMode:  Indica  el  modo en el que está actualmente el parche LOAD (o
  870. sea,  muestra el estado del menu LOAD MODE). El resultado es una cadena ('TAPE'
  871. o 'DISK').
  872.  
  873. formato:    modo = ZXAMActLoadMode()
  874.  
  875. -------------------------------------------------------------------------------
  876.  
  877. ZXAMActSaveMode:  Indica  el  modo en el que está actualmente el parche SAVE (o
  878. sea, muestra el estado del menu SAVE MODE). El resultado es una cadena ('TAPE',
  879. 'DISK' o 'DISK_PP').
  880.  
  881. formato:    modo = ZXAMActSaveMode()
  882.  
  883. -------------------------------------------------------------------------------
  884.  
  885. ZXAMAbout: Muestra el requester de 'About...' del emulador.
  886.  
  887. formato:    ZXAMAbout()
  888.  
  889. -------------------------------------------------------------------------------
  890.  
  891. ZXAMFindBlock:  Busca  un bloque de bytes el la memoria del Spectrum. El primer
  892. argumento  es  la  dirección  donde  empezar  la  búsqueda,  y el segundo es el
  893. conjunto de bytes (en forma de cadena) a buscar. Esto significa que para buscar
  894. 'HOLA'  debemos hacer ZXAMFindBlock(0,'HOLA'), y para buscar los bytes 0F 45 7B
  895. haremos  ZXAMFindBlock(0,'0F457B'x).  En caso de que el numero hexadecimal esté
  896. en  una variable, usar x2c(variable) en el segundo argumento, para que el ARexx
  897. convierta  la cadena hexadecimal en los bytes correspondientes. El resultado es
  898. la  dirección donde esa secuencia de bytes ha sido encontrada, o -1 si no lo ha
  899. sido.
  900.  
  901. formato:    dirección = ZXAMFindBlock( dirección , bloque_a_buscar )
  902.  
  903. -------------------------------------------------------------------------------
  904.  
  905. ZXAMDoChecksum:  Hace  una suma de comprobación como la que hace la rutina SAVE
  906. de la ROM, o sea, un XOR (OR exclusiva) de todos los bytes del bloque de datos.
  907. Los  parámetros  son la dirección de inicio del bloque y el numero de bytes que
  908. lo  componen.  Por  ejemplo,  ZXAMDoChecksum(0,16384) entregará el resultado de
  909. hacer XOR de todos los bytes de la ROM.
  910.  
  911. formato:    resultado = ZXAMDoChecksum( dirección , numero_bytes )
  912.  
  913. -------------------------------------------------------------------------------
  914.  
  915. ZXAMBreakPoint: Coloca un breakpoint (punto de ruptura) en la dirección dada de
  916. la  memoria  del  Spectrum.  Si  durante la ejecución se llega al breakpoint el
  917. emulador  sale  al  workbench  (como si se pulsase la tecla 'HELP'). En memoria
  918. solo puede haber UN breakpoint, por lo que al poner uno se elimina el anterior.
  919. Si la dirección es 0 se borra el breakpoint anterior sin colocar ninguno nuevo.
  920. El  breakpoint es una instrucción, por lo que si el programa modifica esa parte
  921. del  código  desaparece  el  breakpoint.  El  breakpoint solo "sobrevive" a una
  922. entrada  al  emulador,  o sea, tan pronto como se pulse 'HELP' para salir de la
  923. emulación,  éste desaparecerá (las salidas provocadas por load/save de disco no
  924. afectan al breakpoint).
  925.  
  926. formato:    ZXAMBreakPoint( dirección )
  927.  
  928. -------------------------------------------------------------------------------
  929.  
  930. ZXAMTrace: Ejecuta  la  instrucción  a  la  que  apunta  PC (sin desconectar la
  931. multitarea).   Una   vez  ejecutada  la  instrucción  la  función  devuelve  el
  932. desensamblado  de  la  instrucción  ejecutada (igual que ZXAMDisassemble()). El
  933. 'formato' puede ser 'd' o 'h', indicando si el desensamblado debe ser decimal o
  934. hexadecimal  (como  el segundo parámetro de ZXAMDisassemble()). El 'formato' es
  935. opcional,  siendo  hexadecimal  por  defecto. Al contrario que para arrancar el
  936. emulador,  ni  las  CIAs  ni  los  canales de audio necesitan ser alojados para
  937. ejecutar código paso-a-paso.
  938.  
  939. formato:    desen = ZXAMTrace( [formato] )
  940.  
  941. -------------------------------------------------------------------------------
  942.  
  943. ZXAMDoInt:  Efectua  una  interrupción (como si hubiese llegado la señal INT al
  944. microprocesador  Z80), o sea, mete PC en la pila del Z80, y le da a PC el valor
  945. adecuado  al  modo  de interrupción actual (en IM1 le da el valor $38, y en IM2
  946. mete  el  vector  de  la  tabla apuntada por I). Si las interrupciones no están
  947. permitidas, la función no hace nada.
  948.  
  949. formato:    ZXAMDoInt()
  950.  
  951. -------------------------------------------------------------------------------
  952.  
  953. ZXAMBlockOfRegs: Entrega un bloque de 27 bytes que contiene todos los registros
  954. y estados internos del procesador Z80, en el siguiente orden:
  955.  
  956. Pos  Tamaño  Contenido
  957.  0    1    A
  958.  1    1    F
  959.  2    2    BC
  960.  4    2    DE
  961.  6    2    HL
  962.  8    1    A'
  963.  9    1    F'
  964. 10    2    BC'
  965. 12    2    DE'
  966. 14    2    HL'
  967. 16    2    IX
  968. 18    2    IY
  969. 20    2    SP
  970. 22    2    PC
  971. 24    1    Estado Interrupción (0=no permitidas / 1=permitidas)
  972. 25    1    Modo de Interrupción (0, 1 o 2)
  973. 26    1    Color del Borde (0 a 7)
  974.  
  975. Los  registros  dobles  están  en  formato  68000,  o  sea,  con  el  byte  más
  976. significativo PRIMERO.
  977.  
  978. formato:    bloque = ZXAMBlockOfRegs()
  979.  
  980. -------------------------------------------------------------------------------
  981.  
  982. REGISTROS:  los  registros  accesibles  por  ZXAMGetReg  y  ZXAMSetReg  son los
  983. habituales del Z80, en el formato:
  984.     
  985.        -registros de 8 bits: su nombre directo, incluyendo las mitades de
  986.         los registros de 16 bits no divisibles, o sea,  SPH y SPL son las
  987.         dos mitades del registro SP de 16 bits.
  988.         
  989.        -registros de 16 bits:  su nombre directo,  como HL  y PC.  AF  no
  990.         está implementado, o sea que hay que leer A y F por separado.
  991.        
  992.        -registros de 16 bits invertidos:  si se invierte el nombre  de un
  993.         registro de 16 bits (por ejemplo LH o XI) la lectura/escritura se
  994.         realiza intercambiando los bytes alto y bajo del registro.  En el
  995.         script 'LoadSnap.zxam' verás un ejemplo de para que sirve.
  996.         
  997.        -"registros" especiales: son
  998.             INT : estado de las interrupciones (0=OFF, 1=ON)
  999.             IM : modo de interrupción (0, 1 o 2)
  1000.             BOR : color actual del borde (0 a 7)
  1001.  
  1002. en  todos los casos  se le añade  un '2' al final del nombre para acceder a los
  1003. registros del juego alternativo, o sea,  para acceder a hl' y a a' escribiremos
  1004. HL2 y A2.  Los nombres son independientes de mayúsculas/minúsculas.  Todos  los
  1005. casos admiten lectura y escritura.
  1006.  
  1007.  
  1008.  
  1009.  
  1010. ›[0;1mCUESTIONES TECNICAS›[0m
  1011.  
  1012.    Este  programa  ha  sido  escrito  en  ensamblador desde la primera linea de
  1013. código a las 17750 (!!!!) actuales (151023 al expandir las MACROs). En mi Amiga
  1014. 1200  con  disco  duro  y  68030/28MHz  el emulador tarda 51 seg en ensamblarse
  1015. (antes  eran  3 min 50 seg cuando no tenia disco duro, o 4 min 53 seg la última
  1016. versión  que ensamblé sobre el 500 Plus). La verdad es que se me ha ido un poco
  1017. la mano...
  1018.  
  1019.    Este es el tercer programa "completo" que  hago  en    ensamblador.  Empecé  a
  1020. programarlo  sobre  un    Amiga  500  Plus con 2 Megas de RAM, 3 disqueteras y el
  1021. ensamblador Devpac 3.02. En  cuanto  he  podido  comprarme  un    Amiga  1200  he
  1022. covertido el emulador a código 68020 puro y chips AGA.
  1023.  
  1024.    Lo empecé para aprender sobre todo en cuanto a código específico 68020, para
  1025. explorar las posibilidades y ventajas de programar en codigo especial para este
  1026. procesador. Era además un capricho de programador compulsivo (es que soy adicto
  1027. a la programación). Cuando solo tenia el 500Plus programaba condicionalmente en
  1028. código 68000 y 68020 al mismo tiempo y lo probaba en el Amiga  4000/030  de  un
  1029. amigo.      Aprovechado  mi  reciente  adquisición  del  Amiga  1200  también  he
  1030. investigado sobre las posibilidades de los chips AGA  (que  son  muchas)  y  la
  1031. forma de utilizarlos.
  1032.  
  1033.    Ahora al fin tengo un equipo en condiciones (A1200 420Mb HD, 68030/28MHz y 6
  1034. Mb de memoria). Ahora programar es un gustazo!!
  1035.  
  1036.  
  1037.  
  1038.  
  1039. ›[0;1mPRE-HISTORIA›[0m
  1040.  
  1041.    La primera versión (en blanco y negro,  arrancable  desde  SHELL  y    con  el
  1042. ManicMiner  integrado  en el ejecutable)  funcionó en 10 dias.    A partir de ahí
  1043. hay acumulados 6 sistemas diferentes de emulación del color del  Spectrum  (los
  1044. atributos  y  la  estructura de la pantalla), 4 reestructuraciones del emulador
  1045. del Z80 y montones de horas  buscando  errores    y  apurando  la  velocidad  del
  1046. procesador. Ninguna de las versiones pre-AGA han sido distribuidas.
  1047.  
  1048.    El emulador no ha sido, ni es, un  proyecto    de  tiempo  completo.  Mientras
  1049. desarrollaba    el   emulador  he  estado  estudiando  un  curso   de  sistemas
  1050. automáticos, he desarrollado otro  programa,  llamado  MPMaster,  y  he  estado
  1051. practicando mi vagancia habitual ;-)
  1052.  
  1053.  
  1054.  
  1055.  
  1056. ›[0;1mHISTORIA›[0m
  1057.  
  1058.       Versión  Versión
  1059.            interna
  1060.  
  1061.     1.0 ß    39.00
  1062.         -Primera versión en circulación.
  1063.  
  1064.         (distribuida como ZXAM Spectrum Emulator AGA 1.0 ß)
  1065.  
  1066.     1.1 ß    39.01      (ejecutable llamado ZXAM_CuelgueSeguro)
  1067.         -Desactiva filtro de audio al entrar. Lo restaura al salir.
  1068.         -Desactivadas las interrupciones de los Timers. Actualmente
  1069.          solo permanece activada la del teclado. Esto ha mejorado
  1070.          drásticamente el sonido.
  1071.         -Debido a la desactivación de los Timers el emulador se
  1072.          "congela" al cabo de un cierto numero de pulsaciones de
  1073.          tecla (en realidad el que se cuelga es el HANDLER DE
  1074.          TECLADO DEL SISTEMA, ya que se le desborda el buffer).
  1075.  
  1076.         39.02      (19-ABRIL-94, tras 2 semanas sabáticas)
  1077.         -añadido gadget ZOOM a la ventana del programa
  1078.         -el hadler del teclado me sigue tocando las narices...
  1079.  
  1080.         (no se llegó a distribuir)
  1081.  
  1082.     1.2 ß    39.03      (26-JUNIO-94, tras 2 meses de exámenes y MPMaster)
  1083.         -¡Al fin! Arreglado el problema con el teclado. El emulador
  1084.          ya no se cuelga por culpa del desborde del buffer del teclado.
  1085.         -Ahora, si pulsamos Caps Lock dentro del spectrum, al salir
  1086.          al sistema, éste es informado correctamente del estado de
  1087.          mayúsculas del teclado. Antes, al no recibir bién la señal,
  1088.          escribia minúsculas aunque Caps Lock estuviese iluminado.
  1089.         -Disponibles versiones FULL (completa) y FAST (rápida) para
  1090.          usar en Amiga 4000 y 1200 respectivamente. La versión FAST
  1091.          es un 10% más rápida que la FULL, aproximadamente, aunque se
  1092.          aprecia en algunos programas mejor que en otros. Esto se ha
  1093.          conseguido eliminando algunos detalles de la emulación.
  1094.  
  1095.         39.04
  1096.         -El emulador se "despega" de la ventana del SHELL, dejándola
  1097.          libre por si quieres usarla, o cerrarla.
  1098.         -Ahora se leen las opciones del icono incluso si arrancas el
  1099.          emulador desde SHELL.
  1100.  
  1101.         39.05
  1102.         -Eliminado el problema con el audio. Ahora el sonido del
  1103.          spectrum suena perfectamente aunque antes de arrancarlo
  1104.          hubiera algún tipo de player (como el Delitracker) en marcha.
  1105.          A la salida el tracker seguirá donde estaba (al menos, con
  1106.          los players que yo tengo...).
  1107.  
  1108.         39.06
  1109.         -Realizadas algunas optimizaciones preparatorias para la
  1110.          implementación de LOAD y SAVE de cinta.
  1111.         -Ahora alojamos el Timer-B de la CIA-B para las temporizaciones
  1112.          del emulador, en preparación para el estabilizador de audio.
  1113.         
  1114.         (distribuida como ZXAM Spectrum Emulator AGA 1.2 ß)
  1115.  
  1116.     1.3 ß    39.07        (7-JULIO-94)
  1117.         -Primer intento de parchear la ROM para cargar. La carga puede
  1118.          realizarse tanto en B/N como en color, incluso sin la
  1119.          presencia de memoria FAST (!). Tampoco es necesario parar las
  1120.          interrupciones del FLASH (!!). La estabilidad de carga parece
  1121.          muy buena, aunque debe probarse en otras configuraciones
  1122.          (68040, 68030/40MHz o 68030/50MHz). Sobre el 1200 y 4000/030
  1123.          la carga funciona perfectamente.
  1124.         -Sincronizada instrucción OUT. Con esto ya tenemos SAVE en
  1125.          TIEMPO REAL (incluso en color!!), y BEEP en tiempo real. El
  1126.          sonido de algunos juegos ha mejorado extraordinariamente (como
  1127.          el Pheenix). Por otro lado otros juegos se han ralentizado
  1128.          alrededor de un 3% (3 weeks in paradise) debido a que la
  1129.          sincronia supone instrucciones adicionales en la rutina OUT.
  1130.          
  1131.         39.08        (11-JULIO-94)
  1132.         -¡Borde REAL! Si la velocidad es suficiente se pueden ver los
  1133.          efectos de borde que hacen algunos programas.
  1134.         -Reajustada la correspondencia de colores para BRIGHT 0 y 1.
  1135.          Ahora la proporción de brillo es prácticamente idéntica a la
  1136.          del Spectrum original.
  1137.         -Reajustes del parche de carga. Sigue funcionando igual de
  1138.          bién pero ahora reacciona mejor al BREAK, HELP y ESC.
  1139.         -Al fin le he dado la segunda vuelta al contador de lineas del
  1140.          Devpac. La versión 39.08 consta de 133637 lineas con las
  1141.          macros expandidas. Si sigo así no me bastarán los 2 Megas del
  1142.          A1200 para ensamblarlo... :-)
  1143.          
  1144.         39.09        (16-JULIO-94)
  1145.         -Arreglado el problema del borde con el parche de la rutina
  1146.          LOAD y con la instrucción OUT. Ahora el borde es "casi"
  1147.          perfecto tanto con LOAD como con SAVE (y OUT).
  1148.  
  1149.         (distribuida como ZXAM Spectrum Emulator AGA 1.3 ß)
  1150.  
  1151.     1.3b ß    39.10        (23-JULIO-94)
  1152.         -El emulador tiene ahora un "Transfer" integrado para poder
  1153.          pasar a cinta los programas que tenemos en disco (prueba
  1154.          de pulsar F6). Inicialmente incluido para usarlo yo mismo
  1155.          en las comparativas de velocidad entre el 1200 y el +2A.
  1156.         -En el momento de hacer "transfer", el bloque BASIC se graba
  1157.          con el nombre del programa cargado desde disco.
  1158.         -El transfer no usa rutina de carga propia, por lo que puedes
  1159.          cargar los programas en el propio emulador (¡que ilusión! ;-)
  1160.         -La "transfer"-encia se puede interrumpir con la tecla HELP.
  1161.         -El transfer graba en el cargador incluso el color del borde,
  1162.          cosa que los auténticos transfers de Spectrum no hacian.
  1163.         -Al hacer "Save Program" el nombre pasa al gadget "Loaded File",
  1164.          de forma que podemos hacer "Reload" del programa salvado,
  1165.          además de saber el nombre que hemos usado y el formato.
  1166.         -El requester de SAVE conserva un path diferente al de LOAD,
  1167.          facilitando así la conversión de ficheros entre diferentes
  1168.          directorios.
  1169.         -Si no se ha cargado ningún programa, al hacer transfer el
  1170.          programa se graba con el nombre LOADER.
  1171.  
  1172.         39.11        (31-JULIO-94)
  1173.         -Realizados unos ajustes en la sincronización del emulador. El
  1174.          sonido sigue estando estabilizado, pero ciertos juegos (Manic
  1175.          Miner,...) han recuperado su vieja velocidad ;-D
  1176.         -Arreglado un error en el transfer. Con este error, solo la
  1177.          primera transferencia funcionaba correctamente. La segunda vez
  1178.          el código Z80 del transfer resultaba corrupto.
  1179.         -Arreglado el problema del Kempston con el Panama Joe y el
  1180.          Commando.
  1181.         -El acceso al borde es un poco más rápido.
  1182.         
  1183.         (distribuida como ZXAM Spectrum Emulator AGA 1.3b ß)
  1184.  
  1185.     1.4 ß    39.12        (2-SEPTIEMBRE-94)
  1186.         -Primeros ensayos de puerto ARexx. Implementadas funciones
  1187.          GetReg, SetReg, Peek, Poke y Putmem. HA FUNCIONADO A LA
  1188.          PRIMERA!!!!
  1189.  
  1190.          39.13        (10-SEPTIEMBRE-94)
  1191.         -Ahora los menús son tipo NewLook (blancos con letras negras).
  1192.         -Añadidos mas funciones ARexx: DPeek, DPoke, FindByte, y el
  1193.          acceso a los registros Z80 en orientación Z80 y 68000.
  1194.          Posibilidad de recibir comandos y funciones.
  1195.         -Añadido el código para arrancar scripts ARexx desde el
  1196.          emulador. Ahora tengo que modificar la ventana para el botón
  1197.          de ejecutar script ARexx.
  1198.         -Escritos ya algunos scripts de ejemplo.
  1199.  
  1200.          39.14        (16-SEPTIEMBRE-94)
  1201.          -Añadida la versión interna al About...
  1202.          -Añadida ToolType ROMFILE para cargar ROMs externas. La ROM
  1203.           puede estar comprimida con powerpacker.
  1204.          -El nombre del último programa cargado/grabado aparece en el
  1205.           requester de SAVE, pero con la extensión adecuada al formato.
  1206.          -Añadidas funciones ARexx: Run, Quit, NameFormat, GetMem,
  1207.           ppLoadFile, ppSaveFile, LoadRequester, SaveRequester, ActName,
  1208.           ActLoadPath, ActSavePath y ActFormat.
  1209.          -Modificados los scripts de ejemplo para uso de las rutinas
  1210.           SAVE y LOAD a través de powerpacker.
  1211.         -Añadido el gadget para ejecutar scripts ARexx (de forma un
  1212.          poco chapucerilla....). Abre un requester de ficheros para
  1213.          elegir el script a ejecutar.
  1214.         -Añadida ToolType REXXPATH para indicar el path de los scripts
  1215.          ARexx. La extensión es SIEMPRE '.zxam'.
  1216.         -Ahora al arrancar el programa, éste hace CD al directorio
  1217.                  donde está el ejecutable, aunque nos arranquen desde shell con
  1218.                  CD en otro directorio. Esto significa que TODOS los paths
  1219.                  entregados al emulador son relativos al directorio del
  1220.                  ejecutable, o deben contener un path completo.
  1221.  
  1222.                 (no distribuida)
  1223.  
  1224.     1.5    39.15        (28-SEPTIEMBRE-94)
  1225.         -Añadida la posibilidad de grabar los programas comprimidos con
  1226.          la powerpacker.library.
  1227.         -Reorganizados los botones de selección de formato para SAVE.
  1228.          Ahora hay dos botones para cada formato (comprimido y sin
  1229.          comprimir).
  1230.         -Añadida dirección FidoNet al About ;-)
  1231.         -Añadidas funciones ARexx: ProgVersion, ActSaveFormat,
  1232.          SaveFormat, ParseToSave, ParseLoaded, JoinPathName,
  1233.          ClearNameFormat, GetScr, FilePart, PathPart, LoadPath,
  1234.          SavePath, PreRun, ActPreRun, PostRun, ActPostRun,
  1235.          Pattern, ActPattern y BASICToken.
  1236.         -Si hay algún problema inicializando el puerto ARexx, el gadget
  1237.          de ejecución de scripts ARexx queda desactivado.
  1238.         -Añadida la posibilidad de poner un titulo a los requesters de
  1239.          SAVE y LOAD.
  1240.         -Ahora el emulador devuelve correctamente la memoria cuando
  1241.          detecta que falta el WB 3.0+, el 68020+ o los chips AGA.
  1242.         -La ventana es una AppWindow, o sea, puedes tirar dentro los
  1243.          iconos de los ficheros a cargar. Si lo que metes es un cajón
  1244.          o un disco, se abrirá el requester de ficheros en dicho
  1245.          cajón/disco.
  1246.         -Añadidas ToolTypes PRERUN y POSTRUN para correr comandos antes
  1247.          de arrancar la emulación y después de pararla.
  1248.         -Antes de PRERUN se almacena el estado de los cachés, y se
  1249.          recupera al volver, antes de POSTRUN.
  1250.         -El emulador ha dejado de ser BETA. Esto significa que la
  1251.          ventana está completa (o sea, que todo su contenido funciona)
  1252.          y que se puede arrancar sin peligro de cuelgues salvajes
  1253.          ni fuegos artificiales (a mi no se me cuelga desde hace
  1254.          meses). Los defectos de emulación no se incluyen en la
  1255.          consideración de BETA, ya que si no el emulador podria
  1256.          ser BETA eternamente. Esto NO significa que renuncie a
  1257.          mejorar la emulación (¡NI MUCHO MENOS!) ;-)
  1258.  
  1259.         39.16        (12-OCTUBRE-94)
  1260.         -Añadidas funciones ARexx: ClearAbort, ReadAbort y NoReload.
  1261.         -Añadido el gadget 'Abort ARexx' para poder parar los scripts
  1262.          ARexx, aunque es responsabilidad del script el leer dicho
  1263.          gadget.
  1264.  
  1265.         39.17        (27-OCTUBRE-94)
  1266.         -Modificadas algunas instrucciones que acceden al flag P/V.
  1267.         -Creada una versión OCS/ECS del emulador. Esta versión no
  1268.          tiene FLASH y la emulación de color es un poco más lenta
  1269.          que la AGA. Todas las demás posibilidades del emulador AGA
  1270.          están incorporadas al esta versión (ARexx, AppWindow, carga
  1271.          de cinta, etc...)
  1272.  
  1273.         (distribuida como ZXAM Spectrum Emulator 1.5)
  1274.  
  1275.     1.6    39.18        (14-NOVIEMBRE-94)
  1276.         -Ahora el emulador aloja legalmente el canal 0 de audio antes
  1277.          de entrar en la emulación, y lo devuelve al salir. En caso de
  1278.          no poder alojarlo no empieza la emulación y muestra un
  1279.                  requester.
  1280.  
  1281.         39.19        (6-DICIEMBRE-94)
  1282.         -Integrado un desensamblador en el emulador. Hay un nuevo
  1283.                  comando ARexx (ZXAMDisassemble(dirección)) que desensambla la
  1284.                  instrucción de la dirección indicada.
  1285.         -Arreglado el problema con el teclado de algunos juegos de
  1286.                  DINAMIC (debido a sus tecnicas chapuceras de programación).
  1287.         -Añadido menu para activar/desactivar la sincronización del
  1288.                  audio con las CIAs.
  1289.         -Añadida tooltype CIASYNC.
  1290.         -Añadido menu para seleccionar el modo de SAVE de la rutina
  1291.          de la ROM (Cinta/Disco/Disco comprimido). Al salvar un bloque
  1292.                  (ya sea cabecera o datos) salimos al sistema con un requester
  1293.                  de ficheros, que contendrá ya la extensión adecuada. Si
  1294.                  pulsamos CANCEL se realiza un BREAK en el emulador.
  1295.         -Añadido menu para seleccionar el modo de LOAD (Cinta/Disco)
  1296.         -Arreglado un error en la gestión de los flags del Z80 al
  1297.                  modificarlos desde ARexx.
  1298.         -Mejorada la lectura de la CIA.
  1299.         -Ahora el emulador aloja cualquier timer de las CIAs (ya no
  1300.                  tiene que ser específicamente el timer-b de la cia-b).
  1301.         -El timer de la CIA se aloja durante la emulación.
  1302.         -Arreglado problema con el flash en sistemas con caché de datos
  1303.                  (030 y 040).
  1304.         -Añadida posibilidad de cargar snapshots en formato Z80.
  1305.  
  1306.         39.20        (22-DICIEMBRE-94)
  1307.         -Arreglado el problema con scripts arexx situados en un path
  1308.                  que contenga espacios. Aún así, el nombre del script no puede
  1309.                  contener espacios (es una limitación del ARexx).
  1310.         -Añadidas tooltypes LOADMODE y SAVEMODE para controlar los
  1311.                  modos de carga/grabación.
  1312.         -Arreglado un problema al substituir la extensión en el nombre
  1313.                  de un fichero al hacer 'save program'. Cuando el nombre
  1314.                  contenia varios puntos, se ponia la extensión después del
  1315.                  primero, cuando debia ser después del último.
  1316.         -Se pueden cargar juegos con iconos cuya default tool es el
  1317.                  emulador, o también por multiselección
  1318.         -Añadido al comando Disassemble la posibilidad de mostrar los
  1319.                  datos y direcciones en decimal o hexadecimal
  1320.         -Ahora al desensamblar una instrucción de salto relativo se
  1321.                  imprime como comentario la dirección absoluta a donde va dicho
  1322.                  salto.
  1323.         -El transfer ya siempre va a cinta (arreglado el bug por el
  1324.                  cual el trasfer era afectado por el menu "Save mode").
  1325.         -Añadida posibilidad de cargar snapshots Z80 de formato moderno
  1326.                  (2.01). Anteriormente solo se podian cargar los de formato
  1327.                  antiguo (1.45).
  1328.         -Modificada funcion ARexx ParseLoaded() para que reconozca
  1329.                  también el formato Z80.
  1330.                 -Eliminado el menu que permite activar/desactivar la
  1331.                  sincronización del audio con las CIAs. Eliminada también
  1332.                  la ToolType CIASYNC.
  1333.         -Arreglado un bug inofensivo en la rutina de grabar el formato
  1334.                  PC_PP.
  1335.         -Ahora el emulador aloja TODOS los canales de audio, para una
  1336.                  proxima emulación del chip AY-3-8912 del +2/+2A/+3.
  1337.         -El ejecutable ya no está comprimido con powerpacker por que
  1338.                  parece que la rutina descompresora causaba gurús algunas
  1339.                  veces.
  1340.  
  1341.                 (distribuida como ZXAM Spectrum Emulator 1.6)
  1342.  
  1343.     1.6b    39.21        (19-ENERO-94)
  1344.         -Arreglado un error en la carga de snapshots en formato Z80.
  1345.                  En muchos casos el emulador no reconocia correctamente los
  1346.                  programas en formato Z80 (versión 1.45) comprimidos. Esto
  1347.                  es debido a información erronea en el manual del "Z80"
  1348.                  1.45 y a la falta de programas en formato Z80 para probar.
  1349.                 -Añadida la posibilidad de cargar (aunque no grabar)
  1350.                  programas en formato KGB.
  1351.                 -Modificadas algunas instrucciones para que incrementen
  1352.                  correctamente el registro R.
  1353.                 -Ligeras mejoras en la emulación de los flags del Z80.
  1354.                 -Añadido script ARexx para desensamblar, buscar pokes,
  1355.                  y trastear por los programas, como si de un monitor
  1356.                  se tratara (Hecho por Leo Cocaña. ¡Gracias Leo! :-)
  1357.                 -Arreglados dos errores en el desensamblador (en las
  1358.                  instrucciones 'ld hl,(nn)' y 'ld (nn),de').
  1359.                 -Añadidas funciones ARexx LoadMode(), SaveMode(),
  1360.                  ActLoadMode() y ActSaveMode(), para controlar así desde
  1361.                  ARexx el menu de opciones LOAD/SAVE.
  1362.                 -Añadida función ARexx About()
  1363.                 -Modificada la función ARexx ParseLoaded() para que
  1364.                  también reconozca los snapshots en formato KGB.
  1365.                 -Ahora 'Reload' funciona correctamente tras 'Save program'.
  1366.                 -Tras 'Reset & Run' ya no funciona 'Reload' desde teclado.
  1367.                 -integrada una pausa de 1 segundo al final de la rutina
  1368.                  SAVE de la ROM, para programas que salvan bloques demasiado
  1369.                  juntos (como el ensamblador GENS).
  1370.         -Añadidas funciones ARexx FindBlock() y DoChecksum().
  1371.                 -Añadidas funciones ARexx BreakPoint(), Trace(), DoInt() y
  1372.                  BlockOfRegs(). Estas funciones permiten ejecutar código
  1373.                  Z80 paso a paso, y poner puntos de ruptura.
  1374.                 -Modificada la función ARexx GetReg(). Ahora tiene un
  1375.                  segundo parámetro (opcional) con el que se puede indicar
  1376.                  el formato del resultado (decimal o hexadecimal).
  1377.         -Ahora cuando hay en marcha un script ARexx ya no se acumulan
  1378.          los eventos 'cerrar ventana', y los menús son desactivados.
  1379.                 -Arreglado un error en 'Reload' tras grabar un programa en
  1380.                  formato PC_PP.
  1381.  
  1382.                 (distribuida como ZXAM Spectrum Emulator 1.6b)
  1383.  
  1384.  
  1385.  
  1386.  
  1387. ›[0;1mMEJORAS A REALIZAR›[0m
  1388.  
  1389. En el futuro las versiones disponibles serán:
  1390.  
  1391.    - Versión rápida:  con cargador de cinta externo, parcheando la ROM como
  1392.      el Spectrum Emulator v1.7, pensada para Amiga 1200. En esta versión
  1393.      dejan de emularse cosas como el registro R, el BCD, y algunas
  1394.      temporizaciones se hacen menos precisas, para sacar un poco más de
  1395.      velocidad a costa de una emulación menos "refinada". Esta versión
  1396.      servirá solo PARA JUGAR.
  1397.  
  1398.    - Versión  completa:  podrá cargar  en tiempo  real,  con lo que cargará
  1399.      correctamente programas protegidos de cualquier tipo (como un Spectrum
  1400.      real), en ordenadores más potentes (Amiga 4000). En esta versión se emula
  1401.      todo lo posible (registro R, cálculos BCD, etc...). Incorporará un parche
  1402.      opcional para cargar de cinta en sistemas sin la potencia suficiente para
  1403.      cargar en tiempo real.
  1404.  
  1405.    Puede  que  haya posibilidad  de  carga  REAL incluso en un 1200 con memoria
  1406. FAST  de 32 bits,  pero no puedo  comprobarlo hasta  que no consiga  un poco de
  1407. dicha memoria para el mio.
  1408.  
  1409.  
  1410.  
  1411.  
  1412. ›[0;1mAGRADECIMIENTOS›[0m
  1413.  
  1414.    Mis más sinceros agradecimientos para:
  1415.  
  1416.    - Fco Javier Cocaña Galán, Leonardo Cocaña Galán  y Juan A. Estela Valín
  1417.      por su amistad, y por sus constantes sugerencias (y feroces críticas).
  1418.    - Commodore-Amiga Inc por crear el mejor ordenador del mundo.
  1419.    - Motorola por sus excelentes microprocesadores,  fáciles de programar y
  1420.      extremadamente flexibles.
  1421.    - Nico François por crear las  fantásticas librerias  reqtools.library y
  1422.      powerpacker.library.
  1423.    - Jan van den Baard por el utilísimo GadToolsBox.
  1424.    - IBM y Atari por crear  unos ordenadores  tan malos  y facilitar así mi
  1425.      elección por el Amiga (muchiiisimas gracias).
  1426.    - Miguel Barnosi, Sysop de TANIT-BBS,  por haber distribuido el emulador
  1427.      por otras BBS y  por hacer de "puente"  entre la  FidoNET y yo,  y por
  1428.      iniciarme en lo de Fido.
  1429.    - Alberto Ordoñez Tellez,   Raúl  Ureña  Sánchez,  Arturo  Rubio  Pavón,
  1430.      Javier López Cosialls y Sergi Martinez Colldeforn por sus animos y sus
  1431.      sugerencias.
  1432.    - Andrew Pointon (Inglaterra) por mandarme unos snapshots en formato Z80
  1433.      (sin los cuales no podia implementar el formato) y ficheros en formato
  1434.      .TAP (que tampoco tenia).
  1435.    - Flávio Massao Matsumoto (Brasil)  por mandarme el "ZX Spectrum FAQ" de
  1436.      Internet. Sin él, no habria podido añadir el formato KGB.
  1437.    - Jordy Mejias por pasarme el disco del KBG,  que yo habia borrado hacia
  1438.      tiempo.
  1439.  
  1440.  
  1441.  
  1442.  
  1443. ›[0;1mPARA CONTACTAR›[0m
  1444.  
  1445.    Te agradeceria que me enviases toda información que me pueda ser  útil  para
  1446. ampliar  la  potencia  del  emulador, como por ejemplo, información sobre otros
  1447. formatos de fichero. En  el  caso  de  querer  informar  sobre    algún  error  o
  1448. incompatibilidad  lo  mejor  es  que me mandes el/los programas de Spectrum que
  1449. producen dicho problema,  junto con toda la información posible sobre el equipo
  1450. que usas (procesador, sistema operativo, tamaño y tipo de memoria, etc...).
  1451.  
  1452.    También me gustaria que  me informases de  la velocidad  del emulador  en tu
  1453. ordenador.  Yo he podido  probarlo en un  4000/030 con    FAST  (corre más que un
  1454. Spectrum real, y el SAVE va a velocidad de TURBO) y en mi 1200 sin FAST (snif).
  1455. Para  informarme puedes  cronometrar,  por ejemplo,  lo que tarda un RESET,  un
  1456. bucle largo de BASIC (por favor, incluye el listado del bucle para que yo pueda
  1457. ejecutarlo),  o cualquier otra cosa que  yo pueda comparar con el 1200 o con el
  1458. Spectrum  real  (aún conservo un +2A, un Plus, y un +3 que está cadaver [RIP]).
  1459. Prueba también el programa _SpeedTest_.SP que está junto al emulador.
  1460.  
  1461.    Para enviar sugerencias, informar de errores, intercambiar información, etc,
  1462. contacta conmigo en esta dirección:
  1463.  
  1464.  
  1465.              Antonio J. Pomar Rosselló
  1466.                C/ Alférez Cerdá  nº 13-bajos
  1467.               Palma de Mallorca 07014
  1468.                  Baleares (España)
  1469.  
  1470.  
  1471. o,  si  tienes  modem,  puedes  contactar conmigo  a través de  TANIT BBS-IBIZA
  1472. (971-392829). Deja un mensaje a nombre de TONIACE.
  1473.  
  1474. A través de FidoNet puedes mandarme mensajes a: Toni Pomar (2:343/119.80).
  1475.  
  1476. Por AmigaNet también puedes mandarme mensajes a: Toni Pomar (39:190/1.80).
  1477.  
  1478. En InterNet mi dirección es: tpomar@penedes.mazanet.encomix.com
  1479.  
  1480. Palma de Mallorca  14-Enero-1995
  1481.  
  1482. ›[0m›[1 p