123

Uwaga! Ta wi­try­na wy­ko­rzy­stu­je pli­ki cook­ies w ce­lu umoż­li­wie­nia dzia­ła­nia nie­któ­rych fun­kcji ser­wi­su (np. zmia­ny ko­lo­ru tła, wy­glą­du in­ter­fej­su, itp.) oraz w ce­lu zli­cza­nia li­czby od­wie­dzin. Wię­cej in­for­ma­cji znaj­dziesz w Po­li­ty­ce pry­wat­no­ści. Ak­tual­nie Two­ja przeg­lą­dar­ka ma wy­łą­czo­ną ob­słu­gę pli­ków co­o­kies dla tej wi­try­ny. Ten ko­mu­ni­kat bę­dzie wy­świet­la­ny, do­pó­ki nie za­ak­cep­tu­jesz pli­ków cook­ies dla tej wi­try­ny w swo­jej przeg­lą­dar­ce. Kliknięcie ikony * (w pra­wym gór­nym na­ro­żni­ku stro­ny) ozna­cza, że ak­ce­ptu­jesz pli­ki cookies na tej stro­nie. Ro­zu­miem, ak­cep­tu­ję pli­ki cook­ies!
*
:
/
o
[
]
Z
U

Dokumentacja do programu Taquin v. 2.0

  1. Ła­do­wa­nie gry
  2. Uru­cha­mia­nie gry
  3. Po­le­ce­nia oraz fun­kcje ste­ru­ją­ce pra­cą pro­gra­mu
  4. Fun­kcje ob­słu­gu­ją­ce op­cje gry
  5. Fun­kcje zwią­za­ne z dźwię­kiem
  1. Fun­kcje zwią­za­ne z pli­ka­mi coo­kies
  2. Fun­kcje zwią­za­ne z try­bem peł­ne­go ekra­nu
  3. Fun­kcje zwią­za­ne z try­bem de­mon­stra­cyj­nym
  4. Fun­kcje po­wia­da­mia­ją­ce
  5. Po­zo­sta­łe fun­kcje


  1. Ła­do­wa­nie gry   ^

Pli­kiem wy­ko­ny­wal­nym gry jest skom­pre­so­wa­ny i za­ko­do­wa­ny plik taquin.js. Aby uru­cho­mić grę na ser­we­rze, na­le­ży ten plik sko­pio­wać na ser­wer (do ka­ta­lo­gu głó­wne­go lub do­wol­ne­go in­ne­go) i w ko­dzie stro­ny (w sek­cji <head>) do­dać na­stę­pu­ją­cy kod Java­Script:

(1)<script src="taquin.js" defer>​</script>

Po­za pli­kiem taquin.js na­le­ży ró­wnież sko­pio­wać na ser­wer ka­ta­log da­ta za­wie­ra­ją­cy sty­le, dźwię­ki i in­ne po­trzeb­ne do pra­cy gry pli­ki. Za­ró­wno plik taquin.js jak i ka­ta­log da­ta zo­sta­nie au­to­ma­tycz­nie utwo­rzo­ny na Two­im dys­ku przez pro­gram roz­pa­ko­wu­ją­cy grę.


  1. Uru­cha­mia­nie gry   ^

Kod Java­Script, któ­ry uru­cha­mia grę ma na­stę­pu­ją­cą skła­dnię:

(2)
var game=new taqiun('parentID', 'timerID', 'image', 'bkColor', gameOver, setInitParameters);


game – jest obiek­tem gry. Po­przez zmien­ną game mo­żesz od­czy­ty­wać i zmie­niać op­cje gry, a tak­że uru­cha­miać grę, za­trzy­my­wać ją, itp.,

parentID – jest iden­ty­fi­ka­to­rem obiek­tu (naj­czę­ściej ty­pu div), we­wnątrz któ­re­go gra zo­sta­nie wy­świet­lo­na. Je­śli obiekt o po­da­nym iden­ty­fi­ka­to­rze nie ist­nie­je, gra się nie uru­cho­mi,

timerID – jest iden­ty­fi­ka­to­rem obiek­tu (naj­czę­ściej ty­pu div), we­wnątrz któ­re­go gra bę­dzie wy­świet­la­ła czas gry. Je­śli obiekt o po­da­nym iden­ty­fi­ka­to­rze nie ist­nie­je, gra się uru­cho­mi, a czas nie bę­dzie wy­świet­la­ny,

