{***************************************************************************} Program Ulamki; uses crt,dos,graph,turtle; const

{***************************************************************************} Program Ulamki; uses crt,dos,graph,turtle; const kolor15:byte=15; {kolor obrazk w} wypeln=9; {rodzaj wzoru wypelnienia obszar w} czcionka=1; {rodzaj czcionki uzywanej w ulamkach} odstep=4; {odstep pomiedzy ramkami obrazk w} ulamki_h:byte=5; {liczba obrazk w w poziomie 5x4x80 } ulamki_v:byte=4; {liczba obrazk w w pionie 7x5x60 } ulamki_d:byte=80; {dlugosc boku obrazka 9x6x50 } schemat:byte=7; {rodzaj shematu} pocz_x=100; {wspolrzedne lewego gornego wierzcholka} pocz_y=100; {planszy na ekranie} ile_czasu:integer=300; {czas trwania testu potem koniec} punkty:longint=0; {liczba zdobytych punkt w} czas_ulamka=15; {po jakim czasie ma sie pojawiac nowy obrazek} dzwiek=true; {czy sygnalizowac zmiany} koniec_testu:boolean=false; {jesli czas sie skonczy to true} nowy_ulamek:boolean=false; {co 15 sekund losowanie nowego ulamka} mian:array[1..7,1..8] of byte= {mianowniki do rozlosowania} ((2,4,8,2,4,8,4,8), {DiadramKw1} (6,8,6,8,6,8,6,8), {DiagramKw2} (3,4,5,6,7,8,3,4), {DiagramKw3} (2,3,4,5,6,7,8,10), {DiagramKolowy} (2,3,4,5,6,7,8,10), {ObrazekUl} (2,3,4,5,6,7,8,10), {ObrazekPr} (2,3,4,5,6,7,8,10)); {ObrazekDz} znaki:array[1..5] of string[2]= (' =',' <',' >','<=','>='); {znaki por wnania do losowania}

tablica:array[1..20,1..20] of byte;{tablica z numerami schematow ulamkow} wartosc:array[1..20,1..20,1..2] of byte; {tablica na wartosci licznika i mianownika} czas_p, czas_k:datetime; {czas rozpoczecia testu} {czas zakonczenia testu} Procedure OtworzTrybGraficzny; driver,mode:integer; driver:=detect; initgraph(driver,mode,''); Procedure ZamknijTrybGraficzny; closegraph Function Sekundy(czas:datetime):longint; p:longint; {podajemy czas a otrzymujemy} {ile to jest w sumie sekund} with czas do p:=hour; {musi tak byc bo inaczej robi modulo maxword} p:=p*3600+min*60+sec; Sekundy:=p; Procedure CzasStart( czas_p,czas_k:datetime;ile_czasu:longint); p,k:longint; s:word; with czas_p do gettime(hour,min,sec,s); p:=sekundy(czas_p); {sekundowy czas startu} k:=p+ile_czasu; {zwiekszamy o sekundowy czas testu} with czas_k do {zamieniamy z powrotem na normalny czas} hour:=k div 3600; k:=k mod 3600; min:=k div 60; k:=k mod 60; sec:=k; {aby otrzymac czas zakonczenia testu} Function IleSekund(czas_p,czas_k:datetime):string; p,k:longint; n:string; p:=sekundy(czas_p); k:=sekundy(czas_k); ile_czasu:=k-p; str(k-p,n); IleSekund:=n; {obliczamy ile zostalo sekund do konca testu}

