Ver. 1.0 Beta, Nie masz kompilatora? Teraz możesz pisać skrypty ONLINE! Wersja podstawowa -nie zawiera wszystkich poleceń Pascala. Służy do nauki podstaw

Pascal

Mario Bros -kod źródłowy -source code


Postanowiłem zamieścić kod źródłowy gry Mario Bros. Chyba nigdzie w sieci czegoś takiego nie znajdziesz. Powodzenia w nauce!



Program został napisany w Delphi5 z dodatkiem DelphiX



unit Unit1;


    //*************************************************************************
    //
    //                     ORYGINALNY KOD ŹRÓDŁOWY GRY MARIODX
    //
    //                     AUTORZY: KAMIL SKOCZYLAS
    //                              kamilskoczylas@o2.pl
    //                              STANISLAW KOGUT
    //                              staszekpso@wp.pl
    //
    //*************************************************************************




//  Krótka historia :)
{

  02.02 - Program ma ponad 3600 linii- zakładam ten pamiętnik jako motywację
          do działania. Tak naprawdę sam już nie wiem co do czego tu służy
          mam nadzieję, że niedługo wprowadzę poprawki i oczyszczę kod...

  09.03 - Tyle czasu minęło! Nic do tej pory nie zrobiłem, może dzisiaj wezmę
          się za edytor i autorów albo kilka opcji




}
interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
DXSounds, DXDraws, DXClass, ExtCtrls, StdCtrls, ScktComp, Wave;