image – jest naz­wą zdję­cia, któ­re bę­dzie użyte ja­ko plan­sza w grze,

bkColor – jest ko­lo­rem tła (po­daj war­tość transparent, je­śli ko­lor tła gry ma być ta­ki sam jak ko­lor tła str­ony),

void gameOver(game) – jest fun­kcją, któ­ra zo­sta­nie wy­wo­ła­na po za­koń­cze­niu gry. Moż­na nie po­dać tej fun­kcji (na­le­ży wte­dy po­dać war­tość 0). Fun­kcja gameOver() przy­jmu­je je­den pa­ra­metr, któ­rym jest obiekt gry, fun­kcja nie po­win­na ni­cze­go zwra­cać,

void setInitParameters(game) – jest fun­kcją, któ­ra zo­sta­nie wy­wo­ła­na po uru­cho­mie­niu gry, ale przed jej wy­świet­le­niem. Umoż­li­wia zmia­nę pa­ra­me­trów gry przed jej roz­po­czę­ciem. Fun­kcja przy­jmu­je je­den pa­ra­metr, któ­ry jest obiek­tem rep­re­zen­tu­ją­cym na­szą grę i nie po­win­na ni­cze­go zwra­cać. Moż­na nie po­dać tej fun­kcji (na­le­ży wte­dy po­dać war­tość 0). W ta­kiej sy­tua­cji gra uru­cho­mi się z pa­ra­me­tra­mi do­myśl­ny­mi. Fun­kcja mo­że być zmie­nia­na dy­na­micz­nie pod­czas pra­cy pro­gra­mu za po­mo­cą fun­kcji setCallInitParam().
Peł­ny, dzia­ła­ją­cy kod stro­ny in­ter­ne­to­wej za­wie­ra­ją­cy grę uru­cha­mia­ną au­to­ma­tycz­nie po za­ła­do­wa­niu stro­ny wy­glą­da na­stę­pu­ją­co:

(3) <!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="initial-scale=1, width=device-width, height=device-height, user-scalable=yes">
<link rel="shortcut icon" ty­pe="image/x-icon" href="data/games.ico">
<link rel="stylesheet" ty­pe="text/css" href="data/style.css">
<title>Taquin - games.3n.com.pl</title>
<style>
html, body{overflow:hidden; margin: 0; padding: 0; height: 100%}
</style>
<script src="taquin.js" defer>​</script>
<script>
function gameOver(p){
alert("Ułożone, grałeś: "+p.getTime()+" ms");
p.startPlay();
};
function readyToPlay(p){
p.startPlay();
};
function setInitParameters(p){
p.setNotifyReadyToPlay (readyToPlay);
p.setNxNy(3,2);
};
window.​addEventListener('load', function(){
new taquin('parentID', 'timerID', 'images/1BBW_0210.jpg', 'transparent', gameOver, setInitParameters);
});
</script>
</head>
<body>
<div id="parentID" style="width:100%; height:100%">
<div id="timerID"></div>
</div>
</body>
</html>

Po­wyż­szy kod dzia­ła w na­stę­pu­ją­cy spo­sób: po za­ła­do­wa­niu stro­ny (zda­rze­nie 'load') – przeg­lą­dar­ka two­rzy obiekt taquin. Obiekt taquin two­rzy we­wnątrz sie­bie wszyst­kie po­trzeb­ne obiek­ty i pod­łą­cza się do div-aid=pa­ren­tID.

Na­stęp­nie przeg­lą­dar­ka za­czy­na wczy­ty­wać zdję­cie (ima­ges/1BBW_0210.jpg). Po wczy­ta­niu zdję­cia zo­sta­je wy­wo­ła­na fun­kcja setInitParameters() z pa­ra­me­trem p, któ­ry jest obiek­tem rep­re­zen­tu­ją­cym uru­cha­mia­ną właś­nie grę. W fun­kcji setInitParameters() na­stę­pu­je przy­pi­sa­nie fun­kcji po­wia­da­mia­ją­cej o naz­wie readyToPlay() oraz wy­ko­na­nie fun­kcji setNxNy(3,2), któ­ra usta­wia li­czbę ele­men­tów w po­zio­mie na rów­ną 3 i w pio­nie na rów­ną 2.