Procedure Ramka(x1,y1,x2,y2:integer); rectangle(x1,y1,x2,y2) {--------------------------------------------------------------------------} Procedure Rameczka(x1,y1,x2,y2:integer); {rysujemy podwojna ramke z wymazaniem wnetrza} Ramka(x1,y1,x2,y2); setviewport(x1+odstep,y1+odstep,x2-odstep,y2-odstep,true); clearviewport; setviewport(0,0,getmaxx,getmaxy,true); Ramka(x1+odstep,y1+odstep,x2-odstep,y2-odstep); {--------------------------------------------------------------------------} Procedure Kwadrat(x,y,d:integer); rectangle(x,y,x+d,y+d) {--------------------------------------------------------------------------} {losujemy diagram kwadratowy podzielony na 2, 4 lub 8 osiami symetrii} Procedure DiagramKw1(x,y,dlugosc,licznik,mianownik,kolor:integer); type punkty=array[1..8,1..2] of integer; {wsp lrzedne punkt w we wnetrzu obszar w do wypelnienia} const stala:punkty=((-3,-9),( 3,-9),( 9,-3),( 9, 3),( 3, 9),(-3, 9), (-9, 3),(-9,-3)); x1,y1,d1,sr,i,r:integer; p:punkty; Procedure l1; line(x1,y1,x1+d1,y1+d1); Procedure l2; line(x1,y1+d1,x1+d1,y1 ); {osie symetrii} Procedure l3; line(x1+sr,y1,x1+sr,y1+d1); Procedure l4; line(x1,y1+sr,x1+d1,y1+sr); x1:=x+odstep; {wspolrzedne lewego gornego wierzcholka} y1:=y+odstep; {kwadratu we wnetrzu} d1:=dlugosc-2*odstep; {dlugosc boku kwadratu we wnetrzu} {polowa dlugosci boku kwadratu we wnetrzu} Kwadrat(x1,y1,d1); p:=stala; {odswierzamy informacje o wsp lrzednych} case mianownik of {w zaleznosci od mianownika dzielimy kwadrat} 8: {na odpowiednia ilosc czesci} l1;l2;l3;l4 {przy wypelnianiu korzystamy ze starych} {wspolrzednych} 4: p[2]:=p[3];p[3]:=p[5];p[4]:=p[7]; if random(2)=0 then l1;l2 end else l3;l4 2:case random(4) of 0:l1; 1:l2; 2:l3; 3:l4; setfillstyle(wypeln,kolor); r:=random(mianownik); {i w zaleznosci od licznika wypelniamy} if licznik>0 then {wylosowane obszary}

for i:=1 to licznik do floodfill(x1+sr+p[((i+r) mod mianownik)+1,1], y1+sr+p[((i+r) mod mianownik)+1,2], kolor15); {--------------------------------------------------------------------------} {losujemy diagram kwadratowy warstwowy przedzielony pionowa osia symetrii} {podzielony liniami poziomymi na 6 lub 8 czesci} Procedure DiagramKw2(x,y,dlugosc,licznik,mianownik,kolor:integer); type punkty=array[1..8,1..2] of integer; const stala:punkty=((-3,1),(-3,2),(-3,3),(-3,4),(3,1),(3,2),(3,3),(3,4)); x1,y1,d1,sr,po,tr,i,r:integer; p:punkty; Procedure l0; line(x1+sr,y1,x1+sr,y1+d1); Procedure l1(tr:integer); line(x1,y1+tr,x1+d1,y1+tr); Procedure Wypelnij(cz:integer); i:byte; setfillstyle(wypeln,kolor); r:=random(mianownik); if licznik>0 then for i:=1 to licznik do floodfill(x1+sr+p[((i+r) mod mianownik)+1,1], y1+cz*p[((i+r) mod mianownik)+1,2]-3, kolor15); x1:=x+odstep; y1:=y+odstep; d1:=dlugosc-2*odstep; tr:=d1 div 3; po:=sr div 2; Kwadrat(x1,y1,d1); p:=stala; case mianownik of 6: l0;l1(tr);l1(2*tr); p[3]:=p[4];p[4]:=p[5];p[5]:=p[6];p[6]:=p[8] 8: l0;l1(sr);l1(po);l1(sr+po) Wypelnij(po); {losujemy diagram kwadratowy warstwowy,ktory moze byc podzielony} {na 3,4,5,6,7,8 czesci} Procedure DiagramKw3(x,y,dlugosc,licznik,mianownik,kolor:integer); type punkty=array[1..8,1..2] of integer; const stala:punkty=((3,1),(3,2),(3,3),(3,4),(3,5),(3,6),(3,7),(3,8)); x1,y1,d1,sr,po,pi,si,tr,cz,i,r:integer; p:punkty; Procedure l0(cz:integer);

line(x1,y1+cz,x1+d1,y1+cz); Procedure Wypelnij(cz:integer); i:integer; setfillstyle(wypeln,kolor); r:=random(mianownik); if licznik>0 then for i:=1 to licznik do floodfill(x1+sr+p[((i+r) mod mianownik)+1,1], y1+cz*p[((i+r) mod mianownik)+1,2]-3, kolor15); x1:=x+odstep; y1:=y+odstep; d1:=dlugosc-2*odstep; tr:=d1 div 3; pi:=d1 div 5; po:=d1 div 4; si:=d1 div 7; Kwadrat(x1,y1,d1); p:=stala; case mianownik of 3: l0(tr);l0(2*tr); Wypelnij(tr); 4: l0(po);l0(sr);l0(sr+po); Wypelnij(po); 5: for i:=1 to 4 do l0(i*pi); Wypelnij(pi); 6: for i:=1 to 5 do l0(i*(tr div 2)); Wypelnij(tr div 2); 7: for i:=1 to 6 do l0(i*si); Wypelnij(si); 8: for i:=1 to 7 do l0(i*(po div 2)); Wypelnij(po div 2); {losujeby diagram kolowy,ktory moze byc podzielony na 3,4,5,6,7,8,10 czesci} Procedure DiagramKolowy(x,y,dlugosc,licznik,mianownik,kolor:integer); x1,y1,d1,sr,i,r:integer; d1:=dlugosc-2*odstep;

