Facebook - konwersja
Delphi w przykładach dla początkujących - Ebook (Książka EPUB) do pobrania w formacie EPUB
Pobierz fragment

Delphi w przykładach dla początkujących - ebook

Format ebooka:
EPUB
Format EPUB
czytaj
na czytniku
czytaj
na tablecie
czytaj
na smartfonie
Jeden z najpopularniejszych formatów e-booków na świecie. Niezwykle wygodny i przyjazny czytelnikom - w przeciwieństwie do formatu PDF umożliwia skalowanie czcionki, dzięki czemu możliwe jest dopasowanie jej wielkości do kroju i rozmiarów ekranu. Więcej informacji znajdziesz w dziale Pomoc.
Multiformat
E-booki w Virtualo.pl dostępne są w opcji multiformatu. Oznacza to, że po dokonaniu zakupu, e-book pojawi się na Twoim koncie we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu.
, MOBI
Format MOBI
czytaj
na czytniku
czytaj
na tablecie
czytaj
na smartfonie
Jeden z najczęściej wybieranych formatów wśród czytelników e-booków. Możesz go odczytać na czytniku Kindle oraz na smartfonach i tabletach po zainstalowaniu specjalnej aplikacji. Więcej informacji znajdziesz w dziale Pomoc.
Multiformat
E-booki w Virtualo.pl dostępne są w opcji multiformatu. Oznacza to, że po dokonaniu zakupu, e-book pojawi się na Twoim koncie we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu.
(2w1)
Multiformat
E-booki sprzedawane w księgarni Virtualo.pl dostępne są w opcji multiformatu - kupujesz treść, nie format. Po dodaniu e-booka do koszyka i dokonaniu płatności, e-book pojawi się na Twoim koncie w Mojej Bibliotece we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu przy okładce. Uwaga: audiobooki nie są objęte opcją multiformatu.
czytaj
na tablecie
Aby odczytywać e-booki na swoim tablecie musisz zainstalować specjalną aplikację. W zależności od formatu e-booka oraz systemu operacyjnego, który jest zainstalowany na Twoim urządzeniu może to być np. Bluefire dla EPUBa lub aplikacja Kindle dla formatu MOBI.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na czytniku
Czytanie na e-czytniku z ekranem e-ink jest bardzo wygodne i nie męczy wzroku. Pliki przystosowane do odczytywania na czytnikach to przede wszystkim EPUB (ten format możesz odczytać m.in. na czytnikach PocketBook) i MOBI (ten fromat możesz odczytać m.in. na czytnikach Kindle).
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na smartfonie
Aby odczytywać e-booki na swoim smartfonie musisz zainstalować specjalną aplikację. W zależności od formatu e-booka oraz systemu operacyjnego, który jest zainstalowany na Twoim urządzeniu może to być np. iBooks dla EPUBa lub aplikacja Kindle dla formatu MOBI.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
Wydawnictwo:
ISBN:
978-83-8126-883-7
Język:
Polski
Data wydania:
Listopad 2018
Rozmiar pliku:
2,4 MB
Zabezpieczenie:
Watermark
Watermark
Watermarkowanie polega na znakowaniu plików wewnątrz treści, dzięki czemu możliwe jest rozpoznanie unikatowej licencji transakcyjnej Użytkownika. E-książki zabezpieczone watermarkiem można odczytywać na wszystkich urządzeniach odtwarzających wybrany format (czytniki, tablety, smartfony). Nie ma również ograniczeń liczby licencji oraz istnieje możliwość swobodnego przenoszenia plików między urządzeniami. Pliki z watermarkiem są kompatybilne z popularnymi programami do odczytywania ebooków, jak np. Calibre oraz aplikacjami na urządzenia mobilne na takie platformy jak iOS oraz Android.
17,02
Cena w punktach Virtualo:
1702 pkt.

Delphi w przykładach dla początkujących - opis ebooka

Poradnik programowania w języku Delphi dla początkujących. Na przykładzie ponad 20 projektów Czytelnik poznaje programowanie od strony praktycznej. Książka zawiera pełne kody projektów wraz z obszernym komentarzem wyjaśniającym, rozszerzonym o potrzebną wiedzę teoretyczną, dzięki czemu można poznać i zrozumieć algorytmy programowania. Autor w sposób ciekawy i inspirujący opowiada o możliwościach, jakie daje programowanie, nie stroniąc od takich tematów, jak budowa robota czy androida.

FRAGMENT KSIĄŻKI

Oddajemy do rąk Czytelnika pierwszą część książki poświęconej programowaniu w języku Delphi. Nie należy jej traktować jako podręcznika, ponieważ nią nie jest. Ideą przewodnią całego cyklu jest prezentacja możliwości Delphi na podstawie konkretnych rozwiązań. Poprzez nie Czytelnik zapoznaje się ze sztuką programowania.

Każdy zamieszczony w tej książce program jest szczegółowo opisany i skomentowany. W ten sposób Czytelnik sukcesywnie zapoznaje się z nowymi rozwiązaniami i poleceniami Delphi, które później będzie mógł wykorzystać w swoich projektach.

Do tej pory powstało wiele książek i artykułów na temat podstaw Delphi, także w internecie nie brakuje materiałów na ten temat. Niniejsza książka jest odpowiedzią na powstały nie-dosyt, jak owe teoretyczne wiadomości wykorzystać w praktyce. Wychodząc naprzeciw początkującym programistom, zawarliśmy w książce projekty ponad dwudziestu różnych programów komputerowych, jak najbardziej stroniąc od powtarzania podstawowej wiedzy na temat programowania, którą bez problemu można pozyskać, chociażby z internetu. Opierając się na tym założeniu, oczekujemy od Czytelnika posiadania podstawowej wiedzy na temat programowania w języku Delphi. Zakładamy więc, iż Czytelnik wie, w jaki sposób utworzyć nowy projekt programu, w jaki sposób umieścić potrzebne komponenty na formie głównej oraz, w jaki sposób zmieniać właściwości komponentów.

Większość zamieszczonych w książce projektów jest w formie surowej, bez estetycznych upiększeń. Naszym celem bowiem było przedstawienie działających rozwiązań, zadbanie o poprawną pracę programów. W ten sposób też każdy programista powinien pracować nad swoim projektem. Najpierw tworzymy surowy szkic programu, zabiegając wyłącznie o to, aby wszystkie jego procedury działały bez zarzutu. Na samym końcu dopiero zaczynamy zajmować się estetyką programu, nadając kolory, style itd. My pominęliśmy ten etap, wychodząc z założenia, iż dla programisty liczyć się będzie tylko działające rozwiązanie. Z uwagi na to, iż o gustach się nie dyskutuje, przyjmujemy, że programista nada zaprezentowanym programom własną szatę graficzną, przystosowaną do indywidualnej wrażliwości estetycznej. Jako przykład poglądowy, w rozdziale pt. „Hot Spot” zamieszczamy w pełni opracowany projekt, także pod względem szaty graficznej, aby przedstawić jedną z propozycji zadbania o wygląd naszego programu.