Po za­koń­cze­niu wy­ko­ny­wa­nia fun­kcji setInitParameters() pro­gram wy­ko­nu­je ope­ra­cje na wczy­ta­nym zdję­ciu (dzie­le­nie na prosto­kąty, ewen­tu­al­ne na­kła­da­nie liczb i in­ne nie­zbę­dne ob­li­cze­nia). Po ich wy­ko­na­niu zo­sta­je wy­wo­ła­na (przy­pi­sa­na wcześ­niej) fun­kcja readyToPlay() z pa­ra­me­trem p rep­re­zen­tu­ją­cym ca­ły czas na­szą grę. W fun­kcji readyToPlay() na obiek­cie p zo­sta­je wy­ko­na­na fun­kcja startPlay(), któ­ra uru­cha­mia grę.

Po skoń­czo­nej grze zo­sta­je wy­ko­na­na fun­kcja gameOver() (ró­wnież z pa­ra­me­trem p), w któ­rej zo­sta­je wy­świet­lo­ny czas gry od­czy­ta­ny za po­mo­cą fun­kcji getTime() (któ­rą wy­ko­nu­je­my ró­wnież na obiek­cie p rep­re­zen­tu­ją­cym ca­ły czas na­szą grą).

Po za­mknię­ciu ok­na z ko­mu­ni­ka­tem po­no­wnie wy­wo­ły­wa­na jest fun­kcja startPlay() i sy­tua­cja mo­że być w ten spo­sób po­wta­rza­na aż do za­mknię­cia ok­na przeg­lą­dar­ki.

Po­wy­żej omó­wio­ny kod za­pi­sa­ny w pli­ku taquin_1.htm moż­na tu prze­te­sto­wać.


  1. Po­le­ce­nia oraz fun­kcje ste­ru­ją­ce pra­cą pro­gra­mu   ^

void begin()
Fun­kcja przy­wra­ca stan po­cząt­ko­wy gry. Wy­łą­cza pau­zę (je­śli jest włą­czo­na), za­trzy­mu­je grę (tzn. po wy­ko­na­niu tej fun­kcja – fun­kcja getPlay() bę­dzie zwra­ca­ła war­tość ze­ro) oraz ze­ru­je licz­nik cza­su.

bo­ol getPause()
Fun­kcja zwra­ca war­tość nie­ze­ro­wą, je­śli roz­po­czę­to (i nie ukoń­czo­no) ukła­da­nia oraz włą­czo­no pau­zę.

bo­ol getPlay()
Fun­kcja zwra­ca war­tość nie­ze­ro­wą, je­śli roz­po­czę­to (i nie ukoń­czo­no) ukła­da­nia.

void pause()
Fun­kcja wstrzy­mu­je lub uru­cha­mia (po wstrzy­ma­niu) grę. W cza­sie trwa­nia pau­zy ze­gar od­mie­rza­ją­cy czas jest za­trzy­my­wa­ny, plan­sza jest ukry­wa­na, a na ekra­nie wy­świet­la­ny jest ba­ner usta­wio­ny fun­kcją setBanner().

void startPlay()
Fun­kcja uru­cha­mia grę. Ze­gar za­czy­na od­li­cza­nie, a fun­kcja getPlay() bę­dzie zwra­ca­ła od tej chwi­li war­tość nie­ze­ro­wą.


  1. Fun­kcje ob­słu­gu­ją­ce op­cje gry   ^

ti­me getAnimateDuration()
Fun­kcja zwra­ca czas trwa­nia ani­ma­cji po­cząt­ko­wej.

co­lor getBkgColor()
Fun­kcja zwra­ca ko­lor usta­wio­ny fun­kcją setBkgColor().

opacity getBkgOpacity()
Fun­kcja zwra­ca war­tość prze­źro­czy­sto­ści zdję­cia (któ­re sta­no­wi tło) usta­wio­ną fun­kcją setBkgOpacity().

string getImage()
Fun­kcja zwra­ca peł­ną ścież­kę do­stę­pu do ak­tual­nie za­ła­do­wa­ne­go zdję­cia. Zdję­cie moż­na zmie­nić za po­mo­cą fun­kcji setImage().