x1:=x+odstep+sr; y1:=y+odstep+sr; circle(x1,y1,sr); xsro:=x1;ysro:=y1; for i:=1 to mianownik do fd(sr);bk(sr);rt(round(360/mianownik)); setfillstyle(wypeln,kolor); r:=random(mianownik); rt(round((360/mianownik)*r+20)); for i:=1 to licznik do pu;fd(10); floodfill(getx,gety,kolor15); bk(10);pd; rt(round(360/mianownik)); {losujemy obrazek z ulamkiem zwyklym} Procedure ObrazekUl(x,y,dlugosc,licznik,mianownik:integer); x1,y1,d1,sr,po,dl:integer; napis:string; d1:=dlugosc-2*odstep; po:=sr div 2; dl:=sr div 8; x1:=x+odstep; y1:=y+odstep; Kwadrat(x1,y1,d1); line(x1+po,y1+sr,x1+d1-po,y1+sr); settextstyle(czcionka,0,dl); str(licznik,napis); outtextxy(x1+sr-2*dl,y1-dl,napis); str(mianownik,napis); outtextxy(x1+sr-2*dl,y1+sr-dl,napis); {losujemy obrazek z procentem} Procedure ObrazekPr(x,y,dlugosc,procent:integer); x1,y1,d1,sr,po,dl:integer; napis:string; d1:=dlugosc-2*odstep; po:=sr div 2; dl:=sr div 8; x1:=x+odstep; y1:=y+odstep; Kwadrat(x1,y1,d1); settextstyle(czcionka,0,dl); str(procent,napis); napis:=napis+'%'; outtextxy(x1+dl,y1+po,napis);

{losujemy obrazek z ulamkiem dziesietnym} Procedure ObrazekDz(x,y,dlugosc:integer;liczba:real); x1,y1,d1,sr,po,dl:integer; napis:string; d1:=dlugosc-2*odstep; po:=sr div 2; dl:=round(sr*0.1); x1:=x+odstep; y1:=y+odstep; Kwadrat(x1,y1,d1); settextstyle(czcionka,0,dl); str(liczba:4:2,napis); outtextxy(x1+dl,y1+po,napis); {w rameczce nad plansza wypisujemy tresc polecenia} Procedure Polecenie(znak:string;licznik,mianownik:integer); napis:string; Rameczka(150,15,450,70); line(320,42,350,42); settextstyle(czcionka,0,5); outtextxy(250,15,znak); settextstyle(czcionka,0,3); str(licznik,napis); outtextxy(330,15,napis); str(mianownik,napis); outtextxy(330,40,napis); {------------------------------------------------------------------------} {losujemy numer schematu,a takze licznik i mianownik ulamka na tym schemacie} {wylosowany obrazek umieszczamy w odpowiednim miejscu na planszy} Procedure RysujUlamek(i,j,bok,schemat:integer); x,y,s,mianownik,licznik:integer; liczba:real; s:=random(schemat)+1; {numer shematu} tablica[i,j]:=s; {zapis numeru shematu do tablicy} mianownik:=mian[s,random(8)+1]; {losowanie mianownika} licznik :=random(mianownik-1)+1; {losowanie licznika} wartosc[i,j,1]:=licznik; {wstawiamy obie wartosci} wartosc[i,j,2]:=mianownik; {do tablicy} x:=pocz_x+(i-1)*bok; {wyliczamy wsp lrzedne lewego} y:=pocz_y+(j-1)*bok; {gornego wierzcholka kwadratu,} case tablica[i,j] of {w ktorym rysujemy} 1:DiagramKw1(x,y,bok,licznik,mianownik,2); {wybieramy rodzaj shematu} 2:DiagramKw2(x,y,bok,licznik,mianownik,1); 3:DiagramKw3(x,y,bok,licznik,mianownik,4); 4:DiagramKolowy(x,y,bok,licznik,mianownik,14); 5:ObrazekUl(x,y,bok,licznik,mianownik); 6:ObrazekPr(x,y,bok,round((licznik/mianownik)*100)); 7:ObrazekDz(x,y,bok,licznik/mianownik);

