Crear cuenta
{A ver funciona pero tiene asociados archivos pcx por ello teda el error va en partes}
program pacman;
{$G+} { Activation des instructions 286 / 287 }
uses Crt, Dos;{ ÛßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßÛ Û D‚claration des constantes, types et variables Û ÛÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÛ }const
{ Tableau des directions }
tdir : array[0..4, 1..2] of integer = ((0, -1), (-1, 0), (0, 1), (1, 0), (0, 0));
{ Haut Gauche Bas Droite }
MAX_NB_FANT = 10; { Nombre maximum de fant“mes }
type
spr10 = array[0..100] of byte; { Sprite 10 * 10 }
pal = array[0..767] of byte; { Palette 256 * 3 }
ecran = array[0..64000] of byte; { Ecran 320 * 200 }
niveau = array[0..33, 0..18] of byte; { Niveau 31 * 17 + bords }
fantomes = array[1..MAX_NB_FANT, 1..11] of integer; { Tableau des fant“mes }
police = array[0..4000] of byte; { Police de caractŠres 10x10 }
var
buf : ^ecran; { Tampon vid‚o }
buf_adr : word; { Adresse du tampon vid‚o }
ancien_int : procedure; { Ancien gestionnaire d'interruptions }
a_touches : word; { Adresse (Offset) du nouveau gestionnaire d'interruptions }
s_touches : word; { Segment du nouveau gestionnaire d'interruptions }
touches : array[0..3] of byte; { Tableau des touches de direction }
valeur : byte; { Code de la touche press‚e }
hr, min : word; { Heure et minute systŠme }
sec100 : word; { CentiŠmes de seconde systŠme }
sec, dsec : word; { Seconde en cours et derniŠre seconde }
pfps, fps : integer; { Prochain nombre d'image par secondes et nombre actuel }nouvsec : boolean; { Vrai si une nouvelle seconde vient de commencer }
showfps : boolean; { Vrai si le compteur d'images par secondes est activ‚ }
chiffres : array[0..1000] of byte; { Chiffres du score }
score_img : array[0..500] of byte; { Texte "Score" }
temp_img : array[0..40000] of byte; { Image temporaire }
police_1 : police; { Police de caractŠres par d‚faut }
coeur : spr10; { Petit coeur rouge }
pac_oh , pac_fh : spr10; { Pacman haut , bouche ouverte / ferm‚e }
pac_og , pac_fg : spr10; { Pacman gauche, bouche ouverte / ferm‚e }
pac_ob , pac_fb : spr10; { Pacman bas , bouche ouverte / ferm‚e }
pac_od , pac_fd : spr10; { Pacman droit , bouche ouverte / ferm‚e }
pac_ohd, pac_fhd : spr10; { Pacman Diablo haut , bouche ouverte / ferm‚e }
pac_ogd, pac_fgd : spr10; { Pacman Diablo gauche, bouche ouverte / ferm‚e }
pac_obd, pac_fbd : spr10; { Pacman Diablo bas , bouche ouverte / ferm‚e }
pac_odd, pac_fdd : spr10; { Pacman Diablo droit , bouche ouverte / ferm‚e }
energie : spr10; { Capsule d'‚nergie }
pastille : spr10; { Pastille }
fant_1o, fant_1f : spr10; { Fant“me orange, agressif, neutre, effray‚ }
fant_1p : spr10;fant_2o, fant_2f : spr10; { Fant“me rouge , agressif, neutre, effray‚ }
fant_2p : spr10;fant_3o, fant_3f : spr10; { Fant“me vert , agressif, neutre, effray‚ }
fant_3p : spr10;fant_4o, fant_4f : spr10; { Fant“me bleu , agressif, neutre, effray‚ }
fant_4p : spr10;zyeux_1 : spr10; { Yeux }
zyeux_2 : spr10;{ Murs }
mur_ : spr10; { Mur isol‚ }
mur_h , mur_b : spr10; { Murs … 1 raccord }
mur_g , mur_d : spr10;
mur_hg , mur_gb : spr10; { Murs coud‚s (2 raccords) }
mur_bd , mur_hd : spr10;
mur_gd , mur_hb : spr10; { Murs droits (2 raccords) }
mur_hgb, mur_gbd : spr10; { Murs en T }
mur_hbd, mur_hgd : spr10; { (3 raccords) }
mur_hgbd : spr10; { Mur en croix (4 raccords) }
porte_gd : spr10; { Porte de la prison : horizontale et verticale }
porte_hb : spr10;portet_gd : spr10; { Porte transparente : horizontale et verticale }
portet_hb : spr10;vide : spr10; { Bloc noir (vide) }
bouche : integer; { Pacman ouvre la bouche si positif }
blink : integer; { Couleur des pastilles d'‚nergie et des portes }
tfantomes : fantomes; { Tableau des fant“mes }
max_fant : integer; { Nombre maxinum de fant“mes dans le niveau }
depart_x, depart_y : integer; { Coordonn‚es de d‚part de Pacman }
mort : boolean; { Vrai si Pacman est mort }
vies : integer; { Nombres de vies }
quitte : boolean; { Vrai si le joueur veut quitter }
score, score2 : longint; { Score actuel, ancien score }
p1, p2, nega, noir : pal; { Palettes }
niv : niveau; { Le niveau }
boules : integer; { Le nombre de pastilles restant … manger dans le niveau }
titre_niv : string; { Le titre du niveau }
num_niv, max_niv : integer; { Num‚ro du niveau en cours, et nombre maxi de niveaux }
diablo : integer; { Mode Diablo >:-D (si > 0) }
nom_fic_niv : string; { Nom du fichier des niveaux }
bruit : boolean; { Vrai si le son est activ‚ }
{ ÛßßßßßßßßßßßßßßßßßßßßßßßßßßÛ
Û Proc‚dures et fonctions Û
ÛÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÛ }
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE nouveau_int ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Installe un nouveau gestionnaire d'interruption, ³
³ en mettant les valeurs 0 ou 1 dans le tableau ³
³ d'adresse "a_touches" et de segment "s_touches" ³ ³ o— 0 : haut 1 : gauche 2 : bas 3 : droite ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure nouveau_int; interrupt; assembler;
asm
in al, $60 { al prend la v‚leur de la touche press‚e }
mov valeur, al { "valeur" est la valeur de la touche press‚e }
mov si, a_touches { si prend la valeur du segment du tableau de touches }
mov bx, s_touches { bx prend la valeur de l'offset du tableau de touches }
mov es, bx { dest prend la vleur de l'offset }
cmp al, 72 { si touche press‚e = 72 (haut) }
je @@th_on { Va activer la touche haut (th_on) }
mov ah, 0 { Sinon, met 0 … la valeur de la touche (touches[0] <- 0) }
mov es:[si], ah
@@tg:
cmp al, 75 { si touche press‚e = 75 (gauche) }
je @@tg_on { Va activer la touche gauche (tg_on) }
mov ah, 0 { Sinon, met 0 … la valeur de la touche (touches[1] <- 0) }
mov es:[si+1], ah
@@tb:
cmp al, 80 { si touche press‚e = 80 (bas) }
je @@tb_on { Va activer la touche bas (tb_on) }
mov ah, 0 { Sinon, met 0 … la valeur de la touche (touches[2] <- 0) }
mov es:[si+2], ah
@@td:
cmp al, 77 { si touche press‚e = 77 (droite) }
je @@td_on { Va activer la touche droite (td_on) }
mov ah, 0 { Sinon, met 0 … la valeur de la touche (touches[3] <- 0) }
mov es:[si+3], ah
jmp @@fini { On a termin‚, va … la fin de la proc‚dure }
@@th_on: { Touche haut press‚e }
mov ah, 1 { On place la valeur 1 dans le tableau }
mov es:[si], ah { (touches[0] <- 1) }
jmp @@tg { Passe … la touche suivante (gauche) }
@@tg_on: { Touche gauche press‚e }
mov ah, 1 { On place la valeur 1 dans le tableau }
mov es:[si+1], ah { (touches[1] <- 1) }
jmp @@tb { Passe … la touche suivante (bas) }
@@tb_on: { Touche bas press‚e }
mov ah, 1 { On place la valeur 1 dans le tableau }
mov es:[si+2], ah { (touches[2] <- 1) }
jmp @@td { Passe … la touche suivante (droite) }
@@td_on: { Touche droite press‚e }
mov ah, 1 { On place la valeur 1 dans le tableau }
mov es:[si+3], ah { (touches[3] <- 1) }
@@fini: { Fin de la proc‚dure }
pushf
call ancien_int { Appelle l'ancien gestionnaire pour que les autres touches puissent fonctionner }end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE mode_320_200_256 ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Passe en mode video 320 * 200 * 8 bits ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure mode_320_200_256; assembler;
asm
mov AX, $13 { Installe le mode $13 … l'interruption $10 }
int $10
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE refresh ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Copie le tampon vid‚o dans la m‚moire vid‚o ³
³ (affiche le tampon vid‚o quoi !) ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure refresh; assembler;
asm
push ds { Sauvegarde de ds }
mov ax, $A000 { adresse de destination es : segment vid‚o }
mov es, ax { VGA ($A000) }
mov ax, buf_adr { Adresse de source ds : celle du tampon vid‚o }
mov ds, ax
xor si, si { SI <- 0 (Xor est plus rapide que mov car pas besoin
d'aller chercher dans la m‚moire) }
xor di, di { DI <- 0 (idem) }
mov cx, 32000 { Compteur CX mis … 32000 (64000 / 2) }
rep movsw { rep r‚pŠte CX fois (32000) l'op‚ration qui suit :
movsw copie le mot … [DS:SI] vers [ES:DI], puis
incr‚mente SI et DI }
pop ds { Restaure ds }
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE retrace ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Attend le top de synchronisation du signal vid‚o ³
³ pour que les modifications … l'‚cran qui suivent ³ ³ soient invisibles. Mesure ‚galement le nombre ³ ³ d'images par seconde, cad le nombre d'appel de ³ ³ la proc‚dure par seconde. ³ ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure retrace;
begin
gettime(hr, min, sec, sec100); { heure systŠme }
if sec <> dsec then { Si nouvelle seconde }
begin
fps := pfps; { fps : nombre d'images affich‚es … la
seconde pr‚c‚dente }
pfps := 1; { Remise … 1 du compteur (cette image) }
dsec := sec; { Seconde p‚c‚dente : maintenant celle-ci }
nouvsec := true; { Nouvelle seconde }
end
else { Sinon }
begin
inc(pfps); { Une image de plus … cette seconde }
nouvsec := false; { Ce n'est pas une nouvelle seconde }
end;
{ Attente du top de synchro }
asm
mov dx, $3DA { Adresse de l'interruption : $3DA }
@@et1: { Si le signal vid‚o est d‚j… sur le top de synchro }
in al, dx
and al, $08 { On attend qu'il se termine (al and 1000b = 0) } jnz @@et1
@@et2: { Attend que le signal vid‚o arrive au prochain top }
in al, dx
and al, $08 { On attend qu'il se termine (al and 1000b <> 0) }
jz @@et2
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE eff_ecr ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Efface le tampon vid‚o d'adresse "addr" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure efface(addr : word); assembler;
asm
push es { Sauvegarde es }
mov cx, 32000
mov ax, addr { ax : adresse cible }
mov es, ax { place ES sur l'adresse cible }
xor di, di { Met DI … 0 (c'est plus rapide avec XOR) }
xor ax, ax { Met tous les bits de AX … 0 (XOR + rapide)
cad AH = 0 et AL = 0 }
rep stosw { rep r‚pŠte CX fois (32000) l'op‚ration qui suit :
stosw copie le contenu du registre AX dans [ES:DI]
et incr‚mente DI. AX = 16 bits = 2 octets = 1 mot
On fait d'une pierre deux coups (32000 * 2 = 64000) } pop es { Restaure es }
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE changer_palette ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Change les attributs de couleur de la palette par³
³ ceux du tableau "coulRVB". ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure changer_palette(var coulRVB); assembler;
asm
push ds
lds si, coulRVB { Adresse source : le tableau de la palette }
xor bx, bx { bx : position dans le tableau … 0 }
xor cl, cl { cl : num‚ro de l'indice de couleur (mis … 0) }
@@debut:cmp bx, 768 { Si pas au bout du tableau (768) }
jae @@fin
mov dx, $3C8 { Place dx … l'adresse cible de la palette $3C8 }
mov al, cl
out dx, al
inc dx
mov ax, ds:[si+bx] { Rouge }
shr ax, 2 { Division par 4 pour convertir en couleur VGA }
out dx, al
inc bx
mov ax, ds:[si+bx] { Vert }
shr ax, 2 { Division par 4 pour convertir en couleur VGA }
out dx, al
inc bx
mov ax, ds:[si+bx] { Bleu }
shr ax, 2 { Division par 4 pour convertir en couleur VGA }
out dx, al
inc bx
inc cl
jmp @@debut
@@fin:
pop ds { Restaure ds }
end;{2}
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE colle ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Copie une zone m‚moire dans une autre ³³ source : DS:[BX] dest : ES:[BX] taille : CX ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure colle; assembler;
asm
push AX { Sauvegarde des registres }
push BX
mov BX, 0 { BX : d‚but de la ligne source }
@@debut:cmp BX, CX { Si BX = CX, fin }
jae @@fin
mov AH, DS:[SI+BX] { charge la valeur dans AH }
mov ES:[DI+BX], AH { ‚crit la valeur dans dest }
inc BX { bx augment‚ de 1 pour passer au pixel suivant }
jmp @@debut
@@fin:pop BX { restauration registres }
pop AX
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE coller ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Colle l'image du tableau lin‚aire "spr" de taille³
³ i, j … la position x, y du tampon d'adresse ³³ addr ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure coller(x, y : integer;
i, j : integer;
var spr; addr : word); assembler;
asm
mov CX, i { CX : Taille X }
mov BX, 0mov AX, j { AX : Taille Y }
lds SI, spr { pointe DS:SI sur spr }
{ Dessine une ligne }
@@ligne:push BX { Sauvegarde registres }
push AX
push DS
mov AX, y { offset video }
shl AX, 2 { de la ligne (320) }
mov BX, AX shl AX, 2 add AX, BXmov BX, addr { Segment de la zone m‚moire }
add AX, BX mov ES, AXmov DI, x { position horizontale cible }
call colle { Copie la ligne … l'endroit indiqu‚ }
pop DS { restaure DS }
{ Passe … la ligne suivante }
pop AX { Taille y du dessin (AX lignes) }
pop BX { jŠme ligne }
inc BX { Prochaine ligne }
inc y
add SI, CX { place la source sur la ligne suivante (taille CX) }
cmp AX, BX { Recommence si pas la derniŠre ligne (AX) }
jne @@ligne
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE colle_transp ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Copie une zone m‚moire dans une autre pour toute ³
³ valeur diff‚rente de 253 (couleur "transparente")³
³ source : DS:[BX] dest : ES:[BX] taille : CX ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure colle_transp; assembler;
asm
push AX { Sauvegarde des registres }
push BX
mov BX, 0 { BX : d‚but de la ligne source }
@@debut:
cmp BX, CX
jae @@fin
mov AH, DS:[SI+BX] { charge la valeur dans AH }
cmp AH, 253 { passe au pixel suivant si couleur transparente }
je @@pixelsuiv { (indice 253) }
mov ES:[DI+BX], AH { sinon, ‚crit la valeur dans dest }
@@pixelsuiv:
inc BX { bx augment‚ de 1 pour passer au pixel suivant }
jmp @@debut
@@fin:
pop BX { restauration registres }
pop AX
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE coller_transp ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Colle l'image du tableau lin‚aire "spr" de taille³
³ i, j … la position x, y du tampon "addr" avec un ³
³ fond transparent (code 253) ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure coller_transp(x, y : integer;
i, j : integer;
var spr; addr : word); assembler;
asm
mov CX, i { CX : Taille X }
mov BX, 0mov AX, j { AX : Taille Y }
lds SI, spr { pointe DS:SI sur spr }
{ Dessine une ligne }
@@ligne:push BX { Sauvegarde registres }
push AX
push DS
mov AX, y { offset video }
shl AX, 2 { de la ligne (320) }
mov BX, AX shl AX, 2 add AX, BXmov BX, addr { Segment de la zone m‚moire }
add AX, BX mov ES, AXmov DI, x { position horizontale cible }
call colle_transp { Copie la ligne … l'endroit indiqu‚, avec transparence }
pop DS { restaure DS }
{ Passe … la ligne suivante }
pop AX { Taille y du dessin (AX lignes) }
pop BX { jŠme ligne }
inc BX { Prochaine ligne }
inc y
add SI, CX { place la source sur la ligne suivante (taille CX) }
cmp AX, BX { Recommence si pas la derniŠre ligne (AX) }
jne @@ligne
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE point ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Fait prendre la couleur c au pixel de position ³
³ x, y dans le tampon vid‚o d'adresse "addr" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure point(x, y: word ; c : byte; addr : word); assembler;
asm
mov ax, y { Calcul de l'offset du point (y * 320 + x) }
shl ax, 2
mov bx, ax
shl ax, 2
add ax, bx
mov BX, addr { On y ajoute l'adresse }
add ax, bxmov es, ax { Et on y place l'octet c }
mov bx, x
mov al, c
mov es:[bx], al
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³FONCTION existe PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Donne vrai si le fichier de nom "nom" existe ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
function existe(nom : string) : boolean;
var
F : file;
begin
assign(F, nom); { Ouverture du fichier F de nom "nom" }
{$I-}
reset(F);
{$I+}
if (IOResult = 0) then { Si ouverture sans encombres }
begin
close(F); { On ferme le fichier }
existe := true; { Le fichier existe donc bien }
end
else
existe := false; { Autrement, il n'existe pas }
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE son_erreur PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Emet un bip suite … une erreur (chargement de ³
³ fichier par exemple. ³ ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure son_erreur;
begin
sound(1000); { Son 1 KHz }
delay(200); { pendant 200 ms }
nosound; { repos ! }
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE charger_palette PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Charge la palette de l'image PCX de nom "S" dans ³
³ le tableau palette "p" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure charger_palette(S : string; var p : pal);
var
F : file;
begin
assign(F,S); { Ouverture du fichier image PCX F de nom S }
{$I-}
reset(F,1);
{$I+}
if IOResult = 0 then { Si ouverture sans problŠmes }
begin
seek(F, filesize(F) - 768); { Va au 768 Šme dernier octet }
blockread(F, p, 768); { Et balance toute la fin du fichier dans le tableau "p" }
close(F); { Et on ferme le fichier image }
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE charger_PCX MIX PASCAL / ASM³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Charge l'image au format PCX dans le tableau img ³³ et donne ses dimensions dans "tx" et "ty". ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure charger_PCX( S : string; var img;
var tx, ty : word);
var
b1, b2 : byte; { Octets lus }
fp, j : integer; { Pointeur fichier, indice }
i : word; { Position dans le tableau image }
F : file; { Fichier PCX }
xmin, ymin, xmax, ymax : integer; { Dimensions de l'image }
begin
assign(F,S); { Ouverture du fichier image PCX F de nom S }
{$I-}
reset(F,1);
{$I+}
if IOResult = 0 then { Si ouverture sans problŠmes }
begin
seek(F, 4); { Va au 4Šme octet }
blockread(F, xmin, 2); { Origine X }
blockread(F, ymin, 2); { Origine Y }
blockread(F, xmax, 2); { Fin X }
blockread(F, ymax, 2); { Fin Y }
tx := xmax - xmin + 1; { Taille X : diff‚rence des 2 + 1 }
ty := ymax - ymin + 1; { Taille Y : diff‚rence des 2 + 1 }
fp := 129; { Position du pointeur : 129 Šme octet }
{ 1er octet de l'image en elle-mˆme) }
i := 0; { iŠme pixel = 0 }
seek(F,128); { On y va }
{ TQ pas arriv‚ au bout et que toute l'image n'est pas charg‚e }
while (fp <= (FileSize(F) - 768)) and (i <= tx * ty) do
begin
blockread(F, b1, 1); { Lit l'octet b1 }
inc(fp); { position du pointeur : prochain octet }
if ((b1 and 192) = 192) then { si les 2 bits de poids fort sont … 1 }
begin
blockread(F,b2,1); { On lit l'octet suivant }
inc(fp); { position du pointeur : prochain octet }
for j := 1 to (b1 and 63) do { Et copie l'octet b2 le nombre de fois }
begin { d‚fini par les 6 octets de poids faible de b1 }
asm
les DI, [img]{ Dans le tableau image "img" … la position du pixel "i" }
mov BX, i { Et en assembleur parce qu'en Pascal, on doit }
mov AL, b2 { avoir une taille d'image fixe, ce qui n'est }
mov ES:[DI + BX], AL { pas pratique du tout... }
inc i { Pixel suivant (en assembleur, ‡a fait plus savant) }
end;
end;
end
else { Sinon }
begin
asm
les DI, [img] { Copie juste "b1" dans "img" en "i" }
mov BX, i mov AL, b1mov ES:[DI + BX], AL
inc i { "i" Incr‚ment‚ de 1 (pixel suivant) }
end;
end;
end;
close(F); { Ferme "F" }
end
else son_erreur; { Si erreur d'ouverture, bip d'erreur }
end;
{3}
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³FONCTION inttostr ³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Convertit l'entier "i" en chaŒne ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
function inttostr(i : longint) : string;
var
s : string[11]; { ChaŒne obtenue }
begin
str(i, s); { Convertit l'entier "i" en chaŒne "s" }
inttostr := s; { Et donne "s" }
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE fondu_ouverture PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Fait un fondu en ouverture avec la palette "p". ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure fondu_ouverture(p : pal);
var
tp : pal; { Palette temporaire }
i, j : integer; { Indices }
begin
for i := 0 to 64 do { i de 0 … 64 }
begin
for j := 0 to 767 do { j : parcours du tableau des couleurs }
tp[j] := (p[j] * i) div 64; { variation de la couleur en fonction de i }
retrace; { Attente du top de synchro }
changer_palette(tp); { Application de la nouvelle palette }
if keypressed then readkey; { Evite les bipbipbipbip quand on s'‚nerve sur le clavier }
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE fondu_fermeture PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Fait un fondu en fermeture avec la palette "p". ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure fondu_fermeture(p : pal);
var
tp : pal; { Palette temporaire }
i, j : integer; { Indices }
begin
for i := 64 downto 0 do { i de 64 … 0 }
begin
for j := 0 to 767 do { j : parcours du tableau des couleurs }
tp[j] := (p[j] * i) div 64; { variation de la couleur en fonction de i }
retrace; { Attente du top de synchro }
changer_palette(tp); { Application de la nouvelle palette }
if keypressed then readkey; { Evite les bipbipbipbip quand on s'‚nerve sur le clavier }
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE charger_niveau PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Charge le niveau nø "n" de titre "titre" dans le ³
³ fichier texte "S". ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure charger_niveau( S : string; n : integer;
var niv : niveau; var max_niv : integer; var titre : string);
var
i, j : word; { Indices }
ligne : string[34]; { Ligne lue dans le fichier }
F : text; { Fichier texte des niveaux }
elt : integer; { Valeur du tile }
begin
assign(F,S); { Ouverture de F de nom S en lecture }
{$I-}
reset(F);
{$I+}
if IOResult = 0 then { Si le fichier existe bien }
begin
readln(F, max_niv); { nombre total de niveaux }
for i := 1 to n - 1 do { On cherche le niveau "n" qui nous int‚resse }
for j := 1 to 20 do readln(F, titre); { Un niveau = 20 lignes }
readln(F, titre); { 1Šre ligne : titre }
for j := 0 to 18 do { Les 19 autres : le niveau en lui-mˆme }
begin
readln(F, ligne); { On charge ligne par ligne }
for i := 1 to 34 do { CaractŠre par caractŠre }
begin
case ligne[i] of { Et on attribue chaque caractŠre sa valeur }
'.' : elt := 0; { Vide }
'ø' : elt := 1; { Pastille (boule) }
'*' : elt := 2; { Capsule d'‚nergie }
'T' : elt := 3; { T‚l‚porteur } 'P' : elt := 4; { D‚part de Pacman }'F' : elt := 5; { D‚part d'un fant“me }
'=' : elt := 6; { Porte de prison }
'O' : elt := 7; { Mur }
else
elt := 8 { Mur invisible si caractŠre non reconnu }
end;
niv[i - 1, j] := elt; { On place la valeur trouv‚e dans le tableau de niveau }
end;
end;
close(F); { Ferme le fichier }
end
else son_erreur; { Sinon, bip d'erreur }
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE affiche_porte PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Affiche la porte de la prison aux coordonn‚es ³
³ "porte_x", "porte_y" (s'il y'en a une bien s–r ! ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure affiche_porte(porte_x, porte_y : integer; t : word);
var
h, g, b, d : boolean; { Vrai si mur en haut, gauche, bas, droite du mur
en cours }
begin
if niv[porte_x, porte_y] = 6 then { S'il y a une porte aux coordonn‚es }
begin
h := niv[porte_x , porte_y - 1] > 5; { Mur en haut ? }
g := niv[porte_x - 1 , porte_y ] > 5; { Mur … gauche ? }
b := niv[porte_x , porte_y + 1] > 5; { Mur en bas ? }
d := niv[porte_x + 1 , porte_y ] > 5; { Mur … droit ? }
{ Affiche une porte transparente verticale ou horizontale selon h, g, b, d }
if g and d and not(h or b) then coller_transp(-10 + 10 * porte_x, 10 + 10 * porte_y, 10, 10, portet_gd, t);
if h and b and not(g or d) then coller_transp(-10 + 10 * porte_x, 10 + 10 * porte_y, 10, 10, portet_hb, t);
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE affiche_portes PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Affiche les portes de la prison ³ ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure affiche_portes(pex, pey : integer);
var
dir : integer; { Direction }
begin
affiche_porte(pex div 10, pey div 10, $A000); { Affiche la porte ‚ventuelle
aux coordonn‚es correspondant … celle du fant“me ("pex, pey") }
for dir := 0 to 3 do { Et autour (4 directions) }
affiche_porte(pex div 10 + tdir[dir, 1], pey div 10 + tdir[dir, 2], $A000);
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³FONCTION affiche_score PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : affiche le score "score" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure affiche_score;
var
i : integer; { Indice }
sc : longint; { Score temporaire }
begin
i := 120; { Position du premier chiffre }
sc := score; { Score temporaire <- score actuel }
coller(0, 0, 50, 10, score_img, $A000); { Affiche "SCORE" }
coller(i, 0, 10, 10, chiffres[0], $A000); { Affiche le 0 du score nul }
while sc > 0 do { TQ le score temporaire n'est pas nul }
begin
{ On colle le chiffre des unit‚s en i }
coller(i, 0, 10, 10, chiffres[(sc mod 10) * 100], $A000);
sc := sc div 10; { On divise le score temporaire "sc" par 10 pour
supprimer le chiffre d‚j… affich‚ }
i := i - 10; { On recule la position du chiffre des unit‚s de 10 }
end;
{ Affiche les vies }
for i := 1 to vies do coller(150 + 12 * i, 0, 10, 10, coeur, $A000);
{ Avec un blanc … la fin (au cas o— une vie a ‚t‚ perdue) }
if vies < 13 then coller(150 + 12 * (vies + 1), 0, 10, 10, vide, $A000);
end;{4}
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³FONCTION texte_xy PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Affiche le texte "texte" aux coordonn‚es "x, y" ³
³ avec la police "police" dans le tampon "t", avec ³
³ transparence "transp" ou non. ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure texte_xy(texte : string; x, y : integer; t : word; transp : boolean);
var
c : char; { CaractŠre … afficher }
i : integer; { Indice }
begin
i := 0; { Position du caractŠre en cours, relative … x }
while i <= length(texte) - 1 do { TQ i n'est pas au dernier caractŠre }
begin
c := texte[i + 1]; { "c" : caractŠre en cours }
if ((c >= 'A') and (c <= 'Z')) { Si "c" caractŠre affichable }
or ((c >= '0') and (c <= '9'))
or (c = '!') or (c = '?')
or (c = '_') or (c = ' ') then
begin
{ Si pas transparence, on affiche un bloc vide }
if not(transp) then coller(x + i * 10, y, 10, 10, vide, t);
{ Puis, on affiche le caractŠre correspondant
en fonction de sa position dans l'image "police_1" }
if ((c >= 'A') and (c <= 'Z')) then
begin
coller_transp(x + i * 10, y, 10, 10, police_1[100 * (ord(c) - ord('A'))], t)
end
else
begin
if ((c >= '0') and (c <= '9')) then
coller_transp(x + i * 10, y, 10, 10, police_1[100 * (ord(c) - ord('0') + 27)], t)
else
begin
case c of
'_' : coller_transp(x + i * 10, y, 10, 10, police_1[3700], t);
'!' : coller_transp(x + i * 10, y, 10, 10, police_1[3800], t);
'?' : coller_transp(x + i * 10, y, 10, 10, police_1[3900], t);
end;
end;
end;
end
else coller_transp(x + i * 10, y, 10, 10, police_1[2600], t);
inc(i); { CaractŠre suivant }
if x + i * 10 > 310 then { Si sortie de la zone ‚cran }
begin
x := x - i * 10; { "retour … la ligne" }
y := y + 10;
end;
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE affiche_tile PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Affiche le tile du niveau "niv" de position "i,j"³
³ aux coordonn‚es ‚cran "px, py" dans le tampon "t"³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure affiche_tile(i, j : integer; t : word);
var
h, g, b, d : boolean; { Vrai si mur en haut, gauche, bas, droite du mur
en cours }begin
{ Mur en haut ? }
h := (niv[i , j - 1] = 6) or (niv[i , j - 1] = 7);
{ Mur … gauche ? }
g := (niv[i - 1 , j ] = 6) or (niv[i - 1 , j ] = 7);
{ Mur en bas ? }
b := (niv[i , j + 1] = 6) or (niv[i , j + 1] = 7);
{ Mur … droite ? }
d := (niv[i + 1 , j ] = 6) or (niv[i + 1 , j ] = 7);
case niv[i, j] of
{ Pastille }
1 : coller(-10 + 10 * i, 10 + 10 * j, 10, 10, pastille, t);
{ Energie }
2 : coller(-10 + 10 * i, 10 + 10 * j, 10, 10, energie, t);
{ Porte de prison }
6 : beginif g and d and not(h or b) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, porte_gd, t);
if h and b and not(g or d) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, porte_hb, t);
end;
{ Mur }
7 : beginif not(h or b or g or d) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_ , t);
if h and not(b or g or d) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_h , t);
if g and not(b or h or d) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_g , t);
if b and not(h or g or d) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_b , t);
if d and not(b or g or h) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_d , t);
if h and b and not(g or d) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_hb , t);
if g and d and not(h or b) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_gd , t);
if h and g and not(b or d) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_hg , t);
if g and b and not(d or h) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_gb , t);
if b and d and not(h or g) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_bd , t);
if h and d and not(g or b) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_hd , t);
if h and g and b and not(d) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_hgb , t);
if g and b and d and not(h) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_gbd , t);
if h and b and d and not(g) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_hbd , t);
if h and g and d and not(b) then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_hgd , t);
if h and g and d and b then coller(-10 + 10 * i, 10 + 10 * j, 10, 10, mur_hgbd, t);
end;
else { autre ‚l‚ment = vide }
coller(-10 + 10 * i, 10 + 10 * j, 10, 10, vide, t);
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE init_niveau PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Affiche le niveau "niv" dans le tampon vid‚o, ³
³ et initialise les paramŠres (position de Pacman, ³
³ les fant“mes et le nombre de pastilles … manger).³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure init_niveau(niv : niveau);
var
i, j : integer; { Indices de position du tableau du niveau }
px, py : integer; { Position ‚cran du niveau }
begin
affiche_score; { Affiche le score }
max_fant := 0; { aucun fant“me pour le moment }
boules := 0; { Et aucune boule (pastille) }
px := -10; { Position du niveau … l'‚cran }
py := 10; { (Les bords ne sont pas affich‚s) }
for j := 1 to 17 do { Parcours du tableau avec "i", et "j" }
begin
for i := 1 to 32 do
begin
case niv[i, j] of
1 : inc(boules); { Une boule de plus, une ! }
{ "depart_x", "depart_y" : position de d‚part de Pacman }
4 : begin depart_x := i; depart_y := j; end;
5 : begin
if max_fant < MAX_NB_FANT then { Si on peut encore rajouter }
begin { des fant“mes }
inc(max_fant); { on en rajoute un ! }
tfantomes[max_fant, 1] := i; { Position X }
tfantomes[max_fant, 2] := j; { Position Y }
tfantomes[max_fant, 3] := 3; { Direction par d‚faut (droite) }
tfantomes[max_fant, 4] := i * 10; { Position ‚cran X }
tfantomes[max_fant, 5] := j * 10; { Position ‚cran Y }
tfantomes[max_fant, 6] := (max_fant - 1) mod 4 + 1; { Couleur (1-4) }
tfantomes[max_fant, 7] := - 10 + 5 * (max_fant mod 4); { Animation [-10 ; 10] }
tfantomes[max_fant, 8] := 300; { images restantes avant sortie de prison }
tfantomes[max_fant, 9] := - max_fant * 300; { vie du fant“me (nombre d'imagesavant sa naissance) }
tfantomes[max_fant, 10] := i; { Position X de d‚part }
tfantomes[max_fant, 11] := j; { Position Y de d‚part }
end;
end;
end;
affiche_tile(i, j, buf_adr); { Affiche le tile correspondant dans le tampon vid‚o }
end
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE efface_perso PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Efface le personnage … la position "px", "py" de ³
³ direction "dir" dans le niveau "niv". ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure efface_perso(pex, pey : integer);
var
dir : integer; { Direction temporaire }
tex, tey : integer; { Position ‚cran du tile }
begin
affiche_tile(pex div 10, pey div 10, $A000); { Affiche le tile … la position
du personnage }for dir := 0 to 3 do { Et aux 4 directions possibles }
begin
tex := pex div 10 + tdir[dir, 1];
tey := pey div 10 + tdir[dir, 2];
if (tex >= 1) and (tex <= 32) and (tey >= 1) and (tey <= 17) then
affiche_tile(tex, tey, $A000);
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE affiche_pacman PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Dessine pacman … la position "pex", pey" de dire-³
³ ction "dir" dans le niveau "niv" dans le tampon ³
³ "t". ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure affiche_pacman(pex, pey, dir : integer ; t : word);
begin
if (diablo = 0) or ((diablo > 0) and (diablo <= 80) and ((diablo mod 2) = 0)) then { Si pas en mode diablo (gentil quoi) }
begin
if bouche < 0 then { bouche < 0 : bouche ouverte }
begin
case dir of { Affiche Pacman en fonction de sa direction }
0 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_oh, t); end;
1 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_og, t); end;
2 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_ob, t); end;
3 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_od, t); end;
4 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_od, t); end;
end;
end
else { Sinon bouche ferm‚e }
begin
case dir of { Affiche Pacman en fonction de sa direction }
0 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fh, t); end;
1 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fg, t); end;
2 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fb, t); end;
3 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fd, t); end;
4 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fd, t); end;
end;
end;
end
else { Sinon, mode diablo }
begin
if bouche < 0 then { bouche < 0 : bouche ouverte }
begin
case dir of { Affiche Pacman en fonction de sa direction }
0 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_ohd, t); end;
1 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_ogd, t); end;
2 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_obd, t); end;
3 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_odd, t); end;
4 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_odd, t); end;
end;
end
else { Sinon bouche ferm‚e }
begin
case dir of { Affiche Pacman en fonction de sa direction }
0 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fhd, t); end;
1 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fgd, t); end;
2 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fbd, t); end;
3 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fdd, t); end;
4 : begin coller_transp(pex - 10, pey + 10, 10, 10, pac_fdd, t); end;
end;
end;
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE affiche_fant“mes PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Dessine les fant“mes "fant" dans le tampon "t" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure affiche_fantomes(tfant : fantomes; t : word);
var
i : integer; { Indice }
fex, fey : integer; { Position physique du fant“me }{5}
begin
for i := 1 to max_fant do { Parcours du tableau de fant“mes }
begin
fex := tfant[i, 4]; { Position physique du fant“me }
fey := tfant[i, 5];
if tfant[i, 9] = 0 then { si le fant“me est vivant ( = 0) }
begin
if tfant[i, 7] < 0 then { Si animation < 0 (bouche ferm‚e) }
begin
case tfant[i, 6] of { Affiche le fant“me, en fonction de sa couleur }
1 : coller_transp(fex - 10, fey + 10, 10, 10, fant_1f, t);
2 : coller_transp(fex - 10, fey + 10, 10, 10, fant_2f, t);
3 : coller_transp(fex - 10, fey + 10, 10, 10, fant_3f, t);
4 : coller_transp(fex - 10, fey + 10, 10, 10, fant_4f, t);
end;
end
else { Sinon, bouche ouverte en fonction de son humeur }
begin
if diablo = 0 then { Si pas mode diablo, le fant“me est agressif }
begin
case tfant[i, 6] of { Affiche le fant“me, en fonction de sa couleur }
1 : coller_transp(fex - 10, fey + 10, 10, 10, fant_1o, t);
2 : coller_transp(fex - 10, fey + 10, 10, 10, fant_2o, t);
3 : coller_transp(fex - 10, fey + 10, 10, 10, fant_3o, t);
4 : coller_transp(fex - 10, fey + 10, 10, 10, fant_4o, t);
end;
end
else { Sinon, il est carr‚ment flipp‚ }
begin
case tfant[i, 6] of { Affiche le fant“me, en fonction de sa couleur }
1 : coller_transp(fex - 10, fey + 10, 10, 10, fant_1p, t);
2 : coller_transp(fex - 10, fey + 10, 10, 10, fant_2p, t);
3 : coller_transp(fex - 10, fey + 10, 10, 10, fant_3p, t);
4 : coller_transp(fex - 10, fey + 10, 10, 10, fant_4p, t);
end;
end;
end;
affiche_portes(fex, fey); { Affiche les portes de prison ‚ventuelles
transparentes par dessus le fant“me }end;
if tfant[i, 9] > 0 then { Si le fant“me a ‚t‚ mang‚ ( > 0 )}
begin
if tfant[i, 7] < 0 { Affiche les yeux }
then coller_transp(fex - 10, fey + 10, 10, 10, zyeux_1, t)
else coller_transp(fex - 10, fey + 10, 10, 10, zyeux_2, t);
affiche_portes(fex, fey);
end;
end; { Et boum la m‚m‚ }
end; { et paf le chien si tu veux bien }
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³FONCTION droite PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Donne la droite de la direction "dir" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }function droite(dir : integer) : integer;
begin
dec(dir); { Diminue "dir" d'un cran }
if dir < 0 then droite := 3 { modulo 4 }
else droite := dir;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³FONCTION gauche PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Donne la gauche de la direction "dir" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
function gauche(dir : integer): integer;
begin
inc(dir); { Augmente "dir" d'un cran }
if dir > 3 then gauche := 0 { modulo 4 }
else gauche := dir;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³FONCTION demi_tour PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Donne la direction oppos‚e … la direction "dir" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }function demi_tour(dir : integer) : integer;
begin
{ Faire un demi tour, c'est tourner 2 fois … droite
(ou 2 fois … gauche, c'est pareil en somme) }
demi_tour := droite(droite(dir));
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE efface_fant“mes PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Efface les fant“mes "fant" dans le tampon "t" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure efface_fantomes(tfant : fantomes);
var
i : integer;begin
for i := 1 to max_fant do { Parcourt le tableau des fant“mes et
efface chaque fant“me tour … tour }efface_perso(tfant[i, 4], tfant[i, 5]);
end;
{6}
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE bouge_fant“mes PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Contr“le le d‚placement des fant“mes "tfant" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure bouge_fantomes(var tfant : fantomes; px, py : integer);
var
directions : array[1..4] of integer; { Directions possibles }
i, j : integer; { Indices }
max_dir : integer; { indice de direction maximal }
d, dir : integer; { Indice de direction, direction }
dst, min_dst : real; { Carr‚ de la distance fant“me <-> cible, et
carr‚ de la plus courte distance }num_fant : integer; { Num‚ro du fant“me vivant }
fx, fy : integer; { Position du fant“me dans le niveau }
begin
num_fant := 0; { Num‚ro fant“me vivant }
for i := 1 to max_fant do { Parcours du tableau de fant“mes }
begin
inc(tfant[i, 7]); { Incr‚mentation du compteur d'animation }
if tfant[i, 7] > 10 then tfant[i, 7] := -10; { s'il d‚passe 10,
on le remet … -10 }
{ Si fant“me est n‚ }
if (tfant[i, 9] >= 0) then
begin
{ Si le fant“me n'est pas libre (8) et que Pacman n'est pas en mode diablo,
on d‚cr‚mente le compteur de lib‚ration (8) }
if (tfant[i, 8] > 0) and (diablo = 0) then dec(tfant[i, 8]);
{ Si le fant“me est pile poil sur une case, il peut changer de direction }
if (tfant[i, 4] mod 10 = 0) and (tfant[i, 5] mod 10 = 0) then
begin
max_dir := 0; { nombre de directions maximum (direction maximale) = 0 }
tfant[i, 1] := tfant[i, 4] div 10; { Position du fant“me dans le niveau }
tfant[i, 2] := tfant[i, 5] div 10; { … partir de la position physique }
fx := tfant[i, 1]; { Position du fant“me dans le niveau }
fy := tfant[i, 2];
{ Si le fant“me peut aller en face }
dir := tfant[i, 3];
{ Si la case en face }
if ( { n'est pas un mur }
( (niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] < 6)
{ ou est une porte de prison et que le fant“me est libre }
or ((niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] = 6) and (tfant[i, 8] = 0))
{ et n'est pas un t‚l‚porteur }
) and (niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] <> 3)
{ Ou si le fant“me a ‚t‚ mang‚ (peut passer … travers les murs) }
) or (tfant[i, 9] = 1)
then
begin
{ On ajoute cette direction au tableau de directions }
inc(max_dir);
directions[max_dir] := dir;
end;
{ Si le fant“me peut aller … droite }
dir := droite(tfant[i, 3]);
{ Si la case … droite }
if ( { n'est pas un mur }
( (niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] < 6)
{ ou est une porte de prison et que le fant“me est libre }
or ((niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] = 6) and (tfant[i, 8] = 0))
{ et n'est pas un t‚l‚porteur }
) and (niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] <> 3)
{ Ou si le fant“me a ‚t‚ mang‚ (peut passer … travers les murs) }
) or (tfant[i, 9] = 1)
then
begin
{ On ajoute cette direction au tableau de directions }
inc(max_dir);
directions[max_dir] := dir;
end;
{ Si le fant“me peut aller … gauche }
dir := gauche(tfant[i, 3]);
{ Si la case … gauche }
if ( { n'est pas un mur }
( (niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] < 6)
{ ou est une porte de prison et que le fant“me est libre }
or ((niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] = 6) and (tfant[i, 8] = 0))
{ et n'est pas un t‚l‚porteur }
) and (niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] <> 3)
{ Ou si le fant“me a ‚t‚ mang‚ (peut passer … travers les murs) }
) or (tfant[i, 9] = 1)
then
begin
{ On ajoute cette direction au tableau de directions }
inc(max_dir);
directions[max_dir] := dir;
end;
{ Si impasse (aucune direction possible),
ou que Pacman vient de prendre une capsule d'‚nergie, demi-tour ! } if (max_dir = 0) or (diablo >= 480) or (tfant[i, 9] = 1 )then
begin
dir := demi_tour(tfant[i, 3]);
{ Si la case derriŠre }
if ( { n'est pas un mur }
( (niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] < 6)
{ ou est une porte de prison et que le fant“me est libre }
or ((niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] = 6) and (tfant[i, 8] = 0))
{ et n'est pas un t‚l‚porteur }
) and (niv[fx + tdir[dir, 1], fy + tdir[dir, 2]] <> 3)
{ Ou si le fant“me a ‚t‚ mang‚ (peut passer … travers les murs) }
) or (tfant[i, 9] = 1)
then
begin
{ On ajoute cette direction au tableau de directions }
inc(max_dir);
directions[max_dir] := dir;
end;
end;
{ Si aucune direction possible (fant“me bloqu‚ entre 4 murs) }
if (max_dir = 0) then
begin
{ On ajoute la direction nulle (4) }
inc(max_dir);
directions[max_dir] := 4;
end;
{ Carr‚ de la distance minimum par d‚faut :
celui de la diagonale du niveau (Phytagore, 33ý + 19ý) }
min_dst := 1089 + 361;
d := 1; { indice de la distance choisie par d‚faut : la premiŠre qui vient }
for j := 1 to max_dir do { Parcours du tableau de directions possibles }
begin
if tfant[i, 9] = 0 { Si pas mang‚ }
{ calcul du carr‚ de la distance fant“me <-> Pacman }
then dst := sqr(fx + tdir[directions[j], 1] - px)
+ sqr(fy + tdir[directions[j], 2] - py)
{ calcul du carr‚ de la distance fant“me <-> point de d‚part fant“me }
else dst := sqr(fx + tdir[directions[j], 1] - tfant[i, 10])
+ sqr(fy + tdir[directions[j], 2] - tfant[i, 11]);
{ Si le r‚sultat trouv‚ est plus petit que le minimum d‚j… trouv‚ }
if (diablo > 0) and (tfant[i, 9] = 0) then dst := -dst;
if dst < min_dst then
begin
{ "min_dst", l'ancien minimum devient le nouveau }
min_dst := dst;
d := j; { Indice de la direction la plus courte : j }
end;
end;
dir := directions[d]; { "dir" : valeur de la direction trouv‚e }
tfant[i, 3] := dir; { que le fant“me prend }
end;
dir := tfant[i, 3]; { "dir" : direction du fant“me }
{ Le fant“me avance d'un pixel … l'‚cran vers la direction choisie }
tfant[i, 4] := tfant[i, 4] + tdir[dir, 1];
tfant[i, 5] := tfant[i, 5] + tdir[dir, 2];
{ Si fant“me mang‚ }
if tfant[i, 9] = 1 then
{ Si le fant“me est sur sa case de d‚part }
if (tfant[i, 4] div 10 = tfant[i, 10]) and (tfant[i, 5] div 10 = tfant[i, 11]) then
begin
{ il r‚apparait ! }
tfant[i, 9] := 0;
{ mais est emprisonn‚ pour 30 + 305 * num_fant images }
tfant[i, 8] := 30 + 305 * num_fant;
end;
inc(num_fant); { Fant“me suivant }
end
else { Sinon, le fant“me n'est pas encore n‚ (tfant[i, 9] < 0) }
inc(tfant[i, 9]); { Incr‚mentation du compteur de vie }
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³PROCEDURE jouer_niveau PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Proc‚dure principale du jeu : joue une vie dans ³
³ un niveau. ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }{7}
procedure jouer_niveau;
var
blinkdir : integer; { "Direction" de la variation de la oculeur
des pastilles et des portes }i, j : integer; { indices }
px, py : integer; { Position de Pacman dans le niveau }
pex, pey : integer; { Position de Pacman sur l'‚cran }
dir : byte; { Direction de Pacman }
th, tg, tb, td : boolean; { Touches haut, gauche, bas, droite press‚es }
begin
{ Position de d‚part de Pacman }
px := depart_x;
py := depart_y;
{ Position physique de d‚part de Pacman }
pex := px * 10;
pey := py * 10;
fps := 0; { Initialisation du nombre d'images / seconde }
{ Aucune touche de direction }
th := false; tg := false; tb := false; td := false;
dir := 4; { Direction par d‚faut : 4 (fixe) }
diablo := 0; { Mode diablo d‚sactiv‚ }
mort := false; { Pas mort (pas d‚j… !) }
quitte := false; { Ne quitte pas }
p1[77] := 0; { Colorisation des valeurs de gris }
p1[137] := 0; { utilis‚es par les portes et les capsules }
p1[149] := 0; { d'‚nergie en jaune, en mettant les quantit‚s }
p1[200] := 0; { de bleu … 0 dans la palette de base "p1" }
p1[206] := 0;
p2 := p1; { Palette "p2" (actuelle) prend les valeurs de "p1"
(palette de base) }
{ Affiche Pacman … son point de d‚part }
affiche_pacman(pex, pey, dir, $A000);
{ Affiche le score }
affiche_score;
fondu_ouverture(p2); { Fondu ouverture }
bouche := -20; { Initialisation animation bouche }
blink := 64; { valeur de la variation de couleur des pastilles et des portes }
blinkdir := 8; { "Direction" (augmentation / diminution) de la quantit‚ de vert
de la couleur des pastilles et des portes }
texte_xy('PRET ?', 125, 100, $A000, false); { Affiche le message "PRET ?" }
while keypressed do readkey; { Vide le tampon clavier }
readkey; { Attente d'une touche press‚e }
gettime(hr, min, dsec, sec100); { Initialisation des secondes }
retrace; { Attente du top de synchro }
refresh; { Affichage du tampon vid‚o (pour effacer le message) }
getintvec($9, @ancien_int); { Sauvegarde de l'ancien gestionnaire clavier }
repeat
p2[76] := (p1[76] * blink) div 64; { Variation de la valeur de vert }
p2[136] := (p1[136] * blink) div 64; { des couleurs de la palette utilis‚es }
p2[148] := (p1[148] * blink) div 64; { par les portes et les capsules d'‚nergie }
p2[199] := (p1[199] * blink) div 64;
p2[205] := (p1[205] * blink) div 64;
nosound; { Arrˆte un ‚ventuel son }
retrace; { Attente du top de synchro }
changer_palette(p2); { Application des nouvelles valeurs de couleurs "p2" }
{ Si la quantit‚ de vert devient limite, on inverse la direction de variation }
if (blink < 8) or (blink > 56) then
blinkdir := - blinkdir;
blink := blink + blinkdir; { Variation du vert... }
if not(th or tg or tb or td) then
begin
setintvec($9, @ancien_int); { R‚installation de l'ancien gestionnaire clavier
pour ‚viter que le tableau "touches" ne soit modifi‚ }
th := touches[0] = 1;
tg := touches[1] = 1;
tb := touches[2] = 1;
td := touches[3] = 1;
getintvec($9, @ancien_int); { Sauvegarde de l'ancien gestionnaire clavier }
setintvec($9, @nouveau_int); { Installation du nouveau gestionnaire clavier }
end;
{ Calcul de la position de Pacman dans le niveau … partir de sa position physique }
px := pex div 10;
py := pey div 10;
efface_perso(pex, pey); { Efface Pacman }
efface_fantomes(tfantomes); { et les fant“mes }
bouge_fantomes(tfantomes, px, py); { D‚place les fant“mes }
{ Si Pacman est sur une case et une seule }
if ((pex mod 10) = 0) and ((pey mod 10) = 0) then
begin
{ Si la case est une pastille }
if niv[px, py] = 1 then
begin
niv[px, py] := 0; { On l'enlŠve, il l'a mang‚e }
dec(boules); { Il reste une boule en moins }
if bruit then sound(440); { Petit bruit }
score := score + 10; { Ca fait 10 points de plus }
end;
{ Si la case est une capsule d'‚nergie }
if niv[px, py] = 2 then
begin
niv[px, py] := 0; { On l'enlŠve, il l'a mang‚e }
diablo := 500; { Mode diablo pendant 500 images }
{ "nega" : palette n‚gatif de la palette en cours "p2" }
for i := 0 to 767 do nega[i] := 255 - p2[i];
affiche_pacman(pex, pey, dir, $A000); { Affiche pacman }
affiche_fantomes(tfantomes, $A000); { Affiche les fant“mes }
{ Eclair stroboscopique + gros son de la mort qui tue }
for i := 1 to 10 do
begin
retrace; { Top de synchro }
changer_palette(nega); { Met l'‚cran en n‚gatif }
for j := 1 to 10 do { Fait un premier son }
begin
if bruit then sound(i * j * 100 + 500);
delay(2);
nosound;
delay(1);
if keypressed then readkey; { Evite les bipbipbipbip quand on s'‚nerve sur le clavier }
end;
retrace; { Top de synchro }
changer_palette(p2); { Remet l'‚cran en positif }
for j := 10 downto 1 do { Fait un deuxiŠme son }
begin
if bruit then sound(i * j * 100 + 500);
delay(2);
nosound;
delay(1);
if keypressed then readkey; { Evite les bipbipbipbip quand on s'‚nerve sur le clavier }
end;
end;
end;
{ Si la case est un t‚l‚porteur }
if niv[px, py] = 3 then
begin
repeat { R‚p‚ter }
px := px + tdir[dir, 1]; { Avance Pacman de case en case }
py := py + tdir[dir, 2]; { Dans sa direction }
if px > 34 then px := 1; { s'il sort du niveau, on le ramŠne }
if px < 0 then px := 34;{ au bord oppos‚ }
if py > 18 then py := 0; { zoup l… ! }
if py < 0 then py := 18;
until niv[px, py] = 3; { Jusqu'au prochain t‚l‚porteur ou le mˆme }
pex := 10 * px; { Calcul des nouvelles coordonn‚es physiques }
pey := 10 * py;
end
else { Si ce n'est pas un t‚l‚porteur }
begin
{ changement de direction en fonction des touches de direction et des murs }if th and (niv[px , py - 1] < 6) then dir := 0;
if tg and (niv[px - 1, py ] < 6) then dir := 1;
if tb and (niv[px , py + 1] < 6) then dir := 2;
if td and (niv[px + 1, py ] < 6) then dir := 3;
end;
{ Si Pacman ne fonce pas dans un mur }
if niv[px + tdir[dir, 1], py + tdir[dir, 2]] < 6 then
begin
pex := pex + tdir[dir, 1]; { On le fait avancer d'un pixel dans }
pey := pey + tdir[dir, 2]; { la direction voulue }
end;
th := false; tg := false; tb := false; td := false;
end
else { Sinon, Pacman est entre 2 cases }
begin
pex := pex + tdir[dir, 1]; { il peut avancer librement d'un pixel }
pey := pey + tdir[dir, 2]; { dans la direction voulue }
end;
if diablo > 0 then dec(diablo); { Si en mode diablo, on d‚cr‚mente
le compteur diablo }inc(bouche); { Incr‚mentation du compteur d'animation de la bouche }
if bouche > 20 then bouche := -20; { Si limite sup atteinte, remise …
la limite inf }
affiche_fantomes(tfantomes, $A000); { Affiche les fant“mes }
affiche_pacman(pex, pey, dir, $A000); { Et notre ami Pacman }
{ EmpŠche que le score d‚passe 999990 points (sinon, d‚bordement de
l'affichage) }
if score > 999990 then score := 999990;
{ Si la diff‚rence du nouveau et de l'ancien score est sup‚rieure …
50000 points }
if score >= score2 + 50000 then
begin
score2 := score2 + 50000; { On ajoute 50000 … l'ancien score }
inc(vies); { Et une vie ! }
if vies > 13 then vies := 13; { Sauf s'il y en a 13 (le maxi) }
affiche_score; { Affiche le score et les vies }
{ Et ‚met un petit son rigolo }
for i := 100 to 500 do begin if bruit then sound(i * 5); delay(1); end; nosound;
end
else { Sinon }
affiche_score; { Affiche le score et les vies }
{ Contr“le des contacts fant“mes <-> Pacman }
for i := 1 to max_fant do { Parcours du tableau des fant“mes }
begin { Si le fant“me est vivant et "touche" Pacman }
if (pex < tfantomes[i, 4] + 6) and (pex > tfantomes[i, 4] - 6)
and (pey < tfantomes[i, 5] + 6) and (pey > tfantomes[i, 5] - 6)
and (tfantomes[i, 9] = 0) then
begin
if diablo > 0 then { Si Pacman est en mode diablo }
begin
tfantomes[i, 9] := 1; { Le fant“me est mort ( > 0) }
{ Petit bruitage }
for j := 50 downto 10 do
begin
if bruit then sound(j * 20);
delay(1);
end;
{ et 5000 points de plus ! }
score := score + 5000;
nosound { ta gueule ! }
end
else { Sinon }
mort := true; { Pacman est mort }
end;
end;
if mort then { Et si Pacman est mort }
begin
dec(vies); { Une vie en moins }
affiche_score; { Affiche le score avec la vie en moins }
for j := 500 downto 100 do { Ca fait un bruit }
begin
if bruit then sound(j * 5);
delay(1);
end;
end;
if showfps and nouvsec then texte_xy(inttostr(fps) + ' FPS ', 0, 190, $A000, false);
{ Si touche press‚e }
if keypressed then
case readkey of
{ Echap : quitter }
#27 : quitte := true;
{ F : afficher ou cacher le compteur d'images / seconde }
'F', 'f' : begin
showfps := not(showfps);
if not(showfps) then
begin
for i := 0 to 6 do coller(i * 10, 190, 10, 10, vide, $A000);
end;
end;
end;
{ Reboucle jusqu'… ce que l'on quitte, que Pacman est mort ou qu'il
ne reste plus de pastilles … manger }
until quitte or (boules = 0) or mort;
nosound; { La ferme, y'a des gens qui bossent ici ! }
fondu_fermeture(p2); { Fondu fermeture }
setintvec($9, @ancien_int); { R‚installlation de l'ancien gestionnaire clavier }
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³FUNCTION saisie_chaine_xy PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Saisit une chaŒne de caractŠres aux coordonn‚es ³
³ "x, y" de longueur maxi "longmax" ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
function saisie_chaine_xy(x, y : integer; longmax : integer) : string;
var
ch : string; { ChaŒne saisie }
k : char; { CaractŠre de la touche }
s : boolean; { Vrai si touche sp‚ciale }
t : boolean; { Vrai si la saisie est termin‚e }
ck : byte; { Code ASCII de la touche }
lc : integer; { Position du curseur d'‚dition }
i : integer; { Indice }
begin
ch := ''; { ChaŒne finale initialement vide }
t := false; { Termin‚ : faux }
lc := 0; { Longueur de la chaŒne = 0 }
while not(t) do { Tant qu'on n'a pas termin‚ }
begin
{ Affiche le curseur }
coller_transp(lc * 10 + x, y , 10, 10, police_1[3700], $A000);
k := readkey; { "k" valeur de la touche press‚e }
s := keypressed; { "s" vrai si un deuxiŠme signal de touche re‡u = touche sp‚ciale }
if s then k := readkey; { Il s'agit alors d'une touche sp‚ciale, lecture de "k" }
ck := ord(k); { ck : code ASCII de la touche }
coller(lc * 10 + x, y , 10, 10, vide, $A000);
if not(s) then { Si ce n'est pas une touche sp‚ciale }
begin
{ Si lettre majuscule et qu'il reste de la place }
if (k <= 'Z') and (k >= 'A') and (lc < longmax) then
begin
inc(lc); { Incr‚mentation de la longueur de la chaŒne }
ch := ch + k; { On ajoute la lettre tap‚e }
{ Affiche la lettre tap‚e }
coller_transp((lc - 1) * 10 + x, y , 10, 10, police_1[(ck - ord('A')) * 100], $A000);
end;
{ Si lettre minuscule et qu'il reste de la place }
if (k <= 'z') and (k >= 'a') and (lc < longmax) then
begin
inc(lc); { Incr‚mentation de la longueur de la chaŒne }
{ On ajoute la lettre tap‚e mise en majuscule }
ch := ch + chr(ord(k) - ord('a') + ord('A'));
{ Affiche la lettre tap‚e }
coller_transp((lc - 1) * 10 + x, y , 10, 10, police_1[(ck - ord('a')) * 100], $A000);
end;
{ Si espace }
if (k = ' ') and (lc < longmax) then
begin
inc(lc); { Incr‚mentation de la longueur de la chaŒne }
ch := ch + k; { On y ajoute l'espace }
{ Affichage d'un blanc }
coller_transp((lc - 1) * 10 + x, y , 10, 10, police_1[2600], $A000);
end;
{ Si retour arriŠre et qu'il y a des caractŠres … effacer }
if (ck = 8) and (lc > 0) then
begin
{ Efface le dernier caractŠre de la chaŒne }
delete(ch, length(ch), 1);
{ Efface le caractŠre … l'‚cran }
coller((lc - 1) * 10 + x, y , 10, 10, vide, $A000);
dec(lc); { D‚cr‚mentation de la longueur de la chaŒne }
end;
if ck = 13 then t := true; { Si "Entr‚e", fin de la saisie }
end;
end;
saisie_chaine_xy := ch; { On retourne la chaŒne saisie }
end;{8}
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE ajoute_meilleurs_scores PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Affiche les meilleurs scores … partie du fichier ³ ³ d'extension ".sco" . ³ ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }
procedure ajoute_meilleurs_scores;
type
t_score = record
nom : string; { Nom du joueur }
score : longint; { Son score }
end;
var
F : text; { Fichier texte de scores }
i, j : integer; { Indices }
nom : string; { Nom du joueur }
sc : longint; { Score lu dans le fichier }
sc_min : longint; { Score minimum }
sc_max : longint; { Score maximum }
i_max : integer; { position du score maxi dans le tableau }
car : char; { CaractŠre lu dans le fichier }
scores : array[1..11] of t_score; { Tableau des scores }
begin
assign(F, nom_fic_niv + '.sco');{ Ouverture du fichier texte F }
{$I-} { des scores }
reset(F);
{$I+}
if (IOResult = 0) then { Si ouverture sans problŠmes }
begin
sc_min := 999990; { Score le plus faible : le maxi ! }
for i := 1 to 10 do { Lecture du fichier }
begin
{ Lecture du nom }
nom := '';
read(F, car);
{ Lit le caractŠre TQ ce n'est pas un : }
while (car <> ':') do
begin
nom := nom + car; { Et l'ajoute au nom }
read(F, car);
end;
{ Lit ensuite le score du joueur }
readln(F, sc);
{ Si c'est le score le plus faible du fichier }
{ le score mini prend la valeur du score du joueur }
if sc < sc_min then sc_min := sc;
{ Balance le score et le nom dans le tableau des scores }
scores[i].nom := nom;
scores[i].score := sc;
end;
close(F); { Ferme le fichier }
{ Si le score actuel "score" est sup‚rieur au plus petit
score du fichier, on a un nouveau meilleur score }
end
else { Si le fichier des scores n'existe pas }
begin
{ Cr‚ation d'une liste de scores vierge }
for i := 1 to 10 do
begin
scores[i].nom := '';
scores[i].score := 0;
end;
sc_min := 0; { Le score minimum est alors 0 }
end;
if score > sc_min thenbegin
efface($A000); { Efface l'‚cran }
{ Charge la palette par d‚faut }
charger_palette('palette.pcx', p1);
{ Applique la pelette "noir" }
changer_palette(noir);
{ Dessine l'encadr‚ }
for i := 9 to 23 do
begin
coller(i * 10, 105, 10, 10, mur_gd, $A000);
coller(i * 10, 125, 10, 10, mur_gd, $A000);
end;
coller( 80, 105, 10, 10, mur_bd, $A000);
coller(240, 105, 10, 10, mur_gb, $A000);
coller( 80, 125, 10, 10, mur_hd, $A000);
coller(240, 125, 10, 10, mur_hg, $A000);
coller( 80, 115, 10, 10, mur_hb, $A000);
coller(240, 115, 10, 10, mur_hb, $A000);
texte_xy('NOUVEAU MEILLEUR SCORE !', 35, 85, $A000, true);
fondu_ouverture(p1); { Fondu ouverture }
{ Saisie du nom du joueur et ajout … la liste }
scores[11].nom := saisie_chaine_xy(90, 115, 14);
scores[11].score := score; { Ainsi que le score }
fondu_fermeture(p1); { Fondu fermeture }
rewrite(F); { R‚ecriture (‚crasement) de F }
for j := 1 to 10 do { Ecriture des 10 meilleurs scores (parmi les 11) }
begin
sc_max := 0; { Score maxi }
i_max := 1; { Position du score maxi }
{ Recherche du score maximal, et de sa position }
for i := 1 to 11 do
begin
if scores[i].score > sc_max then
begin
i_max := i;
sc_max := scores[i].score;
end;
end;
{ Ecrit le plus haut score dans le fichier }
writeln(F, scores[i_max].nom, ':', inttostr(scores[i_max].score));
{ Et on l'efface dans la liste maintenant qu'on n'en n'a plus besoin }
scores[i_max].score := 0;
scores[i_max].nom := '';
end; { On recommence }
close(F); { Et on ferme F pour sauvegarder }
end;
end;
{ ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿³PROCEDURE affiche_meilleurs_scores PASCAL³
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
³R“le : Affiche les meilleurs scores … partie du fichier ³³ "scores.dat". ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ }procedure affiche_meilleurs_scores;
var
F : text; { Fichier texte de scores }
i, j : integer; { Indices }
sc : string; { Score lu dans le fichier }
nom : string; { Nom du joueur }
car : char; { CaractŠre lu dans le fichier }
{9}
begin
assign(F, nom_fic_niv + '.sco'); { Ouverture du fichier texte F des scores }
{$I-}
reset(F);
{$I+}
if (IOResult = 0) then { Si ouverture sans encombres }
begin
efface($A000); { Efface l'‚cran }
{ Chargement palette par d‚faut }
charger_palette('palette.pcx', p1);
{ On applique la pelette "noir" }
changer_palette(noir);
{ Dessine le tableau des scores }
for i := 6 to 26 do
begin
coller(i * 10, 10, 10, 10, mur_gd, $A000);
coller(i * 10, 180, 10, 10, mur_gd, $A000);
end;
for i := 2 to 17 do
begin
coller( 50, i * 10, 10, 10, mur_hb, $A000);
coller(270, i * 10, 10, 10, mur_hb, $A000);
end;
coller( 50, 10, 10, 10, mur_bd, $A000);
coller( 50, 180, 10, 10, mur_hd, $A000);
coller(270, 10, 10, 10, mur_gb, $A000);
coller(270, 180, 10, 10, mur_hg, $A000);
texte_xy('MEILLEURS SCORES', 80, 30, $A000, true);
{ Affiche le nom de chaque joueur et son score }
for i := 1 to 10 do
begin
{ Lecture du nom du joueur }
nom := '';
read(F, car);
while (car <> ':') do
begin
nom := nom + car;
read(F, car);
end;
{ Lecture de son score }
readln(F, sc);
{ Affichage des 2 }
texte_xy(nom, 60, i * 10 + 50, $A000, true);
texte_xy(sc, 270 - (10 * length(sc)), i * 10 + 50, $A000, true);
end;
close(F); { Fermeture du fichier }
fondu_ouverture(p1); { Fondu ouverture }
readkey; { Attente d'une touche press‚e }
fondu_fermeture(p1); { Fondu fermeture }
end;
end;
{ ÛßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßÛÛ Programme Principal Û
ÛÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÛ }var
i : integer; { Indice }
anim : integer; { Num‚ro de l'image de l'animation }
tx, ty : word; { Tailles d'images }
para1, para2 : string; { ParamŠtres de lancement du jeu }
begin
nom_fic_niv := 'pacman';{ Nom fichier niveau par d‚faut }
bruit := true; { Son activ‚ par d‚faut }
{ On n'affiche pas le nombre d'images / seconde }
showfps := false;
{ Un paramŠtre }
if Paramcount = 1 then
begin
{ S'il s'agit de la d‚sactivation du son, on le d‚sactive }
if paramstr(1) = '/nosound' then bruit := false{ Sinon, c'est un nom de fichier de niveaux }
else nom_fic_niv := paramstr(1);
end;
{ 2 paramŠtres au moins }
if Paramcount >= 2 then
begin
{ Le nom du fichier niveaux est le premier paramŠtre }
nom_fic_niv := paramstr(1);
{ la d‚sactivation du son est le second }
if (paramstr(2) = '/nosound') then bruit := false;
end;
{ Si le fichier niveaux existe }
if existe(nom_fic_niv + '.niv') then
begin
{ Attribution de l'espace m‚moire pour le tampon vid‚o ( 64 Ko) }
getmem(buf, 64000);
buf_adr := seg(buf^);
{ Passe en mode 320 * 200 * 8 bits }
mode_320_200_256;
{ Initiailisation des touches de direction, et recherche du segment
et de l'offset du tableau "touches }
valeur := 0;
touches[0] := 0 ; touches[1] := 0 ; touches[2] := 0 ; touches[3] := 0;
a_touches := ofs(touches);
s_touches := seg(touches);
{ Chargement des graphismes }
efface($A000); { Efface l'‚cran }
{ Chargement de la palette de la police de caractŠres }
charger_palette('police_1.pcx', p1);
changer_palette(p1);
{ Chargement de la police de caractŠres }
charger_PCX('police_1.pcx' , police_1 , tx, ty);
{ Affiche le message 'CHARGEMENT' }
texte_xy('CHARGEMENT', 105, 95, $A000, true);
{ Pacman }
charger_PCX('pac_oh.pcx' , pac_oh , tx, ty);
charger_PCX('pac_fh.pcx' , pac_fh , tx, ty);
charger_PCX('pac_og.pcx' , pac_og , tx, ty);
charger_PCX('pac_fg.pcx' , pac_fg , tx, ty);
charger_PCX('pac_ob.pcx' , pac_ob , tx, ty);
charger_PCX('pac_fb.pcx' , pac_fb , tx, ty);
charger_PCX('pac_od.pcx' , pac_od , tx, ty);
charger_PCX('pac_fd.pcx' , pac_fd , tx, ty);
{ Pacman diablo }
charger_PCX('pac_ohd.pcx' , pac_ohd , tx, ty);
charger_PCX('pac_fhd.pcx' , pac_fhd , tx, ty);
charger_PCX('pac_ogd.pcx' , pac_ogd , tx, ty);
charger_PCX('pac_fgd.pcx' , pac_fgd , tx, ty);
charger_PCX('pac_obd.pcx' , pac_obd , tx, ty);
charger_PCX('pac_fbd.pcx' , pac_fbd , tx, ty);
charger_PCX('pac_odd.pcx' , pac_odd , tx, ty);
charger_PCX('pac_fdd.pcx' , pac_fdd , tx, ty);
{ Fant“me orange }
charger_PCX('fant_1o.pcx' , fant_1o , tx, ty);
charger_PCX('fant_1f.pcx' , fant_1f , tx, ty);
charger_PCX('fant_1p.pcx' , fant_1p , tx, ty);
{ Fant“me rouge }
charger_PCX('fant_2o.pcx' , fant_2o , tx, ty);
charger_PCX('fant_2f.pcx' , fant_2f , tx, ty);
charger_PCX('fant_2p.pcx' , fant_2p , tx, ty);
{ Fant“me vert }
charger_PCX('fant_3o.pcx' , fant_3o , tx, ty);
charger_PCX('fant_3f.pcx' , fant_3f , tx, ty);
charger_PCX('fant_3p.pcx' , fant_3p , tx, ty);
{ Fant“me bleu }
charger_PCX('fant_4o.pcx' , fant_4o , tx, ty);
charger_PCX('fant_4f.pcx' , fant_4f , tx, ty);
charger_PCX('fant_4p.pcx' , fant_4p , tx, ty);
{ Yeux }
charger_PCX('zyeux_1.pcx' , zyeux_1 , tx, ty);
charger_PCX('zyeux_2.pcx' , zyeux_2 , tx, ty);
{ Capsule d'‚nergie }
charger_PCX('energie.pcx' , energie , tx, ty);
{ Pastille }
charger_PCX('pastille.pcx' , pastille , tx, ty);
{ Murs }
charger_PCX('mur_.pcx' , mur_ , tx, ty);
charger_PCX('mur_h.pcx' , mur_h , tx, ty);
charger_PCX('mur_b.pcx' , mur_b , tx, ty);
charger_PCX('mur_g.pcx' , mur_g , tx, ty);
charger_PCX('mur_d.pcx' , mur_d , tx, ty);
charger_PCX('mur_gd.pcx' , mur_gd , tx, ty);
charger_PCX('mur_hb.pcx' , mur_hb , tx, ty);
charger_PCX('mur_hd.pcx' , mur_hd , tx, ty);
charger_PCX('mur_gb.pcx' , mur_gb , tx, ty);
charger_PCX('mur_bd.pcx' , mur_bd , tx, ty);
charger_PCX('mur_hg.pcx' , mur_hg , tx, ty);
charger_PCX('mur_gbd.pcx' , mur_gbd , tx, ty);
charger_PCX('mur_hgd.pcx' , mur_hgd , tx, ty);
charger_PCX('mur_hgb.pcx' , mur_hgb , tx, ty);
charger_PCX('mur_hbd.pcx' , mur_hbd , tx, ty);
charger_PCX('mur_hgbd.pcx' , mur_hgbd , tx, ty);
{ Porte prison opaque }
charger_PCX('porte_gd.pcx' , porte_gd , tx, ty);
charger_PCX('porte_hb.pcx' , porte_hb , tx, ty);
{ Porte prison transparente }
charger_PCX('portetgd.pcx' , portet_gd , tx, ty);
charger_PCX('portethb.pcx' , portet_hb , tx, ty);
{ Vide }
charger_PCX('rien.pcx' , vide , tx, ty);
{ Chiffres du score }
charger_PCX('chiffres.pcx' , chiffres , tx, ty);
{ le mot "SCORE" }
charger_PCX('score.pcx' , score_img, tx, ty);
{ Coeur }
charger_PCX('coeur.pcx' , coeur , tx, ty);
{ Image de titre }
charger_PCX('pactitre.pcx' , buf^ , tx, ty);
charger_palette('pactitre.pcx', p1);
{ Affiche l'image de titre avec fondus }
for i := 0 to 767 do noir[i] := 0; { Cr‚ation d'une palette noire }
changer_palette(noir);
refresh;
fondu_ouverture(p1);
readkey;
fondu_fermeture(p1);
efface($A000);
charger_palette('palette.pcx', p1);
efface(buf_adr);
max_fant := 0; { 0 fant“mes }
num_niv := 0; { Niveau en cours : 0 (y'en n'a pas) }
score := 0; { Score actuel }
score2 := 0; { Score initial }
vies := 3; { 3 vies pour commencer }
repeat
inc(num_niv); { Niveau en cours : le pr‚c‚dent + 1 }
{ Charge le niveau "niv" de titre "titre_niv" dans le fichier
de niveaux "nom_fic_niv" }
charger_niveau(nom_fic_niv + '.niv', num_niv, niv, max_niv, titre_niv);
if (max_niv > 0) then { Si il y a des niveaux dans le fichier }
begin
repeat
{ Efface l'‚cran et affiche le num‚ro et le titre du niveau }
efface($A000);
texte_xy('NIVEAU ' + inttostr(num_niv), 120, 80, $A000, true);
texte_xy(titre_niv, (320 - (length(titre_niv) * 10)) div 2 , 110, $A000, true);
fondu_ouverture(p1);
readkey; { Attend une touche }
fondu_fermeture(p1); { Fondu fermeture }
efface($A000); { Efface l'‚cran }
efface(buf_adr); { et le tampon vid‚o }
changer_palette(noir); { Applique la palette "noir" }
init_niveau(niv); { Dessine le niveau et initialise les personnages }
refresh; { Affiche le tampon vid‚o contenant le niveau }
jouer_niveau; { Lancement de la proc‚dure de jeu ! }
{ Jusqu'… ce que toutes les pastilles soient mang‚es, ou que toutes
les vies ont ‚t‚ perdues ou que le joueur quitte le jeu }
until (vies = 0) or quitte or (boules = 0);
{ Si toutes les pastille ont ‚t‚ mang‚es, le niveau est gagn‚ }
if boules = 0 then
begin
{ Animation "Niveau Termin‚" : Pacman se la pŠte grave }
efface($A000);
charger_palette('lunettes.pcx', p1);
charger_PCX('termine.pcx' , temp_img, tx, ty);
coller(92 , 70, 136, 10, temp_img, $A000);
charger_PCX('lunettes.pcx' , temp_img, tx, ty);
coller(135, 100, 50, 50, temp_img[0], $A000);
fondu_ouverture(p1);
anim := 0;
repeat
retrace;
coller(135, 100, 50, 50, temp_img[2500 * anim], $A000);
delay(300);
inc(anim);
if anim = 5 then anim := 3;
until keypressed;
fondu_fermeture(p1);
efface($A000);
charger_palette('palette.pcx', p1);
end;
end
else { Sinon, il n'y a aucun niveau }
quitte := true; { On quitte le jeu, puisqu'il n'y a rien … jouer ! }
until (num_niv = max_niv) or quitte or (vies = 0);
if not(quitte) then { Si on ne quitte pas }
begin
efface($A000); { On efface l'‚cran }
if vies = 0 then { Si toutes les vies ont ‚t‚ perdues : Game Over }
begin
{ Animation "Game Over" + Pacman qui a bobo … la cabeza }
efface($A000);
charger_palette('bobo.pcx', p1);
charger_PCX('gameover.pcx' , temp_img, tx, ty);
coller(112, 70, 96, 10, temp_img, $A000);
charger_PCX('bobo.pcx' , temp_img, tx, ty);
coller(135, 100, 50, 50, temp_img[0], $A000);
fondu_ouverture(p1);
anim := 0;
repeat
retrace;
coller(135, 100, 50, 50, temp_img[2500 * anim], $A000);
delay(300);
inc(anim);
if anim = 2 then anim := 0;
until keypressed;
end;
{ Si le dernier niveau … ‚t‚ termin‚ }
if (num_niv = max_niv) and (boules = 0) then
begin
{ Affiche le message "YOU WIN" et le score }
texte_xy('YOU WIN !', 115, 80, $A000, true);
texte_xy('SCORE', 100 , 110, $A000, true);
texte_xy(inttostr(score), 170 , 110, $A000, true);
fondu_ouverture(p1);
{ Pendant ce temps l…, on charge l'animation de fin }
charger_PCX('banc.pcx' , buf^ ,tx, ty);
charger_PCX('kiss.pcx' , temp_img , tx, ty);
readkey;
fondu_fermeture(p1);
{ Affiche l'image de fin }
efface($A000);
refresh; { Attente touche press‚e }
charger_palette('banc.pcx', p1);
fondu_ouverture(p1);
delay(2000);
{ Animation du bisou 'smak !' }
for anim := 0 to 3 do
begin
retrace;
coller(106, 55, 110, 78, temp_img[anim * 8580], $A000);
delay(600);
end;
{ Animation texte 'Fin' }
charger_PCX('fin.pcx' , temp_img , tx, ty);
delay(1400);
for anim := 0 to 2 do
begin
retrace;
coller(138, 164, 54, 21, temp_img[anim * 1134], $A000);
delay(300);
end;
readkey; { Attente touche press‚e }
end;
fondu_fermeture(p1); { Fondu fermeture }
efface($A000); { Efface l'‚cran }
charger_palette('palette.pcx', p1); { Palette par d‚faut }
ajoute_meilleurs_scores; { Ajoute le score aux meilleur scores
(s'il est aussi bon que ‡a) }
affiche_meilleurs_scores; { Affiche les meilleurs scores }
end;
textmode(C80); { Restaure le mode texte 80 colonnes }
end
else { Sinon, fichier niveaux non trouv‚ }
begin
{ Message d'erreur }
textcolor(12);
write('ERREUR');
textcolor(7);
write(' : Le fichier niveau ');
textcolor(15);
write(nom_fic_niv);
textcolor(7);
writeln(' n''a pu ˆtre ouvert ! ');
son_erreur; { Et petit son ! }
end;
end.