co­lor getHOverColor()
Fun­kcja zwra­ca ko­lor usta­wio­ny fun­kcją setHOverColor().

number getMoveMode()
Fun­kcja zwra­ca tryb prze­su­wa­nia kloc­ków usta­wio­ną fun­kcją setMoveMode().

number getNx()
Fun­kcja zwra­ca li­czbę kloc­ków w po­zio­mie usta­wio­ną fun­kcją setNx().

number getNy()
Fun­kcja zwra­ca li­czbę kloc­ków w pio­nie usta­wio­ną fun­kcją setNy().

mode getPlaneMode()
Fun­kcja zwra­ca tryb pracy usta­wio­ny fun­kcją setPlaneMode().

size getSize()
Fun­kcja zwra­ca wiel­kość plan­szy usta­wio­ną fun­kcją setSize().

void setAnimateDuration(time)
Fun­kcja usta­la czas trwa­nia ani­ma­cji po­cząt­ko­wej. War­tość 0 wy­łą­cza ani­ma­cję. War­to­ści więk­sze od ze­ra usta­la­ją w se­kun­dach czas trwa­nia ani­ma­cji.

void setBkgColor(color)
Fun­kcja usta­wia ko­lor tła w grze na war­tość co­lor.

void setBkgOpacity(opacity)
Fun­kcja usta­wia prze­źro­czy­stość tła (wzo­ru). War­tość 1 ozna­cza peł­ną wi­do­czność tła, war­tość 0 – zu­peł­ne ukry­cie tła. War­tość do­myśl­na jest 0.

void setImage(img)
Fun­kcja usta­wia no­we zdję­cie. Pa­ra­metr img jest ścież­ką do­stę­pu do zdję­cia. Dla try­bu pra­cy usta­wio­ne­go funk­cją setPlaneMode() na war­tość ze­ro, naz­wa zdję­cia jest igno­ro­wa­na (po­win­na być pu­stym łań­cu­chem zna­ków).

void setHOverColor(color, ref­resh)
Fun­kcja usta­wia ko­lor ob­ry­su kloc­ka, nad któ­rym znaj­du­je się mysz­ka. Pa­ra­metr ref­resh usta­la, czy po zmia­nie ko­lo­ru ma­ją być od­świe­żo­ne wszyst­kie kloc­ki. Je­śli ko­lor zmie­nia­my przed grą, to od­świe­że­nie nie jest ko­nie­czne, je­śli w trak­cie gry, to aby zmia­ny od­nios­ły sku­tek na­le­ży od­świe­żyć wszyst­kie kloc­ki. Ko­lor do­myśl­ny jest 'rgba(255,0,0,0.4)'.

void setMoveMode(mode)
Fun­kcja usta­la tryb (sposób) przesuwania klocków. Możliwe są dwa warianty:
0 – klo­cki są prze­su­wa­ne mysz­ką przez przy­ciś­nię­cie le­we­go przy­cis­ku mysz­ki i prze­su­nię­cie kloc­ka w wy­bra­nym kie­run­ku.
1 – do prze­su­nię­cia kloc­ka wys­tar­czy je­go klik­nię­cie (dot­knię­cie na ekra­nie do­ty­ko­wym).

void setNxNy(nx, ny)
Fun­kcja usta­la li­czbę kloc­ków w po­zio­mie na war­tość nx i w pio­nie na war­tość ny. War­to­ści do­myśl­ne, to: 9 i 6. Uwa­ga! Zmia­na li­czby kloc­ków wy­ma­ga po­no­wnej ini­cja­li­za­cji gry. Op­ty­mal­nym miej­scem na zmia­nę li­czby kloc­ków jest fun­kcja setInitParameters(), któ­ra jest wy­wo­ły­wa­na zwrot­nie po za­ła­do­wa­nia zdję­cia, ale przed je­go po­cię­ciem na prosto­ką­ty. Można zmienić tylko wartość nx (lub ny) za po­mo­cą funkcji setNx() lub setNy(), ale wte­dy pro­ce­du­ra cię­cia zdję­cia bę­dzie wy­ko­ny­wa­na dwu­krot­nie, więc je­śli chce­my zmie­nić obie war­to­ści, to ko­rzy­stniej jest wy­wo­łać fun­kcję setNxNy.