Książka podzielona jest na dwa główne działy: Gry i zabawy oraz Programy użytkowe. Nie chcemy w naszym cyklu ograniczać Delphi tylko do programów użytkowych. Programowanie daje znacznie większe możliwości i nie chcemy mentalności początkującego programisty zamykać w tym ograniczonym wyobrażeniu. Zgodnie z tym założeniem w następnych częściach pojawią się kolejne działy, jak chociażby budowa robota czy androida, które odsłonią pełną ofertę możliwości, jaką daje programowanie w języku Delphi. Nabywając w ten sposób szerszego spojrzenia na temat programowania, staniemy się profesjonalnymi programistami, którzy nie będą bali się wyzwań. Tylko na tej podstawie możliwe są wszelkie innowacje i rewolucje technologiczne. Ktoś, kto boi się poszukiwać i z góry zakłada, że to się nie uda, nigdy nie stanie się autorem czegoś przełomowego. Jako przykład — choć może z nieco innej dziedziny — przywołamy Alberta Einsteina, który zapytany o to, w jaki sposób wpadł na pomysł swojej teorii względności, odpowiedział krótko, że nie bał się myśleć. Nie bójmy się zatem i my. Zastanawiajmy się, poszukujmy i pytajmy, jeżeli czegoś nie wiemy, bo tylko w ten sposób możemy się rozwijać, także jako programiści.

Mam nadzieję, że niniejsza książka będzie inspiracją dla Czytelników i zachętą do rozwijania własnych projektów. Tego wszystkim życzę z całego serca.

Robert TrafnyPolicz, ile to jest — wersja prosta

Rozdział poświęcony grom i zabawom wykonanych w środowisku Borland Turbo Delphi otwieramy, chyba najprostszym przykładem z możliwych (z punktu widzenia programistycznego), zabawą matematyczną polegającą na odgadnięciu poprawnego wyniku działania na dwóch liczbach.

Założenia i opis zabawy:

Po naciśnięciu przycisku START program wybierze dla nas jakieś działanie matematyczne z użyciem dwóch liczb, wyświetli je i poprosi o podanie właściwego wyniku. Ponieważ zależy nam na rozwijaniu swego umysłu, wszystkie obliczenia wykonujemy w pamięci. Z uwagi na ten wymóg, ograniczymy zakres używanych liczb do dwudziestu: program będzie wybierał liczby tylko z zakresu od 0 do 20. Oczywiście, programista może sobie ustalić ten zakres w sposób zupełnie indywidualny.

Kolejnym ograniczeniem, jakiego dokonamy, będzie wyeliminowanie z używanych działań, dzielenia. W ten sposób nie będziemy musieli obliczać w pamięci liczb ułamkowych. Trudno przecież w pamięci policzyć, ile to jest 19 podzielić przez 7. Nasz program będzie obsługiwał tylko dodawanie, odejmowanie i mnożenie.

Po obliczeniu w pamięci wyniku wpisujemy go w pole edycyjne programu i naciskamy przycisk Sprawdź. Program sprawdza poprawność wyniku i wyświetla odpowiedni komunikat informacyjny, czy dobrze, czy źle. Jeżeli odpowiedź jest poprawna, działanie jest usuwane z panelu programu. Inna sytuacja ma miejsce w przypadku podania niepoprawnej odpowiedzi. Działanie do policzenia nie znika, usuwany jest tylko podany przez nas wynik. W ten sposób możemy spróbować swoich sił jeszcze raz, a gdy się znowu nie uda, jeszcze raz i jeszcze raz. Decyzja będzie zależała od nas. Jeżeli będziemy chcieli zrezygnować z tego działania, wystarczy, że naciśniemy przycisk START, a program wymieni nam działanie na inne.

Wprowadzamy do programu także tabelę wyników, która będzie pokazywała, ile do tej pory udzieliliśmy odpowiedzi poprawnych, a ile niepoprawnych. Przy zamykaniu programu, pojawi się także komunikat, w którym w zależności od uzyskanych wyników, program nam pogratuluje lub zachęci do większego zaangażowania.

Jako rozszerzenie możliwości programu zadbamy o to, aby program informował nas, gdy nieopatrznie naciśniemy przycisk Sprawdź bez wpisania wyniku w polu edycyjnym oraz aby umożliwiał wpisywanie w tym polu tylko liczb, minusa (bo wyniki będą czasami liczbami ujemnymi) oraz pozwalał na używanie klawisza Backpace do kasowania wprowadzanych znaków w przypadku pomyłki.

Użyte komponenty:

Edit1 — pole edycyjne do wpisywania odpowiedzi,

Button1 — przycisk START,

Button2 — przycisk Sprawdź,

Label1 — wyświetla napis „Wyniki”,

Label2 — wyświetla napis „Poprawne:”,

Label3 — wyświetla napis „Niepoprawne:”,

Label4 — wyświetla ilość poprawnych odpowiedzi,

Label5 — wyświetla ilość niepoprawnych odpowiedzi,

Label6 — wyświetla działanie do policzenia.

Powyższe komponenty wstawiamy na formę główną i układamy względem siebie tak jak na rysunku poniżej:

Należy zwrócić uwagę, że numery komponentów lub formy głównej (TForm) mogą się w Waszych projektach różnić. Należy więc poszczególny kod przypisać do właściwych komponentów i nadać im właściwe nazwy. W naszym projekcie modyfikujemy nazwy poszczególnym komponentom w następujący sposób (właściwość Caption w Inspektorze Obiektów):

Komponent nazwa

Edit1 (usuwamy nazwę)

Button1 START

Button2 Sprawdź

Label1 Wyniki

Label2 Poprawne:

Label3 Niepoprawne:

Label4 0 (zero)

Label5 0 (zero)

Label6 Ile to jest:

W dalszej kolejności także przy pomocy Inspektora Obiektów zmieniamy inne właściwości tych komponentów, a więc: kolor, rozmiar, położenie itp.

Kod programu

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Edit1: TEdit;

Button1: TButton;

Button2: TButton;

Label1: TLabel;

Label2: TLabel;

Label3: TLabel;

Label4: TLabel;

Label5: TLabel;

Label6: TLabel;

procedure Button1Click(Sender: TObject);

procedure Button2Click(Sender: TObject);

procedure Edit1KeyPress(Sender: TObject; var Key: Char);

procedure FormCreate(Sender: TObject);

procedure FormClose(Sender: TObject; var Action: TcloseAction);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

WYNIK: Integer; //zmienna przechowująca wynik działania

Poprawne: Integer; //zmienna przechowująca ilość poprawnych odpowiedzi

Niepoprawne: Integer; //zmienna przechowująca ilość niepoprawnych odpowiedzi

implementation

{$R *.dfm}

//przy uruchomieniu programu wyzeruj punktację

procedure TForm1.FormCreate(Sender: TObject);

begin

Poprawne:=0; //wyzeruj ilość poprawnych odpowiedzi

Niepoprawne:=0; //wyzeruj ilość niepoprawnych odpowiedzi

Label4.Caption:= „0”; //wyświetl „0” poprawnych odpowiedzi

Label5.Caption:= „0”; //wyświetl „0” niepoprawnych odpowiedzi

end;

//przy zamykaniu programu oceń uzyskane wyniki

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);

begin

if (Poprawne
begin

ShowMessage(„Musisz jeszcze trochę potrenować”);

end

else

ShowMessage(„Gratuluję! Uzyskałeś dobry wynik”);

end;

//pozwól na wpisywanie tylko liczb, minusa i Backpace w polu odpowiedzi

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);