Procedure WyswietlSekundy(czas_k:datetime); {w ramce no dole ekranu wyswietlamy ile zostalo} napis:string; {sekund do konca testu} czas :datetime; s :word; with czas do gettime(hour,min,sec,s); if Sekundy(czas)>Sekundy(czas_k) then koniec_testu:=true; napis:=ilesekund(czas,czas_k); Rameczka(350,440,500,470); settextstyle(0,0,2); outtextxy(380,448,napis); Procedure DzwiekZle; sound(70);delay(300);nosound Procedure DzwiekBim; sound(700);delay(100);nosound procedure DzwiekDobrze; i:integer; for i:=1 to 50 do sound(70+i*10);delay(10) nosound; {sprawdzamy zgodnosc wartosci na obrazku z wypisanym poleceniem} Function Sprawdz(u_x,u_y:integer;licznik,mianownik,porownanie:byte):boolean; ok:boolean; l,m:integer; z:string[2]; ok:=false; l:=wartosc[u_x,u_y,1]; m:=wartosc[u_x,u_y,2]; z:=znaki[porownanie]; if z=' =' then if l/m =licznik/mianownik then ok:=true; if z=' <' then if l/m <licznik/mianownik then ok:=true; if z=' >' then if l/m >licznik/mianownik then ok:=true; if z='<=' then if l/m<=licznik/mianownik then ok:=true; if z='>=' then if l/m>=licznik/mianownik then ok:=true; Sprawdz:=ok; {------------------------------------------------------------------------}

Procedure Punktacja(p:integer); napis:string; {wyswietlenie rameczki z punktacja} punkty:=punkty+p; Rameczka(100,440,250,470); settextstyle(0,0,2); str(punkty,napis); outtextxy(150,448,napis); {------------------------------------------------------------------------} Procedure ObslugaProgramu; {gl wna procedura programu-obsluguje caly program} znak :char; u_x,u_y:byte; {aktualnie podswietlony obrazek} x,y,l,m,i,j,ux,uy:integer; z :string[2]; ok :boolean; nowa_plansza:boolean; {jesli odgadniete wszystkie ulamki} licznik, {wylosowany licznik ulamka} mianownik, {wylosowany mianownik ulamka} porownanie:byte; {wylosowany znak porownania ulamk w} mrug :pointer; {wskaznik na obrazek mrugajacej ramki} Procedure NowePolecenie( licznik,mianownik,porownanie:byte); {wylosowanie i wyswietlenie nowego polecenia} mianownik:=mian[random(schemat)+1,random(8)+1]; licznik:=random(mianownik-1)+1; porownanie:=random(5)+1; Polecenie(znaki[porownanie],licznik,mianownik); Function Czekaj(x,y:integer):char; {ramka mruga oczekiwanie na nacisnieciecie} znak:char; {jakiegos klawisza} i :longint; czas:datetime; s :word; i:=0; while keypressed do znak:=readkey; repeat putimage(x,y,mrug^,xorput); {mruganie ramki} inc(i); delay(50); {sprawdzamy czy nie losowac} with czas do gettime(hour,min,sec,s); {nowego ulamka} if Sekundy(czas) mod czas_ulamka =0 then nowy_ulamek:=true; WyswietlSekundy(czas_k); {wyswietlenie ilosci sekund} until keypressed; {do konca testu} znak:=readkey; if znak=#0 then znak:=readkey; if i mod 2 = 1 then putimage(x,y,mrug^,xorput); {aby ramka pozostala biala} Czekaj:=znak; {--------------------------------------------------------------------------} {zapamietujemy w zmiennej dynamicznej wz r ramki do mrugania} Procedure Zapalanie; x,y:integer;