void setNx(nx)
Fun­kcja usta­la li­czbę kloc­ków w po­zio­mie na war­tość nx. War­tość do­myśl­na to 9.

void setNy(ny)
Fun­kcja usta­la li­czbę kloc­ków w pio­nie na war­tość ny. War­tość do­myśl­na to 6.

void setPlaneMode(mode)
Fun­kcja usta­la tryb pracy gry. Możliwe są trzy warianty:
0 – ustawia grę jako klasycz­ny Taquin (16 pól, po­le wol­ne jest po pra­wej stro­nie na do­le). Tłem jest za­wsze zdję­cie przed­sta­wia­ją­ce dre­wnia­ną płytę, a kloc­ki są po­nu­me­ro­wa­ne,
1 – usta­wia tryb, w któ­rym tłem mo­że być do­wol­ne zdję­cie. Licz­ba pól w po­zio­mie i pio­nie mo­że być usta­wia­na przez użyt­ko­wni­ka. Pole wol­ne jest wy­bie­ra­ne lo­so­wo,
2 – usta­wia ta­ki sam tryb pra­cy jak w wa­rian­cie 1, ale kloc­ki są do­dat­ko­wo nu­me­ro­wa­ne.

void setSize(size)
Fun­kcja usta­la wiel­kość plan­szy wzglę­dem div-a, po­da­ne­go ja­ko pa­rent. War­tość 1 ozna­cza, że plan­sza za­jmie ob­szar ca­łe­go div-a. War­to­ści mniej­sze od 1 usta­la­ją po­mniej­sze­nie plan­szy wzglę­dem ro­dzi­ca. War­tość do­myśl­na jest 0.8.


  1. Fun­kcje zwią­za­ne z dźwię­kiem   ^

bo­ol getSound()
Fun­kcja zwra­ca war­tość nie­ze­ro­wą, je­śli dźwięk jest włą­czo­ny.

ele­ment getSoundElement()
Fun­kcja zwra­ca li­czbę, któ­rej po­szcze­gól­ne bi­ty ozna­cza­ją, któ­re efek­ty dźwię­ko­we są ak­ty­wne. Bi­ty te usta­wia­my fun­kcją setSoundElement().

void setSound(value)
Fun­kcja włą­cza lub wy­łą­cza dźwięk w za­leż­no­ści od pa­ra­me­tru va­lue. War­tość do­myśl­na jest 1 (dźwięk jest włą­czo­ny). Uwa­ga! Nie­któ­re prze­glą­dar­ki mo­gą blo­ko­wać auto­ma­tycz­ne od­twa­rza­nie dźwię­ku do mo­men­tu, w któ­rym użyt­ko­wnik jaw­nie nie włą­czy dźwię­ku

void setSoundElement(element)
Fun­kcja włą­cza od­po­wie­dnie efek­ty dźwię­ko­we:
bit 1 – włą­cza dźwięk pod­czas roz­po­czy­na­nia gry (pli­ki: scat­terc.wav i scat­ters.wav), plik scatters.wav jest skró­co­ną wer­sją pli­ku scatterc.wav i jest wy­ko­rzy­sty­wa­ny wte­dy, gdy ani­ma­cja po­czą­tko­wa nie wy­stę­pu­je,
bit 2 – włą­cza dźwięk pod­czas prze­su­wa­nia klocków (pliki: mo­ve.wav i mo­vec.wav, plik move.wav jest wy­ko­rzy­sty­wa­ny pod­czas prze­su­wa­nia kloc­ka mysz­ką, a plik movec.wav, kie­dy klo­cek jest prze­su­wa­ny pro­gra­mo­wo),
bit 4 – włą­cza dźwięk pod­czas kliknięcia w klocek, któ­ry nie może wy­ko­nać ru­chu (plik click.wav),
bit 8 – włą­cza dźwięk pod­czas za­koń­cze­nia prze­su­wa­nia kloc­ka (plik con­ne­ct.wav),
bit 16 – włą­cza ap­lauz na za­koń­cze­nie (plik ap­lau­se.­wav),
bit 32 – włą­cza dźwięk pod­czas włą­cza­nia i wy­łą­cza­nia pau­zy (plik pau­se.­wav),
bit 64 – włą­cza dźwięk pod­czas po­wro­tu do po­cząt­ku gry (plik be­gin­.wav).
bit 128 – włą­cza dźwięk pod­czas ude­rza­nia kloc­ka o klo­cek są­sie­dni.
War­tość do­myśl­na jest 255 (wszyst­kie efek­ty są włą­czo­ne).

