123

Attention! The website uses cookies to offer you better browsing experience. Find out more on Privacy Policy. Now your browser has blocked cookies. This information will be displayed until you enable cookies in your browser.
I understand and accept cook­ies!
*
:
/
o
[
]
Z
U

Dokumentacja do programu Puzzle 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 puz­zle.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="puzzle.js" defer>​</script>

Po­za pli­kiem puz­zle.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 puz­zle.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 puzzle('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 po­dzie­lo­ne na puz­zle,

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(puzzle) – 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(puzzle) – 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>Puz­zle - games.3n.com.pl</title>
<style>
html, body{overflow:hidden; margin: 0; padding: 0; height: 100%}
</style>
<script src="puzzle.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 puzzle('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 puz­zle. Obiekt puz­zle 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ę puz­zli 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 puz­zle 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 puzzle_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, puz­zle są ukry­wa­ne, 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   ^

mo­de getAnimCheckMode()
Fun­kcja zwra­ca tryb ani­ma­cji wy­świet­la­nej pod­czas łą­cze­nia puz­zli.

class getAnimateClass()
Fun­kcja zwra­ca naz­wę kla­sy, któ­ra zo­sta­nie uży­ta do ani­ma­cji po­cząt­ko­wej.

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().

time getDblClkTime()
Fun­kcja zwra­ca czas usta­wio­ny fun­kcją setDblClkTime().

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 getNx()
Fun­kcja zwra­ca li­czbę puz­zli w po­zio­mie usta­wio­ną fun­kcją setNx().

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

mode getRandomMode()
Fun­kcja zwra­ca tryb roz­rzu­ca­nia puz­zli usta­wio­ny fun­kcją setRandomMode().

mode getRotateMode()
Fun­kcja zwra­ca tryb ob­ra­ca­nia puz­zli usta­wio­ny fun­kcją setRotateMode().

mo­de getRotateSnap()
Fun­kcja zwra­ca do­zwo­lo­ny kąt ob­ra­ca­nia puz­zli usta­wio­ny fun­kcją setRotateSnap().

shape getShape()
Fun­kcja zwra­ca kształt puz­zli usta­wio­ny fun­kcją setShape().

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

value getSnap()
Fun­kcja zwra­ca mar­gi­nes au­to­ma­tycz­ne­go przy­cią­ga­nia usta­wio­ny fun­kcją setSnap().

void setAnimCheckMode(mode)
Fun­kcja usta­la spo­sób ani­ma­cji wy­świet­la­nej pod­czas łą­cze­nia puz­zli.
0 – ozna­cza ani­ma­cję przez po­więk­sze­nie łą­czo­nych ele­men­tów,
1 – przez roz­jaś­nie­nie (łą­czo­ne­go) je­dne­go ele­men­tu,
2 – roz­jaś­nie­nie wszyst­kich łą­czo­nych ele­men­tów.
War­tość do­myśl­na jest 1.

void setAnimateClass(class)
Fun­kcja usta­la naz­wę kla­sy, któ­ra zo­sta­nie uży­ta do ani­ma­cji po­cząt­ko­wej. Kla­sy ani­ma­cji są zde­fi­nio­wa­ne w pli­ku da­ta/puz­zle.css. Moż­na zde­fi­nio­wać swo­je kla­sy i na­dać im swo­je naz­wy, przy czym na­le­ży zde­fi­nio­wać czte­ry wa­rian­ty tej sa­mej ani­ma­cji dla czte­rech ćwiar­tek ukła­du współ­rzę­dnych i do­dać do nazw cyf­ry 1, 2, 3 i 4 (od­po­wie­dnio do rep­re­zen­to­wa­nych ćwiar­tek ukła­du współ­rzę­dnych).

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.2.

void setDblClkTime(time)
Fun­kcja usta­la czas reak­cji (w mi­li­se­kun­dach) na pod­wój­ne klik­nie­cie mysz­ki w sy­tua­cji, gdy fun­kcja setRotateMode() ma usta­wio­ny bit o war­to­ści 2. War­tość do­myśl­na jest 250 ms.

void setImage(img)
Fun­kcja usta­wia no­we zdję­cie. Pa­ra­metr img jest ścież­ką do­stę­pu do zdję­cia.

void setHOverColor(color, ref­resh)
Fun­kcja usta­wia ko­lor ob­ry­su puz­zla, 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 puz­zle. 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 puz­zle. Ko­lor do­myśl­ny jest 'rgba(255,0,0,0.4)'.

void setNxNy(nx, ny)
Fun­kcja usta­la li­czbę puz­zli 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 puz­zli wy­ma­ga po­no­wnej ini­cja­li­za­cji gry. Op­ty­mal­nym miej­scem na zmia­nę li­czby puz­zli 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 puz­zle. 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ę puz­zli 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ę puz­zli w pio­nie na war­tość ny. War­tość do­myśl­na to 6.

void setRandomMode(mode)
Fun­kcja usta­la spo­sób lo­so­wa­nia po­ło­że­nia puz­zli. Je­śli war­tość mo­de jest 0, to puz­zle zo­sta­ną roz­sy­pa­ne na ca­łej po­wierz­chni plan­szy. Je­śli war­tość ta jest wię­ksza od ze­ra, to puz­zle zo­sta­ną roz­sy­pa­ne wokół plan­szy na sze­ro­ko­ści sta­no­wią­cej za­da­ny uła­mek sze­ro­koś­ci lub wy­so­koś­ci plan­szy. Np. dla war­to­ści 0.2 – puz­zle zaj­mą pas wo­kół plan­szy o sze­ro­ko­ści 20% sze­ro­ko­ści plan­szy i wy­so­ko­ści ró­wnej 20% wy­so­koś­ci plan­szy. War­tość do­myśl­na jest 0.

void setRotateMode(mode)
Fun­kcja usta­la spo­sób ob­słu­gi ob­ro­tów (je­śli ob­ro­ty są włą­czo­ne). Ob­ro­ty mo­gą być ob­słu­gi­wa­ne na trzy spo­so­by, tj.:
1 – za po­mo­cą prze­su­wa­nia mysz­ki,
2 – za po­mo­cą dwu­krot­ne­go klik­nię­cia,
4 – za po­mo­cą pra­we­go przy­cis­ku mysz­ki.
Spo­so­by te mo­gą być łą­czo­ne bi­to­wo. War­tość mo­de=7 ozna­cza ob­słu­gę za po­mo­cą wszyst­kich trzech spo­so­bów je­dno­cześ­nie. War­tość 0 wy­łą­cza ob­słu­gę ob­ro­tów. War­tość do­myśl­na jest 2.

void setRotateSnap(snap)
Fun­kcja usta­la „za­trzas­ki” pod­czas ob­ro­tów. Je­że­li snap jest rów­ne 0, to ob­ro­ty są nie­do­zwo­lo­ne, je­że­li snap wy­no­si 1, to ob­ro­ty są płyn­ne (o do­wol­ny kąt). Je­że­li snap jest więk­sze od 1, (np. 90), to ob­ro­ty są do­zwo­lo­ne tyl­ko o okreś­lo­ny (w tym wy­pad­ku 90 stop­ni) kąt.

void setShape(shape)
Fun­kcja usta­la kształt puz­zli. Do­zwo­lo­ne są trzy war­to­ści, tj.:
0 – kształt kla­sycz­ny,
1 – kształt pro­sto­kąt­ny,
2 – kształt okrąg­ły.
War­tość do­myśl­na jest 0.

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.

void setSnap(snap)
Fun­kcja usta­la mar­gi­nes au­to­ma­tycz­ne­go przy­cią­ga­nia puz­zli do sie­bie. Np. je­że­li war­tość snap jest rów­na 5 i dwa pa­su­ją­ce do sie­bie puz­zle znaj­dą się w od­leg­ło­ści mniej­szej lub rów­nej 5 pik­se­li, to zo­sta­ną au­to­ma­tycz­nie przy­ciąg­nię­te.

void setStartOffsetXY(x, y)
Fun­kcja usta­la prze­su­nię­cie w po­zio­mie (war­tość x) i w pio­nie (war­tość y) puz­zli po ich roz­sy­pa­niu na po­cząt­ku gry. War­to­ści do­myśl­ne, to: 0 i 0. W tym przy­kła­dzie po­ka­za­no plan­szę o wy­mia­rach 300px na 200px i prze­su­nię­cie w po­zio­mie 300px i w pio­nie 50px.


  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­ter.wav i scat­ters.wav), plik scatters.wav jest skró­co­ną wer­sją pli­ku scatter.wav i jest wy­ko­rzy­sty­wa­ny wte­dy, gdy ani­ma­cja po­czą­tko­wa nie wy­ko­rzy­stu­je efe­ktu roz­sy­pa­nia puz­zli,
bit 2 – włą­cza dźwięk pod­czas prze­su­wa­nia puz­zli (plik move.wav),
bit 4 – włą­cza dźwięk pod­czas ob­ro­tu puz­zli (plik click.wav),
bit 8 – włą­cza dźwięk pod­czas skle­je­nia puz­zli (plik connect.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 begin.wav).
War­tość do­myśl­na jest 127 (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­nia puz­zli na ekra­nie. Ł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 puz­zli na ekra­nie 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 puz­zli na ekra­nie 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 puz­zle3N. 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 puz­zli na ekra­nie. 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 puz­zli 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 puz­zli, 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ę puz­zli, ich kształt 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 uło­ży wszyst­kie puz­zle. Je­śli tej fun­kcji nie przy­pi­sze­my, to wy­ko­na się fun­kcja ga­meO­ver(), 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 puz­zli 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.


^

Our Services

Kombi logo
Virtual Gallery logo
3N STOCK PHOTOS logo
Kombi PDF Tools logo
K3D logo
Logo 3N Games