begin

if not (Key in ) then

begin

Key:=#0;

ShowMessage(„To nie jest liczba”); //wyświetl komunikat o błędzie

end;

end;

//gdy naciśniesz przycisk START

procedure TForm1.Button1Click(Sender: TObject);

var

Liczba1: Integer; //zmienna przechowująca pierwszą liczbę

Liczba2: Integer; //zmienna przechowująca drugą liczbę

Dzialanie: Integer; //zmienna pomocnicza do losowania znaku działania

Znak: String; //zmienna przechowująca znak działania

begin

Edit1.Clear; //wyczyść pole edycyjne (Do podawania Odpowiedzi)

Randomize; //uruchom maszynę losującą

Liczba1:=Random(21); //losuj pierwszą liczbę

Liczba2:=Random(21); //losuj drugą liczbę

Dzialanie:=Random(3); //losuj znak działania matematycznego

case Dzialanie of //gdy zostanie wylosowana dana liczba to…

0: WYNIK:= Liczba1+Liczba2; //…wykonaj dodawanie

1: WYNIK:= Liczba1-Liczba2; //…wykonaj odejmowanie

2: WYNIK:= Liczba1*Liczba2; //…wykonaj mnożenie

end;

if Dzialanie=0 then

Znak:= '+'; //jeżeli wylosowano dodawanie to pokaż znak '+”

if Dzialanie=1 then

Znak:= '-'; //jeżeli wylosowano odejmowanie to pokaż znak '-”

if Dzialanie=2 then

Znak:= „x”; //jeżeli wylosowano mnożenie to pokaż znak „x”