void setSoundOnOff()
Fun­kcja włą­cza lub wy­łą­cza dźwięk. Fun­kcja nie przy­jmu­je pa­ra­me­trów i nap­rze­mien­nie włą­cza lub wy­łą­cza dźwięk.


  1. Fun­kcje zwią­za­ne z pli­ka­mi coo­kies   ^

void deleteCookies()
Fun­kcja usu­wa plik coo­kies za­wie­ra­ją­cy za­pi­sa­ny stan op­cji gry, a na­stęp­nie od­świe­ża stro­nę.

string getCookiesName()
Fun­kcja zwra­ca naz­wę pli­ków coo­kies usta­lo­ną fun­kcją setCookiesName().

bo­ol getEnableCookies()
Fun­kcja zwra­ca war­tość nie­ze­ro­wą, je­śli włą­czy­liś­my ob­słu­gę pli­ków coo­kies fun­kcją setEnableCookies().

string getGameStatus()
Fun­kcja zwra­ca łań­cuch tek­sto­wy za­wie­ra­ją­cy usta­wie­nia wszyst­kich op­cji oraz po­ło­że­nie kloc­ków na planszy. Łań­cuch ten mo­że być np. za­pi­sa­ny w ba­zie da­nych na kon­cie kon­kret­ne­go użyt­ko­wni­ka lub też moż­na za­pi­sać go w pli­ku coo­kies.

bool loadParamsFromCookies()
Fun­kcja od­czy­tu­je stan op­cji z pli­ku coo­kies i usta­wia op­cje na od­czy­ta­ne war­to­ści. Fun­kcja zwra­ca true, je­śli plik coo­kies był za­pi­sa­ny i usta­wie­nie op­cji się po­wiod­ło lub fal­se, je­śli pli­ku coo­kies nie by­ło.

string loadGameStatusFromCookies(name)
Fun­kcja od­czy­tu­je stan op­cji gry oraz uło­że­nie kloc­ków na plan­szy z pli­ku coo­kies. Pa­ra­metr na­me jest naz­wą do­da­wa­ną do naz­wy usta­lo­nej fun­kcją setCookiesName(). Zwra­ca­na war­tość jest na­pi­sem (łań­cu­chem zna­ków) i mo­że być np. za­pi­sa­na w ba­zie na kon­cie użyt­ko­wni­ka lub w in­nym pli­ku coo­kies.

void saveGameStatus(status, na­me)
Fun­kcja za­pi­su­je stan op­cji gry oraz uło­że­nie kloc­ków na plan­szy w pli­ku coo­kies, pod wa­run­kiem, że uży­wa­nie pli­ków coo­kies jest do­zwo­lo­ne (patrz fun­kcja setEnableCookies()). Pa­ra­metr sta­tus jest tek­stem otrzy­ma­nym z fun­kcji getGameStatus(), pa­ra­metr na­me jest naz­wą do­da­wa­ną do naz­wy usta­lo­nej fun­kcją setCookiesName().

void saveParams()
Fun­kcja za­pi­su­je stan ak­tual­nie usta­wio­nych op­cji gry w pli­ku coo­kies, pod wa­run­kiem, że uży­wa­nie pli­ków coo­kies jest do­zwo­lo­ne (patrz fun­kcja setEnableCookies()). Fun­kcja jest wy­ko­ny­wa­na au­to­ma­tycz­nie po zmia­nie do­wol­nej op­cji, ale moż­na też wy­ko­nać ją w do­wol­nej chwi­li np. po zmia­nie naz­wy pli­ku coo­kies (patrz fun­kcja setCookiesName()).

