COLABORACION     

COLABORACIONES DE LOS LECTORES

* LISTADOS COLABORACIONES *
/
/*************************************************/
/*     Color v1.0 16/jul/92                      */
/*                                               */
/*     Copyright 1992 hi-score Alvaro Mateos     */
/*                                               */
/*************************************************/
#include 
#include <exec/types.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <proto/all.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
/* declaracion de funciones */
int number(char *);
int openall(void);
void closeall(void);
void chgcolor(SHORT,UBYTE,UBYTE,UBYTE);
/* declaracion de variables globales */
struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;
/* Funcion principal donde comprobamos el numero de parametros,
los convertimos en numeros, abrimos las librerias necesarias,
llamamos a la funcion que cambian el color especificado y
cerramos la librerias.
Si hay algun error en la linea de comandos imprimimos el mensaje de ayuda.
*/
void main (int argc,char *argv[])
{
SHORT colorN;
UBYTE colorR,colorG,colorB;
   if (argc==5)
   {
      if ((colorN=(SHORT) number(argv[1]))!=-1)
         if ((colorR=(UBYTE) number(argv[2]))!=-1)
            if ((colorG=(UBYTE) number(arg[3]))!=-1)
               if ((colorB=(UBYTE) number(arg[4]))!=-1)
                  if (colorN<64) && ((colorR*colorG*colorB)<4096) )
                  {
                      if (openall())
                         chgcolor(colorN,colorR,colorG,colorB);
                      closeall();
                      exit (0);
                  }
               printf ("** Expresion no valida **\n");
               }
               printf("Usar: Color    \n");
               printf("Ejemplo: Color 0 15 15 15 pone el fondo de color
blanco\n");
               printf("Color v1.0 Copyright hi-score 1992\n");
           }
/* Esta funcion convierte una cadena de caracteres en un numero
entero. Devuelve -1 si hay algun error
*/
int number(char *cadena)
{
int n,num;
n=0
num=0;
   while (cadena[n]!='\0')
   {
      if (1(cadena[n]>='0' && cadena[n]<='9'))
         return (-1);
      num=num*10+(cadena[n]-'0');
      n++;
   }
   return (num);
}
/* Aqui abrimos las librerias necesarias. Si ocurre algun error
devolvemos FALSE.
*/
int openall(void)
{
   if ( (IntuitionBase=(struct IntuitionBase *)
      OpenLibrary ("intuition.library",0)) != NULL)
         if ((GfxBase=(struct GfxBase *)
      OpenLibrary ("graphics.library",0)) != NULL)
         return (TRUE);
   return (FALSE);
}
/* Aquí cerramos las librerias abiertas anteriormente
*/
void closeall(void)
{
   if (IntuitionBase) CloseLibrary( (struct Library *) IntuitionBase);
   if (GfxBase) CloseLibrary( (struct Library *) GfxBase);
}
/* Esta es la funcion que cambia el color
Primero cogemos la ventana que esta activada, cogemos su estructura ViewPort
y con esto llamamos a la funcion de la
libreria Graphics SetRGB4, que toma como parametros el ViewPort,
el numero de color y los valores de rojo, verde y azul.
*/
void chgcolor(SHORT colorN, UBYTE colorR, UBYTE colorG, UBYTE colorB)
{
struct Window *window;
struct ViewPort *vp;
   window=IntuitionBase->ActiveWindow;
   vp=ViewPortAddress(window);
   SetRGB4(vp,colorN,colorR,colorG,colorB);
}
;*****************************************
; Lectura de los dos puertos del Joystick
;  Copyright 1992 hi-score Alvaro Mateos
;               25/Sep/1992
;
;*****************************************
| Situar el tabulador a 4 espacios
;**********
; JOYSTICK
;**********
; Esta funcion devuelve en d0 el estado de los dos puetos del Joystick
; de la siguiente forma:
; PUERTO 1                PUERTO 2
; bit 0 -> derecha        bit 16 -> derecha
; bit 1 -> izquierda      bit 17 -> izquierda
; bit 2 -> abajo          bit 18 -> abajo
; bit 3 -> arriba         bit 19 -> arriba
; bit 4 -> disparo        bit 20 -> disparo
;
; Conserva todos los registros menos d0 y d1
Joystick:
    move    CUSTOM+joy1dat,d0    ; cogemos el valor del puerto 2
    bsr         Decode_JoyDat    ; lo decodificamos
    move.b  $bfe001,d1
    not         d1
    and         #$0080,d1        ; cogemos el bit 'disparo'
    lsr         #3,d1
    or          d0,d1            ; ponemos el valor del Joystick 2
    swap    d1                   ; en la palabra alta
    move    CUSTOM+joy0dat,d0    ; cogemos el valor del puerto 1
    bsr         Decode_JoyDat    ; lo decodificamos
    move.b  $bfe001,d1
    not         d1
    and         #$0040,d1        ; cogemos el bit 'disparo'
    lsr         #2,d1
    or          d0,d1            ; unimos los valores en d1
    move.l  d1,d0                ; y pasamos el valor completo a d0
    RTS