type
TForm1 = class(TDXForm)
DXDraw1: TDXDraw;
DXTimer1: TDXTimer;
DXImageList1: TDXImageList;
DXSound1: TDXSound;
DXImageList2: TDXImageList;
DXImageList3: TDXImageList;
Timer1: TTimer;
Label1: TLabel;
Timer2: TTimer;
DXImageList4: TDXImageList;
DXWaveList1: TDXWaveList;
DXWaveList2: TDXWaveList;
Memo1: TMemo;
Memo2: TMemo;
OpenDialog1: TOpenDialog;
SaveDialog1: TSaveDialog;
procedure DXDraw1Initialize(Sender: TObject);
procedure DXDraw1Finalize(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure FormKeyUp(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure DXTimer1Timer(Sender: TObject; LagCount: Integer);
procedure FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure Timer1Timer(Sender: TObject);
Procedure Kanal_lub_plansza;
procedure Pelny_Ekran_czy_nie;
Procedure Ustaw_Pozycje;
procedure Next_Level;
procedure Rysuj_Menu;
procedure Odkoduj;
procedure RysujMenu;
procedure Rysuj_wroga;
procedure NowaGra;
Procedure Historyjka(nazwa:String);
procedure Wybor_ludzika;
procedure RysujMenuX;
procedure RysujKlocek(X, Y:Integer; Nr:Byte);
procedure Tekstura;
procedure Opcje;
procedure Siec;
procedure Steruj;
procedure Siatka;
procedure Paski;
procedure RysujMario;
procedure rama(x, y, szer, wys:Integer);
procedure Kanal(I:Byte);
procedure Graj(b:byte);
procedure TextXY(X, Y: Integer; Czc: Byte; S: String);
procedure Timer2Timer(Sender: TObject);
procedure DXDraw1MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
procedure DXDraw1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure DXDraw1DblClick(Sender: TObject);
procedure DXSound1Finalize(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure DXDraw1MouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
private
{ Private declarations }
public
{ Public declarations }
end;

TStrzal = Record
X, Y       :Longint;
DX, DY     :Integer;
Graw       :Single;
Jest       :Boolean;
Wybuch     :Byte;
End;

//Zapis wrogów i wind -wszystko co o nich wiadomo
TSprite = Record
X, Y       :Longint;
Klatka     :Byte;
Czas       :Byte;
SY         :Longint;
Cyk        :Byte;
Ludzik     :Byte;
DX         :ShortInt;
Graw       :Single;
DYY        :Integer;
Zyje, rysuj:Boolean;
Duzy       :Boolean;
Kwiat      :Boolean;
Szer       :Integer;
Wys        :Integer;
Skok       :Boolean;
DY         :Integer;
Przem      :Integer;
Kierunek   :Integer;
Krzywda    :Boolean;
Smierc     :Byte;
Chmura     :Byte;
CzasChmury :Byte;
Winda      :Boolean;
End;

//Spadające odłamki cegieł
TSC     = Record
X, Y       :Array[1..4] Of Longint;
Gr         :Array[1..4] of Single;
DX, DY     :Array[1..4] of Integer;
Jest       :Array[1..4] of Boolean;
Typ        :Byte;
End;

//Lecące punkty
TLP     = Record
Jest       :Boolean;
X, Y       :Longint;
Lot        :Byte;
End;

//Lecący grzyb
LGRZYB  = Record
X, Y       :Longint;
DX, DY     :ShortInt;
Graw       :Single;
Jest       :Boolean;
szer       :Integer;
wys        :Integer;
Kwiat      :Byte;
Kogo       :Byte;
Skok       :Boolean;
End;


//Mario Bros - wszystkie Dane
TMario  = record
X, Y       :Longint;
Graw       :Single;
DX         :Integer;
DY, DYY    :Integer;
MaxDY      :Integer;
Szans      :Byte;
Ki         :Byte;
Kierunek   :Boolean;
sktrwa,
skok,
duzy,
Jump       :Boolean;
Poz        :Integer;
Koniec     :Boolean;
Czas       :Integer;
przysp     :Single;
Li         :Byte;
Klatka     :Byte;
Ludzik     :Byte;
Szer       :Integer;
Wys        :Integer;
Przem      :Integer;
Halucyn    :Integer;
Zniszczon  :Byte;
Punkty     :Byte;
Wchodzi    :Boolean;
Wszedl     :Boolean;
Kwiat      :Boolean;
CzasLad    :Byte;
Postrzal   :Boolean;
Chmura     :Byte;
CzasChmury :Byte;
Winda      :Boolean;
przenik    :Boolean;
Nietykalny :Byte;



//Poruszanie
Vk_Up,
Vk_Down,
Vk_Left,
Vk_Right,
Vk_run,
Vk_Strzal     :Integer;

//Strzał
Strzal     :Array[1.. 20] of TStrzal;

End;

Type TPrzen=record
X1, Y1, X2: Byte;
XD1, YD1, XD2:Byte;
Nazwa:String[15];
End;

Type TDeszcz=record
X, Y  : Single;
Graw  : Single;
Jest  : Boolean;
End;

Type TMenuX=record
X, Y    : Integer;
Kat     : Single;
Zazn    : Byte;
Nr      : Byte;
Width   : Integer;
Height  : Integer;
Odsyl   : Byte;
Enabled : Boolean;
End;

TPlansza=record
MaxPX, MaxPY  : Integer;
Textura       : Byte;
Muzyka        : Byte;
LOT           : ShortInt;
PL            : Array[1..500, 1..256] of Byte;
Sprite        : Array[1..200] of TSprite;
Przen         : Array[1..200] of TPrzen;
 End;


Const
 //Rozmiar ekranu
 MaxEX       : Integer=640;
 MaxEY       : Integer=480;
 MaxBit      : Integer=16;

 //Srodek ekranu
 SekrX       : Integer=320;
 SekrY       : Integer=240;

 //Szerokosc klockow
 SzerK       : Byte   = 50;


 //Komunikat do hackerów :
 Komunikat1='UWAGA !!! - WSZELKIE METODY DEKOMPILACJI, DEZASAMBLACJA ITP... SĄ ZABRONIONE - POZDROWIENIA DLA WSZYSTKICH PROGRAMISTÓW - WŁĄCZNIE Z TOBĄ';

 //Litery czcionki
 LiteryX='aąbcćdeęfghijklłmnoóprstuwyzżźqxv!@$%&()-+?[]":/0123456789*AĄBCĆDEĘFGHIJKLŁMNŃOÓPRSŚTUVWXYZŻŹ';

 //Ile opcji na pasku w edytorze
 MaxOpPas=12;

 //Teksty podpowiadacza na pasku
 TextyPas:Array[1..MaxOpPa'> of String=
 ('Nowa plansza','Zapisz','Odczytaj','Wybór klocka','Zmiana Tła',
 'Wybór wroga/obiektu','Gotowe elementy','Rozmiar planszy','Muzyka','Wiatr',
 'Siatka ON/OFF','Uruchom');

 //Ilosc padających kropli
 Maxdeszczu=100;

 //Ile rysunków do Menu
 Men=13;

 //Ile różnych pozycji mario
 MaxDX=3;

 //Przezroczystosc
 Alpha:Boolean=True;
               //False;

 //Przeskakiwanie dla wolniejszych
 MaxRysuj:Byte=0;

 //Detaile czyli ile mam rysowac
 Detaile:Byte=3;

 //Max FPS
 MaxFPS:Byte=60;

//Ile dźwięków
MaxDzw=18;

 //Maxymalnie muzyk
 MaxMuz=3;

 //Czy mają byc dźwięki
 Sound:Boolean=True;
               //False;
 //Początkowy poziom
 lev:Integer=0;

 //Tekstura planszy (tlo)
 Textura:Byte=2;
 Lot:ShortInt=0;

 //Skakanie
 Skok:Boolean=True;

 //Uruchomienie w edytorze
 Uruchom:Boolean=False;

 //Siatka
 Siateczka:Boolean=True;
              //  True;
 //Maksymalna ilosc Bitmap
 MaxBMP=41;

 //Ile obiektów Sprite - animacje ludzika
 MaxSpr=9;

//Ile obiektów rysunkowych
MAxOB=52; //+gówno

 //Ilosc dźwięków
 MaxWave=3;

 //Ile wrogów
 MaxWr=5;

 //Maksymalnie wrogów
 MaxLudz:Byte=5;

 //Grawitacja
 Grawitacja:Single=0.25;

 //Sliskosc planszy
 Sliskosc1:Single=0.7;
 Sliskosc2:Single=0.93;

 //Klawisz do przycisku FPS
 Frame_Key=70;

 //Klatek na sekunde
 Frame:Boolean=fALSE;

//Max tekstur
MaxTxt=5;

 //nazwy bitmap obiektów sprite
 SPR:Array[1..MaxSpr] of String[12]=
 ('mario','ego','zolw','kwiatek','ogien','winda','mario2','luigi','luigi2');

 //Ile obiektów innych
 OB:Array[1..MAxOB] of String[12]=
 ('Sz.BMP','C1.Bmp','Punkt1.Bmp','Punkt2.Bmp',
  'Strz1.Bmp','Strz2.Bmp','Strz3.Bmp','Strz4.Bmp',
  'Tex1.Bmp','Tex2.Bmp','Sl.Bmp','Grzyb.Bmp','Mysz.Bmp',
  'mt.bmp', 'lt.bmp','tlo.bmp','tlo2.bmp','wybor.bmp',
  'Pauza.Bmp','Chmura.bmp','cyfry.bmp','kps.bmp','Strz.Bmp'
  ,'Tex3.Bmp','c2.bmp','slonko.bmp','kwiat.bmp','strzal.bmp',
  'strzal2.bmp','Chmura1.bmp','Chmura2.Bmp','Grzyb2.bmp',
  'Grzyb3.bmp','logo.bmp','guwno.bmp','cien.bmp','TEX4.BMP',
  'demo.bmp','demo2.bmp','kropla.bmp','czc1.bmp','tex5.bmp',
  'pr1.bmp','pr2.bmp','pr3.bmp','pr4.bmp','ka1.bmp','ka2.bmp',
  'ka3.bmp','ka4.bmp','aut.bmp','edytor.bmp');

 //Przyrost X i Y dla spadającej cegły
 PSC:Array[1..4, 1..2] of integer=
 ((-1, -1),(-1, -3),(1, -1),(1, -3));

 //Pozycje kawałków cegły
 PSCC:Array[1..4, 1..2] of integer=
 ((0,25), (0,0), (25,25), (25, 0));

 //Literki dla każdego ludzika
 Lit:String[10]=
 'mlmmmmmmmm';

//Literki dla wrogów
 Lw:String[MaxWr]=
 'eżkow';

 //Szybkosc chodzenia wrogów
 Sch:Array[1..5] of ShortInt=
(3, 6, 0, 0, 0);

 //Czy masz wtapiac przy kolizji z nim
 Wt:Array[1..5] of Byte=
 (1, 0, 2, 2, 0);

 //Menu główne - gdzie i co
 MenuGl:Array[1..4, 1..2] of Integer=
 ((400, 50),(400, 120),(400, 190),(400, 260));

 DK:Array[1..4] of integer=
 (6, 5, 3, 2);

 NrMuz:Array[1..MaxMuz] of byte=
 (18, 19, 20);

 Muza:Byte=0;

 HasloX='1928';

 Poruszanie:Array[1..MaxWr, 1..10] of Boolean=  //AI - Sztuczna inteligencja obiektów sprite
({NAZWA}{chodzenie}{nie spadanie}{Y po sin}{Skok DY=20}{sprężynka}{winda}{Grawitacja}{Strzelanie}{}{}
({EGO}   True,     False,         False,    False,      False,    False,  True,       False,     False,False),
({ŻÓŁW}  True,     True,          False,    False,      True,     False,  True,       False,     False,False),
({KWIAT} False,    False,         True,     False,      False,    False,  False,      False,     False,False),
({OGIEŃ} False,    False,         False,    True,       False,    False,  True,       False,     False,False),
({WINDA} False,    False,         False,    False,      False,    True,   False,      False,     False,False));


Menu1X   : Array[1..4] of String=
('URUCHOM GRĘ','USTAWIENIA','GRA W SIECI','WYŁĄCZ');

Menu2X   : Array[1..4] of String=
('GRAFIKA','AUDIO','KONTROLOWANIE','POWRÓT');

Szer_czc:Array[1..1] of Byte=
(8);

MaxMenuDod=2;
MaxWid=6;
MaxPl=20;

{START ========================================================================}
const
POLE_PUSTE = 0;
POLE_CEGLA = 1;

const
SKOK_DO_PRZODU = 0;
SKOK_DO_GORY = 1;
{========================================================================== END}


var
Form1                      : TForm1;
Pl, Tab                    : Array[1..500, 1..256] Of Byte;
 P                          : Array[1..maxPl] of TPlansza;
Maska                      : Array[1..500, 1..256] of Byte;
 Sprite                     : Array[1..200] Of TSprite;
 Keys                       : Array[0..255] Of Boolean;
 MenuDod                    : Array[1..MaxMenuDod] of TMenuX;
 Bitmapy                    : Array[1..maxWid] of TBitmap;
 Pg, Ks                     : Integer;
MaxPX, MaxPY               : Integer;
 COL                        : lONGINT;
 Mario                      : Array[1..10] of Tmario;
 MinX, MaxX, MinY, MaxY     : Longint;
 L1, L2                     : Byte;
 cz                         : Byte;
 Mx, My                     : Integer;
 KatMenu                    : Array[1..4] Of Single;
 o                          : Integer;
 RysMenu                    : Boolean;
 Gra                        : Boolean;
 KatGry                     : Integer;
 Last                       : Byte;
 Next_l                     : Boolean;
 K1, K2, KH                 : Integer;
 OPcja, Grafika             : Boolean;
 O2                         : Byte;
C1, C2                     : Byte;
 Przen                      : Array[1..200] of TPrzen;
 IP, KanalX                 : Byte;
MaxLot                     : Byte;
 Nazwa_Planszy              : String[15];
 Nazwy                      : Array[1..200] of String[15];
 TxtNr                      : Byte;
 StatusKat, StatusCzas      : Integer;
 Rysuj                      : Byte;
 Xa, Ya                     : Longint;
 Licz                       : Byte;
 Kol                        : Longint;

 //Kąt ramki w ustawieniach
 Kat_ust                    : Single;

 //Czy jest wcisnięta pauza
 IleS                       : Integer;
Pauza                      : Boolean;

 //Czy opcja jest już wybrana
 Wybrana                    : Boolean;


 //Ilosc graczy
 Graczy                     : Byte;

 //Ktory jest ktory
 Op                         : Array[1..10] of byte;


//Twarze ludzików
 Twarz                       : Array[1..10] of Byte;

 //FP                         : Integer;

 //Zegar animacji
 Zegar                      : Integer;

 //Zapis spadającej cegły
SC                         : Array[1..100] of TSC;

 //Zapis lecacego punktu
 LP                         : Array[1..100] of TLP;

 //Grzyb - WF
 GRZYB                      : Array[1..20] of LGRZYB;

 //X i Y przyrostu planszy
 XP, YP                     : Longint;
 SX                         : Longint;
 XD, YD                     : Integer;

 //Przesuwanie tekstury
 XTX                        : Single;

 SZDX                       : Array[1..10] Of Byte;

 Teraz                      : Array[1..10] of Boolean;

 //Opcja graficzna
 og                         : Byte;

 //Trzęsienie ziemi
 POWER                      : Integer;

 Wyg                        : Array[1..4] of Single;
 Wyga                       : Array[1..4] of Boolean;

 //Deszcz
 Deszcz                     : Array[1..MaxDeszczu] of TDeszcz;

 //Tablica znaków
 TZn                        : Array[0..255] of Byte;

 //Kąt do menu przy wyborze ludzików
 Kat_Wyb                    : Array[1..3] of Single;

 // Stosunek ile powinno byc FPS do wyswietlanych klatek
 przeskok                   : Single;

 //KLOCKI WYSTĘPUJĄCE W GRZE
 cegla, nieb_cegla, nic,
 lawa1, lawa2               : Byte;

 //Co jaki czas przesuwa zdjęcia
 CzasBMP                    : Byte;
NrWid                      : Byte;

 //Pozycja scrollu
 Scroll_Y                   : Integer;

 //Przeciąganie
Drag                       : Boolean;

 //EDYTOR PLANSZ
 OpRYS                      : Byte;

 NrKlocka                   : Byte;
 NrWroga                    : Byte;

 //Paski przewijające
 PVERT,
 PHOR                       : Boolean;

 Pas_op                     : Boolean;
 LButton                    : TMouseButton;
 WyborKl                    : Boolean;
 WyborWr                    : Boolean;
 DodKl                      : Integer;


implementation

{$R *.DFM}




procedure Daz_od_do(Var Xs, Ys:Single; X, Y:Integer;Speed:Byte);
//
//  PROCEDURKA POWOLI ZMIENIA WARTOŚĆ ZMIENNYCH XS i YS Do X i Y
//
Begin
If (X-Xs<>0) Then Xs:=Xs+(X-Xs)/Speed;
 If (Y-Ys<>0) Then Ys:=Ys+(Y-Ys)/Speed;
End;


procedure TForm1.TextXY(X, Y: Integer; Czc: Byte; S: String);
Var a:Byte;
Begin
For a:=0 to Length(s) do
If Tzn[BYTE(S[a])]<>0 Then
DXImageList3.Items[40].Draw(DXDraw1.Surface, X+a*Szer_czc[Czc], Y, Tzn[BYTE(S[a])]-1);
End;

procedure TForm1.Odkoduj;
Var a, b:Integer;
c, d:Byte;
S, t:String;

Begin
Memo1.Clear;d:=0;

For a:=0 to Memo2.Lines.Count do
Begin
S:=Memo2.Lines.Strings[a];
t:='';
For b:=1 to Length(s) do
Begin
If Length(HasloX)>0 Then
Begin
Inc(d);If d>Length(HasloX) Then d:=1;
c:=BYTE(HasloX[d]);
End Else c:=0;

t:=t+Char(BYTE(S[b])-c);
End;
Memo1.Lines.Add(T);
End;
End;


procedure MenuDodatkowe(o:Byte);
Begin
With Form1 do
Begin
DXImageList3.Items[MenuDod[o].Nr].Draw(DXDraw1.Surface, MenuDod[o].X, MenuDod[o].Y, MenuDod[o].Zazn);
End;
End;


procedure TextSXY(X, Y: Integer;Czc: Byte; S: String);
Var nx:Integer;
Begin
Nx:=X-(Length(S)*Szer_Czc[Czc]) div 2;
Form1.TextXY(nx, y, Czc, S);
End;


Procedure Tform1.Historyjka(nazwa:String);
Var F:TextFile;
Begin
 If not FileExists(nazwa) Then Exit;
 AssignFile(F, nazwa);
Reset(F);
{ gdzie jest reszta kodu }
CloseFile(F);
End;


procedure TForm1.rama(x, y, szer, wys:Integer);
const
CELL_WIDTH = 20;
CELL_HEIGHT = 19;
Var a:Integer;
Begin
For a:=1 to szer do
Begin
DXImageList3.Items[42].Draw(DXDraw1.Surface, a*CELL_WIDTH+x-7, y, 0);
DXImageList3.Items[43].Draw(DXDraw1.Surface, a*CELL_WIDTH+x-7, y+wys*CELL_HEIGHT+14, 0);
End;

For a:=1 to wys do
Begin
DXImageList3.Items[44].Draw(DXDraw1.Surface, x, y+a*CELL_HEIGHT-5, 0);
DXImageList3.Items[45].Draw(DXDraw1.Surface, x+szer*CELL_WIDTH+13, y+a*CELL_HEIGHT-5, 0);
End;

// lewa gora
DXImageList3.Items[46].Draw(DXDraw1.Surface, x, y, 0);
// prawa gora
DXImageList3.Items[47].Draw(DXDraw1.Surface, x+szer*CELL_WIDTH+13, y, 0);
// lewy dol
DXImageList3.Items[48].Draw(DXDraw1.Surface, x, y+wys*CELL_HEIGHT+14, 0);
// prawy dol
DXImageList3.Items[49].Draw(DXDraw1.Surface, x+szer*CELL_WIDTH+13, y+wys*CELL_HEIGHT+14, 0);
End;

FUNCTION V_RGB(R, G, B:Byte):Word;
BEGIN
V_RGB:= (B SHR 3) OR ((G SHR 2) SHL 5) OR ((R SHR 3) SHL 11);
END;

Procedure StopMusic;
//Var a:Byte;
Begin
 //If not FileExists('.DaneDzwiekM'+InttoStr(muza)+'.wav') Then Exit;
 //For a:=1 to MaxMuz do
 //If Muzyka[NrMuz[a]].Playing Then
 //If muza<>0 Then MuzykaX.Stop;
End;

Procedure PlayMusic;
Begin
If not (FileExists('.DaneDzwiekMuzyka'+InttoStr(muza)+'.MDX') and Sound) Then
Exit;

 Form1.DXWaveList2.Items.LoadFromFile('.DaneDzwiekMuzyka'+InttoStr(muza)+'.MDX');
 Form1.DXWaveList2.Items[0].Looped:=True;
 Form1.DXWaveList2.Items[0].Play(False);
End;


Procedure Delete_XFiles;
Var a:Byte;
   F:File;
Begin
  For a:=1 to IleS do
   If FileExists('.DaneDzwiekX'+Nazwy[a]) Then
   Begin
     AssignFile(F, '.DaneDzwiekX'+Nazwy[a]);
     Erase(F);
   End;
End;



Procedure LoadPl(Fn:String);
Var F:Text;
   a, b:integer;
   st:string [19];
   c1, c2, c3:Char;
   TabChar:Array[1..4] Of Char;
   By:Array[1..4] Of Byte;

Begin
 AssignFile(F,  Fn);
 {$I-}
 Reset(F);
 {$I+}
 If IOResult<>0 then
   Begin
     CloseFile(F);
     Application.MessageBox('Niestety, ale wystąpił Błąd w pliku z planszą.', 'Błąd w pliku', 0);
   End;
 Read(F,st);
 If st<>'Plansza gry MarioDX' Then
Begin
   CloseFile(F);
   Application.MessageBox('Niestety, ale wystąpił Błąd w pliku z planszą.', 'Błąd w pliku', 0);
 End;

 Read(F, c1,c2,c3);
 MaxPX:=BYTE(c1)*256+BYTE(c2);
 MAxPY:=BYTE(c3);

 For a:=1 to 4 do
Read(F, TabChar[a]);

 Move(TabChar, By, SizeOf(TabChar));

col:=(By[1] div 4)*$FFFF;      { ???????? }
 col:=col+By[2] div 4*$FF;
 col:=col+By[3] div 4;

 Read(F, c1);
 Textura:=BYTE(c1);

 Txtnr:=Form1.DxImageList3.Items.IndexOf('Tex'+Inttostr(Textura));
 If TxtNr>MaxOB-1 Then TxtNr:=MaxOB-1;

 //Form1.Caption:=Inttostr(textura)+' - '+Inttostr(Txtnr);

 //If (Textura<1) or (Textura>2) then Textura:=1;



 For a:=1 to MaxPX do
For b:=1 to MAxPY do
Begin
   Read(F, c1);
   Pl[a,b]:=255-BYTE(c1);
 End;

 For a:=1 to 10 do
 Begin
   Read(F, c1, c2, c3);
   Mario[a].X:=(BYTE(c1)*256+BYTE(c2))*SzerK;
   Mario[a].Y:=(BYTE(c3)-1)*SzerK;
 End;
 Read(F, c1);
 IP:=BYTE(c1);
 KanalX:=0;
  For a:=1 to IP do
   Begin
     Read(F, Przen[a].Nazwa);
Read(F, c1, c2, c3);
Przen[a].X1:=BYTE(c1);
Przen[a].X2:=BYTE(c2);
Przen[a].Y1:=BYTE(c3);
     Read(F, c1, c2, c3);
     Przen[a].XD1:=BYTE(c1);
     Przen[a].XD2:=BYTE(c2);
     Przen[a].YD1:=BYTE(c3);

     //Form1.Caption:=IntToStr(Przen[a].XD1{Mario[c].X})+'x'+IntToStr(Przen[a].XD2){MArio[c].Y}+'x'+IntToStr(Przen[a].YD1);
   End;

  Read(F, C1);
MaxLudz:=BYTE(C1);

 For A:=1 to MaxLudz do
   With Sprite[a] do Begin
     Read(F, C1, C2, C3);
     Zyje:=True;
     X:=(BYTE(C1)*256+BYTE(C2)-1)*SzerK;
     Y:=(BYTE(C3)-1)*SzerK;
     Read(F, C1);
     Ludzik:=BYTE(C1);
   End;


 Read(F, C1);
 a:=BYTE(C1);
 Lot:=a-15;

 CloseFile(F);
End;

Procedure SavePl(Fn:String);
Var F:Text;
   a, b:integer;
   st:string [19];
   s:String[15];
   TabChar:Array[1..4] Of Char;

Begin
 AssignFile(F,  Fn);
 {$I-}
 Rewrite(F);
{$I+}

 st:='Plansza gry MarioDX';Write(F, st);



Write(F, CHAR(MaxPX div 256), CHAR(MaxPX mod 256), CHAR(MaxPY mod 256));



 Move(col, TabChar, SizeOf(TabChar));

 For a:=1 to 4 do
 Write(F, TabChar[a]);

 Write(F, CHAR(textura mod 256));


 For a:=1 to MaxPX do
 For b:=1 to MAxPY do
   Write(F, CHAR(255-(Pl[a,b] mod 256)));


For a:=1 to 10 do
   Write(F, CHAR((Mario[a].X div SzerK) div 256), CHAR((Mario[a].X div SzerK) mod 256), CHAR((Mario[a].Y div SzerK) mod 256));

 Write(F, CHAR(IP mod 256));
 KanalX:=0;
  For a:=1 to IP do
   Begin

S:=Przen[a].Nazwa+'                       ';
     Write(F, S);
     Write(F, CHAR(Przen[a].X1)+CHAR(Przen[a].X2)+CHAR(Przen[a].Y1)+
              CHAR(Przen[a].XD1)+CHAR(Przen[a].XD2)+CHAR(Przen[a].YD1));

     //Form1.Caption:=IntToStr(Przen[a].XD1{Mario[c].X})+'x'+IntToStr(Przen[a].XD2){MArio[c].Y}+'x'+IntToStr(Przen[a].YD1);
   End;



 MaxLudz:=0;
 For a:=1 to 200 do
   If Sprite[a].Zyje Then Inc(MaxLudz);


 Write(F, CHAR(MaxLudz));
 MaxLudz:=0;

 Repeat
   Inc(MaxLudz);

   If Sprite[MaxLudz].Zyje Then
   With Sprite[MaxLudz] do
       Write(F, CHAR((X div SzerK) div 256), CHAR((X div SzerK) mod 256), CHAR(Y div SzerK), CHAR(Ludzik));

 Until MaxLudz>199;


 //Wiatr
 Write(F, CHAR(Lot+15));

CloseFile(F);
End;

Procedure Load;
Var a:integer;


Begin
 //Wczytywanie ...

 For a:=1 to MaxBMP do
   If not (a in [1, 37]) Then Form1.DXImageList1.Items[a-1].Picture.LoadFromFile('.DaneGrafikaT'+IntToStr(a)+'.BMP');
For a:=1 to MaxSpr do
Form1.DXImageList2.Items[a-1].Picture.LoadFromFile('.DaneGrafika'+Spr[a]+'.bmp');
 For a:=1 to MaxOB do
   If not (a in[ 35]) Then Form1.DXImageList3.Items[a-1].Picture.LoadFromFile('.DaneGrafika'+OB[a]);
 For a:=1 to Men do
If not (a in [25, 26]) Then
   Form1.DXImageList4.Items[a-1].Picture.LoadFromFile('.DaneGrafikaMenu'+IntToStr(a)+'.BMP');
 For a:=1 to MaxWid do
   Begin
     Bitmapy[a]:=TBitmap.Create;
     If FileExists('.DaneGrafikaWid'+IntToStr(a)+'.Bmp') Then
        Bitmapy[a].LoadFromFile('.DaneGrafikaWid'+IntToStr(a)+'.Bmp');
   End;

 If FileExists('.DaneIntroAutorzy.kod') Then
   Begin
     Form1.Memo2.Lines.LoadFromFile('.DaneIntroAutorzy.kod');
     Form1.Odkoduj;
   End;

 NrWroga:=1;
 {For a:=0 to MaxDzw-1 do
   Begin
    {muzyka[a]:=TAudioFileStream.create(Form1.DXSound1.Dsound);}
    //If FileExists('.DaneDzwiek'+IntToStr(a+1)+'.wav') Then
    {Muzyka[a].FileName:='.DaneDzwiek'+IntToStr(a+1)+'.wav';
    //Form1.DXWaveList1.Items.SaveToFile
   End;}

 Form1.DXWaveList1.Items.LoadFromFile('.DaneDzwiekEfekty.MDX');
 Randomize;
 {Wczytywanie planszy}
//Form1.Next_Level;
Form1.DXDraw1.Initialize;
End;

Procedure TForm1.Graj(B:Byte);
Begin
   If not Sound Then Exit;
   {Muzyka[b].Position:=0;
   Muzyka[b].Play;}
   DXWaveList1.Items[B].Play(False);
End;

Function Sin_z(k, r:integer):Integer;

//
//    Sprawdza w jakiej pozycji powinna byc listwa jezeli podano
//    promien i kat aktualnego wychylenia
//

Begin
If k<>0 then Sin_z:=Round(Sin256(Round((k/360.0)*256.0))*r) Else Sin_z:=0;
end;


Function Kolizja(X1, Y1, Szer1, Wys1, X2, Y2, Szer2, Wys2:Integer):Boolean;

//
//    Sprawdza czy obiekt w pozycji X1, Y1 i szerokosci Szer1 i Wys1
//    zderzył się z obiektem o współrzędnych X2, Y2, Szer2, Wys2
//

Begin
 { Jezeli, ktorys z warunkow bedzie spelniony to nie ma kolizji }
result := not
((x1 > x2+szer2) or (x1+szer1 < x2) or
(y1 > y2+wys2) or (y1+wys1 < y2));

{
If ((X1>=X2) and (Y1>=Y2) and (Y1<=Y2+Wys2) and (X1<=X2+Szer2)) or
((X1+Szer1>=X2) and (Y1>=Y2) and (Y1<=Y2+Wys2) and (X1+Szer1<=X2+Szer2)) or
((X1>=X2) and (Y1+Wys1>=Y2) and (Y1+Wys1<=Y2+Wys2) and (X1<=X2+Szer2)) or
((X1+Szer1>=X2) and (Y1+Wys1>=Y2) and (Y1+Wys1<=Y2+Wys2) and (X1+Szer1<=X2+Szer2))
Then Kolizja:=True Else Kolizja:=False;
}
End;



Procedure CEG(X, Y:Integer);

//
//    Procedura ta rozwala ceglówkę, która jest w pozycji X, Y w tablicy
//    Pamięci planszy, ustawia cztery kawałki, które będą spadały
//

Var xx, c         :BYTE;
b             :Integer;
const
MAX_CEGIEL = 99;
Begin

xx:=PL[X, Y];
PL[X, Y]:= POLE_PUSTE;

c:=0;
Repeat
Inc(c);
If not
((sc[c].Jest[1]) or (sc[c].Jest[2]) or
(sc[c].Jest[3]) or (sc[c].Jest[4])) then
For b:=1 to 4 do
begin
Sc[c].X[b]:=(X-1)*SzerK+PSCC[b, 1];
Sc[c].Y[b]:=(Y-1)*SzerK+PSCC[b, 2];
Sc[c].DX[b]:=PSC[b, 1];
Sc[c].DY[b]:=PSC[b, 2];
End;
Until (((not Sc[c].Jest[1]) and (Sc[c].DX[1]<>0)) or (c>MAX_CEGIEL));
//Zaznacz, że będą spadały 4 kawałki cegieł
for b:=1 to 4 do
Begin
Sc[c].Jest[b]:=True;
If xx in [POLE_CEGLA] Then
Sc[c].Typ:=POLE_CEGLA Else Sc[c].Typ:=2;
End;
//Graj dźwięk uderzania w cegłę
If Sound Then
Begin
Form1.Graj(2);
End;
End;

{START ========================================================================}
(*
* Dodalem te funkcje zeby kod byl bardziej czytelniejszy
*)
function IsSprite(number : Byte) : Boolean;
begin
result := (number > 0) and (number < 201);
end;

function IsPowerUp(number : Byte) : Boolean;
begin
result := (number > 200) and (number < 221);
end;

function IsPlayer(number : Byte) : Boolean;
begin
result := (number > 220) and (number < 231);
end;
{========================================================================== END}

Procedure SKO(X, Y:Integer; podrzut:Boolean);

//
//    Ta procedura wyrzuca ludzika, lub sprite w powietrze
//    i dodatkowo podrzuca klocek o MAX_PODRUT_KLOCKA pikseli, na którym jest
//

const
MAX_PODRZUT_KLOCKA = 10;
var
number : Byte;
Begin
If podrzut Then
Tab[X, Y]:=MAX_PODRZUT_KLOCKA;
DEC(Y);
number := maska[x, y];
If (IsSprite(number)) Then // sprajty
Begin
Sprite[number].DY:=5;
Sprite[number].Skok:=True;
Sprite[number].Graw:=0;
End
else If (IsPowerUp(number)) Then // palerapy
begin
Dec(number, 200);
Grzyb[number].Skok:=True;
Grzyb[number].Graw:=0;
Grzyb[number].DY:=5;
end
else If (IsPlayer(number)) Then // postacie
begin
Dec(number, 221);
Mario[number].Jump:=True;
Mario[number].Skok:=True;
Mario[number].SkTrwa:=True;
Mario[number].DY:=5;
Keys[Vk_up]:=True;
end;
End;

Procedure POD(NR: BYTE; NR2:Integer);

//
//    Ta procedura podnosi ludzika, lub sprite o kilka pikseli
//    Używane w windzie
//

Begin
If (IsSprite(nr)) Then
With Sprite[nr] do
If Kolizja(X, Y+Wys, Szer, 1, Sprite[nr2].X, Sprite[nr2].Y, Sprite[nr2].Szer, Sprite[nr2].Wys) Then
Begin
Y:=Sprite[nr2].Y-Wys-1;
If (Y < 0) Then
Y:=0;
Graw:=0;
Winda:=True;
End
else If (IsPlayer(nr)) Then
begin
With Mario[nr-220] do
If Kolizja(X, Y+WYS, Szer, 1, Sprite[nr2].X, Sprite[nr2].Y, Sprite[nr2].Szer, Sprite[nr2].Wys) Then
Begin
Y:=Sprite[nr2].Y-Wys-1;
If (Y < 0) Then
Y:=0;
Graw:=0;
Winda:=True;
Skok:=False;
Jump:=False;
SkTrwa:=False;
End
Else
Winda:=False;
end;
End;

Procedure PUN(X, Y:Integer);

//
//    Powoduje ustawienie punktu, który leci do góry, po podbiciu
//

Var
b : BYTE;
const
MAX_LECACYCH_PUNKTOW = 99;
Begin
PL[X, Y]:=4;
If Sound Then
Begin
Form1.Graj(1);
End;

DEC(X);
DEC(Y);

b := 1;
while (b < MAX_LECACYCH_PUNKTOW) and (lp[b].Jest) do
Inc(b);

If (b < MAX_LECACYCH_PUNKTOW) Then
Begin
Lp[b].X := X * SzerK + 10;
Lp[b].Y := Y * SzerK - 30;
Lp[b].Lot := 0;
Lp[b].Jest := True;
End;

End;

Procedure GRZ(X, Y: Integer; Duzy:Byte; K:BYTE; Ki:Boolean);

//
//    Tworzy nowego grzyba, lub kwiatek, w zależnosci od ludzika, który
//    uderzył w ten klocek
//

Var B:BYTE;
const
MAX_GRZYBOW = 20;
Begin
PL[X, Y]:=4;
If Sound Then
Begin
Form1.Graj(1);
End;

DEC(Y);
DEC(X);

b := 1;
while (b < MAX_GRZYBOW) and (grzyb[b].Jest) do
Inc(b);

if (b < MAX_GRZYBOW) then
begin
Grzyb[b].X := X * SzerK;
Grzyb[b].Y := Y * SzerK - 10;
Grzyb[b].Jest:=True;
Grzyb[b].Kwiat:=Duzy; //Jezeli mario jest duzy to grzyb jest = kwiatek
Grzyb[b].Kogo:=K;
Grzyb[b].Skok:=True;
Grzyb[b].DY:=5;
If Ki Then
Grzyb[b].DX := 3
Else
Grzyb[b].DX := -3;
end;
End;

{START ========================================================================}
(*
* Sandardowe funkcje
*)
function Max(a, b : Integer) : Integer;
begin
if (a > b) then
result := a
else
result := b;
end;

function Min(a, b : Integer) : Integer;
begin
if (a < b) then
result := a
else
result := b;
end;
{========================================================================== END}


Procedure POW(X, Y:Integer);

//
//    Powoduje podbicie klocka POWER, który rozwala wszystko w promieniu
//    10 klocków i niszczy inne klocki
//

Var X1, X2, Y1, Y2:Integer;
a, b          :Integer;

Begin
X1 := Max(X - 10, 1);
X2 := Min(X + 10, MaxPX);
Y1 := Max(Y - 10, 1);
Y2 := Min(Y + 10, MaxPY);

 For a:=X1 to X2 do
For b:=Y1 to Y2 do
case (pl[a, b]) of
1, 23:
Ceg(a, b);
3, 5:
Pun(a, b);
7, 8:
Grz(a, b, 0, 0, Random(5) > Random(5));
else
Sko(a, b, False);
end;

PL[X, Y]:=POLE_PUSTE;
POWER:=60;

End;


Procedure CHODZ(nr:Byte);

//
//    Procedura wykorzystywana do standardowego poruszania obiektami sprite
//    Zawiera podstawowe funkcje, zmiane kierunku i zabezpieczenie przed scianą
//

Begin
With Sprite[nr] do
Begin
If (Kierunek = SKOK_DO_PRZODU) Then
Begin
If (DX < 0) and ((X < 2)
or not (PL[(X+DX) div SzerK+1, (Y+1) div SzerK+1] in [0, 6, 36, 37])
or not (PL[(X+DX) div SzerK+1, (Y+Wys-1) div SzerK+1] in [0, 6, 36, 37])) Then
Kierunek:=SKOK_DO_GORY
Else If (DX > 0) and ((X > MaxPX*SzerK-Szer)
or not (PL[(X+DX+szer) div SzerK+1, (Y+1) div SzerK+1] in [0, 6, 36, 37])
or not (PL[(X+DX+szer) div SzerK+1, (Y+Wys-1) div SzerK+1] in [0, 6, 36, 37])) Then
Kierunek:=SKOK_DO_GORY;
End;

If Kierunek=SKOK_DO_PRZODU Then
Begin
If (DX < 0) Then
If (PL[(X+DX) div SzerK+1, (Y+1) div SzerK+1] in [0, 6, 36, 37])
and (PL[(X+DX) div SzerK+1, (Y+Wys-1) div SzerK+1] in [0, 6, 36, 37]) Then
X := X + DX;
If (DX > 0) Then
If (PL[(X+DX+Szer) div SzerK+1, (Y+1) div SzerK+1] in [0, 6, 36, 37])
and (PL[(X+DX+Szer) div SzerK+1, (Y+Wys-1) div SzerK+1] in [0, 6, 36, 37]) Then
X := X + DX;
End;

If not Skok Then
If Zegar mod (Sch[Ludzik]+1)=1 Then
If Kierunek=SKOK_DO_PRZODU Then
Begin
If Cyk<4 Then
Inc(Cyk)
Else
Cyk:=0;
End
Else If Zegar mod 3=0 Then
Begin
Cyk := 6 + Kierunek;
Inc(Kierunek);
If Kierunek>2 Then
Begin
Kierunek := SKOK_DO_PRZODU;
DX := -DX;
End;
End;


If Skok and (Ludzik=2) Then
If DY>Graw Then
Cyk:=4
Else
Cyk:=5;

If Dx>0 Then
Klatka:=1
Else
Klatka:=0;
Klatka:=Klatka+Cyk*2;
End;
End;


Procedure SPADA(nr:Byte);

//
//    Sztuczna inteligencja dla np. żółwi, nie skoczą dobrowolnie w przepasc
//

Begin
With Sprite[nr] do
If (Kierunek=SKOK_DO_PRZODU) AND NOT SKOK Then
Begin
If dx>0 Then
Begin
IF (PL[(X+Szer+dx) div SzerK+1, (Y+Wys+5) div SzerK+1] in [0, 6, 36, 37]) AND
(PL[(X+Szer+dx) div SzerK+1, (Y+Wys+5) div SzerK+2] in [0, 6, 36, 37]) Then Kierunek:=1;
End
Else
   Begin
     IF (PL[(X+dx) div SzerK+1, (Y+Wys+5) div SzerK+1] in [0, 6, 36, 37]) AND
        (PL[(X+dx) div SzerK+1, (Y+Wys+5) div SzerK+2] in [0, 6, 36, 37]) Then Kierunek:=1;
   End;
 End;
End;

Procedure SINUS(nr:BYTE);

//
//    Ruch kwiatka tego co wychodzi z kanału
//

Begin
 With Sprite[nr] do
 Begin
    //JEŚLI NIC NIE STOI NAD KANAŁEM
    If (MASKA[(X-Szer div 2) div SzerK+1, (Y-SzerK) div SzerK+1]=0) and
       (MASKA[(X-SzerK) div SzerK+1, (Y+SzerK+Wys) div SzerK+1]=0) and
       (MASKA[(X+Szer+SzerK) div SzerK+1, (Y+SzerK+Wys) div SzerK+1]=0) and
       (MASKA[(X+Szer div 2) div SzerK+1, (Y-SzerK) div SzerK+1]=0)

    Then Begin
      If X mod SzerK=0 Then X:=X+25;
      Dec(Czas);
      Y:=SY+Round(Sin256(CZas)*(50+(Ludzik-3)*300));
    End Else

    If Y<SY Then
    Begin
      If X mod SzerK=0 Then X:=X+25;
      Dec(Czas, 5);
      Y:=SY+Round(Sin256(CZas)*(50+(Ludzik-3)*300));
    End;

    If Zegar mod 10=5 Then Inc(Klatka);
    If Klatka>2 Then Klatka:=0;

    {If Klatka=0 Then
    Begin
      If Zegar mod 10=5 Then Klatka:=1;
    End Else If (Zegar mod 10=5) or (Klatka<>1) Then Klatka:=0;}
 End;
End;

Procedure SKOKW(nr:Byte);

//
//    Ruch ognia (Skok i opadanie)
//

Begin
 With Sprite[nr] do
 Begin
    If DY>Graw Then Klatka:=0 Else Klatka:=1;
    IF Y>SY+Wys Then
    Begin
    If Czas>0 Then Dec(Czas);
    Y:=SY+Wys-1;
    If czas=0 Then
    Begin
      Czas:=60;
      Y:=SY;
      Skok:=True;
      DY:=19;
      Graw:=0;
    End;
    End;
 End;
End;

Procedure SPREZ(nr:BYTE);

//
//    Żółwik naskakuje innym na głowę jeżeli będą odpowiednie warunki
//

Begin
If not (MASKA[(Sprite[nr].X div SzerK)+(Sprite[nr].DX div 2), (Sprite[nr].Y div SzerK)+1] in [0, nr]) Then
Begin
Sprite[nr].Skok:=True;
Sprite[nr].DY:=4;
Sprite[nr].Kierunek:=SKOK_DO_PRZODU;
End;
If not (MASKA[Sprite[nr].X div SzerK+Sprite[nr].DX div 2, Sprite[nr].Y div SzerK] in [0, nr]) Then
Begin
Sprite[nr].Skok:=True;
Sprite[nr].DY:=7;
     Sprite[nr].Kierunek:=SKOK_DO_PRZODU;
   End;
End;


Procedure WINDX(nr:BYTE);

//
//    Poruszanie Sprite'u jak windy albo raczej windy
//

Begin
 With Sprite[nr] do
 Begin
     Dec(Y, 2);
     If Y<-Wys Then Y:=MaxPY*SzerK;
     Klatka:=0;
 End;
End;

Procedure GRAWI(nr:Byte);

//
//    Grawitacja obiektów sprite
//

Var n:Byte;

Begin

    With Sprite[nr] do
    Begin

    Graw:=Graw+Grawitacja;
    DYY:=Round(Graw);
    n:=Maska[(X+Szer div 2) div SzerK+1, (Y+wys+5) div SzerK+1];
    If n<>0 Then
      Begin
        If n<201 Then If Kolizja(X, Y+Wys-10, Szer, 10, Sprite[n].x, Sprite[n].y, Sprite[n].szer, Sprite[n].wys) Then Begin Y:=Sprite[n].Y-wys;Graw:=0;End;
        If n in [221..230] Then If Kolizja(X, Y+Wys-10, Szer, 10, Mario[n-220].x, Mario[n-220].y, Mario[n-220].szer, Mario[n-220].wys) Then Begin Y:=Mario[n-220].Y-wys;Graw:=0;End;
      End;


    If (PL[(X+Szer div 2) div SzerK+1, (Y+Wys-1) div SzerK+1] in [0, 6, 36, 37, 30, 31]) and
        not (PL[(X+Szer div 2) div SzerK+1, (Y+DYY+Wys-1) div SzerK+1] in [0, 6, 36, 37, 30, 31]) Then
        Y:=((Y+5) div SzerK+1)*SzerK-Wys-1;

    If (PL[X div SzerK+1, (Y+DYY+Wys) div SzerK+1] in [0, 6, 30, 31, 36, 37]) and
       (PL[(X+Szer) div SzerK+1, (Y+DYY+Wys) div SzerK+1] in [0, 6, 30, 31, 36, 37])
       Then Inc(Y, DYY) Else If Graw>0 Then Begin Graw:=0;Skok:=False;End;

    End;
End;



Procedure Rusz_Sprite;

//
//    RUCH OBIEKTÓW WROGÓW - JEDNA Z WAŻNIEJSZYCH PROCEDUR, BEZ NIEJ LUDZIKI BY SIĘ
//    WCALE NIE PORUSZAŁY, A NAWET NIE REAGOWAŁYBY NA RÓŻNE CZYNNIKI NP. GRAWITACJA
//

Var a, b, c, xx:Integer;
   nr : word;

Begin
  For A:=1 to MaxLudz do    //Zbadaj ruch wszystkich obiektów
    With Sprite[a] do
    Begin

    Wys:=Form1.DXImageList2.Items.Find(Lw[Ludzik]).PatternHeight;
    Szer:=Form1.DXImageList2.Items.Find(Lw[Ludzik]).PatternWidth;

    If Maska[(X+szer) div SzerK+1, (Y+wys div 2) div SzerK+1]=A Then Maska[(X+szer) div SzerK+1, (Y+wys div 2) div SzerK+1]:=0;
    If Maska[(X) div SzerK+1, (Y+wys div 2) div SzerK+1]=A Then Maska[(X) div SzerK+1, (Y+wys div 2) div SzerK+1]:=0;
    If Maska[(X+szer div 2) div SzerK+1, (Y+wys div 2) div SzerK+1]=A Then Maska[(X+szer div 2) div SzerK+1, (Y+wys div 2) div SzerK+1]:=0;
    If Maska[(X+szer div 2) div SzerK+1, Y div SzerK+1]=A Then Maska[(X+szer div 2) div SzerK+1, Y div SzerK+1]:=0;


    If Rysuj Then
    If Zyje Then
    Begin

    //CHODZENIE, I INNE WAŻNE (OSOBISTE) FUNKCJE

    If Poruszanie[Ludzik, 1] Then CHODZ(A);
    If Poruszanie[Ludzik, 2] Then SPADA(A);
    If Poruszanie[Ludzik, 3] Then SINUS(A);
    If Poruszanie[Ludzik, 4] Then SKOKW(A);
    If Poruszanie[Ludzik, 5] Then SPREZ(A);
    If Poruszanie[Ludzik, 6] Then WINDX(A);
    If Poruszanie[Ludzik, 7] Then GRAWI(A);



    If Skok Then If (PL[(X+1) div SzerK+1, (Y-DY) div SzerK+1] in [0, 6, 36, 37, 30, 31]) and
         (PL[(X+Szer-1) div SzerK+1, (Y-DY) div SzerK+1] in [0, 6, 36, 37, 30, 31]) Then Y:=Y-DY
         Else
         Begin
         Graw:=DY;

       //1. CEGŁÓWKA
       If (PL[(X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1] in [1, 23]) Then
       If Duzy Then
         CEG((X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1)
       Else
         SKO((X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1, True);

       //2. UDERZENIE W PUNKT LUB COS PODOBNEGO
       If (PL[(X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1] in [3,5]) Then
       Begin
         PUN((X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1);
         SKO((X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1, True);
       END;

       //3. UDERZENIE W GRZYBA LUB COS PODOBNEGO
       If (PL[(X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1] in [7,8]) Then
       If duzy Then GRZ((X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1, 0, a, Kierunek=0) Else
       GRZ((X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1, 1, a, Kierunek=0);

       //4. UDERZENIE W PUSTY PUNKT
       If (PL[(X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1] in [4]) Then
       SKO((X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1, True);

       //5. UDERZENIE W POWER
       If (PL[(X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1] in [32, 35]) Then
       POW((X+szer div 2) div SzerK+1, (Y-DY) div SzerK+1);
       End;  //Koniec Uderzania

   

   For c:=0 to 4 do     //Sprawdzanie kolizji
   For b:=0 to 2 do
   Begin
     nr:= MASKA[(X+Szer div 2) div SzerK+c-1, (Y+Wys) div SzerK+b];

     If nr<201 Then
     //Zderzenia z wrogami
     Begin
       If Sprite[nr].Ludzik=5 Then POD(a, nr);
       If Kolizja(X+DX, Y+Wys-10, Szer+DX, 10, Sprite[nr].X, Sprite[nr].Y+Sprite[nr].Wys-10, Sprite[nr].Szer, 10)
         Then DX:=-DX;
     End;

     //Zderzenie z grzybem
     If ((nr>200) and (nr<221)) Then
     If Grzyb[nr-200].Jest and Kolizja(X, Y, Szer, Wys, Grzyb[nr-200].X, Grzyb[nr-200].Y, Grzyb[nr-200].szer, Grzyb[nr-200].wys) Then
     Begin
       Grzyb[nr-200].Jest:=False;
       If Duzy Then Kwiat:=True Else Duzy:=True;
     End;
   End;     //Sprawdzanie kolizji


    If (Maska[(X+szer) div SzerK+1, (Y+wys div 2) div SzerK+1]>200) or (Maska[(X+szer) div SzerK+1, (Y+wys div 2) div SzerK+1]=0) or (Ludzik=5) Then Maska[(X+szer) div SzerK+1, (Y+wys div 2) div SzerK+1]:=a;
    If (Maska[X div SzerK+1, (Y+wys div 2) div SzerK+1]>200) or (Maska[X div SzerK+1, (Y+wys div 2) div SzerK+1]=0) or (Ludzik=5)  Then Maska[X div SzerK+1, (Y+wys div 2) div SzerK+1]:=a;
    If (Maska[(X+szer div 2) div SzerK+1, (Y+wys div 2) div SzerK+1]>200) or (Maska[(X+szer div 2) div SzerK+1, (Y+wys div 2) div SzerK+1]=0) or (Ludzik=5)  Then Maska[(X+szer div 2) div SzerK+1, (Y+wys div 2) div SzerK+1]:=a;
    If (Maska[(X+szer div 2) div SzerK+1, Y div SzerK+1]>200) or (Maska[(X+szer div 2) div SzerK+1, Y div SzerK+1]=0) or (Ludzik=5) Then Maska[(X+szer div 2) div SzerK+1, Y div SzerK+1]:=A;

    End Else//Do żyjącego ludzika
      Begin
        If Y>Yp*SzerK+MaxEY Then
          Begin
            Rysuj:=False;
            Graw:=0;
          End;

        If Smierc=0 Then
        Begin
        Inc(Przem, 3);
        Inc(Y, 3);

        If Przem>Wys Then
          Begin
            Rysuj:=False;
            Graw:=0;
          End;
        End;

        If Smierc=1 Then
        Begin
          Graw:=Graw+Grawitacja;
          DYY:=Round(Graw);
          If SKOK Then DEC(Y, DY);
          Inc(Y, DYY);
          Inc(X, DX);
        End;
      End;
    End;//Do With
End;


Procedure TForm1.Kanal_lub_plansza;
//
//       CZYŚCI PAMIĘĆ PO PRZEJŚCIU DO KANAŁU LUB PLANSZY
//
Begin
 Timer1.Enabled:=False;
 Timer2.Enabled:=False;
 DXTimer1.Enabled:=False;
 Next_l:=False;
 FillChar(Maska, SizeOf(Maska), 0);
 FillChar(Tab, SizeOf(Tab), 0);
 FillChar(Keys, SizeOf(Keys), False);
End;

Procedure TForm1.Ustaw_Pozycje;
Var c:Byte;
//
//       USTAWIA POZYCJE SPRITE'ÓW I MARIO W ICH NATURALNYM POŁOŻENIU
//       I KASUJE RÓŻNE GŁUPOTY Z POPRZEPRZEDNIEJ PLANSZY LUB KANAŁU
//
Begin
 KatGry:=0;

 //     Własciwosci twojego ludzika (MARIO)
 ZeroMemory(@Maska, SizeOf(Maska));
 
 For c:=1 to 10 do
   Begin
     Mario[c].DY:=10;
     Mario[c].MaxDY:=10;
     Mario[c].DX:=2;
     Mario[c].Graw:=0;
     Mario[c].Koniec:=False;
     Mario[c].sktrwa:=False;
     Mario[c].Jump:=False;
     Mario[c].skok:=False;
     Mario[c].Zniszczon:=0;
     Mario[c].Wchodzi:=false;
     Mario[c].Wszedl:=false;
   End;

 //     Wszyscy wrogowie ożywają !?!

 For c:=1 to 200 do
   Begin
     Sprite[c].Zyje:=True;
     Sprite[c].rysuj:=True;
     Sprite[c].Przem:=0;
     Sprite[c].Smierc:=0;
     Sprite[c].SY:=Sprite[c].Y;
     Sprite[c].Czas:=Random(255);
     Sprite[c].Skok:=False;
     Sprite[c].Kierunek:=0;
   End;

 //     Tylko grzyby giną w niewyjasnionych okolicznosciach

 For c:=1 to 20 do With Grzyb[c] do
   Begin
     Jest:=False;
     Graw:=0;
     SKOK:=False;
     DX:=4;
   End;

 //     Jednak nie tylko grzyby - punkty też - ale te lecące w górę

 For c:=1 to 20 do With LP[c] do
   Begin
     Jest:=False;
   End;

 //     Prędkosc chodzenia wrogów

 For c:=1 to MaxLudz do
     Begin
       Sprite[c].DX:=Sch[Sprite[c].Ludzik];
       If Wt[Sprite[c].Ludzik]>0 Then Sprite[c].Krzywda:=True Else Sprite[c].Krzywda:=False;
     End;

 //     WYŁĄCZA MUZYKĘ Z PEGAZUSA I SZUKA NASTĘPNEJ

 StopMusic;
 muza:=1;
 If (Textura in [1, 3]) Then if not (lev mod 5=0) Then muza:=2 Else muza:=3;
 If Textura in[ 4] Then muza:=4;
 PlayMusic;

 

Strona korzysta z plików cookie w celu świadczenia usług Google (reklamy, statytyki) oraz Facebook. Jeśli chcesz zablokować pliki cookies wyłacz je w swojej przeglądarce. Potrzebujesz pomocy? kliknij