void setCookiesName(name)
Fun­kcja usta­la naz­wę pli­ków coo­kies na war­tość na­me. Je­śli nie usta­wi­my tej war­to­ści, to do­myśl­na naz­wa pli­ków coo­kies bę­dzie taqiun3N. Zmia­na naz­wy pli­ków coo­kies mo­że mieć za­sto­so­wa­nie np. w ce­lu za­pa­mię­ta­nia sta­nu kil­ku róż­nych gier uru­cha­mia­nych w tej sa­mej prze­glą­dar­ce.

void setEnableCookies(enable)
Fun­kcja dla enab­le=1 włą­cza uży­wa­nie przez grę pli­ków coo­kies. Je­że­li uży­wa­nie pli­ków coo­kies jest włą­czo­ne, każ­da zmia­na op­cji gry zo­sta­nie za­pa­mię­ta­na w pli­ku coo­kies, a po­no­wnie uru­cho­mio­na gra od­czy­ta te op­cje i je za­sto­su­je. Dla enab­le=0, fun­kcja wy­łą­czy uży­wa­nie pli­ków coo­kies. Do­myśl­nie uży­wa­nie pli­ków coo­kies jest wy­łą­czo­ne.

void setGameStatus(status, pau­se)
Fun­kcja usta­wia stan op­cji gry oraz uło­że­nie kloc­ków na plan­szy. Pa­ra­metr sta­tus jest tek­stem otrzy­ma­nym z fun­kcji getGameStatus() lub loadGameStatusFromCookies(). Pa­ra­metr pau­se usta­la, czy bez­po­śre­dnio po wy­ko­na­niu tej fun­kcji gra za­cznie się to­czyć, tzn. czas za­cznie być od­li­cza­ny. Je­śli pau­se jest rów­ne 1, to użyt­ko­wnik mu­si wzno­wić grę przy­cis­kiem pau­se.


  1. Fun­kcje zwią­za­ne z try­bem peł­ne­go ekra­nu   ^

void cancelFullScreen(element)
Fun­kcja wy­łą­cza tryb peł­ne­go ekra­nu dla obiek­tu ele­ment.

bo­ol isFullScreen(element)
Fun­kcja zwra­ca war­tość nie­ze­ro­wą, je­śli ele­ment jest w try­bie peł­ne­go ekra­nu.

void setFullScreen(element)
Fun­kcja włą­cza tryb peł­ne­go ekra­nu dla obiek­tu ele­ment.


  1. Fun­kcje zwią­za­ne z try­bem de­mon­stra­cyj­nym   ^

void setDemoDuration(value)
Fun­kcja usta­la czas prze­su­wa­nia kloc­ków w try­bie de­mon­stra­cyj­nym. Tryb de­mon­stra­cyj­ny gry moż­na zo­ba­czyć na na­szej stro­nie głów­nej. War­tość va­lue po­da­je­my w je­dnost­kach umo­wnych. War­tość do­myśl­na jest 1. War­to­ści więk­sze od je­den wyd­łu­ża­ją czas prze­su­wa­nia kloc­ków, mniej­sze od 1 – skra­ca­ją.

void startDemo()
Fun­kcja włą­cza tryb de­mon­stra­cyj­ny.

void setDemoLink(link)
Fun­kcja usta­la od­noś­nik, pod któ­ry zo­sta­nie­my prze­nie­sie­ni po klik­nię­ciu w plan­szę z grą w try­bie de­mon­stra­cyj­nym.


  1. Fun­kcje po­wia­da­mia­ją­ce   ^

void setCallInitParam(function)
Fun­kcja przy­pi­su­je function do gry. Function jest wy­wo­ły­wa­na po za­ła­do­wa­niu zdję­cia, ale przed wy­ko­na­niem na nim ja­kich­kol­wiek ope­ra­cji. Jest to dob­re miej­sce, by np. usta­lić li­czbę kloc­ków, itp. Moż­na to zro­bić ró­wnież w in­nym mo­men­cie, ale wte­dy pro­ce­du­ra „cię­cia” zdję­cia bę­dzie mu­sia­ła być po­wtó­rzo­na. Je­że­li na na­szej stro­nie przy­go­tu­je­my kod, któ­ry po za­ła­do­wa­niu stro­ny usta­li pa­ra­me­try po­cząt­ko­we, to po ich usta­le­niu, na­le­ży tę fun­kcję „wy­łą­czyć” (przez wy­wo­ła­nie setCallInitParam(0)). Za­po­bieg­nie to po­no­wne­mu usta­wie­niu pa­ra­me­trów po­cząt­ko­wych po ewen­tual­nej zmia­nie zdję­cia.

