4592 lines
120 KiB
ObjectPascal
4592 lines
120 KiB
ObjectPascal
{Unitat Grafica per al mode 13h}
|
||
{Ultima actualitzacio 19-02-2000}
|
||
{$G+}
|
||
unit grafix;
|
||
|
||
interface
|
||
|
||
const _32bit =$66;
|
||
MAXFRAMES=3;
|
||
|
||
type
|
||
TRGB=record
|
||
red:byte;
|
||
green:byte;
|
||
blue:byte;
|
||
end;
|
||
|
||
Tpaleta=array[0..255] of TRGB; {tipus per guardar paletes}
|
||
|
||
t_pantalla = array[1..64000] of byte; {pantalla del tamany de la VGA}
|
||
ptr_pantalla = ^t_pantalla;
|
||
|
||
TDoubleBuffer=record
|
||
PDBuffer:pointer; {Punter al DBuffer}
|
||
AltDBuffer:word; {Alt del Dbuffer}
|
||
SizeDBuffer:word; {Tamany en Dwords}
|
||
MDBuffer:word; {segment de memoria del DBuffer}
|
||
end;
|
||
|
||
TSPRITE=record
|
||
x,
|
||
y,
|
||
xold,
|
||
yold:integer;
|
||
ample,
|
||
alt,
|
||
{camps d'animacio}
|
||
anim_clock,
|
||
anim_speed,
|
||
motion_clock,
|
||
motion_speed:word;
|
||
{gestio de frames}
|
||
curr_frame,
|
||
num_frames,
|
||
estat:word;
|
||
frames:array[1..MAXFRAMES] of pointer;
|
||
end;
|
||
|
||
PTSPRITE=^TSPRITE;
|
||
|
||
var
|
||
ys:array [0..199] of word;
|
||
DBuffer:TDoubleBuffer;{El DoubleBuffer ha de ser global}
|
||
|
||
procedure Put_Sprite_ICE(mem_orig,mem_dest,x_orig,y_orig,ample,alt,posx,posy : word);
|
||
procedure Put_Sprite_ICE_dreta(mem_orig,mem_dest,x_orig,y_orig,ample,alt : word; posx,posy:integer);
|
||
procedure Put_Sprite_ICE_esquerra(mem_orig,mem_dest,x_orig,y_orig,ample,alt : word; posx,posy:integer);
|
||
procedure Put_Sprite_ICE_dalt(mem_orig,mem_dest,x_orig,y_orig,ample,alt : word; posx, posy:integer);
|
||
procedure Put_Sprite_ICE_baix(mem_orig,mem_dest,x_orig,y_orig,ample,alt : word; posx, posy:integer);
|
||
|
||
procedure putpix(x,y:word;color:byte;zona_mem:word); {Rapida}
|
||
{Entrada: x,y -> coordenades on possar el pixel;
|
||
color -> color del pixel;
|
||
zona_mem-> Zona de memoria on possar el pixel;
|
||
Funcio : Possar un pixel en una zona de memoria}
|
||
procedure putpixel(x,y:word;color:byte;zona_mem:word);
|
||
{Entrada: x,y -> coordenades on possar el pixel;
|
||
color -> color del pixel;
|
||
zona_mem-> Zona de memoria on possar el pixel;
|
||
Funcio : Possar un pixel en una zona de memoria}
|
||
procedure espera_vga;
|
||
{Funcio : Esperar el reta‡ vertical de la VGA}
|
||
procedure GetPaleta(var paleta:tpaleta);
|
||
{Funcio : Guardar la paleta activa}
|
||
procedure SetPaleta(paleta:tpaleta);
|
||
{Funcio : Possar una paleta en la VGA}
|
||
procedure SetMode(mode:word);
|
||
{Funcio : Canviar el mode actual}
|
||
procedure SetVGA;
|
||
{Funcio : Canviar al mode grafic 320x200x256}
|
||
procedure SetText;
|
||
{Funcio : Canviar al mode text 80x25}
|
||
procedure putpixel_trans(x,y:word;color,trans:byte;zona_mem:word);
|
||
{Entrada: x,y -> coordenades on possar el pixel;
|
||
color -> color del pixel;
|
||
trans -> color transparent;
|
||
zona_mem-> Zona de memoria on possar el pixel;
|
||
Funcio : Possar un pixel en una zona de memoria}
|
||
procedure SetupVirtual(var screen:ptr_pantalla;var virtual_addr:word);
|
||
{Entrada: screen -> punter a un vector de 64000 posicions;
|
||
Eixida : virtual_addr -> adre‡a de memoria reservada;
|
||
Funcio : Reservar una zona de memoria de 64000 posicions}
|
||
procedure TancarVirtual(var screen:ptr_pantalla);
|
||
{Entrada: screen -> punter a un vector de 64000 posicions;
|
||
Funcio : Alliberar una zona de memoria previament reservada}
|
||
procedure volcar32(mem_orig,mem_dest:word);
|
||
{Entrada: mem_orig -> memoria des d'on copiar;
|
||
mem_dest -> memoria on copiar;
|
||
Funcio : copiar una zona de memoria a un altra}
|
||
procedure volcar_pantalla(mem_orig,mem_dest:word);
|
||
{Entrada: mem_orig -> memoria des d'on copiar;
|
||
mem_dest -> memoria on copiar;
|
||
Funcio : copiar una zona de memoria a un altra}
|
||
procedure LoadPCX(name:string;MemD:word);
|
||
{Entrada: name -> nom del arxiu que volem carregar;
|
||
MemD -> adre‡a de memoria on possar el dibuix;
|
||
Funcio : Carregar un PCX}
|
||
procedure SavePCX(name:string);
|
||
{Entrada: name -> nom del arxiu que volem carregar;
|
||
Funcio : Guardar en un fitxer PCX el contingut de la pantalla}
|
||
procedure LoadBMP(name:string;MemD:word);
|
||
{Entrada: name -> nom del arxiu que volem carregar;
|
||
MemD -> adre‡a de memoria on possar el dibuix;
|
||
Funcio : Carregar un BMP}
|
||
procedure GetColor(color:byte;var red,green,blue:byte); {Rapida}
|
||
{Entrada : color -> numero del color del qual volem aconseguir RGB;
|
||
Eixida : red -> intensitat de Roig del color;
|
||
green -> intensitat de Green del color;
|
||
blue -> intensitat de Blue del color;
|
||
Funcio : Aconseguir els valors RGB d'un color}
|
||
procedure get_color(color:byte;var red,green,blue:byte);
|
||
{Entrada : color -> numero del color del qual volem aconseguir RGB;
|
||
Eixida : red -> intensitat de Roig del color;
|
||
green -> intensitat de Green del color;
|
||
blue -> intensitat de Blue del color;
|
||
Funcio : Aconseguir els valors RGB d'un color}
|
||
procedure SetColor(color,red,green,blue:byte); {Rapida}
|
||
{Entrada : color -> numero del color del qual volem aconseguir RGB;
|
||
Eixida : red -> intensitat de Roig del color;
|
||
green -> intensitat de Green del color;
|
||
blue -> intensitat de Blue del color;
|
||
Funcio : Aconseguir els valors RGB d'un color}
|
||
procedure set_color(color,red,green,blue:byte);
|
||
{Entrada : color -> numero del color al qual volem posar el RGB;
|
||
red -> intensitat de Roig del color;
|
||
green -> intensitat de Green del color;
|
||
blue -> intensitat de Blue del color;
|
||
Funcio : Possar els valors RGB a un color}
|
||
procedure cls32(color:byte;zona_mem:word); {Rapida}
|
||
{Entrada : color -> color del qual volem omplir una zona de memoria;
|
||
zona_mem -> Zona de memoria que volem "netejar";
|
||
Funcio : Omplir una zona de memoria d'un color}
|
||
procedure cls(color:byte;zona_mem:word);
|
||
{Entrada : color -> color del qual volem omplir una zona de memoria;
|
||
zona_mem -> Zona de memoria que volem "netejar";
|
||
Funcio : Omplir una zona de memoria d'un color}
|
||
procedure FadeUp(var paleta_e:tpaleta;espera:byte);
|
||
{Entrada: paleta_e -> paleta a la que volem arribar;
|
||
espera -> temps de retard;
|
||
Funcio : Fade Up}
|
||
procedure FadeDown(red,green,blue,espera:byte);
|
||
{Entrada: red -> valor de roig del color al que volem arribar
|
||
green -> valor de verd del color al que volem arribar
|
||
blue -> valor de blau del color al que volem arribar
|
||
espera -> temps de retard;
|
||
Funcio : Fade Down}
|
||
Procedure FadeDown_C(color,red,green,blue,espera:byte);
|
||
{Entrada: color -> color del que volem fer fade
|
||
red -> valor de roig del color al que volem arribar
|
||
green -> valor de verd del color al que volem arribar
|
||
blue -> valor de blau del color al que volem arribar
|
||
espera -> temps de retard;
|
||
Funcio : Fade Down d'un color}
|
||
procedure Line(x1, y1, x2, y2 : integer; color : byte;z_mem:word);
|
||
|
||
procedure blackout;
|
||
{Funcio -> possar la paleta a Negre}
|
||
procedure parallax_scroll(mem_orig,mem_dest,desplasament:word);
|
||
{Entrada: Mem_orig -> zona de memoria on esta guardat el dibuix
|
||
Mem_dest -> zona de memoria on volem possar el dibuix
|
||
desplasament -> posicio en la memoria desti on comensarem a volcar
|
||
el dibuix
|
||
Funcio : possar una pantalla damunt d'un altra amb transparencies}
|
||
procedure put_sprite(mem_orig,mem_dest,m_offset,ample,alt,posx,posy:word);
|
||
{Entrada: Mem_orig -> zona de memoria on esta guardat el sprite
|
||
Mem_dest -> zona de memoria on volem possar el sprite
|
||
m_offset -> offset on es troba el sprite
|
||
ample -> ample del sprite
|
||
alt -> alt del sprite
|
||
posx -> posicio en l'eix x on volem possar el sprite
|
||
posy -> posicio en l'eix y on volem possar el sprite
|
||
Funcio : possar un sprite amb transparencies, color transparent = 0}
|
||
procedure PutSprite(mem_orig,mem_dest,m_offset,ample,alt,posx,posy:word);
|
||
{Entrada: Mem_orig -> zona de memoria on esta guardat el sprite
|
||
Mem_dest -> zona de memoria on volem possar el sprite
|
||
m_offset -> offset on es troba el sprite
|
||
ample -> ample del sprite
|
||
alt -> alt del sprite
|
||
posx -> posicio en l'eix x on volem possar el sprite
|
||
posy -> posicio en l'eix y on volem possar el sprite
|
||
Funcio : possar un sprite amb transparencies, color transparent = 0
|
||
Nota : Mes rapida que put_sprite}
|
||
procedure scroll_v(mem_orig,mem_dest,desplasament:word);
|
||
{Entrada: Mem_orig -> zona de memoria on esta guardat el dibuix
|
||
Mem_dest -> zona de memoria on volem possar el dibuix
|
||
desplasament -> posicio en la memoria desti on comensarem a volcar
|
||
el dibuix
|
||
Funcio : volcar una pantalla a un offset d'un altra}
|
||
procedure PutBloc(mem_orig,m_offset,mem_dest,ample,alt,posx,posy:word);
|
||
{Entrada: Mem_orig -> zona de memoria on esta guardat el sprite
|
||
m_offset -> offset on es troba el sprite
|
||
Mem_dest -> zona de memoria on volem possar el sprite
|
||
ample -> ample del sprite
|
||
alt -> alt del sprite
|
||
posx -> posicio en l'eix x on volem possar el sprite
|
||
posy -> posicio en l'eix y on volem possar el sprite
|
||
Funcio : possar un sprite}
|
||
Function GetPix(tmem,x, y : Word) : Byte;
|
||
{Entrada: tmem -> zona de memoria on esta el pixel
|
||
x -> coordenada x
|
||
y -> coordenada y
|
||
Funcio : obtindre el color d'un pixel d'una zona de memoria}
|
||
procedure Escalat(Mem1,Mem2,Xini,Yini,Xfi,Yfi,PosX,PosY:word;escala:integer);
|
||
{Entrada: Mem1 -> Memoria on es troba la imatge orige
|
||
Mem2 -> Memoria on posarem la imatge desti
|
||
Xini -> X inicial de la imatge orige
|
||
Yini -> Y inicial de la imatge orige
|
||
Xfi -> X final de la imatge orige
|
||
Yfi -> Y final de la imatge orige
|
||
PosX -> Coordenada X on volem comen‡ar a posar l'imatge
|
||
PosY -> Coordenada Y on volem comen‡ar a posar l'imatge
|
||
escala -> escala que li volem aplicar a l'imatge
|
||
Funcio : Escalar una imatge
|
||
Nota : Per a escales de reduccio aplicar el zoom en negatiu
|
||
Ex: escala 1/4 = escala -4}
|
||
procedure BlitString(cadena:string;xc,yc,color,tamany:word);
|
||
{Entrada: cadena -> text que volem escriure
|
||
xc -> coordenada x
|
||
yc -> coordenada y
|
||
color -> color del text
|
||
tamany -> tamany del text
|
||
Funcio : Escriu una cadena de text en mode grafic
|
||
Nota : la cadena sols pot contindre codi ascii (0-127)}
|
||
procedure BlitChar(c:char;xc,yc,color,tamany:word);
|
||
{Entrada: c -> lletra que volem escriure
|
||
xc -> coordenada x
|
||
yc -> coordenada y
|
||
color -> color del text
|
||
tamany -> tamany del text
|
||
Funcio : Escriu una lletra en mode grafic
|
||
Nota : la lletra sols pot ser codi ascii (0-127)}
|
||
procedure RotatePal(index1,index2:word);
|
||
{Entrada : index1 -> index del primer color
|
||
index2 -> index del segon color
|
||
Funcio : rota la paleta (Sols un desplasament)
|
||
Ex: 1234 -> 4123}
|
||
procedure GWindow(x1,y1,x2,y2:word;color:byte;Zmem:word);
|
||
{Entrada : x1 -> x inicial de la finestra
|
||
y1 -> y inicial de la finestra
|
||
x2 -> x final de la finestra
|
||
y2 -> y final de la finestra
|
||
color -> color del marc de la finestra
|
||
Zmem -> zona de memoria on crear la finestra
|
||
Funcio : Crea un marc de color i per deixar visible una zona de memoria}
|
||
procedure Out(NumOut,Color,velocitat:byte;separacio:word);
|
||
{Entrada : NumOut -> index del tipus de transicio que volem fer
|
||
Color -> color al que arriben alguns outs al final
|
||
velocitat -> velocitat de la transicio
|
||
Separacio -> separacio entre quadres per a l'out11
|
||
Funcio : Transicio entre pantalles
|
||
Nota : Index de les trancisions i definicions
|
||
1:Fa uns zoom per fer l'imatge xicoteta i despres la fa molt gran
|
||
2:Va creant un rombo fins "apagar" la pantalla
|
||
3:"Cortina" d'esquerra a dreta
|
||
4:"Cortina" de dreta a esquerra
|
||
5:"Cortina" d'amunt a avall
|
||
6:"Cortina" d'avall a amunt
|
||
7:"Cortina" d'avall a amunt i d'amunt a avall
|
||
8:"Cortina" del centre a amunt i avall
|
||
9:"Cortina" d'esquerra a dreta i de dreta a esquerra
|
||
10:"Cortina" del centre a esquerra i dreta
|
||
11:"Quadretjat"
|
||
12:Disolve}
|
||
function Colisio(x1,y1,w1,h1, x2,y2,w2,h2 :integer):boolean;
|
||
{Entrada : x1 -> coordena x inicial de la primera regio
|
||
y1 -> coordena y inicial de la primera regio
|
||
w1 -> ample de la primera regio
|
||
h1 -> alt de la primera regio
|
||
x2 -> coordena x inicial de la segona regio
|
||
y2 -> coordena y inicial de la segona regio
|
||
w2 -> ample de la segona regio
|
||
h2 -> alt de la segona regio
|
||
Eixida : TRUE si hi ha colisio, FALSE si no hi ha colisio
|
||
Funcio : calcular la colisio entre dos regions rectangulars}
|
||
procedure CreateDB(NumLines:word);
|
||
{Entrada: NumLinies -> nombre de linies de alt del doble buffer
|
||
Funcio : Reserva una zona de memoria per crear un doble Buffer a la VGA}
|
||
procedure ClearDB(color:byte);
|
||
{Entrada: color -> color en el que omplirem el doble buffer
|
||
Funcio : "Netejar" el doble buffer de un color}
|
||
procedure FlipDB;
|
||
{Funcio : Volcar el doble buffer a la VGA}
|
||
procedure DeleteDB;
|
||
{Funcio : Alliberar la zona de memoria ocupada pel doble buffer}
|
||
procedure Scale2D(font,desti,ample,alt,posx,posy:word;zoom:real);
|
||
{Entrada: Font -> Zona de memoria orige
|
||
desti-> Zona de meoria desti
|
||
ample-> Ample del Sprite
|
||
alt -> Alt del Sprite
|
||
posx -> posicio inicial en X
|
||
posy -> posicio inicial en Y
|
||
zoom -> Valor de l'escala del nou sprite
|
||
Funcio : Escalar un sprite}
|
||
procedure Scale2DClipped(font,desti,ample,alt,posx,posy:word;zoom:real);
|
||
{Entrada: Font -> Zona de memoria orige
|
||
desti-> Zona de meoria desti
|
||
ample-> Ample del Sprite
|
||
alt -> Alt del Sprite
|
||
posx -> posicio inicial en X
|
||
posy -> posicio inicial en Y
|
||
zoom -> Valor de l'escala del nou sprite
|
||
Funcio : Escalar un sprite amb clipping}
|
||
procedure Scale2DMasked(font,desti,ample,alt,posx,posy:word;zoom:real);
|
||
{Entrada: Font -> Zona de memoria orige
|
||
desti-> Zona de meoria desti
|
||
ample-> Ample del Sprite
|
||
alt -> Alt del Sprite
|
||
posx -> posicio inicial en X
|
||
posy -> posicio inicial en Y
|
||
zoom -> Valor de l'escala del nou sprite
|
||
Funcio : Escalar un sprite amb transparencies}
|
||
procedure Scale2DMaskedClipped(font,desti,ample,alt,posx,posy:word;zoom:real);
|
||
{Entrada: Font -> Zona de memoria orige
|
||
desti-> Zona de meoria desti
|
||
ample-> Ample del Sprite
|
||
alt -> Alt del Sprite
|
||
posx -> posicio inicial en X
|
||
posy -> posicio inicial en Y
|
||
zoom -> Valor de l'escala del nou sprite
|
||
Funcio : Escalar un sprite amb transparencies i clipping}
|
||
procedure GrabFrame(font,x0,y0:word;var Sprite:PTSprite);far;
|
||
{Entrada: Font -> Zona de memoria on es troba guardada l'imatge
|
||
x0 -> posicio x inicial de l'imatge
|
||
y0 -> posicio y inicial de l'imatge
|
||
x1 -> posicio x final de l'imatge
|
||
y1 -> posicio y final de l'imatge
|
||
Sprite-> Sprite al que volem afegir el frame
|
||
Funcio : Agafar un frame per a un sprite d'una zona de memoria}
|
||
procedure CreateSprite(var Sprite:PTSprite;
|
||
x0,y0:integer;
|
||
width,height,a_sp,m_sp,state:word);far;
|
||
{Entrada: x0 -> posicio x inicial
|
||
y0 -> posicio y inicial
|
||
width -> ample del Sprite
|
||
height -> alt del Sprite
|
||
a_sp -> velocitat de animacio
|
||
M_Sp -> velocitat de moviment
|
||
state -> estat del Sprite (Ex VIU,MORT,MORINT)
|
||
Eixida : Sprite -> Punter al sprite
|
||
Funcio : Inicialitzar un Sprite}
|
||
procedure DeleteSprite(Sprite:ptsprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Alliberar una zona de memoria ocupada per un sprite}
|
||
|
||
procedure DrawSprite(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla el Sprite}
|
||
procedure DrawSpriteM(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'espill del Sprite}
|
||
procedure DrawSpriteF(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'invertit del Sprite}
|
||
procedure DrawSpriteMF(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'espill invertit del Sprite}
|
||
procedure MaskedSprite(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla el Sprite amb transparencies}
|
||
procedure MaskedSpriteM(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'espill del Sprite amb transparencies}
|
||
procedure MaskedSpriteF(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'invertit del Sprite amb transparencies}
|
||
procedure MaskedSpriteMF(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'espill invertit del Sprite amb transparencies}
|
||
procedure DrawSpriteDB(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DobleBuffer el Sprite}
|
||
procedure DrawSpriteDBM(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al doblebuffer l'espill del Sprite}
|
||
procedure DrawSpriteDBF(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DobleBuffer l'invertit del Sprite}
|
||
procedure DrawSpriteDBMF(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DoubleBuffer l'espill invertit del Sprite}
|
||
procedure MaskedSpriteDB(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DobleBuffer el Sprite amb transparencies}
|
||
procedure MaskedSpriteDBM(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al doblebuffer l'espill del Sprite amb transparencies}
|
||
procedure MaskedSpriteDBF(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al doble buffer l'invertit del Sprite amb transparencies}
|
||
procedure MaskedSpriteDBMF(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DoubleBuffer l'espill invertit del Sprite amb transparencies}
|
||
procedure DrawSpriteC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla el Sprite}
|
||
procedure DrawSpriteMC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'espill del Sprite}
|
||
procedure DrawSpriteFC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'invertit del Sprite}
|
||
procedure DrawSpriteMFC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'espill invertit del Sprite}
|
||
procedure MaskedSpriteC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla el Sprite amb transparencies}
|
||
procedure MaskedSpriteMC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'espill del Sprite amb transparencies}
|
||
procedure MaskedSpriteFC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'invertit del Sprite amb transparencies}
|
||
procedure MaskedSpriteMFC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Traure per pantalla l'espill invertit del Sprite amb transparencies}
|
||
procedure DrawSpriteDBC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DobleBuffer el Sprite}
|
||
procedure DrawSpriteDBMC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al doblebuffer l'espill del Sprite}
|
||
procedure DrawSpriteDBFC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DobleBuffer l'invertit del Sprite}
|
||
procedure DrawSpriteDBMFC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DoubleBuffer l'espill invertit del Sprite}
|
||
procedure MaskedSpriteDBC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DobleBuffer el Sprite amb transparencies}
|
||
procedure MaskedSpriteDBMC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al doblebuffer l'espill del Sprite amb transparencies}
|
||
procedure MaskedSpriteDBFC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al doble buffer l'invertit del Sprite amb transparencies}
|
||
procedure MaskedSpriteDBMFC(sprite:PTSprite);far;
|
||
{Entrada: Sprite -> Punter al Sprite
|
||
Funcio : Possar al DoubleBuffer l'espill invertit del Sprite amb transparencies}
|
||
implementation
|
||
|
||
{------------------------------------------------------------------}
|
||
procedure Put_Sprite_ICE_dreta(mem_orig,mem_dest,x_orig,y_orig,ample,alt : word; posx, posy:integer);
|
||
var i,j : word;
|
||
begin
|
||
for j:=0 to alt-1 do
|
||
for i:=0 to ample-1 do
|
||
if (posx+i<320) and not((mem[mem_orig:x_orig+i+((y_orig+j)*320)])=0) then mem[mem_dest:posx+i+((posy+j)*320)]:=
|
||
(mem[mem_orig:x_orig+i+((y_orig+j)*320)]);
|
||
end;
|
||
{------------------------------------------------------------------}
|
||
procedure Put_Sprite_ICE_esquerra(mem_orig,mem_dest,x_orig,y_orig,ample,alt : word; posx, posy:integer);
|
||
var i,j : word;
|
||
begin
|
||
for j:=0 to alt-1 do
|
||
for i:=0 to ample-1 do
|
||
if (posx+i>0) and not((mem[mem_orig:x_orig+i+((y_orig+j)*320)])=0) then mem[mem_dest:posx+i+((posy+j)*320)]:=
|
||
(mem[mem_orig:x_orig+i+((y_orig+j)*320)]);
|
||
end;
|
||
{------------------------------------------------------------------}
|
||
procedure Put_Sprite_ICE_dalt(mem_orig,mem_dest,x_orig,y_orig,ample,alt : word; posx, posy:integer);
|
||
var i,j : word;
|
||
begin
|
||
for j:=0 to alt-1 do
|
||
for i:=0 to ample-1 do
|
||
if (posy+j>0) and not((mem[mem_orig:x_orig+i+((y_orig+j)*320)])=0) then mem[mem_dest:posx+i+((posy+j)*320)]:=
|
||
(mem[mem_orig:x_orig+i+((y_orig+j)*320)]);
|
||
end;
|
||
{------------------------------------------------------------------}
|
||
procedure Put_Sprite_ICE_baix(mem_orig,mem_dest,x_orig,y_orig,ample,alt : word; posx, posy:integer);
|
||
var i,j : word;
|
||
begin
|
||
for j:=0 to alt-1 do
|
||
for i:=0 to ample-1 do
|
||
if (posy+j<200) and not((mem[mem_orig:x_orig+i+((y_orig+j)*320)])=0) then mem[mem_dest:posx+i+((posy+j)*320)]:=
|
||
(mem[mem_orig:x_orig+i+((y_orig+j)*320)]);
|
||
end;
|
||
{------------------------------------------------------------------}
|
||
procedure Put_Sprite_ICE(mem_orig,mem_dest,x_orig,y_orig,ample,alt,posx, posy : word);
|
||
var i,j : word;
|
||
begin
|
||
for j:=0 to alt-1 do
|
||
for i:=0 to ample-1 do
|
||
{if not((mem[mem_orig:x_orig+i+((y_orig+j)*320)])=0) then}
|
||
mem[mem_dest:posx+i+((posy+j)*320)]:=(mem[mem_orig:x_orig+i+((y_orig+j)*320)]);
|
||
end;
|
||
{------------------------------------------------------------------}
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
Function GetPix(tmem,x, y : Word) : Byte; Assembler;
|
||
Asm
|
||
mov bx,y
|
||
shl bx,1
|
||
mov ax,tmem
|
||
mov es,ax
|
||
mov di,x
|
||
add di,word ptr ys[bx]
|
||
nop
|
||
mov al,es:[di]
|
||
End;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure PutBloc(mem_orig,m_offset,mem_dest,ample,alt,posx,posy:word);
|
||
begin
|
||
asm
|
||
push ds;
|
||
|
||
mov si,m_offset;
|
||
|
||
mov ax,mem_orig;
|
||
mov ds,ax; {memoria orige}
|
||
mov ax,mem_dest;
|
||
mov es,ax; {memoria desti}
|
||
|
||
mov di,posx; {DI = X}
|
||
mov dx,posy; {DX = Y}
|
||
shl dx,8; {DX = 256*Y}
|
||
add di,dx; {DI = 256*Y+BX}
|
||
shr dx,2; {DX = 64*Y}
|
||
add di,dx; {DI = 320*Y+X}
|
||
|
||
mov cx,alt; {guarde el alt}
|
||
|
||
@1: push cx; {guarde el alt}
|
||
push di; {guarde el offset desti}
|
||
push si; {guarde el offset orige}
|
||
|
||
mov cx,ample; {carregue el ample}
|
||
shr cx,2;
|
||
|
||
db _32bit
|
||
rep movsw; {mentres no siga l'ample continuar}
|
||
|
||
pop si; {recuperem l'offset orige}
|
||
pop di; {recuperem l'offset desti}
|
||
add si,320; {seg�ent linia orige}
|
||
add di,320; {seg�ent linia desti}
|
||
pop cx; {recuperem l'alt}
|
||
dec cx; {una linia menys}
|
||
cmp cx,0; {Queden linies?}
|
||
jnz @1; {Si.Anar a @1}
|
||
|
||
pop ds;
|
||
end;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure cls32(color:byte;zona_mem:word);assembler;
|
||
asm
|
||
mov ax,zona_mem
|
||
mov es,ax
|
||
xor di,di
|
||
mov al,color
|
||
mov ah,al
|
||
mov bx,ax
|
||
mov cx,16000
|
||
db _32bit
|
||
shl ax,16
|
||
mov ax,bx
|
||
db _32bit
|
||
rep stosw
|
||
end;
|
||
|
||
|
||
procedure cls(color:byte;zona_mem:word);assembler;
|
||
asm
|
||
mov ax,zona_mem;
|
||
mov es,ax;
|
||
xor di,di;
|
||
mov al,color;
|
||
mov ah,al;
|
||
mov cx,32000;
|
||
rep stosw;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure espera_vga;assembler;
|
||
label
|
||
l1,l2;
|
||
asm
|
||
mov dx,3dah;
|
||
l1:
|
||
in al,dx;
|
||
test al,8;
|
||
jne l1;
|
||
l2:
|
||
in al,dx;
|
||
test al,8;
|
||
je l2;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure GetPaleta(var paleta:tpaleta);
|
||
var count:word;
|
||
begin
|
||
port[$3C7]:=0;
|
||
for count:=0 to 255 do
|
||
begin
|
||
paleta[count].red:=port[$3C9];
|
||
paleta[count].green:=port[$3C9];
|
||
paleta[count].blue:=port[$3C9];
|
||
end;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure SetPaleta(paleta:tpaleta);
|
||
var count:word;
|
||
begin
|
||
port[$3C8]:=0;
|
||
for count:=0 to 255 do
|
||
begin
|
||
port[$3C9]:=paleta[count].red;
|
||
port[$3C9]:=paleta[count].green;
|
||
port[$3C9]:=paleta[count].blue;
|
||
end;
|
||
end;
|
||
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure putpix(x,y:word;color:byte;zona_mem:word);assembler;
|
||
asm
|
||
mov bx,y
|
||
mov di,x
|
||
shl bx,1
|
||
mov es,[zona_mem]
|
||
add di,word ptr ys[bx]
|
||
mov al,color
|
||
stosb
|
||
end;
|
||
|
||
procedure putpixel(x,y:word;color:byte;zona_mem:word);assembler;
|
||
asm
|
||
mov ax,zona_mem
|
||
mov es,ax
|
||
mov di,x
|
||
mov dx,y
|
||
shl dx,8
|
||
add di,dx
|
||
shr dx,2
|
||
add di,dx
|
||
mov al,color
|
||
mov es:[di],al
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure setmode(mode:word);assembler;
|
||
{Canviar a un cert mode}
|
||
asm
|
||
mov ax,mode;
|
||
int 10h;
|
||
end;
|
||
|
||
procedure SetVGA;assembler;
|
||
asm
|
||
mov ax,13h
|
||
int 10h
|
||
end;
|
||
|
||
procedure SetText;assembler;
|
||
asm
|
||
mov ax,3
|
||
int 10h
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure putpixel_trans(x,y:word;color,trans:byte;zona_mem:word);assembler;
|
||
asm
|
||
{Guardar en ES la zona de memoria}
|
||
mov ax,zona_mem;
|
||
mov es,ax;
|
||
{Calcular el offset}
|
||
mov di,x; {DI = X}
|
||
mov dx,y; {DX = Y}
|
||
shl dx,8; {DX = 256*Y}
|
||
add di,dx; {DI = 256*Y+BX}
|
||
shr dx,2; {DX = 64*Y}
|
||
add di,dx; {DI = 320*Y+X}
|
||
mov al,color; {Possem el color en AL}
|
||
xor al,trans; {si color=trans...}
|
||
jnz @paint; {... saltem a @paint}
|
||
|
||
inc(di); {Avancem el punter de pantalla}
|
||
jmp @exit; {anem a l'eixida}
|
||
|
||
@Paint: mov es:[di],al; {posem al segment de memoria el color}
|
||
|
||
@exit:
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure Volcar32(mem_orig,mem_dest:word);assembler;
|
||
asm
|
||
push ds;
|
||
mov cx,16000;
|
||
mov ds,word ptr mem_orig
|
||
mov es,word ptr mem_dest
|
||
xor di,di;
|
||
xor si,si;
|
||
db _32bit;
|
||
rep movsw;
|
||
pop ds;
|
||
end;
|
||
|
||
|
||
procedure volcar_pantalla(mem_orig,mem_dest:word);assembler;
|
||
asm
|
||
push ds;
|
||
mov ax,mem_orig;
|
||
mov ds,ax;
|
||
xor di,di;
|
||
mov ax,mem_dest;
|
||
mov es,ax;
|
||
xor si,si;
|
||
mov cx,32000;
|
||
rep movsw;
|
||
pop ds;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure SetupVirtual(var screen:ptr_pantalla;var virtual_addr:word);
|
||
begin
|
||
getmem(screen,64000);
|
||
virtual_addr:=seg(screen^);
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure TancarVirtual(var screen:ptr_pantalla);
|
||
begin
|
||
freemem(screen,64000);
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure get_color(color:byte;var red,green,blue:byte);
|
||
begin
|
||
port[$3C7]:=color;
|
||
red:= port[$3C9];
|
||
green:= port[$3C9];
|
||
blue:= port[$3C9];
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure set_color(color,red,green,blue:byte);
|
||
begin
|
||
port[$3C8]:=color;
|
||
port[$3C9]:=red;
|
||
port[$3C9]:=green;
|
||
port[$3C9]:=blue;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
Procedure Fadeup(var paleta_e:tpaleta;espera:byte);
|
||
VAR loop1,i:integer;
|
||
color:word;
|
||
n_color:byte;
|
||
Tmp : Array [1..3] of byte;
|
||
{ Per a guardar temporalment un color }
|
||
BEGIN
|
||
For loop1:=1 to 64 do BEGIN
|
||
{ A color value for Red, green or blue is 0 to 63, so this loop only
|
||
need be executed a maximum of 64 times }
|
||
for i:=0 to espera do Espera_Vga;
|
||
color:=0;
|
||
n_color:=0;
|
||
repeat
|
||
Get_color(n_color,Tmp[1],Tmp[2],Tmp[3]);
|
||
If Tmp[1]<Paleta_e[color].red then inc (Tmp[1]);
|
||
If Tmp[2]<Paleta_e[color].green then inc (Tmp[2]);
|
||
If Tmp[3]<Paleta_e[color].blue then inc (Tmp[3]);
|
||
{ If the Red, Green or Blue values of color loop2 are less then they
|
||
should be, increase them by one. }
|
||
Set_color(n_color,Tmp[1],Tmp[2],Tmp[3]);
|
||
{ Set the new, altered pallette color. }
|
||
inc(color);
|
||
inc(n_color);
|
||
until color=255;
|
||
End;
|
||
END;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
Procedure FadeDown(red,green,blue,espera:byte);
|
||
{ This procedure fades the screen out to black. }
|
||
VAR loop1,loop2,i:integer;
|
||
Tmp : Array [1..3] of byte;
|
||
{ This is temporary storage for the values of a color }
|
||
BEGIN
|
||
For loop1:=1 to 64 do BEGIN
|
||
for i:=0 to espera do Espera_vga;
|
||
For loop2:=0 to 255 do BEGIN
|
||
Get_color (loop2,Tmp[1],Tmp[2],Tmp[3]);
|
||
If Tmp[1]>red then dec (Tmp[1]);
|
||
If Tmp[2]>green then dec (Tmp[2]);
|
||
If Tmp[3]>blue then dec (Tmp[3]);
|
||
{ If the Red, Green or Blue values of color loop2 are not yet zero,
|
||
then, decrease them by one. }
|
||
set_color (loop2,Tmp[1],Tmp[2],Tmp[3]);
|
||
{ Set the new, altered pallette color. }
|
||
END;
|
||
END;
|
||
END;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
Procedure FadeDown_C(color,red,green,blue,espera:byte);
|
||
{ This procedure fades one color to another }
|
||
VAR loop1,loop2,i:integer;
|
||
Tmp : Array [1..3] of byte;
|
||
{ This is temporary storage for the values of a color }
|
||
BEGIN
|
||
For loop1:=1 to 64 do
|
||
BEGIN
|
||
for i:=0 to espera do Espera_vga;
|
||
|
||
Get_color (color,Tmp[1],Tmp[2],Tmp[3]);
|
||
If Tmp[1]>red then dec (Tmp[1]);
|
||
If Tmp[2]>green then dec (Tmp[2]);
|
||
If Tmp[3]>blue then dec (Tmp[3]);
|
||
{ If the Red, Green or Blue values of color loop2 are not yet zero,
|
||
then, decrease them by one. }
|
||
set_color (color,Tmp[1],Tmp[2],Tmp[3]);
|
||
{ Set the new, altered pallette color. }
|
||
END;
|
||
END;
|
||
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure Line(x1, y1, x2, y2 : integer; color : byte;z_mem:word);
|
||
var i, deltax, deltay, numpixels,
|
||
d, dinc1, dinc2,
|
||
x, xinc1, xinc2,
|
||
y, yinc1, yinc2 : integer;
|
||
begin
|
||
|
||
{ Calculate deltax and deltay for initialisation }
|
||
deltax := abs(x2 - x1);
|
||
deltay := abs(y2 - y1);
|
||
|
||
{ Initialize all vars based on which is the independent variable }
|
||
if deltax >= deltay then
|
||
begin
|
||
|
||
{ x is independent variable }
|
||
numpixels := deltax + 1;
|
||
d := (2 * deltay) - deltax;
|
||
dinc1 := deltay Shl 1;
|
||
dinc2 := (deltay - deltax) shl 1;
|
||
xinc1 := 1;
|
||
xinc2 := 1;
|
||
yinc1 := 0;
|
||
yinc2 := 1;
|
||
end
|
||
else
|
||
begin
|
||
|
||
{ y is independent variable }
|
||
numpixels := deltay + 1;
|
||
d := (2 * deltax) - deltay;
|
||
dinc1 := deltax Shl 1;
|
||
dinc2 := (deltax - deltay) shl 1;
|
||
xinc1 := 0;
|
||
xinc2 := 1;
|
||
yinc1 := 1;
|
||
yinc2 := 1;
|
||
end;
|
||
|
||
{ Make sure x and y move in the right directions }
|
||
if x1 > x2 then
|
||
begin
|
||
xinc1 := - xinc1;
|
||
xinc2 := - xinc2;
|
||
end;
|
||
if y1 > y2 then
|
||
begin
|
||
yinc1 := - yinc1;
|
||
yinc2 := - yinc2;
|
||
end;
|
||
|
||
{ Start drawing at <x1, y1> }
|
||
x := x1;
|
||
y := y1;
|
||
|
||
{ Draw the pixels }
|
||
for i := 1 to numpixels do
|
||
begin
|
||
PutPixel(x, y, color,z_mem);
|
||
if d < 0 then
|
||
begin
|
||
d := d + dinc1;
|
||
x := x + xinc1;
|
||
y := y + yinc1;
|
||
end
|
||
else
|
||
begin
|
||
d := d + dinc2;
|
||
x := x + xinc2;
|
||
y := y + yinc2;
|
||
end;
|
||
end;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure blackout;
|
||
var loop:byte;
|
||
begin
|
||
for loop:=0 to 255 do setcolor(loop,0,0,0);
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure parallax_scroll(mem_orig,mem_dest,desplasament:word);assembler;
|
||
asm
|
||
push ds;
|
||
{inicialitzar l'acces a les memories orige i desti}
|
||
mov ax,mem_orig;
|
||
mov ds,ax;
|
||
xor si,si;
|
||
|
||
mov ax,mem_dest;
|
||
mov es,ax;
|
||
mov di,desplasament;
|
||
|
||
{comen‡ar a copiar primer tros}
|
||
mov cx,64000; {bytes en una pantalla}
|
||
sub cx,desplasament; {bytes a copiar}
|
||
shr cx,1; {words a copiar}
|
||
jz @part2;
|
||
|
||
@pintar1:
|
||
mov ax,ds:[si];
|
||
or al,00h;
|
||
jz @next1;
|
||
mov es:[di],al;
|
||
@next1:
|
||
inc di;
|
||
or ah,00h;
|
||
jz @next2;
|
||
mov es:[di],ah;
|
||
@next2:
|
||
inc si;
|
||
inc di;
|
||
inc si;
|
||
loop @pintar1;
|
||
|
||
@part2:
|
||
{comen‡ar a copiar segon tros}
|
||
mov cx,desplasament;
|
||
shr cx,1;
|
||
jz @fi;
|
||
xor di,di;
|
||
|
||
@pintar2:
|
||
mov ax,ds:[si];
|
||
or al,00h;
|
||
jz @next3;
|
||
mov es:[di],al;
|
||
@next3:
|
||
inc di;
|
||
or ah,00h;
|
||
jz @next4;
|
||
mov es:[di],ah;
|
||
@next4:
|
||
inc si;
|
||
inc di;
|
||
inc si;
|
||
loop @pintar2;
|
||
|
||
@fi: pop ds;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure PutSprite(mem_orig,mem_dest,m_offset,ample,alt,posx,posy:word);
|
||
begin
|
||
asm
|
||
push ds;
|
||
|
||
mov si,m_offset;
|
||
|
||
mov ax,mem_orig;
|
||
mov ds,ax; {memoria orige}
|
||
mov ax,mem_dest;
|
||
mov es,ax; {memoria desti}
|
||
mov bx,320
|
||
sub bx,ample
|
||
mov di,posx; {DI = X}
|
||
mov dx,posy; {DX = Y}
|
||
shl dx,8; {DX = 256*Y}
|
||
add di,dx; {DI = 256*Y+BX}
|
||
shr dx,2; {DX = 64*Y}
|
||
add di,dx; {DI = 320*Y+X}
|
||
|
||
mov cx,alt; {guarde el alt}
|
||
|
||
@1: push cx; {guarde el alt}
|
||
|
||
mov cx,ample; {carregue el ample}
|
||
|
||
@nou_pixel:
|
||
mov al,ds:[si] {color del pixel orige en al}
|
||
cmp al,00h; {AL=0?}
|
||
jnz @paint;
|
||
jmp @new; {altre pixel}
|
||
|
||
@paint:
|
||
mov es:[di],al; {pintar pixel}
|
||
|
||
@new:
|
||
inc di; {augmentar punter pantalla}
|
||
inc si; {augmentar punter font}
|
||
loop @nou_pixel; {mentres no siga l'ample continuar}
|
||
|
||
add si,bx
|
||
add di,bx
|
||
pop cx; {recuperem l'alt}
|
||
{loop @1;}
|
||
dec cx; {una linia menys}
|
||
cmp cx,0; {Queden linies?}
|
||
jnz @1; {Si.Anar a @1}
|
||
|
||
pop ds;
|
||
end;
|
||
end;
|
||
|
||
|
||
procedure put_sprite(mem_orig,mem_dest,m_offset,ample,alt,posx,posy:word);
|
||
begin
|
||
asm
|
||
push ds;
|
||
|
||
mov si,m_offset;
|
||
|
||
mov ax,mem_orig;
|
||
mov ds,ax; {memoria orige}
|
||
mov ax,mem_dest;
|
||
mov es,ax; {memoria desti}
|
||
|
||
mov di,posx; {DI = X}
|
||
mov dx,posy; {DX = Y}
|
||
shl dx,8; {DX = 256*Y}
|
||
add di,dx; {DI = 256*Y+BX}
|
||
shr dx,2; {DX = 64*Y}
|
||
add di,dx; {DI = 320*Y+X}
|
||
|
||
mov cx,alt; {guarde el alt}
|
||
|
||
@1: push cx; {guarde el alt}
|
||
push di; {guarde el offset desti}
|
||
push si; {guarde el offset orige}
|
||
|
||
mov cx,ample; {carregue el ample}
|
||
|
||
@nou_pixel:
|
||
mov al,ds:[si] {color del pixel orige en al}
|
||
or al,00h; {AL=0?}
|
||
jnz @paint;
|
||
jmp @new; {altre pixel}
|
||
|
||
@paint:
|
||
mov es:[di],al; {pintar pixel}
|
||
|
||
@new:
|
||
inc di; {augmentar punter pantalla}
|
||
inc si; {augmentar punter font}
|
||
loop @nou_pixel; {mentres no siga l'ample continuar}
|
||
pop si; {recuperem l'offset orige}
|
||
pop di; {recuperem l'offset desti}
|
||
add si,320; {seg�ent linia orige}
|
||
add di,320; {seg�ent linia desti}
|
||
pop cx; {recuperem l'alt}
|
||
dec cx; {una linia menys}
|
||
cmp cx,0; {Queden linies?}
|
||
jnz @1; {Si.Anar a @1}
|
||
pop ds;
|
||
end;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure scroll_v(mem_orig,mem_dest,desplasament:word);assembler;
|
||
asm
|
||
push ds;
|
||
{inicialitzar l'acces a les memories orige i desti}
|
||
mov ax,mem_orig;
|
||
mov ds,ax;
|
||
xor si,si;
|
||
|
||
mov ax,mem_dest;
|
||
mov es,ax;
|
||
mov di,desplasament;
|
||
|
||
mov cx,64000; {bytes en una pantalla}
|
||
sub cx,desplasament; {bytes a copiar}
|
||
shr cx,1; {words a copiar}
|
||
{comen‡ar a copiar primer tros}
|
||
rep movsw;
|
||
|
||
mov cx,desplasament;
|
||
shr cx,1;
|
||
xor di,di;
|
||
{comen‡ar a copiar segon tros}
|
||
rep movsw;
|
||
|
||
pop ds;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure BlitChar(c:char;xc,yc,color,tamany:word);
|
||
const ROM_SET = $F000;
|
||
ROM_SET_OFFSET =$FA6E;
|
||
|
||
var i,j,offset,x,y,x1:word;
|
||
bit_mask:byte;
|
||
|
||
begin
|
||
bit_mask:=$80;
|
||
offset:=(yc shl 8) + (yc shl 6) +xc;
|
||
|
||
if tamany>0 then
|
||
for y:=0 to 7 do
|
||
begin
|
||
for j:=1 to tamany do
|
||
begin
|
||
bit_mask:=$80;
|
||
for x:=0 to 7 do
|
||
begin
|
||
x1:=x*tamany;
|
||
for i:=1 to tamany do
|
||
begin
|
||
if ((mem[ROM_SET:ROM_SET_OFFSET+(ord(c)*8)+y] and bit_mask)<>0) then
|
||
mem[$a000:offset+x1]:=color;
|
||
inc(x1);
|
||
end;
|
||
bit_mask:=bit_mask shr 1;
|
||
end;
|
||
offset:=offset+320;
|
||
end;
|
||
end
|
||
else
|
||
for y:=0 to 7 do
|
||
begin
|
||
bit_mask:=$80;
|
||
x1:=0;
|
||
for x:=0 to 7 do
|
||
begin
|
||
if x1 mod 2=0 then
|
||
if ((mem[ROM_SET:ROM_SET_OFFSET+(ord(c)*8)+y] and bit_mask)<>0) then
|
||
mem[$a000:offset+(x1 div 2)]:=color;
|
||
bit_mask:=bit_mask shr 1;
|
||
inc(x1);
|
||
end;
|
||
offset:=offset+320;
|
||
end;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure BlitString(cadena:string;xc,yc,color,tamany:word);
|
||
var i:word;
|
||
begin
|
||
for i:=1 to length(cadena) do
|
||
begin
|
||
blitchar(cadena[i],xc,yc,color,tamany);
|
||
inc(xc,8*tamany);
|
||
if (xc>319) then
|
||
begin
|
||
inc(yc,(8*tamany)+1);
|
||
xc:=0;
|
||
end;
|
||
if tamany=0 then inc(xc,5);
|
||
end;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure Escalar(x,y,z,Distance:word;var xp,yp:word);
|
||
begin
|
||
xp:=Distance*x div z;
|
||
yp:=Distance*y div z
|
||
end;
|
||
|
||
procedure Escalat(Mem1,Mem2,Xini,Yini,Xfi,Yfi,PosX,PosY:word;escala:integer);
|
||
var x,y,x1,y1:word;
|
||
color:byte;
|
||
i,j,k,l:word;
|
||
z,d:word;
|
||
begin
|
||
if escala>0 then
|
||
begin
|
||
d:=escala;
|
||
z:=1;
|
||
end
|
||
else
|
||
begin
|
||
z:=-escala;
|
||
d:=1;
|
||
end;
|
||
for j:=Yfi downto Yini do
|
||
for i:=Xfi downto Xini do
|
||
begin
|
||
color:=getpix(mem1,i,j);
|
||
Escalar(i-Xini,j-Yini,z,d,x,y);
|
||
if (Xini+x<320) and (Yini+y<200) then putpix(Xini+x,Yini+y+PosY,color,Mem2);
|
||
if (d>z) then
|
||
begin
|
||
for l:=1 to d-z do
|
||
begin
|
||
for k:=1 to d-z do
|
||
begin
|
||
inc(x);
|
||
if (Xini+x<320) and (Yini+y<200) then putpix(Xini+x,Yini+y+PosY,color,Mem2);
|
||
end;
|
||
inc(y);
|
||
if (Xini+x<320) and (Yini+y<200) then putpix(Xini+x,Yini+y+PosY,color,Mem2);
|
||
for k:=1 to d-z do
|
||
begin
|
||
dec(x);
|
||
if (Xini+x<320) and (Yini+y<200) then putpix(Xini+x,Yini+y+PosY,color,Mem2);
|
||
end;
|
||
|
||
end;
|
||
end;
|
||
end;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure GetColor(color:byte;var red,green,blue:byte);
|
||
var r,g,b:byte;
|
||
begin
|
||
asm
|
||
mov dx,3C7h
|
||
mov al,color
|
||
out dx,al
|
||
mov dx,3C9h
|
||
in al,dx
|
||
mov r,al
|
||
in al,dx
|
||
mov g,al
|
||
in al,dx
|
||
mov b,al
|
||
end;
|
||
red:=r;green:=g;blue:=b;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure SetColor(color,red,green,blue:byte);assembler;
|
||
asm
|
||
mov dx,3C8h
|
||
mov al,color
|
||
out dx,al
|
||
mov dx,3C9h
|
||
mov al,red
|
||
out dx,al
|
||
mov al,green
|
||
out dx,al
|
||
mov al,blue
|
||
out dx,al
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure RotatePal(index1,index2:word);
|
||
var i:word;
|
||
color,aux:array[1..3] of byte;
|
||
begin
|
||
if index1>index2 then
|
||
begin
|
||
i:=index1;
|
||
index1:=index2;
|
||
index2:=i;
|
||
end;
|
||
getcolor(index1,color[1],color[2],color[3]);
|
||
for i:=index1+1 to index2 do
|
||
begin
|
||
getcolor(i,aux[1],aux[2],aux[3]);
|
||
setcolor(i-1,aux[1],aux[2],aux[3]);
|
||
end;
|
||
setcolor(index2,color[1],color[2],color[3]);
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure zoom05(mem_orig,mem_dest:word);
|
||
var i,j,offset:word;
|
||
begin
|
||
for i:=0 to 159 do
|
||
for j:=0 to 99 do
|
||
begin
|
||
offset:=320*j+i;
|
||
mem[mem_dest:offset]:=mem[mem_orig:320*(j*2)+(i*2)];
|
||
mem[mem_dest:offset+1]:=mem[mem_orig:320*(j*2)+(i*2)];
|
||
mem[mem_dest:offset+320]:=mem[mem_orig:320*(j*2)+(i*2)];
|
||
mem[mem_dest:offset+321]:=mem[mem_orig:320*(j*2)+(i*2)]
|
||
end;
|
||
end;
|
||
|
||
procedure zoomx2(mem_orig,mem_dest:word);
|
||
var i,j:word;
|
||
begin
|
||
for i:=0 to 159 do
|
||
for j:=0 to 99 do
|
||
begin
|
||
mem[mem_dest:320*(j*2)+(i*2)]:=mem[mem_orig:320*(j)+(i)];
|
||
mem[mem_dest:320*(j*2)+((i*2)+1)]:=mem[mem_orig:320*(j)+(i)];
|
||
mem[mem_dest:320*((j*2)+1)+(i*2)]:=mem[mem_orig:320*(j)+(i)];
|
||
mem[mem_dest:320*((j*2)+1)+((i*2)+1)]:=mem[mem_orig:320*(j)+(i)]
|
||
end;
|
||
end;
|
||
|
||
procedure out1;
|
||
var i,j,a:word;
|
||
v:ptr_pantalla;
|
||
begin
|
||
setupvirtual(v,a);
|
||
for i:=1 to 8 do
|
||
begin
|
||
espera_vga;
|
||
zoom05($a000,$a000);
|
||
end;
|
||
volcar32($a000,a);
|
||
for i:=1 to 8 do
|
||
begin
|
||
for j:=1 to 3 do espera_vga;
|
||
zoomx2(a,$a000);
|
||
volcar32($a000,a);
|
||
end;
|
||
tancarvirtual(v);
|
||
end;
|
||
|
||
procedure out2(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 160 do
|
||
begin
|
||
line(0,199,2*x1,0,color,$a000);
|
||
line(0,199,2*x1+1,0,color,$a000);
|
||
|
||
line(0,0,2*x1,199,color,$a000);
|
||
line(0,0,2*x1+1,199,color,$a000);
|
||
|
||
line(319,0,319-(2*x1),199,color,$a000);
|
||
line(319,0,319-(2*x1+1),199,color,$a000);
|
||
|
||
line(319,199,319-(2*x1),0,color,$a000);
|
||
line(319,199,319-(2*x1+1),0,color,$a000);
|
||
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out3(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 160 do
|
||
begin
|
||
line(2*x1,199,2*x1,0,color,$a000);
|
||
line(2*x1+1,199,2*x1+1,0,color,$a000);
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out4(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 160 do
|
||
begin
|
||
line(319-(2*x1),199,319-(2*x1),0,color,$a000);
|
||
line(319-(2*x1+1),199,319-(2*x1+1),0,color,$a000);
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out5(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 100 do
|
||
begin
|
||
line(0,2*x1,319,2*x1,color,$a000);
|
||
line(0,2*x1+1,319,2*x1+1,color,$a000);
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out6(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 100 do
|
||
begin
|
||
line(0,199-(2*x1),319,199-(2*x1),color,$a000);
|
||
line(0,199-(2*x1+1),319,199-(2*x1+1),color,$a000);
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out7(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 100 do
|
||
begin
|
||
line(0,x1,319,x1,color,$a000);
|
||
line(0,200-(x1+1),319,200-(x1+1),color,$a000);
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out8(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 100 do
|
||
begin
|
||
line(0,100-x1,319,100-x1,color,$a000);
|
||
line(0,100+(x1+1),319,100+(x1+1),color,$a000);
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out9(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 160 do
|
||
begin
|
||
line(x1,0,x1,199,color,$a000);
|
||
line(320-(x1+1),0,320-(x1+1),199,color,$a000);
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out10(color,velocitat:byte);
|
||
var x1,loop:word;
|
||
begin
|
||
for x1:=0 to 160 do
|
||
begin
|
||
line(160-x1,0,160-x1,199,color,$a000);
|
||
line(160+(x1+1),0,160+(x1+1),199,color,$a000);
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure out11(color:byte;separacio:word;velocitat:byte);
|
||
var x1,x2,y2,loop:word;
|
||
begin
|
||
x2:=320 div separacio;
|
||
y2:=200 div separacio;
|
||
for x1:=0 to separacio do
|
||
begin
|
||
for loop:=0 to x2 do
|
||
begin
|
||
line(x1+(separacio*loop),199,x1+(separacio*loop),0,color,$a000);
|
||
end;
|
||
for loop:=0 to y2 do
|
||
begin
|
||
line(0,x1+(separacio*loop),319,x1+(separacio*loop),color,$a000);
|
||
end;
|
||
for loop:=0 to velocitat do espera_vga;
|
||
end;
|
||
end;
|
||
|
||
procedure disolve(color:byte;velocitat:byte);
|
||
var i,j:word;
|
||
offset:word;
|
||
begin
|
||
randomize;
|
||
for i:=1 to 300 do
|
||
begin
|
||
if velocitat>=1 then espera_vga;
|
||
for j:=1 to 1000 do
|
||
putpixel(random(320),random(200),color,$a000);
|
||
end;
|
||
cls(color,$a000);
|
||
end;
|
||
|
||
procedure Out(NumOut,color,velocitat:byte;separacio:word);
|
||
begin
|
||
case NumOut of
|
||
1:out1;
|
||
2:out2(color,velocitat);
|
||
3:out3(color,velocitat);
|
||
4:out4(color,velocitat);
|
||
5:out5(color,velocitat);
|
||
6:out6(color,velocitat);
|
||
7:out7(color,velocitat);
|
||
8:out8(color,velocitat);
|
||
9:out9(color,velocitat);
|
||
10:out10(color,velocitat);
|
||
11:out11(color,separacio,velocitat);
|
||
12:Disolve(color,velocitat);
|
||
end;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure GWindow(x1,y1,x2,y2:word;color:byte;Zmem:word);assembler;
|
||
asm
|
||
mov ax,zmem;
|
||
mov es,ax; {ES=ZMEM}
|
||
{for i:=0 to y1 do line(0,i,319,i,color,z_mem);}
|
||
xor di,di; {DI=0}
|
||
|
||
mov ax,y1; {AX=Y1}
|
||
shl ax,8; {AX=256*AX}
|
||
mov cx,ax; {CX=AX}
|
||
shr ax,2; {AX=AX div 4}
|
||
add cx,ax; {CX=CX+AX}
|
||
|
||
mov al,color;
|
||
rep stosb;
|
||
|
||
{for i:=y2 to 199 do line(0,i,319,i,color,z_mem);}
|
||
mov ax,y2;
|
||
shl ax,8;
|
||
mov di,ax;
|
||
shr ax,2;
|
||
add di,ax;
|
||
|
||
|
||
mov ax,200;
|
||
sub ax,y2;
|
||
shl ax,8; {AX=256*AX}
|
||
mov cx,ax; {CX=AX}
|
||
shr ax,2; {AX=AX div 4}
|
||
add cx,ax; {CX=CX+AX}
|
||
|
||
mov al,color;
|
||
rep stosb;
|
||
|
||
{for i:=0 to x1 do line(i,0+y1,i,199-(199-y2),color,z_mem);}
|
||
mov al,color
|
||
|
||
mov cx,y2
|
||
sub cx,y1
|
||
@bucle1:
|
||
mov dx,cx{push cx}
|
||
mov bx,y2
|
||
sub bx,cx
|
||
shl bx,8
|
||
mov di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
mov cx,x1
|
||
rep stosb
|
||
mov cx,dx{pop cx}
|
||
loop @bucle1
|
||
|
||
{for i:=x2 to 319 do line(i,0+y1,i,199-(199-y2),color,z_mem);}
|
||
mov al,color
|
||
|
||
mov cx,y2
|
||
sub cx,y1
|
||
|
||
@bucle2:
|
||
mov dx,cx{push cx}
|
||
|
||
mov bx,y2
|
||
sub bx,cx
|
||
shl bx,8
|
||
mov di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,x2
|
||
|
||
mov bx,320
|
||
sub bx,x2
|
||
mov cx,bx
|
||
rep stosb
|
||
mov cx,dx{pop cx}
|
||
loop @bucle2
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄGestio del DoubleBuffer ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure CreateDB(NumLines:word);
|
||
begin
|
||
GetMem(Dbuffer.PDbuffer,NumLines*320);
|
||
Dbuffer.AltDbuffer:=NumLines;
|
||
Dbuffer.SizeDBuffer:=(320*NumLines) div 4;{El tamany expresat en DWORDs}
|
||
DBuffer.MDbuffer:=seg(Dbuffer.PDbuffer^);
|
||
end;
|
||
|
||
procedure ClearDB(color:byte);assembler;
|
||
asm
|
||
mov dx,seg [Dbuffer]
|
||
mov ds,dx
|
||
mov si,offset [Dbuffer+6]
|
||
mov cx,word ptr [ds:si] {cx conte el tamany de DBuffer}
|
||
mov ax,word ptr [ds:si+2]
|
||
mov es,ax
|
||
xor di,di
|
||
mov al,color
|
||
mov ah,al
|
||
mov bx,ax
|
||
mov cx,Dbuffer.SizeDbuffer
|
||
db _32bit
|
||
shl ax,16
|
||
mov ax,bx
|
||
db _32bit
|
||
rep stosw
|
||
end;
|
||
|
||
procedure FlipDB;assembler;
|
||
asm
|
||
push ds {Guardar l'adre‡a del segment de dades}
|
||
mov dx,seg [Dbuffer]
|
||
mov ds,dx
|
||
mov si,offset [Dbuffer+6]
|
||
mov cx,word ptr [ds:si] {cx conte el tamany de DBuffer}
|
||
mov ax,$a000
|
||
xor di,di {di=0}
|
||
mov es,ax {es=VGA}
|
||
mov ds,word ptr [ds:si+2]
|
||
mov si,di {si=0}
|
||
cld {Asegurarse que l'increment no siga decrement}
|
||
db _32bit {Mode 32bits}
|
||
rep movsw {movsdw}
|
||
pop ds {Restaurar l'adre‡a del segment de dades}
|
||
end;
|
||
|
||
procedure DeleteDB;
|
||
begin
|
||
FreeMem(DBuffer.PDBuffer,DBuffer.SizeDBuffer);
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure Scale2D(font,desti,ample,alt,posx,posy:word;zoom:real);
|
||
var IndexEscalaY,IndexEscalaX,PasEscalaY,PasEscalaX:real;
|
||
TamanyDesti:word;
|
||
offset:word;
|
||
x,y:word;
|
||
data:byte;
|
||
Pdibuix:word;
|
||
fiY,fiX:longint;
|
||
|
||
begin
|
||
IndexEscalaY:=0; {Posar l'orige del primer pixel}
|
||
PasEscalaY:=alt/(alt*zoom); {calcular el pas}
|
||
PasEscalaX:=ample/(ample*zoom);
|
||
Pdibuix:=0; {punter al dibuix}
|
||
offset:=320*PosY+PosX; {calcular el offset desti}
|
||
fiY:=trunc(alt*zoom);
|
||
fiX:=Trunc(ample*zoom);
|
||
{escalar l'objecte fila a fila}
|
||
for y:=0 to fiY do
|
||
begin
|
||
{copiar la proxima fila en el desti usant copia de memoria rapida}
|
||
IndexEscalaX:=0;
|
||
for x:=0 to fiX do
|
||
begin
|
||
{comprobar transparencies}
|
||
data:=mem[font:Pdibuix+trunc(IndexEscalaX)];
|
||
{if data<>0 then} mem[desti:offset+x]:=data;
|
||
IndexEscalaX:=IndexEscalaX+PasEscalaX;
|
||
end; {final per a les x}
|
||
{usant el pas de l'escala calculem el proxim pixel font}
|
||
IndexEscalaY:=IndexEscalaY+PasEscalaY;
|
||
{moure el punter a la seguent linia desti}
|
||
offset:=offset+320;
|
||
Pdibuix:=ample*trunc(IndexEscalaY);
|
||
end;{final per a les Y}
|
||
end;{final de l'escalat}
|
||
|
||
procedure Scale2DClipped(font,desti,ample,alt,posx,posy:word;zoom:real);
|
||
var IndexEscalaY,IndexEscalaX,PasEscalaY,PasEscalaX:real;
|
||
TamanyDesti:word;
|
||
offset:word;
|
||
x,y:word;
|
||
data:byte;
|
||
Pdibuix:word;
|
||
fiY,fiX,Cclip:longint;
|
||
|
||
begin
|
||
IndexEscalaY:=0; {Posar l'orige del primer pixel}
|
||
PasEscalaY:=1/zoom; {calcular el pas}
|
||
PasEscalaX:=1/zoom;
|
||
Pdibuix:=0; {punter al dibuix}
|
||
offset:=320*PosY+PosX; {calcular el offset desti}
|
||
fiY:=trunc((alt-1)*zoom); {Nou Alt}
|
||
fiX:=Trunc((ample-1)*zoom);{nou ample}
|
||
{comprobar que no ix de la pantalla
|
||
i corregir en cas contrari -> optimitzar}
|
||
if fiY>200 then fiY:=199;
|
||
if fiX>320 then fiX:=319;
|
||
{escalar l'objecte fila a fila}
|
||
for y:=0 to fiY do
|
||
begin
|
||
{copiar la proxima fila en el desti usant copia de memoria rapida}
|
||
IndexEscalaX:=0;
|
||
for x:=0 to fiX do
|
||
begin
|
||
data:=mem[font:Pdibuix+trunc(IndexEscalaX)];
|
||
{comprobar transparencies}
|
||
{if data<>0 then} mem[desti:offset+x]:=data;
|
||
IndexEscalaX:=IndexEscalaX+PasEscalaX;
|
||
end; {final per a les x}
|
||
{usant el pas de l'escala calculem el proxim pixel font}
|
||
IndexEscalaY:=IndexEscalaY+PasEscalaY;
|
||
{moure el punter a la seguent linia desti}
|
||
offset:=offset+320;
|
||
Pdibuix:=ample*trunc(IndexEscalaY);
|
||
end;{final per a les Y}
|
||
end;{final de l'escalat}
|
||
|
||
procedure Scale2DMasked(font,desti,ample,alt,posx,posy:word;zoom:real);
|
||
var IndexEscalaY,IndexEscalaX,PasEscalaY,PasEscalaX:real;
|
||
TamanyDesti:word;
|
||
offset:word;
|
||
x,y:word;
|
||
data:byte;
|
||
Pdibuix:word;
|
||
fiY,fiX:longint;
|
||
|
||
begin
|
||
IndexEscalaY:=0; {Posar l'orige del primer pixel}
|
||
PasEscalaY:=alt/(alt*zoom); {calcular el pas}
|
||
PasEscalaX:=ample/(ample*zoom);
|
||
Pdibuix:=0; {punter al dibuix}
|
||
offset:=320*PosY+PosX; {calcular el offset desti}
|
||
fiY:=trunc(alt*zoom);
|
||
fiX:=Trunc(ample*zoom);
|
||
{escalar l'objecte fila a fila}
|
||
for y:=0 to fiY do
|
||
begin
|
||
{copiar la proxima fila en el desti usant copia de memoria rapida}
|
||
IndexEscalaX:=0;
|
||
for x:=0 to fiX do
|
||
begin
|
||
{comprobar transparencies}
|
||
data:=mem[font:Pdibuix+trunc(IndexEscalaX)];
|
||
if data<>0 then mem[desti:offset+x]:=data;
|
||
IndexEscalaX:=IndexEscalaX+PasEscalaX;
|
||
end; {final per a les x}
|
||
{usant el pas de l'escala calculem el proxim pixel font}
|
||
IndexEscalaY:=IndexEscalaY+PasEscalaY;
|
||
{moure el punter a la seguent linia desti}
|
||
offset:=offset+320;
|
||
Pdibuix:=ample*trunc(IndexEscalaY);
|
||
end;{final per a les Y}
|
||
end;{final de l'escalat}
|
||
|
||
procedure Scale2DMaskedClipped(font,desti,ample,alt,posx,posy:word;zoom:real);
|
||
var IndexEscalaY,IndexEscalaX,PasEscalaY,PasEscalaX:real;
|
||
TamanyDesti:word;
|
||
offset:word;
|
||
x,y:word;
|
||
data:byte;
|
||
Pdibuix:word;
|
||
fiY,fiX,Cclip:longint;
|
||
|
||
begin
|
||
IndexEscalaY:=0; {Posar l'orige del primer pixel}
|
||
PasEscalaY:=1/zoom; {calcular el pas}
|
||
PasEscalaX:=1/zoom;
|
||
Pdibuix:=0; {punter al dibuix}
|
||
offset:=320*PosY+PosX; {calcular el offset desti}
|
||
fiY:=trunc((alt-1)*zoom); {Nou Alt}
|
||
fiX:=Trunc((ample-1)*zoom);{nou ample}
|
||
{comprobar que no ix de la pantalla
|
||
i corregir en cas contrari -> optimitzar}
|
||
if fiY>200 then fiY:=199;
|
||
if fiX>320 then fiX:=319;
|
||
{escalar l'objecte fila a fila}
|
||
for y:=0 to fiY do
|
||
begin
|
||
{copiar la proxima fila en el desti usant copia de memoria rapida}
|
||
IndexEscalaX:=0;
|
||
for x:=0 to fiX do
|
||
begin
|
||
data:=mem[font:Pdibuix+trunc(IndexEscalaX)];
|
||
{comprobar transparencies}
|
||
if data<>0 then mem[desti:offset+x]:=data;
|
||
IndexEscalaX:=IndexEscalaX+PasEscalaX;
|
||
end; {final per a les x}
|
||
{usant el pas de l'escala calculem el proxim pixel font}
|
||
IndexEscalaY:=IndexEscalaY+PasEscalaY;
|
||
{moure el punter a la seguent linia desti}
|
||
offset:=offset+320;
|
||
Pdibuix:=ample*trunc(IndexEscalaY);
|
||
end;{final per a les Y}
|
||
end;{final de l'escalat}
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄSpritesÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
|
||
procedure GrabFrame(font,x0,y0:word;var Sprite:PTSprite);
|
||
var i,j:word;
|
||
begin
|
||
with sprite^ do
|
||
begin
|
||
inc(num_frames); {aumentar el frames que te}
|
||
Getmem(frames[num_frames],ample*alt); {reservar memoria per a un frame}
|
||
for j:=y0 to y0+alt-1 do
|
||
for i:=x0 to x0+ample-1 do
|
||
mem[seg(Frames[num_frames]^):(ample*j)+i+ofs(Frames[num_frames]^)]:=
|
||
mem[font:320*j+i];
|
||
end;
|
||
end;
|
||
|
||
|
||
procedure CreateSprite(var Sprite:PTSprite;
|
||
x0,y0:integer;
|
||
width,height,a_sp,m_sp,state:word);
|
||
var i:word;
|
||
begin
|
||
getmem(sprite,sizeof(Sprite^));
|
||
with sprite^ do
|
||
begin
|
||
x:=x0;
|
||
y:=y0;
|
||
xold:=x0;
|
||
yold:=y0;
|
||
ample:=width;
|
||
alt:=height;
|
||
anim_clock:=0;
|
||
anim_speed:=a_sp;
|
||
motion_clock:=0;
|
||
motion_speed:=m_sp;
|
||
curr_frame:=1;
|
||
num_frames:=0;
|
||
estat:=state;
|
||
For i:=1 to MAXFRAMES do frames[i]:=nil;
|
||
end;
|
||
end;
|
||
|
||
procedure DeleteSprite(Sprite:PTsprite);
|
||
var i:word;
|
||
begin
|
||
with sprite^ do
|
||
for i:=1 to num_frames do
|
||
begin
|
||
Freemem(frames[i],ample*alt);
|
||
Dispose(frames[i]);
|
||
end;
|
||
freemem(sprite,sizeof(sprite));
|
||
end;
|
||
|
||
procedure DrawSprite(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
mov bx,320
|
||
sub bx,dx {bx conte el despla‡ament de DI quan acabe de pintar
|
||
una linia}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
rep movsb
|
||
add di,bx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteDB(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,Dbuffer.MDBuffer
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
mov bx,320
|
||
sub bx,dx {bx conte el despla‡ament de DI quan acabe de pintar
|
||
una linia}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
rep movsb
|
||
add di,bx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteM(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,$a000
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,dx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
add di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteDBM(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,Dbuffer.MDBuffer
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,dx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
add di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteF(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,$a000
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
add bx,cx {nova y=y+alt-1}
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
mov bx,di
|
||
add bx,cx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
sub di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteDBF(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,Dbuffer.MDBuffer
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
add bx,cx {nova y=y+alt-1}
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
mov bx,di
|
||
add bx,cx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
sub di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteMF(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,$a000
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
add bx,cx {nova y=y+alt-1}
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,dx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
sub di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteDBMF(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,Dbuffer.MDBuffer
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
add bx,cx {nova y=y+alt-1}
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,dx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
sub di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSprite(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,$a000
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,cx
|
||
add bx,di
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
add di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteDB(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,Dbuffer.MDBuffer
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,cx
|
||
add bx,di
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
add di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteM(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,$a000
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,dx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
add di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteDBM(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,Dbuffer.MDBuffer
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,dx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
add di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteF(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,$a000
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
add bx,cx {nova y=y+alt-1}
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
dec di {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
add bx,cx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
sub di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteDBF(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,Dbuffer.MDBuffer
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
add bx,cx {nova y=y+alt-1}
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
dec di {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
add bx,cx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
sub di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteMF(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,$a000
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
add bx,cx {nova y=y+alt-1}
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,dx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
sub di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteDBMF(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
mov ax,Dbuffer.MDBuffer
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov dx,[bp+8]
|
||
mov es,dx {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
add bx,cx {nova y=y+alt-1}
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx
|
||
add di,dx {*di conte l'offset de pantalla}
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+X}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
sub di,320
|
||
pop dx
|
||
add ax,dx {AX=AX+Sprite^.ample}
|
||
pop cx
|
||
loop @loopY
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub si,di {nou offset orige}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor ax,ax
|
||
sub ax,bx {ax=-y}
|
||
mov bx,ax {bx=-y}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx
|
||
@EndClip:
|
||
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
mov bx,cx
|
||
mov es:[di+bx],dl
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
add di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteDBC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov ax,Dbuffer.MDBuffer {si ho possem mes tard al haver modificat DS
|
||
no sabem quin valor pot recuperat}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
{mov ax,$a000}
|
||
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub si,di {nou offset orige}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor ax,ax
|
||
sub ax,bx {ax=-y}
|
||
mov bx,ax {bx=-y}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx
|
||
@EndClip:
|
||
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
mov bx,cx
|
||
mov es:[di+bx],dl
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
add di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteMC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
|
||
jl @clipY
|
||
add si,dx
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
sub si,dx
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor ax,ax
|
||
sub ax,bx {ax=-y}
|
||
mov bx,ax {bx=-y}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx
|
||
@EndClip:
|
||
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
add di,dx {possar DI al final del dibuix}
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+x}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
add di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteDBMC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov ax,Dbuffer.MDBuffer {si ho possem mes tard al haver modificat DS
|
||
no sabem quin valor pot recuperat}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
mov es,ax {*ES conte el segment del DB}
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
add si,dx
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
sub si,dx
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor ax,ax
|
||
sub ax,bx {ax=-y}
|
||
mov bx,ax {bx=-y}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx
|
||
@EndClip:
|
||
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
add di,dx {possar DI al final del dibuix}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+x}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
add di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteFC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub si,di {nou offset orige}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx {CX=nou alt}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
@EndClip:
|
||
|
||
add bx,cx
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
mov bx,cx
|
||
mov es:[di+bx],dl
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
sub di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
|
||
procedure DrawSpriteDBFC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov ax,Dbuffer.MDBuffer {si ho possem mes tard al haver modificat DS
|
||
no sabem quin valor pot recuperat}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
{mov ax,$a000}
|
||
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub si,di {nou offset orige}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx {CX=nou alt}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
@EndClip:
|
||
|
||
add bx,cx
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
mov bx,cx
|
||
mov es:[di+bx],dl
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
sub di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure DrawSpriteMFC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
add si,dx
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
sub si,dx
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx {CX=nou alt}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
@EndClip:
|
||
|
||
add bx,cx
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
add di,dx
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
mov bx,di
|
||
sub bx,cx
|
||
inc bx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
sub di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
|
||
procedure DrawSpriteDBMFC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov ax,Dbuffer.MDBuffer {si ho possem mes tard al haver modificat DS
|
||
no sabem quin valor pot recuperat}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
{mov ax,$a000}
|
||
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
add si,dx
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
sub si,dx
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx {CX=nou alt}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
@EndClip:
|
||
|
||
add bx,cx
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
add di,dx
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
mov bx,di
|
||
sub bx,cx
|
||
inc bx
|
||
mov es:[bx],dl
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
sub di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub si,di {nou offset orige}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor ax,ax
|
||
sub ax,bx {ax=-y}
|
||
mov bx,ax {bx=-y}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx
|
||
@EndClip:
|
||
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,cx
|
||
mov es:[di+bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
add di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteDBC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov ax,Dbuffer.MDBuffer {si ho possem mes tard al haver modificat DS
|
||
no sabem quin valor pot recuperat}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
{mov ax,$a000}
|
||
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub si,di {nou offset orige}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor ax,ax
|
||
sub ax,bx {ax=-y}
|
||
mov bx,ax {bx=-y}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx
|
||
@EndClip:
|
||
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,cx
|
||
mov es:[di+bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
add di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteMC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
|
||
jl @clipY
|
||
add si,dx
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
sub si,dx
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor ax,ax
|
||
sub ax,bx {ax=-y}
|
||
mov bx,ax {bx=-y}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx
|
||
@EndClip:
|
||
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
add di,dx {possar DI al final del dibuix}
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+x}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
add di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteDBMC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov ax,Dbuffer.MDBuffer {si ho possem mes tard al haver modificat DS
|
||
no sabem quin valor pot recuperat}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
mov es,ax {*ES conte el segment del DB}
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
add si,dx
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
sub si,dx
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor ax,ax
|
||
sub ax,bx {ax=-y}
|
||
mov bx,ax {bx=-y}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx
|
||
@EndClip:
|
||
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
add di,dx {possar DI al final del dibuix}
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,ax {BX=Pdib}
|
||
add bx,cx {BX=Pdib+x}
|
||
add bx,si
|
||
dec bx
|
||
mov dl,ds:[bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
sub bx,cx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
add di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteFC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub si,di {nou offset orige}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx {CX=nou alt}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
@EndClip:
|
||
|
||
add bx,cx
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,cx
|
||
mov es:[di+bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
sub di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
|
||
procedure MaskedSpriteDBFC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov ax,Dbuffer.MDBuffer {si ho possem mes tard al haver modificat DS
|
||
no sabem quin valor pot recuperat}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
{mov ax,$a000}
|
||
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub si,di {nou offset orige}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx {CX=nou alt}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
@EndClip:
|
||
|
||
add bx,cx
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,cx
|
||
mov es:[di+bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
sub di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
procedure MaskedSpriteMFC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
mov ax,$a000
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
add si,dx
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
sub si,dx
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx {CX=nou alt}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
@EndClip:
|
||
|
||
add bx,cx
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
add di,dx
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
sub bx,cx
|
||
inc bx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
sub di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
|
||
procedure MaskedSpriteDBMFC(sprite:PTSprite);assembler;
|
||
asm
|
||
push ds
|
||
{obtindre posicio de l'estructura sprite a la memoria}
|
||
mov di,[bp+6] {DI=ofs(sprite)}
|
||
mov ax,[bp+8]
|
||
mov es,ax {ES=seg(sprite)}
|
||
mov bx,es:[di+20] {Curr_frame}
|
||
shl bx,2
|
||
sub bx,4 {a‡o es per saber el despla‡ament dins el vector
|
||
de punters}
|
||
mov ax,Dbuffer.MDBuffer {si ho possem mes tard al haver modificat DS
|
||
no sabem quin valor pot recuperat}
|
||
mov si,es:[di+bx+26] {*offset del frame}
|
||
mov ds,es:[di+bx+28] {*segment del frame}
|
||
mov cx,es:[di+10] {sprite^.alt}
|
||
mov dx,es:[di+8] {*sprite^.ample}
|
||
mov bx,es:[di+2] {bx=sprite^.y}
|
||
mov di,es:[di] {di=sprite^.x}
|
||
{mov ax,$a000}
|
||
|
||
mov es,ax {*ES conte el segment de la pantalla}
|
||
|
||
push dx
|
||
{Clipping}
|
||
test di,$8000 {x<0?}
|
||
jz @ClipXdreta
|
||
add dx,di {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
xor di,di
|
||
jmp @ClipY
|
||
@clipXdreta:
|
||
mov ax,di
|
||
add ax,dx
|
||
cmp ax,320
|
||
jl @clipY
|
||
add si,dx
|
||
mov dx,320 {!! atencio hem modificat DX que contenia Sprite^.ample i
|
||
ara conte el nou ample}
|
||
sub dx,di
|
||
sub si,dx
|
||
@clipY:
|
||
test bx,$8000
|
||
jz @ClipYavall
|
||
add cx,bx {A‡i encara que hem modificat CX no importa}
|
||
xor bx,bx
|
||
jmp @EndClip
|
||
@ClipYavall:
|
||
mov ax,bx
|
||
add ax,cx
|
||
cmp ax,200
|
||
jle @endClip
|
||
mov cx,200
|
||
sub cx,bx {CX=nou alt}
|
||
pop ax
|
||
push ax
|
||
push dx {la multiplicacio canvia el valor del registre DX!}
|
||
mul bx
|
||
pop dx
|
||
add si,ax {ample*y+x}
|
||
@EndClip:
|
||
|
||
add bx,cx
|
||
dec bx
|
||
shl bx,8
|
||
add di,bx
|
||
shr bx,2
|
||
add di,bx {*di conte l'offset de pantalla}
|
||
add di,dx
|
||
dec di
|
||
xor ax,ax {*AX=0=Pdib}
|
||
@loopY:
|
||
push cx
|
||
mov cx,dx
|
||
push dx
|
||
@loopX:
|
||
mov bx,cx {BX=X}
|
||
add bx,ax {BX=Pdib+x}
|
||
dec bx
|
||
mov dl,ds:[si+bx]
|
||
cmp dl,0
|
||
jz @transparent
|
||
mov bx,di
|
||
sub bx,cx
|
||
inc bx
|
||
mov es:[bx],dl
|
||
@transparent:
|
||
loop @loopX
|
||
pop dx
|
||
pop cx
|
||
sub di,320
|
||
|
||
pop bx
|
||
add ax,bx {AX=AX+Sprite^.ample}
|
||
push bx
|
||
|
||
loop @loopY
|
||
pop bx
|
||
pop ds
|
||
end;
|
||
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
function Colisio(x1,y1,w1,h1, x2,y2,w2,h2 :integer):boolean;
|
||
var xd,yd : boolean;
|
||
Begin
|
||
xd:=false;
|
||
yd:=false;
|
||
if ((x1 <=x2) and (x1+w1>=x2)) then xd:=true else
|
||
if ((x1 <=x2+w2) and (x1+w1>=x2+w2)) then xd:=true else
|
||
if ((x1 >=x2) and (x1+w1<=x2+w2)) then xd:=true;
|
||
if ((y1 <=y2) and (y1+h1>=y2)) then yd:=true else
|
||
if ((y1 <=y2+h2) and (y1+h1>=y2+h2)) then yd:=true else
|
||
if ((y1 >=y2) and (y1+h1<=y2+h2)) then yd:=true;
|
||
Colisio:=xd and yd;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure LoadPCX(Name:String;MemD:word);
|
||
Const MAX_BUFFER=2047;
|
||
COMPRESS = $C0;
|
||
COUNT = $3F;
|
||
|
||
type
|
||
TPCXHEADER = Record
|
||
Manufacturer:byte;
|
||
Version:byte;
|
||
Encoding:byte;
|
||
BitsXPix:byte;
|
||
Xmin:word;
|
||
YMin:word;
|
||
XMax:word;
|
||
YMAx:word;
|
||
HDpi:word;
|
||
VDpi:word;
|
||
Colormap:array[0..47]of byte;
|
||
Reserved:byte;
|
||
Planes:byte;
|
||
BytesPerLine:word;
|
||
PaletteInfo:word;
|
||
HScrSize:word;
|
||
VScrSize:word;
|
||
Filler:array[0..53] of byte;
|
||
end;
|
||
|
||
TRGBPCX = Record
|
||
red:byte;
|
||
green:byte;
|
||
blue:byte;
|
||
end;
|
||
|
||
var f:file;
|
||
Buffer:array[0..MAX_BUFFER] of byte;
|
||
Paleta:array[0..255] of TRGBPCX;
|
||
PBuf,Pscr,BytesInLine,Reps,i:word;
|
||
PCXheader:TPCXHEADER;
|
||
DataSize:longint;
|
||
|
||
begin
|
||
assign(f,name);
|
||
reset(f,1);
|
||
DataSize:=Filesize(f)-128-769;
|
||
blockread(f,PCXheader,sizeof(PCXHeader));
|
||
|
||
Pscr:=0;
|
||
bytesInLine:=0;
|
||
repeat
|
||
if DataSize>=MAX_BUFFER+1 then
|
||
begin
|
||
Pbuf:=0;
|
||
blockread(f,buffer,Sizeof(buffer));
|
||
dec(DataSize,MAX_BUFFER+1);
|
||
repeat
|
||
if (Buffer[Pbuf] and COMPRESS = COMPRESS) then
|
||
begin
|
||
Reps:=Buffer[Pbuf] and COUNT;
|
||
inc(Pbuf);
|
||
if Pbuf>MAX_BUFFER then
|
||
begin
|
||
dec(Pbuf);
|
||
blockread(f,buffer[Pbuf],1);
|
||
dec(DataSize);
|
||
end;
|
||
for i:=1 to Reps do
|
||
begin
|
||
mem[memD:Pscr]:=buffer[Pbuf];
|
||
inc(BytesInLine);
|
||
if BytesInLine=PcxHeader.BytesPerLine then
|
||
begin
|
||
Pscr:=Pscr+320-PcxHeader.BytesPerLine+1;
|
||
BytesInLine:=0;
|
||
end
|
||
else inc(Pscr);
|
||
end;
|
||
inc(Pbuf);
|
||
end
|
||
else
|
||
begin
|
||
mem[memD:Pscr]:=buffer[Pbuf];
|
||
inc(BytesInLine);
|
||
if BytesInLine=PcxHeader.BytesPerLine then
|
||
begin
|
||
Pscr:=Pscr+320-PcxHeader.BytesPerLine+1;
|
||
BytesInLine:=0;
|
||
end
|
||
else inc(Pscr);
|
||
inc(Pbuf);
|
||
end;
|
||
until Pbuf=MAX_BUFFER+1;
|
||
end
|
||
else
|
||
begin
|
||
Pbuf:=0;
|
||
blockread(f,buffer,DataSize);
|
||
repeat
|
||
if (Buffer[Pbuf] and COMPRESS = COMPRESS) then
|
||
begin
|
||
Reps:=Buffer[Pbuf] and COUNT;
|
||
inc(Pbuf);
|
||
for i:=1 to Reps do
|
||
begin
|
||
mem[memD:Pscr]:=buffer[Pbuf];
|
||
inc(BytesInLine);
|
||
if BytesInLine=PcxHeader.BytesPerLine then
|
||
begin
|
||
Pscr:=Pscr+320-PcxHeader.BytesPerLine+1;
|
||
BytesInLine:=0;
|
||
end
|
||
else inc(Pscr);
|
||
end;
|
||
inc(Pbuf);
|
||
end
|
||
else
|
||
begin
|
||
mem[memD:Pscr]:=buffer[Pbuf];
|
||
inc(BytesInLine);
|
||
if BytesInLine=PcxHeader.BytesPerLine then
|
||
begin
|
||
Pscr:=Pscr+320-PcxHeader.BytesPerLine+1;
|
||
BytesInLine:=0;
|
||
end
|
||
else inc(Pscr);
|
||
inc(Pbuf);
|
||
end;
|
||
until Pbuf=DataSize;
|
||
DataSize:=0;
|
||
end;
|
||
until DataSize=0;
|
||
|
||
|
||
blockread(f,buffer,1); {llegir un dotze que indica la paleta}
|
||
blockread(f,Paleta,Sizeof(Paleta));
|
||
port[$3c8]:=0;
|
||
for i:=0 to 255 do
|
||
begin
|
||
port[$3c9]:=paleta[i].red shr 2;
|
||
port[$3c9]:=paleta[i].green shr 2;
|
||
port[$3c9]:=paleta[i].blue shr 2;
|
||
end;
|
||
close(f);
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure SavePCX(name:string);
|
||
type
|
||
TPCXHEADER = Record
|
||
Manufacturer:byte;
|
||
Version:byte;
|
||
Encoding:byte;
|
||
BitsXPix:byte;
|
||
Xmin:word;
|
||
YMin:word;
|
||
XMax:word;
|
||
YMAx:word;
|
||
HDpi:word;
|
||
VDpi:word;
|
||
Colormap:array[0..47]of byte;
|
||
Reserved:byte;
|
||
Planes:byte;
|
||
BytesPerLine:word;
|
||
PaletteInfo:word;
|
||
HScrSize:word;
|
||
VScrSize:word;
|
||
Filler:array[0..53] of byte;
|
||
end;
|
||
|
||
TRGBPCX = Record
|
||
red:byte;
|
||
green:byte;
|
||
blue:byte;
|
||
end;
|
||
|
||
var SCRLINE:array [0..319] of byte;
|
||
Paleta:array [0..255] of TRGBPCX;
|
||
PLINE,PSCR,i:word;
|
||
Header:TPCXHEADER;
|
||
f:file;
|
||
Count,Data:byte;
|
||
|
||
begin
|
||
assign(f,name);
|
||
rewrite(f,1);
|
||
{escriure cap‡alera}
|
||
Header.manufacturer:=10;
|
||
Header.version:=5;
|
||
Header.encoding:=1;
|
||
Header.bitsxpix:=8;
|
||
Header.xmin:=0;
|
||
Header.ymin:=0;
|
||
Header.xmax:=319;
|
||
Header.ymax:=199;
|
||
Header.hdpi:=72;
|
||
Header.vdpi:=72;
|
||
for i:=0 to 47 do
|
||
Header.colormap[i]:=0;
|
||
Header.reserved:=0;
|
||
Header.planes:=1;
|
||
Header.bytesperline:=320;
|
||
Header.paletteinfo:=1;
|
||
Header.Hscrsize:=320;
|
||
Header.vscrsize:=200;
|
||
for i:=0 to 53 do
|
||
Header.filler[i]:=0;
|
||
blockwrite(f,header,sizeof(header));
|
||
{codificar i escriure cada linea de la pantalla}
|
||
PLINE:=0;
|
||
repeat
|
||
move(mem[$a000:PLINE*320],SCRLINE,320); {una linea al buffer}
|
||
PSCR:=0;
|
||
repeat
|
||
Data:=SCRLINE[PSCR];
|
||
Count:=0;
|
||
while (Data=SCRLINE[PSCR]) and (PSCR<320) and (Count<63) do
|
||
begin
|
||
inc(pscr);
|
||
inc(count);
|
||
end;
|
||
{algorisme de compresio del PCX}
|
||
if (count=1) and ($C0 <> ($C0 and data)) then blockwrite(f,data,1)
|
||
else
|
||
begin
|
||
count:=count or $C0;
|
||
blockwrite(f,count,1);
|
||
blockwrite(f,data,1);
|
||
end;
|
||
{==============================}
|
||
until PSCR=320;
|
||
inc(Pline);
|
||
until PLINE=200;
|
||
{escriure la paleta activa}
|
||
Data:=12;
|
||
blockwrite(f,Data,1);
|
||
Port[$3c7]:=0;
|
||
for i:=0 to 255 do
|
||
begin
|
||
paleta[i].red:=Port[$3c9];
|
||
paleta[i].green:=Port[$3c9];
|
||
paleta[i].blue:=Port[$3c9];
|
||
paleta[i].red:=paleta[i].red shl 2;
|
||
paleta[i].green:=paleta[i].green shl 2;
|
||
paleta[i].blue:=paleta[i].blue shl 2;
|
||
end;
|
||
blockwrite(f,paleta,sizeof(paleta));
|
||
close(f);
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure LoadBMP(name:string;MemD:word);
|
||
(* Format BMP -> Windows, 256 Colors, 320x200 maxim, RLE *)
|
||
Const MAX_BUFFER=2047; {2K de Buffer}
|
||
|
||
type TBITMAPFILEHEADER=record
|
||
Sign:word;
|
||
Size:longint;
|
||
Reserved1:word;
|
||
Reserved2:word;
|
||
OffBits:longint;
|
||
end;
|
||
|
||
TBITMAPINFOHEADER=record
|
||
Size:longint;
|
||
Ample:longint;
|
||
Alt:longint;
|
||
Planes:word;
|
||
BitsXPix:word;
|
||
Compresio:longint;
|
||
SizeImage:longint;
|
||
XPelsPerMeter:longint;
|
||
YPelsPerMeter:longint;
|
||
ColorsUsed:longint;
|
||
ColorImportant:longint;
|
||
end;
|
||
|
||
TRGBBM=record
|
||
Blue:byte;
|
||
Green:byte;
|
||
Red:byte;
|
||
Reserved:byte;
|
||
end;
|
||
|
||
var buffer:array[0..MAX_BUFFER] of byte;
|
||
paleta:array[0..255] of TRGBBM;
|
||
f:file;
|
||
fileheader:TbitmapFileHeader;
|
||
InfoHeader:TbitmapInfoHeader;
|
||
DataSize:longint;
|
||
PBuf,PScr,i,X,Y:word;
|
||
{MovX,MovY:byte; proximes versions}
|
||
nocomp,reps:byte;
|
||
|
||
begin
|
||
assign(f,name);
|
||
reset(f,1);
|
||
blockread(f,fileheader,sizeof(fileheader));
|
||
blockread(f,infoheader,sizeof(infoheader));
|
||
|
||
seek(f,54);
|
||
blockread(f,paleta,sizeof(paleta));
|
||
port[$3C8]:=0;
|
||
for i:=0 to 255 do
|
||
begin
|
||
port[$3c9]:=paleta[i].red shr 2;
|
||
port[$3c9]:=paleta[i].green shr 2;
|
||
port[$3c9]:=paleta[i].blue shr 2;
|
||
end;
|
||
|
||
seek(f,fileheader.offbits);
|
||
{Descomprimir i escriure imatge}
|
||
DataSize:=infoheader.SizeImage;
|
||
Pscr:=320*(infoheader.alt-1);
|
||
repeat
|
||
if DataSize>=MAX_BUFFER+1 then
|
||
begin
|
||
PBuf:=0;
|
||
Blockread(f,buffer,sizeof(buffer));
|
||
DataSize:=DataSize-Sizeof(buffer);
|
||
repeat
|
||
if Buffer[PBuf]=0 then
|
||
begin
|
||
inc(Pbuf);
|
||
if Pbuf>MAX_BUFFER then
|
||
begin
|
||
dec(pbuf);
|
||
blockread(f,buffer[Pbuf],1);
|
||
dec(Datasize);
|
||
end;
|
||
case Buffer[Pbuf] of
|
||
0:{eol}begin Pscr:=Pscr-320-infoheader.ample;inc(Pbuf);end;
|
||
1:inc(Pbuf);
|
||
2:;
|
||
else
|
||
begin
|
||
nocomp:=buffer[Pbuf];
|
||
inc(Pbuf);
|
||
if Pbuf>MAX_BUFFER then
|
||
begin
|
||
dec(Pbuf);
|
||
blockread(f,buffer[pbuf],1);
|
||
dec(Datasize);
|
||
end;
|
||
For i:=1 to nocomp do
|
||
begin
|
||
mem[MemD:Pscr]:=Buffer[Pbuf];
|
||
inc(Pscr);
|
||
inc(Pbuf);
|
||
if Pbuf>MAX_BUFFER then
|
||
begin
|
||
dec(Pbuf);
|
||
blockread(f,buffer[Pbuf],1);
|
||
dec(DataSize);
|
||
end;
|
||
end;
|
||
if nocomp mod 2 =1 then inc(Pbuf);
|
||
end;
|
||
end;
|
||
end
|
||
else
|
||
begin
|
||
reps:=Buffer[Pbuf];
|
||
inc(Pbuf);
|
||
if Pbuf>MAX_BUFFER then
|
||
begin
|
||
dec(Pbuf);
|
||
blockread(f,buffer[Pbuf],1);
|
||
dec(DataSize);
|
||
end;
|
||
For i:=1 to reps do
|
||
begin
|
||
mem[memd:Pscr]:=Buffer[Pbuf];
|
||
inc(Pscr);
|
||
end;
|
||
inc(PBuf);
|
||
end;
|
||
until PBuf=MAX_BUFFER+1;
|
||
end
|
||
else
|
||
begin
|
||
PBuf:=0;
|
||
Blockread(f,buffer,DataSize);
|
||
repeat
|
||
if Buffer[PBuf]=0 then
|
||
begin
|
||
case Buffer[Pbuf+1] of
|
||
0:{eol}begin Pscr:=Pscr-320-infoheader.ample;inc(Pbuf,2);end;
|
||
1:{eof}inc(Pbuf,2);
|
||
2:;
|
||
else
|
||
begin
|
||
nocomp:=buffer[Pbuf+1];
|
||
inc(pbuf,2);
|
||
for i:=1 to nocomp do
|
||
begin
|
||
mem[memd:Pscr]:=Buffer[Pbuf];
|
||
inc(Pscr);
|
||
inc(pbuf);
|
||
end;
|
||
if nocomp mod 2 =1 then inc(pbuf);{consumir un byte si dades no comp. son impars}
|
||
end;
|
||
end;
|
||
end
|
||
else
|
||
begin
|
||
For i:=1 to Buffer[Pbuf] do
|
||
begin
|
||
mem[memd:Pscr]:=Buffer[Pbuf+1];
|
||
inc(Pscr);
|
||
end;
|
||
inc(PBuf,2);
|
||
end;
|
||
until PBuf=DataSize;
|
||
DataSize:=0;
|
||
end;
|
||
until DataSize=0;
|
||
close(f);
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
procedure init_ys;
|
||
var i:word;
|
||
begin
|
||
for i:=0 to 199 do
|
||
ys[i]:=320*i;
|
||
end;
|
||
|
||
{ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ}
|
||
begin
|
||
init_ys;
|
||
end. |