x:=100; y:=100; Rameczka(x,y,x+ulamki_d,y+ulamki_d); setfillstyle(1,kolor15); floodfill(x+1,y+1,kolor15); getmem(mrug,imagesize(x,y,x+ulamki_d,y+ulamki_d)); {utworzenie zmiennej} {dynamicznej} getimage(x,y,x+ulamki_d,y+ulamki_d,mrug^); {zapamietanie obrazka} {w zmiennej dynamicznej} zapalanie; clearviewport; nowa_plansza:=true; u_x:=1;u_y:=1; {na poczatku zaznaczamy obrazek 1,1} repeat ok:=false; {sprawdzamy czy na ekranie jest co badac} for i:=1 to ulamki_h do {czy sa jeszcze poprawne wartosci} for j:=1 to ulamki_v do if Sprawdz(i,j,licznik,mianownik,porownanie)=true then ok:=true; if ok=false then {gdy wszystko zostalo odgadniete} {to rysujemy nowa plansze} nowa_plansza:=true; for i:=1 to 4 do DzwiekDobrze; if nowa_plansza then {gdy trzeba przerysowac plansze} {zaraz na poczatku} if dzwiek then DzwiekBim; clearviewport; Ramka(0,0,getmaxx,getmaxy); Ramka(3,3,getmaxx-3,getmaxy-3); NowePolecenie(licznik,mianownik,porownanie); for i:=1 to ulamki_h do for j:=1 to ulamki_v do RysujUlamek(i,j,ulamki_d,schemat); nowa_plansza:=false; Punktacja(0); if dzwiek then DzwiekBim; x:=pocz_x+(u_x-1)*ulamki_d; {wsp lrzedne zaznaczonego obrazka} y:=pocz_y+(u_y-1)*ulamki_d; znak:=czekaj(x,y); {czekamy na znak} case znak of {obsluga klawiatury} {l} #75:if u_x>1 then dec(u_x) else u_x:=ulamki_h; {p} #77:if u_x<ulamki_h then inc(u_x) else u_x:=1; {g} #72:if u_y>1 then dec(u_y) else u_y:=ulamki_v; {d} #80:if u_y<ulamki_v then inc(u_y) else u_y:=1; #13,#32: {enterem lub spacja potwierdzamy wybor} ok:=sprawdz(u_x,u_y,licznik,mianownik,porownanie); if ok=false then {zla odpowiedz} if dzwiek then DzwiekZle; Punktacja(-1); end else {dobra odpowiedz} if dzwiek then DzwiekDobrze; Rameczka(x,y,x+ulamki_d,y+ulamki_d);

RysujUlamek(u_x,u_y,ulamki_d,schemat); Punktacja(1); if nowy_ulamek then {gdy trzeba losowo narysowac nowy obrazek} {bo uplynelo 15 sekund} ux:=random(ulamki_h)+1; uy:=random(ulamki_v)+1; x:=pocz_x+(ux-1)*ulamki_d; y:=pocz_y+(uy-1)*ulamki_d; Rameczka(x,y,x+ulamki_d,y+ulamki_d); RysujUlamek(ux,uy,ulamki_d,schemat); if dzwiek then DzwiekBim; nowy_ulamek:=false; until (znak=#27) or (koniec_testu); for i:=1 to 15 do DzwiekBim; Procedure OdczytajKonfig; p:text; assign(p,'ulamki.cfg'); {w pliku ulamki.cfg zapisana jest podstawowa} reset(p); {konfiguracja programu - mozna ja zmieniac} readln(p,ulamki_h); {w ilu kolumnach obrazki} readln(p,ulamki_v); {w ilu wierszach obrazki} readln(p,ulamki_d); {dlugosc boku kwadratu na schemat ulamka} readln(p,schemat); {kt re rodzaje schematow sa losowane} readln(p,ile_czasu); {ile czasu ma trwac test} close(p); Procedure nazwisko; plik:text; czas:datetime; d :word; podpis:string; gotoxy(30,10);writeln('podaj IMIE I NAZWISKO: '); gotoxy(30,11);readln(podpis); with czas do getdate(hour,min,sec,d); assign(plik,'ulamki.wyn'); append(plik); with czas do write(plik,podpis:20,hour:2,':',min:2,':',sec:2); close(plik); Procedure Wyniki(punkty:longint); plik:text; czas:datetime; d:word; with czas do getdate(hour,min,sec,d); assign(plik,'ulamki.wyn'); append(plik); with czas do writeln(plik,punkty:10,hour:2,':',min:2,':',sec:2);

close(plik); {programu glownego} clrscr; nazwisko; OdczytajKonfig; randomize; OtworzTrybGraficzny; clearviewport; CzasStart(czas_p,czas_k,ile_czasu); Ramka(0,0,getmaxx,getmaxy); Ramka(3,3,getmaxx-3,getmaxy-3); ObslugaProgramu; Wyniki(punkty); readln; ZamknijTrybGraficzny; textmode(lastmode); end. {**************************************************************************}