void setNotifyEndPlay(function)
Fun­kcja przy­pi­su­je function do gry. Function jest wy­wo­ły­wa­na, kie­dy użyt­ko­wnik prze­rwie grę (kie­dy wy­ko­na się fun­kcja be­gin()).

void setNotifyGameOver(function)
Fun­kcja przy­pi­su­je function do gry. Function jest wy­wo­ły­wa­na, kie­dy użyt­ko­wnik roz­wią­że łami­głów­kę. Je­śli tej fun­kcji nie przy­pi­sze­my, to wy­ko­na się fun­kcja game­Over(), o ile zo­sta­ła po­da­na ja­ko ar­gu­ment pod­czas uru­cha­mia­nia gry.

void setNotifyReadyToPlay(function)
Fun­kcja przy­pi­su­je function do gry. Function jest wy­wo­ły­wa­na po za­ła­do­wa­niu zdję­cia i po wy­ko­na­niu na zdję­ciu wszyst­kich nie­zbę­dnych ope­ra­cji (cię­ciu, usta­le­niu kształ­tów, itp.). Je­że­li na na­szej stro­nie są ja­kieś ele­men­ty in­ter­ak­ty­wne, to po­win­ny one być za­blo­ko­wa­ne do te­go mo­men­tu. Function po­win­na je uak­ty­wnić.

void setNotifySetParams(function)
Fun­kcja przy­pi­su­je function do gry. Function jest wy­wo­ły­wa­na, kie­dy pro­gram sam (lub w od­po­wie­dzi na dzia­ła­nia użyt­ko­wni­ka) zmie­ni ja­kąś op­cję. Fun­kcja mo­że być uży­ta do aktu­ali­zo­wa­nia sta­nu in­ter­fej­su po zmia­nie op­cji gry.

void setNotifyStartPlay(function)
Fun­kcja przy­pi­su­je function do gry. Function jest wy­wo­ły­wa­na, kie­dy użyt­ko­wnik uru­cho­mi grę (kie­dy wy­ko­na się fun­kcja startPlay()).


  1. Po­zo­sta­łe fun­kcje   ^

ti­me getTime()
Fun­kcja zwra­ca w do­wol­nym mo­men­cie czas w ms, któ­ry upły­nął od mo­men­tu roz­po­czę­cia gry.

void reSize()
Fun­kcja do­pa­so­wu­je po­ło­że­nie obie­któw we­wnę­trznych gry do wy­mia­rów ro­dzi­ca. Funk­cja po­win­na być wy­wo­ły­wa­na w od­po­wie­dzi na po­wia­do­mie­nie onresize. Uwaga! Gra została tak zaprojektowana, że po zmia­nie wy­mia­rów do­stęp­ne­go po­la ro­bo­cze­go ele­men­ty gry zo­sta­ną wy­cen­tro­wa­ne w no­wym po­lu, jed­nak ich wy­mia­ry nie zo­sta­ną zmie­nio­ne. Zmia­na wy­mia­rów kloc­ków wy­ma­ga po­no­wnej ini­cja­li­za­cji gry. Jest mo­żli­we prze­chwy­ce­nie zda­rze­nia on­resize i ob­słu­że­nie go w ta­ki spo­sób, że gra zo­sta­nie przer­wa­na i za­ini­cja­li­zo­wa­na po­no­wnie z no­wy­mi wy­mia­ra­mi, jed­nak uwa­ża­my, że to roz­wią­za­nie nie by­ło­by wy­god­ne dla użyt­ko­wni­ka.

void setBanner(element)
Fun­kcja usta­wia ele­ment ja­ko ba­ner wy­świet­la­ny pod­czas pau­zy. Do­myśl­nie wy­świet­la­ny jest na­pis Pau­za.

void setDataPath(path)
Fun­kcja po­zwa­la zmie­nić ścież­kę do­stę­pu do pli­ków za­war­tych w ka­ta­lo­gu data.


^

Serwisy 3n

Logo Kombi
Logo Wirtualnej Galerii
Logo Internetowego Banku Fotografii
Logo Interpretera PostScriptu
Logo Projektora K3D