; DECODE JOYDAT
; Esta subrutina toma en d0 el valor dado por uno de los puertos del
; joystick y lo decodifica, devolviendo en d0 el estado del joystick de
; la siguiente forma:
;                     bit 0 -> derecha
;                     bit 1 -> izquierda
;                     bit 2 -> abajo
;                     bit 3 -> arriba
Decode_JoyDay:
    movem.l  d1-d2,-(a7)        ; guardamos los registros utilizados
    move     d0,d1              ; copiamos JOYDAT en d1
    lsr          #1,d1
    and          #%0001,d1      ; cogemos el bit 'derecha'
    move     d1,d2              ; en d2 vamos almacenando los valores
    move     d0,d1
    lsr          #8,d1
    and          #%0010,d1      ; cogemos el bit 'izquierda'
    or           d1,d2          ; en d2 ya tenemos el valor de 'izq' y 'der'
    move     d0,d1              ; ahora vienen los valores de 'abajo'
    lsr          #1,d1          ; y 'arriba'- Para ello hay que tener en
    eor          d1,d0          ; cuenta que:
    move     d0,d1              ;            'abajo' = bit 1 XOR bit 0
    lsl          #2,d1          ;            'arriba'= bit 9 XOR bit 8
    and          #%0100,d1
    or           d1,d2          ; ... y lo vamos situando en d2
    lsr          #5,d0
    and          #%1000,d0
    or           d0,d2
    move     d2,d0              ; por ultimo pasamos el valor a d0
    movem.l  (a7)+,d1-d2        ; recuperamos los registros y
    RTS                         ; salimos
; Etiquetas utilizadas
CUSTOM  equ $dff000
joy0dat equ $000a
joy1dat equ $000c
;*********************************************************************
; KeyDevice v1.00
; Copyright 1992 hi-score Alvaro Mateos
; 22/Sep/92
;
; Rutinas necesarias para leer el teclado mediante el keyboard.device
; Estas rutinas pueden ser utilizadas libremente, sin hacerse
; responsable el autor de cualquier daño o perdida de informacion
; que pudiese ocasionar su uso directa o indirectamente.
; KeyDevice debera ser suministrado con el fichero Readme que explica
; su uso y el programa ejemplo KeyEjmp.
; La distribucion de estos ficheros es libre siempre que se respete
; el copyright del autor, no se haga con fines comerciales y se
; respete lo dicho anteriormente en este o en los otros 2 ficheros.
; Cualquier mejora podra hacerse sobre el programa, en cuyo caso
; agradecieria que me enviaran una copia.
; *******************************************************************
;Ajustar el tabulador a 4 espacios
; Aqui estan las funciones necesarias para leer el keyboard.device
; Open_Keyboard: Abre el keyboard.device y crea las estructuras
; necesarias para trabajar con el. Deberemos llamarla una sola vez
; antes de trabajar con el device.
; Close_Device: Cierra el keyboard.device y desaloja la memoira
; utilizada por las estructuras utilizadas.
; Read_Keyboard: Lee el estado de todas las teclas. En a0 le daremos
; la direccion de un buffer de 13 bytes que se interpretara como una
; matriz de 8 x 13 bits. Cada bit representa una tecla. Si la tecla esta
; pulsada su bit correspondiente estara a 1 y si no esta pulsada a 0.
; Para saber a que byte corresponde una tecla determinada tendremos que
; dividir el codigo de la tecla por 8. El resto de la division nos dara el
; bit correspondiente. Asi por ejemplo para ver si esta pulsada la
; tecla 'espacio' que tiene como codigo el $40 (64 en decimal) hariamos
; lo siguiente:
;    move    #$40,d0      ; cargamos el codigo del 'espacio'
;    lea     buffer,a0    ; apuntamos al buffer
;    divu    #8,d0        ; div. por 8 para saber que byte
;    move    0(a0,d0)d1   ; cogemos el byte correspondiente
;    swap    d0           ; cogemos el resto de la division
;    btst    d0,d1        ; comprobamos si el bit esta a cero
;    beq     tecla_NO_pulsada
;    (aqui sabemos que la tecla
;    en cuestion esta pulsada)
;    ...
; Estas funciones llaman a las siguiente rutinas:
; Create_Port: Crea la estructura MsgPort necesaria para comunicarnos
; con otra tarea, en este caso con el keyboard.device'.
; Create_ExtIO: Crea la estructura IORequest, que sera el mensaje con
; el que nos comunicaremos con el device.
; Delete_Port: Borra el MsgPort creado anteriormente.
; Delete_ExtIO: Borra el IORequest creado anteriormente.
; NOTA IMPORTANTE:
; Todas estas rutinas funcionan bajo el control de EXEC.
; Para el perfecto funcionamiento de ellas tendremos que asegurarnos de
; que las interrupciones del sistema no estan deshabilitadas o
; desactivadas. Todas las rutinas y funciones cumplen con las leyes que
; hacen que el sistema permita la multitarea. Asi pues el uso de estas
; rutinas estara en armonia con otras aplicaciones que esten corriendo
; simultaneamente.
; La velocidad que he calculado de la lectura del teclado es bastante alta.
; esto significa que una llamada a Read_Keyboard volvera casi al
; instante.