Label6.Caption:=(„Ile jest: ' + IntToStr(Liczba1) + ' ' + znak + ' ' +IntToStr(Liczba2) + ”? ”); //wyświetl działanie

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

end;

//gdy naciśniesz przycisk Sprawdź

procedure TForm1.Button2Click(Sender: TObject);

Label KONIEC; //Etykieta do przechodzenia w inne miejsca kodu

var

Odp: String; //zmienna przechowująca naszą odpowiedź

begin

Odp:= Edit1.Text; //odczytaj podaną odpowiedź i przypisz ja do zmiennej

if Odp=„” then //gdy nie podano odpowiedzi monituj o wpisaniu wyniku

begin

ShowMessage(„Wpisz najpierw wynik”); //wyświetl komunikat informujący

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

goto KONIEC; //pomiń poniższy kod i przejdź od razu na koniec procedury

end;

if Odp=(IntToStr(WYNIK)) then //jeżeli odpowiedź jest poprawna to …

begin

ShowMessage(„Bardzo dobrze!”); //wyświetl komunikat o poprawnej odpowiedzi

Label6.Caption:= „Ile jest: '; //wyczyść działanie

Poprawne:=Poprawne +1; //dodaj punkt do poprawnych odpowiedzi

end //bez średnika

else //w przeciwnym wypadku …

begin

ShowMessage(„Niestety źle”); //wyświetl komunikat o złej odpowiedzi

Niepoprawne:=Niepoprawne +1; //dodaj punkt do niepoprawnych odpowiedzi

end;

Edit1.Clear; //wyczyść pole do podawania Odpowiedzi)

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

Label4.Caption:= IntToStr(Poprawne); //wyświetl ilość poprawnych odpowiedzi

Label5.Caption:= IntToStr(Niepoprawne); //wyświetl ilość niepoprawnych odpowiedzi

KONIEC: //etykieta do której przechodzi kod, gdy ktoś nie wpisze żadnej liczby

end;

end.

Komentarz

1. Zmienne globalne

Zazwyczaj w programach używamy zmiennych lokalnych, powiązanych tylko z daną procedurą. W ten sposób unikamy konfliktu logicznego, gdy w tym samym czasie jedną zmienną chcą wykorzystać dwie lub więcej procedur.

Czasami jednak zachodzi potrzeba dostępu do parametru z poziomu różnych procedur tak, jak w naszym programie: procedura dla przycisku START generuje wynik działania, który jest umieszczony w zmiennej globalnej WYNIK, a inna procedura, powiązana z obsługą przycisku Sprawdź, korzysta z tej zmiennej, aby porównać, czy udzielona odpowiedź jest poprawna. Gdyby zmienna WYNIK była zmienną lokalną, zamkniętą w jednej procedurze, nie udałoby się tego dokonać. Stąd też w naszym projekcie umieszczamy trzy zmienne globalne:

WYNIK — do przechowywania wyniku działania,

Poprawne — do przechowywania ilości poprawnych odpowiedzi,

Niepoprawne — do przechowywania ilości niepoprawnych odpowiedzi.

Umieszczamy je w sekcji między var a Implementation, po deklaracji zmiennej Form1: TForm1.

var

Form1: TForm1;

WYNIK: Integer; //zmienna przechowująca wynik działania

Poprawne: Integer; //zmienna przechowująca ilość poprawnych odpowiedzi

Niepoprawne: Integer; //zmienna przechowująca ilość niepoprawnych odpowiedzi

Wszystkie trzy zmienne będą przechowywać liczby, więc muszą być typu Integer.

2. Form Create

Poprawne:=0; //wyzeruj ilość poprawnych odpowiedzi

Niepoprawne:=0; //wyzeruj ilość niepoprawnych odpowiedzi

Label9.Caption:= „0”; //wyświetl „0” poprawnych odpowiedzi

Label10.Caption:= „0”; //wyświetl „0” niepoprawnych odpowiedzi

Procedura Form Create wykonuje napisany przez nas kod w chwili uruchomienia programu, więc w miejscu tym wyzerujemy tabelę wyników i wyświetlimy oba wyniki jako zerowe.

Aby utworzyć procedurę Form Create, klikamy na puste miejsce naszej formy, a następnie w Inspektorze Obiektów przechodzimy do zakładki Events i obok zdarzenia OnCreate klikamy dwa razy. Zostaniemy automatycznie przeniesieni do kodu z nowo utworzoną procedurą.

3. Form Close

if (Poprawne
begin

ShowMessage(„Musisz jeszcze trochę potrenować”);

end

else

ShowMessage(„Gratuluję! Uzyskałeś dobry wynik”);

Procedura Form Close realizowana jest w momencie zamykania programu i tworzymy ją tak samo, jak poprzednią, wybierając jednak zdarzenie OnClose. W sekcji tej umieściliśmy możliwość oceny naszych wyników w zabawie.

Na początku mamy instrukcję warunkową if...then (jeżeli…, to…) oraz warunek do spełnienia. Cały kod możemy przetłumaczyć następująco: Jeżeli (if) Ilość poprawnych odpowiedzi (Poprawne) jest mniejsza (<) od Ilości niepoprawnych odpowiedzi (Niepoprawne) lub (or) Ilość poprawnych (Poprawne) jest taka sama (=) jak Ilość niepoprawnych odpowiedzi (Niepoprawne) to wtedy (then) wyświetl komunikat (ShowMessage) o treści: „Musisz jeszcze trochę potrenować”, w przeciwnym razie (else) (czyli, gdy ilość poprawnych odpowiedzi jest większa od niepoprawnych) wyświetl komunikat: „Gratuluję! Uzyskałeś dobry wynik”.

W tego typu konstrukcji, gdzie używamy operatora else, pamiętajmy o tym, że przed nim polecenie występuje bez zwyczajowo wymaganego średnika (w tym przypadku słowo end). To częsty błąd początkujących programistów.

Kolejne niedopatrzenie, które często staje się udziałem początkujących programistów, jest podawanie warunku. W prostym przypadku instrukcji warunkowej wystarczy napisać tak:

if Poprawne < Niepoprawne then

(kod do wykonania)

Jeżeli jednak chcemy, aby zostało spełnionych kilka warunków, wtedy każdy z nich musimy ująć w nawias, na przykład tak:

if (Poprawne < Niepoprawne) and (Liczba1 = 5) then

(kod do wykonania)

4. Procedura Edit1KeyPress

if not (Key in ) then

begin

Key:=#0;

ShowMessage(„To nie jest liczba”); //wyświetl komunikat o błędzie

end;

Aby utworzyć tę procedurę, klikamy na komponent Edit1, a następnie w Inspektorze Obiektów, w zakładce Events wybieramy zdarzenie OnKeyPress i otwieramy je podwójnym kliknięciem.

Jak sama nazwa wskazuje, procedurę tę wykorzystamy do kontroli wpisywania znaków w polu edycyjnym. Zgodnie z naszymi założeniami chcemy, aby była możliwość wpisywania tylko liczb, minusa i, aby aktywny był klawisz Backpace do kasowania źle wpisanych liczb.

Cały kod odczytamy tak: Jeżeli (if) naciśnięty klawisz (Key) nie jest (not) klawiszem liczb („0”.. „9”), minusem (#45- kod klawisza „minus”), ani Backpace (#8- kod klawisza Backpace), wtedy (then) nie reaguj (Key:#0) tylko wyświetl komunikat (ShowMessage) „To nie jest liczba”.

Z punktu widzenia programu procedura ta nie jest konieczna. Jest to tylko udogodnienie dla nas eliminujące pomyłki.

5. Gdy naciśniesz przycisk START

var

Liczba1: Integer; //zmienna przechowująca pierwszą liczbę

Liczba2: Integer; //zmienna przechowująca drugą liczbę

Dzialanie: Integer; //zmienna pomocnicza do losowania znaku działania

Znak: String; //zmienna przechowująca znak działania

Na początku procedury definiujemy zmienne lokalne, które będą nam potrzebne. Przede wszystkim musimy przygotować dwie zmienne na dwie liczby, które zostaną użyte w działaniu. Za każdym razem program będzie sobie jakieś dwie liczby losowo wybierał, musi więc mieć gdzie je zapisać. Stąd umieszczone zmienne Liczba1 i Liczba2 są typu Integer, a więc typu liczbowego.

Poza liczbami program będzie losował także znak działania (dodawanie, odejmowanie, mnożenie), który następnie będzie mógł wyświetlić w pytaniu. To implikuje użycie zmiennej typu String, a więc typu tekstowego. Zmiennej tej nadaliśmy nazwę „Znak”.

Ostatnia zmienna, czyli „Dzialanie” (nie możemy nadać nazwy „Działanie”, ponieważ Delphi nie używa polskich znaków dialektycznych) służy do wylosowania rodzaju działania (dodawanie, odejmowanie, mnożenie). Jest ona typu liczbowego, ponieważ za jej pomocą będziemy losowali liczbę, do której przypiszemy jedno z tych trzech działań:

Edit1.Clear; //wyczyść pole edycyjne (do podawania Odpowiedzi)

Randomize; //uruchom maszynę losującą

Liczba1:=Random(21); //losuj pierwszą liczbę

Liczba2:=Random(21); //losuj drugą liczbę

Dzialanie:=Random(3); //losuj znak działania matematycznego

case Dzialanie of //gdy zostanie wylosowana dana liczba to…

0: WYNIK:= Liczba1+Liczba2; //…wykonaj dodawanie

1: WYNIK:= Liczba1-Liczba2; //…wykonaj odejmowanie

2: WYNIK:= Liczba1*Liczba2; //…wykonaj mnożenie

Przechodząc do kodu wykonywalnego, po naciśnięciu przycisku START, następuje wyczyszczenie pola edycyjnego (Edit1.Clear), a następnie uruchomienie maszyny losującej (Randomize). Po jej uruchomieniu losujemy potrzebne nam elementy, a więc obie liczby z zakresu od 0 do 20 (Liczba:= Random(21)), oraz rodzaj działania (Dzialanie:=Random(3)). Delphi liczy liczby od zera, stąd też przy Random mamy liczbę 21, a nie 20, tak samo, jak w przypadku zmiennej Dzialanie mamy trzy liczby, ale liczone od zera, a więc: 0, 1, 2.

Dalsza część kodu informuje program, co ma zrobić, gdy zostanie wylosowana odpowiednia liczba dla zmiennej Dzialanie: Jeżeli zostało wylosowane zero, wtedy do zmiennej globalnej WYNIK ma zapisać wynik dodawania obu wcześniej wylosowanych liczb (Liczba1 i Liczba2). Gdy wylosowano 1 lub 2 to, odpowiednio, ma zapisać w zmiennej WYNIK wynik odejmowania lub mnożenia tychże liczb. W ten oto prosty sposób uzyskujemy dużą nieprzewidywalność kolejnego działania, jaki program wygeneruje.

Przypominamy, że przy mnożeniu wykorzystujemy klawisz „gwiazdka”, a przy dzieleniu „ukośnik”.

if Dzialanie=0 then

Znak:= '+'; //jeżeli wylosowano dodawanie to pokaz znak '+”

if Dzialanie=1 then

Znak:= '-'; //jeżeli wylosowano odejmowanie to pokaz znak '-”

if Dzialanie=2 then

Znak:= „x”; //jeżeli wylosowano mnożenie to pokaz znak „x”

W tej sekcji realizujemy dalszą procedurę związaną ze zmienną Dzialanie opartą na instrukcji warunkowej if...then, czyli: Jeżeli dla zmiennej Dzialanie wylosowano zero, wtedy do zmiennej Znak przypisz znak „+”. W podobny sposób odczytujemy informacje dla pozostałych wylosowanych możliwości.

Informacje powyższe potrzebne są nam do wyświetlenia odpowiedniego znaku na etykiecie Label6: Label6.Caption:=(„Ile jest: ' + IntToStr(Liczba1) + ' ' + znak + ' ' +IntToStr(Liczba2) + ”? ”);

Ponieważ etykieta Label6 musi przedstawić wiele różnych informacji, stąd też jest ona zbiorem tekstu i zmiennych. Jako że etykieta służy do wyświetlenia krótkiego tekstu, stąd też informacje wyświetlamy z pozycji kodu, zmieniając jej właściwość Caption. To samo robiliśmy wcześniej, przygotowując projekt z pozycji Inspektora Obiektów (Caption).

Ponieważ nazwa jest zbiorem różnych elementów, więc całość musimy ująć w nawias. W jego środku zwykły tekst umieszczamy w apostrofie, a zmienne dokładamy za pomocą znaku „+”. Gdybyśmy chcieli wyświetlić taki plus, musielibyśmy go także zawrzeć w apostrofie. Z uwagi na to, że liczby nie są typu tekstowego (string), tylko liczbowego (integer), musimy je przekonwertować do postaci string, stosując konwersję typu IntToStr. W ten sposób liczby będą mogły zostać wyświetlone, gdyż zostaną potraktowane jako znaki tekstowe. Proszę nie zapomnieć o spacji po słowie „jest” ani przed znakiem zapytania. To samo tyczy się pustych miejsc ujętych w apostrofy przed i za zmienną „Znak”. Są one potrzebne do tego, aby porobić odstępy między słowami i liczbami.

Na zakończenie kodu umieszczamy polecenie: Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

Ta linia nie jest konieczna, ale jest użyteczna, ponieważ po wyświetleniu działania umieszcza kursor w polu edycyjnym. Bez tego kodu, po każdorazowym naciśnięciu przycisku START i wyświetleniu działania, musielibyśmy myszką klikać w pole edycyjne, aby wpisać wynik. Rozwiązanie, które tu stosujemy, umożliwia po wyświetleniu działania od razu wpisać z klawiatury wynik bez użycia myszki. To duże udogodnienie przy zabawie.

6. Gdy naciśniesz przycisk Sprawdź

Label KONIEC; //Etykieta do przechodzenia w inne miejsca kodu

var

Odp: String; //zmienna przechowująca naszą odpowiedź

Zanim zadeklarujemy zmienną Odp, deklarujemy element Label. Nie jest to jednak komponent Label służący do wyświetlania napisów, co widać w innym pokolorowaniu składni w kodzie. Element ten jest częścią instrukcji goto, przy pomocy której możemy przenieść się w inne miejsce kodu i służy do zadeklarowania nazwy, która będzie ten punkt określała. Może być ona dowolna. Starajmy się wybierać takie nazwy, które będą nas informowały o przeznaczeniu tych instrukcji. W późniejszym czasie, gdyby zaistniała potrzeba modyfikacji kodu, odpowiednie nazwy ułatwią nam rozeznanie się w tych tysiącach linii kodu.

Zadeklarujemy teraz zmienną, która będzie przechowywać naszą odpowiedź. Teoretycznie powinna być typu liczbowego (Integer), ponieważ w pole edycyjne Edit1 wpisujemy z klawiatury liczby. Niestety, pomimo wpisywania do komponentu Edit cyfr są one traktowane jako znaki tekstowe, a nie liczbowe, ponieważ komponent ten służy do wyświetlania znaków tekstowych. Nie jest to problem, ponieważ w dalszej części kodu będziemy mogli przekonwertować te wartości. Mając tę wiedzę, deklarujemy więc zmienną „Odp” typu tekstowego (String).

Odp:= Edit1.Text; //odczytaj podaną odpowiedź i przypisz ją do zmiennej

if Odp=„” then //gdy nie podano odpowiedzi monituj o wpisaniu wyniku

begin

ShowMessage(„Wpisz najpierw wynik”); //wyświetl komunikat informujący

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

goto KONIEC; //pomiń poniższy kod i przejdź od razu na koniec procedury

W pierwszej części kodu przypisujemy podaną przez nas odpowiedź (wpisaną do pola Edit) do zmiennej „Odp”. Tutaj wprowadzamy jedno z naszych wcześniejszych założeń, mianowicie chcemy, aby program informował nas o sytuacji, gdy naciśniemy przycisk „Sprawdź”, a w polu edycyjnym nie będzie wpisana żadna liczba. Jest to zadanie opcjonalne, niewpływające na poprawną pracę samej zabawy, ale warto zaopatrzyć w nie nasz program na wszelki wypadek. W sytuacji, gdy naciśniemy przycisk „Sprawdź”, a w polu edycyjnym nie będzie wpisana żadna liczba, bez tego kodu, program uzna to za błędną odpowiedź, ponieważ puste pole nie będzie pasowało do poprawnego wyniku.

Aby zrealizować nasze założenie, wprowadzamy instrukcję warunkową if: Jeżeli zmienna „Odp” nie zawiera żadnej wartości (if Odp = „” — normalnie, pomiędzy apostrofami powinien znaleźć się jakiś znak lub tekst), wtedy (then) wykonaj następujące instrukcje (begin… end): Wyświetl komunikat informujący o tym (ShowMessage), ustaw kursor (focus) ponownie na polu edycyjnym, oraz przejdź do punktu „KONIEC:”, aby pominąć wykonywanie dalszych instrukcji (goto KONIEC). Bez tego przejścia program, po wyświetleniu komunikatu zrealizowałby kolejne linie kodu, czyli porównałby naszą odpowiedź z poprawnym wynikiem i uznał ją za błędną.

W przypadku jakiejkolwiek instrukcji warunkowej, jeżeli chcemy, aby program wykonał kilka różnych operacji, musimy je wszystkie zawrzeć w bloku „begin… end”. Podobnie, jak w poprzednim przypadku, ustawiamy kursor na polu edycyjnym dla naszej wygody, aby nie trzeba było klikać na nie myszką.

if Odp= (IntToStr(WYNIK)) then //jeżeli odpowiedź jest poprawna to …

begin

ShowMessage(„Bardzo dobrze!”); //wyświetl komunikat o poprawnej odpowiedzi

Label11.Caption:= „Ile jest: '; //wyczyść działanie

Poprawne:= Poprawne +1; //dodaj punkt do poprawnych odpowiedzi

end //bez średnika

else //w przeciwnym wypadku …

begin

ShowMessage(„Niestety źle”); //wyświetl komunikat o złej odpowiedzi

Niepoprawne:= Niepoprawne +1; //dodaj punkt do niepoprawnych odpowiedzi

end;

Czas najwyższy ocenić naszą odpowiedź. W tym celu stosujemy instrukcję warunkową if...then: Jeżeli udzielona przez nas odpowiedź (Odp) jest taka sama (=) jak wynik działania (WYNIK), wtedy (then) wykonaj następujące instrukcje (begin… end): Wyświetl komunikat (ShowMessage) informujący o poprawnej odpowiedzi, pozostaw tylko napis „Ile jest:” (Label6.Caption) oraz zwiększ zmienną przechowującą ilość poprawnych odpowiedzi o 1 (Poprawne:= Poprawne+1), w przeciwnym wypadku (else) (czyli, gdy nasza odpowiedź będzie się różniła od poprawnego wyniku), wykonaj następujące instrukcje (begin… end): wyświetl komunikat o błędnej odpowiedzi (ShowMessage) oraz zwiększ zmienną przechowującą ilość niepoprawnych odpowiedzi o 1.

Konstrukcja typu Zmienna:=Zmienna+1 pozwala nam zapamiętywać wynik i powiększać go lub pomniejszać w trakcie działania programu. W ten sposób program „pamięta” nasz wynik.

Aby dopasować typy danych, wynik ze zmiennej WYNIK (typu Integer) konwertujemy do typu String za pomocą konwersji IntToStr.

Edit1.Clear; //wyczyść pole do podawania Odpowiedzi

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

Label9.Caption:= IntToStr(Poprawne); //wyświetl ilość poprawnych odpowiedzi

Label10.Caption:= IntToStr(Niepoprawne); //wyświetl ilość niepoprawnych odpowiedzi

KONIEC

Bez względu na udzieloną przez nas odpowiedź, po jej ocenie, wymazujemy ją z pola edycyjnego (Edit1.Clear) i ustawiamy na nim kursor (focus), przygotowując program na przyjęcie kolejnej odpowiedzi.

Na koniec wyświetlamy podsumowanie naszych wyników. W tym celu w komponencie Label4 wyświetlamy ilość poprawnych odpowiedzi, zmieniając jego nazwę (Caption) na wartość odpowiadającą zmiennej Poprawne. Ponieważ zmienna ta jest typu Integer, więc musimy zastosować konwersję, aby dostosować ją do charakteru tekstowego, jakim jest nazwa komponentu Label.

Powyższe zadanie powtarzamy dla komponentu Label5 wyświetlającego ilość niepoprawnych odpowiedzi, wiążąc jego nazwę (Caption) z wartością zmiennej Niepoprawne.

Na samym końcu umieszczamy etykietę KONIEC, czyli miejsce, do którego przechodzi instrukcja goto. Jest ona na samym końcu, więc cały kod pomiędzy instrukcjami „goto KONIEC” a „KONIEC” jest przez nią pomijany.

Zaprezentowany przez nas przykład prostej zabawy matematycznej możemy traktować jako punkt wyjścia dla bardziej rozbudowanych rozwiązań. Aby dać tego przykład, w dwóch kolejnych propozycjach rozwiniemy tę zabawę w dwóch różnych obszarach: w jednym, utrudnimy sobie liczenie, dokładając kolejne dwie liczby, a w drugim, zamiast wyświetlać komunikaty, program będzie je wypowiadał. Po zastosowaniu dodatkowych rozwiązań z tej książki możemy nawet sprawić, aby całkiem wyłączyć monitor i bawić się z komputerem tak, jak z żywym człowiekiem. To naprawdę zależy tylko od naszej inwencji.Policz, ile to jest — wersja trudniejsza

Poniższy przykład jest trudniejszą wersją poprzednio zaprezentowanej gry. W tamtej działania odbywały się z użyciem dwóch liczb, a w tej, z użyciem aż czterech, na przykład: „Ile to jest: 2 +8 x 11 — 7?”. Wszystkie inne nasze założenia i rozwiązania pozostają bez zmian.

Kod programu

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Edit1: TEdit;

Button1: TButton;

Button2: TButton;

Label1: TLabel;

Label2: TLabel;

Label3: TLabel;

Label4: TLabel;

Label5: TLabel;

Label6: TLabel;

procedure FormCreate(Sender: TObject);

procedure FormClose(Sender: TObject; var Action: TCloseAction);

procedure Edit1KeyPress(Sender: TObject; var Key: Char);

procedure Button1Click(Sender: TObject);

procedure Button2Click(Sender: Tobject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

WYNIK: Integer; //zmienna przechowująca wynik działania

Poprawne: Integer; //zmienna przechowująca ilość poprawnych odpowiedzi

Niepoprawne: Integer; //zmienna przechowująca ilość niepoprawnych odpowiedzi

implementation

{$R *.dfm}

//przy uruchomieniu programu wyzeruj punktację

procedure TForm1.FormCreate(Sender: TObject);

begin

Poprawne:=0; //wyzeruj ilość poprawnych odpowiedzi

Niepoprawne:=0; //wyzeruj ilość niepoprawnych odpowiedzi

Label4.Caption:= „0”; //wyświetl „0” poprawnych odpowiedzi

Label5.Caption:= „0”; //wyświetl „0” niepoprawnych odpowiedzi

end;

//przy zamykaniu programu oceń uzyskane wyniki

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);

begin

if (Poprawne
begin

ShowMessage(„Musisz jeszcze trochę potrenować”);

end

else

ShowMessage(„Gratuluję! Uzyskałeś dobry wynik”);

end;

//pozwól na wpisywanie tylko liczb, minusa i Backpace w polu odpowiedzi

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);

begin

if not (Key in ) then

begin

Key:=#0;

ShowMessage(„To nie jest liczba”); //wyświetl komunikat o błędzie

end;

end;

//gdy naciśniesz przycisk START

procedure TForm1.Button1Click(Sender: TObject);

var

Liczba1: Integer; //zmienna przechowująca pierwszą liczbę

Liczba2: Integer; //zmienna przechowująca drugą liczbę

Liczba3: Integer; //zmienna przechowująca trzecią liczbę

Liczba4: Integer; //zmienna przechowująca czwartą liczbę

Dzialanie: Integer; //zmienna pomocnicza do losowania znaku działania

Znak1: String; //zmienna przechowująca pierwszy znak działania

Znak2: String; //zmienna przechowująca drugi znak działania

Znak3: String; //zmienna przechowująca trzeci znak działania

begin

Edit1.Clear; //wyczyść pole edycyjne (Do podawania Odpowiedzi)

Randomize; //uruchom maszynę losującą

Liczba1:=Random(21); //losuj pierwszą liczbę

Liczba2:=Random(21); //losuj drugą liczbę

Liczba3:=Random(21); //losuj trzecią liczbę

Liczba4:=Random(21); //losuj czwartą liczbę

//wygeneruj pierwszą część działania

Dzialanie:=Random(3); //losuj znak działania matematycznego

case Dzialanie of //gdy zostanie wylosowana dana liczba to…

0: WYNIK:= Liczba1+Liczba2; //…wykonaj dodawanie

1: WYNIK:= Liczba1-Liczba2; //…wykonaj odejmowanie

2: WYNIK:= Liczba1*Liczba2; //…wykonaj mnożenie

end;

if Dzialanie=0 then

Znak1:= '+'; //jeżeli wylosowano dodawanie to pokaż znak '+”

if Dzialanie=1 then

Znak1:= '-'; //jeżeli wylosowano odejmowanie to pokaż znak '-”

if Dzialanie=2 then

Znak1:= „x”; //jeżeli wylosowano mnożenie to pokaż znak „x”

//wygeneruj drugą część działania

Dzialanie:=Random(3); //losuj znak działania matematycznego

case Dzialanie of //gdy zostanie wylosowana dana liczba to…

0: WYNIK:= WYNIK+Liczba3; //…wykonaj dodawanie

1: WYNIK:= WYNIK-Liczba3; //…wykonaj odejmowanie

2: WYNIK:= WYNIK*Liczba3; //…wykonaj mnożenie

end;

if Dzialanie=0 then

Znak2:= '+'; //jeżeli wylosowano dodawanie to pokaż znak '+”

if Dzialanie=1 then

Znak2:= '-'; //jeżeli wylosowano odejmowanie to pokaż znak '-”

if Dzialanie=2 then

Znak2:= „x”; //jeżeli wylosowano mnożenie to pokaż znak „x”

//wygeneruj trzecią część działania

Dzialanie:=Random(3); //losuj znak działania matematycznego

case Dzialanie of //gdy zostanie wylosowana dana liczba to…

0: WYNIK:= WYNIK+Liczba4; //…wykonaj dodawanie

1: WYNIK:= WYNIK-Liczba4; //…wykonaj odejmowanie

2: WYNIK:= WYNIK*Liczba4; //…wykonaj mnożenie

end;

if Dzialanie=0 then

Znak3:= '+'; //jeżeli wylosowano dodawanie to pokaż znak '+”

if Dzialanie=1 then

Znak3:= '-'; //jeżeli wylosowano odejmowanie to pokaż znak '-”

if Dzialanie=2 then

Znak3:= „x”; //jeżeli wylosowano mnożenie to pokaż znak „x”

//wyświetl działanie

Label6.Caption:= („Ile jest: '+ IntToStr(Liczba1) + ' ' + znak1 + ' ' +IntToStr(Liczba2) + ' ' + znak2 + ' ' + IntToStr(Liczba3) + ' ' + znak3 + ' ' +IntToStr(Liczba4) + ”? ”);

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

end;

//gdy naciśniesz przycisk Sprawdź

procedure TForm1.Button2Click(Sender: TObject);

Label KONIEC; //Etykieta do przechodzenia w inne miejsca kodu

var

Odp: String; //zmienna przechowująca naszą odpowiedź

begin

Odp:= Edit1.Text; //odczytaj podaną odpowiedź i przypisz ją do zmiennej

if Odp=„” then //gdy nie podano odpowiedzi monituj o wpisaniu wyniku

begin

ShowMessage(„Wpisz najpierw wynik”); //wyświetl komunikat informujący

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

goto KONIEC; //pomiń poniższy kod i przejdź od razu na koniec procedury

end;

if Odp=(IntToStr(WYNIK)) then //jeżeli odpowiedź jest poprawna to …

begin

ShowMessage(„Bardzo dobrze!”); //wyświetl komunikat o poprawnej odpowiedzi

Label6.Caption:= „Ile jest:'; //wyczyść działanie

Poprawne:=Poprawne +1; //dodaj punkt do poprawnych odpowiedzi

end //bez średnika

else //w przeciwnym wypadku …

begin

ShowMessage(„Niestety źle”); //wyświetl komunikat o złej odpowiedzi

Niepoprawne:=Niepoprawne +1; //dodaj punkt do niepoprawnych odpowiedzi

end;

Edit1.Clear; //wyczyść pole do podawania Odpowiedzi)

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

Label4.Caption:= IntToStr(Poprawne); //wyświetl ilość poprawnych odpowiedzi

Label5.Caption:= IntToStr(Niepoprawne); //wyświetl ilość niepoprawnych odpowiedzi

KONIEC: //etykieta do której przechodzi kod, gdy ktoś nie wpisze żadnej liczby

end;

end.

Komentarz

W tej części pomijamy te elementy wraz z komentarzem, które zostały już opisane w poprzedniej wersji. Omówimy tylko te elementy, które się zmieniają.

Gdy naciśniemy przycisk START

Najważniejszą zmianą, jaką wprowadzamy to ilość liczb. Zamiast dwóch, mamy je teraz cztery. Sytuacja generalnie jednak nie zmienia się: wartość każdej z nich wyznaczamy losowo z przedziału od 0 do 20 za pomocą instrukcji Random(21). Nie zmienia się także procedura wyznaczająca znak działania, musimy ją tylko zastosować trzy razy, ponieważ tyle znaków będziemy potrzebować na obsługę czterech liczb. Każdy znak działania przypisujemy do innej zmiennej tekstowej (Znak1, Znak2, Znak3), dzięki czemu całe działanie będziemy mogli wyświetlić na etykiecie Label6.

Procedura dla przycisku „Sprawdź” nie zmienia się, gdyż w dalszym ciągu będzie ona sprawdzała wpisany przez nas wynik działania, bez względu na to, jakie działanie wygeneruje procedura przycisku START.

W następnym przykładzie ożywimy nieco nasz program i sprawimy, że przemówi on do nas ludzkim głosem.Powtórz liczby

Jest to kolejna zabawa rozwijająca nasz umysł. W tej trenujemy i rozwijamy pamięć. Program będzie podawał szereg liczb, które będziemy musieli z pamięci powtórzyć.

Założenia i opis zabawy:

Podobnie jak w poprzednich przypadkach, przyjmujemy możliwość wpisywania odpowiedzi po raz drugi, gdy pierwsza nasza odpowiedź będzie błędna. Pozostawiamy także sprawdzone rozwiązania z poprzednich przykładów, czyli możliwość oceny naszych wyników przez program na zakończenie gry i wyświetlanie na bieżąco wyników, ile odpowiedzi udzieliliśmy poprawnych, a ile niepoprawnych.

Zachowujemy także ograniczenia dla pola do wpisywania odpowiedzi: dopuszczamy tylko możliwość wpisywania liczb oraz ich kasowanie. W poprzednich zabawach istniała możliwość wpisywania minusa, w tej zabawie minus nie jest nam potrzebny, więc usuwamy tę możliwość.

Aby ułatwić sobie zadanie, nie będziemy losować każdej liczby osobno. Wylosujemy jedną dużą liczbę, składającą się z pięciu znaków, które będziemy musieli wpisać jedna za drugą, tworząc w ten sposób na powrót jedną dużą liczbę. Jest to dobry kompromis między trudnością zabawy a naszą niewyćwiczoną pamięcią. Nic nie stoi jednak na przeszkodzie, aby zwiększyć ilość liczb do powtórzenia.

Potrzebne komponenty:

Generalnie będziemy używać tych samych komponentów, co w poprzednich zabawach, różnice będą tylko w sposobie ich oprogramowania.

Na formie głównej umieszczamy więc następujące komponenty, nadając im odpowiednie nazwy:

komponent Nazwa (Caption)

Edit1 (usuwamy nazwę)

Button1 START

Button2 Sprawdź

Label1 Powtórz liczby:

Label2 Wyniki

Label3 Poprawne:

Label4 Niepoprawne:

Label5 0

Label 6 0

Label7 00000

A oto interfejs programu i pełny kod zabawy:

Kod programu

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Edit1: TEdit;

Button1: TButton;

Button2: TButton;

Label1: TLabel;

Label2: TLabel;

Label3: TLabel;

Label4: TLabel;

Label5: TLabel;

Label6: TLabel;

Label7: TLabel;

procedure Edit1KeyPress(Sender: TObject; var Key: Char);

procedure FormClose(Sender: TObject; var Action: TCloseAction);

procedure Button1Click(Sender: TObject);

procedure Button2Click(Sender: Tobject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

WYNIK: Integer; //zmienna przechowująca liczby do powtórzenia

Poprawne: Integer; //zmienna przechowująca ilość poprawnych odpowiedzi

Niepoprawne: Integer; //zmienna przechowująca ilość niepoprawnych odpowiedzi

implementation

{$R *.dfm}

//pozwól na wpisywanie tylko liczb i Backpace w polu odpowiedzi

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);

begin

if not (Key in ) then

begin

Key:=#0;

ShowMessage(„To nie jest liczba”); //wyświetl komunikat o błędzie

end;

end;

//przy zamykaniu programu oceń uzyskane wyniki

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);

begin //jeżeli uzyskałeś więcej złych odpowiedzi lub tyle samo co dobrych wtedy…

if (Poprawne
begin

ShowMessage(„Musisz jeszcze trochę potrenować”); //wyświetl komunikat

end //bez średnika

else //w przeciwnym wypadku…

ShowMessage(„Gratuluję! Uzyskałeś dobry wynik”); //wyświetl komunikat

end;

//gdy naciśniesz przycisk START

procedure TForm1.Button1Click(Sender: TObject);

begin

Edit1.Clear; //wyczyść pole edycyjne (Do podawania Odpowiedzi)

Randomize; //uruchom maszynę losującą

WYNIK:=Random(99999); //wylosuj plik do powtórzenia od 0 do 99999

Label7.Caption:=IntToStr(WYNIK); //wyświetl liczbę do powtórzenia

Label7.Update; //uaktualnij komponent label

Button2.Enabled:=false; //zablokuj przycisk Sprawdź

Sleep(3000); //czekaj 3 sekundy

Label7.Caption:=„powtórz”; //zamiast liczby wyświetl napis „powtórz”

Button2.Enabled:=true; //odblokuj przycisk Sprawdź

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

end;

//gdy naciśniesz przycisk Sprawdź

procedure TForm1.Button2Click(Sender: TObject);

Label KONIEC; //Etykieta do przechodzenia w inne miejsce kodu

var

Odp: String; //zmienna przechowująca naszą odpowiedź

begin

Odp:= Edit1.Text; //odczytaj podaną odpowiedź i przypisz ją do zmiennej

if Odp=„” then //gdy nie podano odpowiedzi monituj o błędzie

begin

ShowMessage(„Wpisz najpierw wynik”); //wyświetl komunikat informujący

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

goto KONIEC; //pomiń poniższy kod i przejdź od razu na koniec procedury

end;

if Odp=(IntToStr(WYNIK)) then //jeżeli odpowiedź jest poprawna to …

begin

ShowMessage(„Bardzo dobrze!”); //wyświetl komunikat o poprawnej odpowiedzi

Label7.Caption:= „00000: '; //wyczyść działanie

Poprawne:=Poprawne +1; //dodaj punkt do poprawnych odpowiedzi

end //bez średnika

else //w przeciwnym wypadku …

begin

ShowMessage(„Niestety źle”); //wyświetl komunikat o złej odpowiedzi

Niepoprawne:=Niepoprawne +1; //dodaj punkt do niepoprawnych odpowiedzi

end;

Edit1.Clear; //wyczyść pole do podawania Odpowiedzi)

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

Label5.Caption:= IntToStr(Poprawne); //wyświetl ilość poprawnych odpowiedzi

Label6.Caption:= IntToStr(Niepoprawne); //wyświetl ilość niepoprawnych odpowiedzi

KONIEC: //etykieta do której przechodzi kod, gdy ktoś nie wpisze żadnej liczby

end;

end.

Komentarz

1. Stałe elementy, znane z poprzednich zabaw

Pierwszą część kodu, aż do procedury opisującej przycisk START, nie komentujemy, gdyż znalazła ona swój opis w komentarzu do zabawy „Policz, ile to jest — wersja prosta”.

2. Gdy naciśniesz przycisk START

Edit1.Clear; //wyczyść pole edycyjne (Do podawania Odpowiedzi)

Randomize; //uruchom maszynę losującą

WYNIK:=Random(99999); //wylosuj plik do powtórzenia od 0 do 99999

Na początku procedury usuwamy naszą poprzednią odpowiedź z pola edycyjnego, a następnie uruchamiamy maszynę losującą, aby wylosowała liczby do powtórzenia. W naszej zabawie nie musimy losować każdej liczby osobno, choć oczywiście moglibyśmy. Upraszczamy jednak kod, losując jedną liczbę z zakresu od 0 do 99999. Zazwyczaj wylosowana zostanie liczba pięcioznakowa, czyli tyle, ile założyliśmy. Istnieje małe prawdopodobieństwo, że wylosowana liczba będzie jedno- czy powiedzmy dwuznakowa, taka możliwość istnieje, jednak możemy uznać to za bonus zabawy, że daje nam do powtórzenia prostą liczbę. Gdybyśmy chcieli, aby program za każdym razem przedstawiał pięć liczb, musielibyśmy każdą z nich losować i przedstawiać osobno, względnie musielibyśmy tę naszą jedną liczbę obarczyć kilkoma warunkami, aby program wymuszał użycie pięciu znaków.

Ponieważ w naszej zabawie używamy prostej formy, więc najprościej będzie po prostu wyświetlić ową liczbę na etykiecie programu, obok etykiety Label1, która przedstawia napis „Powtórz liczby”. Skoro wszystkie liczby do powtórzenia wyświetlamy jedna obok drugiej (jako jedną liczbę pięcioznakową), to i w takiej samej formie musimy wpisywać odpowiedź, w przeciwnym wypadku program potraktuje ją jako błędną.

Dla przejrzystości przedstawianych liczb możemy oddzielić je spacjami, używając metody WYNIK , czyli na przykład, chcąc wyświetlić trzecią liczbę ze zmiennej WYNIK, piszemy: Wynik. Spacje wyświetlamy na etykiecie, dodając segment typu (+' '+) — pomiędzy apostrofami umieszczamy jedno miejsce wolne, czyli właśnie spację. Chcąc teraz podać prawidłową odpowiedź, musimy i my podawać liczby, oddzielając je spacjami.

Label7.Caption:=IntToStr(WYNIK); //wyświetl liczbę do powtórzenia

Label7.Update; //uaktualnij komponent label

Button2.Enabled:=false; //zablokuj przycisk Sprawdź

Sleep(3000); //czekaj 3 sekundy

Label7.Caption:=„powtórz”; //zamiast liczby wyświetl napis „powtórz”

Button2.Enabled:=true; //odblokuj przycisk Sprawdź

Edit1.SetFocus; //ustaw focus w Polu do Odpowiedzi

W drugiej części kodu, którą powyżej prezentujemy, wyświetlamy nasze liczby jako jedną liczbę pięcioznakową. Druga linia (Label7.Update) odpowiada za aktualizację napisu etykiety, gdyż zmieniamy ją dwukrotnie w czasie pracy procedury. Teraz wprowadzamy blokadę na przycisk Sprawdź, aby nieuczciwy gracz nie mógł go użyć podczas wyświetlania liczb.

Czas wyświetlania ustaliliśmy na trzy sekundy. Należy w tym miejscu pamiętać, że maszyny mikroprocesorowe, w tym między innymi komputer, jako podstawowej jednostki czasu nie używają sekundy (sekunda dla procesora to kawał czasu), lecz milisekundy i w tych też jednostkach podajemy wszelkie wartości związane z czasem, a więc wartość „3 sekundy” podajemy jako 3000 (ms). Po tym czasie program realizuje kolejne polecenia kodu: w miejsce liczb do odgadnięcia wyświetla teraz napis zachęcający „Powtórz”, odblokowuje przycisk „Sprawdź” oraz, na samym końcu, umieszcza kursor (focus) na polu do wpisywania odpowiedzi, wyręczając nas od klikania w to miejsce myszką.

3. Gdy naciśniesz przycisk „Sprawdź”

Poza drobnymi szczegółami procedura obsługująca sprawdzenie naszej odpowiedzi nie różni się od rozwiązania stosowanego w poprzednich grach, więc nie będziemy jej ponownie opisywać.

W kolejnych dwóch propozycjach gier i zabaw, przedstawimy podobne projekty: pierwszy, zamiast liczb będzie oczekiwał od nas powtórzenia liter, a drugi, powtórzenia zarówno liter, jak i liczb.
mniej..

BESTSELLERY