Ver. 1.0 Beta, Don't have a compiler? Now you can write simple scripts ONLINE! This is a basic version -does not include all the Pascal statements. Only to learn basics

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;

 

ON-LINE scripts!

This website uses cookie files in order to provide Google services (advertisements, analitycs) and Facebook. If you want to block using cookies, turn them off in your browser settings. Need a help? Click me