Rosetta Code

15 puzzle game: Difference between revisions

Page Discussion

15 puzzle game (view source)

Revision as of 16:00, 27 March 2021

13,725 bytes added ,  3 years ago
→‎{{header|Ring}}
(Undo revision 328519 by CalmoSoft (talk))
Line 8,438:
=={{header|Ring}}==
 
<lang ring>
CalmoSoft [[wp:15_puzzle|Fifteen Puzzle Game]] written in Ring Programming Language (http://ring-lang.net)
/* ------------------------------------------------------------------------------------------------------
 
Copyright (c) 2004 - Gal Zsolt (CalmoSoft)
Video:
[https://www.google.com/url?q=https%3A%2F%2F1drv.ms%2Fv%2Fs!AqDUIunCqVnIg0J6sL9df0JcV2TY&sa=D&sntz=1&usg=AFQjCNEFaWD8AqElMZK3KGnRKDhKxCO1Sw CalmoSoft Fifteen Puzzle Game Video]
 
------------------------------------------------------------------------------------------------------ */
Output Image:
[https://1drv.ms/i/s!AqDUIunCqVnIg0zg_d-lOM8CfLdM CalmoSoft Fifteen Puzzle Game Image]
 
implement playDialog
The code:
open core, vpiDomains, vpiOldDomains, resourceIdentifiers
<lang ring># Project : CalmoSoft Fifteen Puzzle Game (Under Development)
 
facts
load "guilib.ring"
thisWin : vpiDomains::windowHandle := erroneous.
 
clauses
app1 = new qapp {
show(Parent):-
_ = vpi::winCreateDynDialog(Parent, controlList, eventHandler, gui_api::lNull).
 
/* ------------------------------------------------------------------------------------------------------ */
stylefusionblack()
empty = 16
nrMoves = 0
nrSleep = 1
butSize = 4
curBut = 4
temp = 0
flaginit = 0
flagsave = 0
flagmove = 0
button = list(52)
sizebtn = list(7)
table1 = []
table2 = []
table3 = []
nDegree = 0
nrDegree = [0,90,180,270 ,-90,-180,-270]
nDegreeRight = 0
nDegreeLeft = 0
btnDegree = newlist(52,2)
CounterMan = 0
t1 = 0
 
predicates
win1 = new qwidget() {
eventHandler : move(0,0)vpiDomains::ehandler.
clauses
resize(380,760)
eventHandler(Win, Event) = Result :-
setwindowtitle("CalmoSoft Fifteen Puzzle Game")
Result = generatedEventHandler(Win, Event).
 
/* ------------------------------------------------------------------------------------------------------ */
for n=1 to 52
for m=1 to 2
btnDegree[n][m] = 0
next
next
 
for n = 4 to 7
sizebtn[n] = new qpushbutton(win1)
{
col = n%4
setgeometry(100+col*40,60,40,40)
settext(string(n) + "x" + string(n))
setclickevent("newsize(" + string(n) + ")")
}
next
 
predicates
btnMoves = new qpushbutton(win1)
onDestroy : vpiOldDomains::destroyHandler.
{
clauses
setgeometry(100,260,80,40)
onDestroy() = vpiOldDomains::defaultHandling() :-
settext("0")
thisWin := show() erroneous.
}
 
/* ------------------------------------------------------------------------------------------------------ */
scramblebtn = new qpushbutton(win1)
{
setgeometry(100,300,160,40)
settext("Scramble")
setclickevent("scramble()")
}
 
predicates
resetbtn = new qpushbutton(win1)
onControlCancel : vpiOldDomains::controlHandler.
{
clauses
setgeometry(100,340,160,40)
onControlCancel(_Ctrl, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull) :-
settext("Reset")
setclickeventfile::save("resettiles()game.dba",gameDB),
}retractall(table(_,_)),
retractall(gameplay(_,_)),
retractall(empty_cell(_)),
retractall(cell(_,_)),
retractall(cellnr(_,_)),
retractall(good(_,_,_)),
vpi::winDestroy(thisWin).
 
/* ------------------------------------------------------------------------------------------------------ */
savebtn = new qpushbutton(win1)
{
setgeometry(100,380,160,40)
settext("Save Game")
setclickevent("pSave()")
}
 
predicates
playbtn = new qpushbutton(win1)
onUpdate : {vpiOldDomains::updateHandler.
clauses
setgeometry(100,420,160,40)
onUpdate(Rectangle) = vpiOldDomains::defaultHandling():-
settext("Resume Game")
vpi::winClear( thisWin,Rectangle,0x808040),
setclickevent("pPlay()")
}!.
 
/* ------------------------------------------------------------------------------------------------------ */
sleepbtn = new qpushbutton(win1)
{
setgeometry(100,460,160,40)
settext("Sleep Time: ")
 
class facts - }gameDB
table:(integer,string).
gameplay:(integer,integer).
empty_cell:(integer).
 
class facts
decbtn = new qpushbutton(win1)
cell:(integer,vpiDomains::windowHandle).
{
cellnr:(integer,integer).
setgeometry(220,460,40,40)
settext("<-")
setclickevent("pDecSleep()")
}
 
/* ------------------------------------------------------------------------------------------------------ */
incbtn = new qpushbutton(win1)
{
setgeometry(260,460,40,40)
settext("->")
setclickevent("pIncSleep()")
}
 
class facts
rightbtn = new qpushbutton(win1)
{step_nr:integer:=0.
setgeometry(100,500,160,40)
settext("In the Right Place : ")
}
 
predicates
timebtn = new qpushbutton(win1)
onCreate : {vpiOldDomains::createHandler.
clauses
setgeometry(100,540,160,40)
onCreate(_CreationData) = vpiOldDomains::defaultHandling():-
settext("Elapsed Time : ")
}retractall(table(_,_)),
retractall(gameplay(_,_)),
retractall(empty_cell(_)),
retractall(cell(_,_)),
retractall(cellnr(_,_)),
retractall(good(_,_,_)),
 
TimerMan = new qtimerscrollbars_init(win1),
{cellhandle_init(),
setinterval(500)empty:=16,
settimeouteventgood_cell("pTime()"0),
stoptable_save(),
}step_nr:=0,
newsize(4) fail.
onCreate(_CreationData) = vpiOldDomains::defaultHandling().
show()
}
exec()
}
 
/* ------------------------------------------------------------------------------------------------------ */
Func newlist x, y
if isstring(x) x=0+x ok
if isstring(y) y=0+y ok
alist = list(x)
for t in alist
t = list(y)
next
return alist
 
facts
func scramble
vsbarr : vpiDomains::windowHandle := erroneous.
for n= 1 to 1000
vsbarl : vpiDomains::windowHandle := erroneous.
curBut=random(butSize*butSize-1)+1
hsbart : vpiDomains::windowHandle := erroneous.
up = (empty = (curBut - butSize))
hsbarb : vpiDomains::windowHandle := erroneous.
down = (empty = (curBut + butSize))
left = ((empty = (curBut - 1)) and ((curBut % butSize) != 1))
right = ((empty = (curBut + 1)) and ((curBut % butSize) != 0))
move = up or down or left or right
if move = 1
button[curBut] { temp2 = text() }
col = empty%butSize
if col = 0 col = butSize ok
row = ceil(empty/butSize)
button[empty] {
setgeometry(60+col*40,60+row*40,40,40)
rnd = random(6)+1
nDegree = nrDegree[rnd]
button[empty].setbuttoncolor("yellow")
button[empty].settext(temp2)
button[empty].setClickEvent("movetile(" + string(empty) +")")
btnDegree[empty] [1] = temp2
btnDegree[empty] [2] = nDegree
}
button[curBut].setbuttoncolor("yellow")
btnDegree[curBut][2] = 0
button[curBut]{settext("")}
empty = curBut
ok
next
button[butSize*butSize+2]{settext("Here")}
for n=1 to butSize*butSize
button[n].setbuttoncolor("yellow")
next
table1 = []
table2 = []
table3 = []
for n = 1 to butSize*butSize
add(table1, button[n].text())
add(table2, button[n].text())
add(table3, string(btnDegree[n][2]))
next
add(table1, string(empty))
add(table2, string(empty))
add(table3, string(empty))
add(table1, "OK")
add(table2, "OK")
add(table3, "OK")
flagsave = 0
flagmove = 0
nrMoves = 0
btnMoves.settext(string(nrMoves))
timebtn.settext("Elapsed Time : ")
t1 = clock()
rightPlace()
return
 
predicates
func movetile curBut2
scrollbars_init:().
if (curBut2 = butSize*butSize-1 and button[curBut2].text() = "In")
pBack()clauses
else scrollbars_init():-
see charvsbarr := vpi::winGetCtlHandle(7thisWin,idc_sbvr),
up = (emptyvsbarl := vpi::winGetCtlHandle(curBut2 - butSize)thisWin,idc_sbvl),
down = (emptyhsbart := vpi::winGetCtlHandle(curBut2 + butSize)thisWin,idc_sbht),
hsbarb := vpi::winGetCtlHandle(thisWin,idc_sbhb),
left = ((empty = (curBut2- 1)) and ((curBut2 % butSize) != 1))
right = ((empty = (curBut2 + 1)) and ((curBut2 % butSize) != 0))
move = up or down or left or right
if move = 1
temp2 = button[curBut2].text()
btnDegree[empty][1] = temp2
add(table1, temp2)
add(table2, string(curBut2))
col = empty%butSize
if col = 0 col = butSize ok
row = ceil(empty/butSize)
button[empty] {
setgeometry(60+col*40,60+row*40,40,40)
nDegree = btnDegree[curBut2][2]
btnDegree[empty][2] = nDegree
button[empty].setbuttoncolor("orange")
button[empty].settext(temp2)
}
add(table3, string(nDegree))
button[curBut2].setbuttoncolor("cyan")
button[curBut2]{settext("")}
empty = curBut2
nrMoves = nrMoves + 1
btnMoves.settext(string(nrMoves))
isGameOver()
ok
ok
flagmove = 1
pElapsedTime()
rightPlace()
return
 
func resettiles
nDegree = 0
empty = butSize*butSize
for empty = 1 to butSize*butSize-1
btnDegree[empty][2] = 0
nDegree = 0
btnDegree[empty][1] = string(empty)
button[empty].setstylesheet("background-color:yellow")
button[empty] {settext(string(empty))}
next
button[butSize*butSize].setstylesheet("background-color:yellow")
button[butSize*butSize] {settext("")}
table1 = []
table2 = []
table3 = []
for n = 1 to butSize*butSize
add(table1, button[n].text())
add(table2, button[n].text())
add(table3, string(btnDegree[n][2]))
next
add(table1, string(empty))
add(table2, string(empty))
add(table3, string(empty))
add(table1, "OK")
add(table2, "OK")
add(table3, "OK")
flagsave = 0
flagmove = 0
nrMoves = 0
btnMoves.settext(string(nrMoves))
timebtn.settext("Elapsed Time : ")
t1 = clock()
rightPlace()
return
 
vpi::winSetScrollRange(vsbarr,sb_Ctl,1,4),
func pHere
vpi::winSetScrollProportion(vsbarr,sb_Ctl,1),
if button[butSize*butSize-1].text() != "" and button[butSize*butSize+2].text() = "Here"
vpi::winSetScrollPos(vsbarr,sb_Ctl,4),
button[butSize*butSize-1] { temp = text() }
button[butSize*butSize+2].close()
button[butSize*butSize+2] = new ButtonWithRotatedText(win1)
button[butSize*butSize+2] {
setgeometry(60+(butSize-1)*40,60+(butSize+1)*40,40,40)
setstylesheet("background-color:yellow")
btnDegree[butSize*butSize+2][2] = btnDegree[butSize*butSize-1][2]
nDegree = btnDegree[butSize*butSize+2][2]
emptysave = empty
empty = butSize*butSize+2
btnDegree[empty][1] = temp
settext(temp)
}
nDegree = 0
empty = butSize*butSize-1
btnDegree[empty][1] = "In"
button[butSize*butSize-1]{settext("In")}
for n = 1 to butSize*butSize
button[n].setenabled(false)
next
button[butSize*butSize-1].setenabled(true)
scramblebtn.setenabled(false)
resetbtn.setenabled(false)
savebtn.setenabled(false)
playbtn.setenabled(false)
empty = emptysave
ok
 
vpi::winSetScrollRange(vsbarl,sb_Ctl,1,4),
func pBack
vpi::winSetScrollProportion(vsbarl,sb_Ctl,1),
button[butSize*butSize+2] { temp = text() }
vpi::winSetScrollPos(vsbarl,sb_Ctl,4),
nDegree = btnDegree[butSize*butSize+2][2]
btnDegree[butSize*butSize-1][2] = btnDegree[butSize*butSize+2][2]
emptysave = empty
empty = butSize*butSize-1
btnDegree[empty][1] = temp
button[butSize*butSize-1] {settext(temp)}
button[butSize*butSize+2].close()
button[butSize*butSize+2] = new qpushbutton(win1)
{
setgeometry(60+(butSize-1)*40,60+(butSize+1)*40,40,40)
settext("Here")
setclickevent("pHere()")
show()
}
for n = 1 to butSize*butSize
button[n].setenabled(true)
next
scramblebtn.setenabled(true)
resetbtn.setenabled(true)
savebtn.setenabled(true)
playbtn.setenabled(true)
empty = emptysave
isGameOver()
 
vpi::winSetScrollRange(hsbart,sb_Ctl,1,4),
func rotateleft
vpi::winSetScrollProportion(hsbart,sb_Ctl,1),
if button[butSize*butSize+2].text() != "Here"
button[butSize*butSize+2].close vpi::winSetScrollPos(hsbart,sb_Ctl,4),
button[butSize*butSize+2] = new ButtonWithRotatedText(win1)
button[butSize*butSize+2] {
setgeometry(60+(butSize-1)*40,60+(butSize+1)*40,40,40)
setstylesheet("background-color:yellow")
nDegreeLeft = (nDegreeLeft-90)%360
nDegree = nDegreeLeft
btnDegree[butSize*butSize+2][2] = nDegree
emptysave = empty
empty = butSize*butSize+2
btnDegree[empty][1] = temp
button[butSize*butSize+2]{settext(temp)}
}
empty = emptysave
ok
 
vpi::winSetScrollRange(hsbarb,sb_Ctl,1,4),
func rotateright
vpi::winSetScrollProportion(hsbarb,sb_Ctl,1),
if button[butSize*butSize+2].text() != "Here"
button[butSize*butSize+2].close vpi::winSetScrollPos(hsbarb,sb_Ctl,4).
button[butSize*butSize+2] = new ButtonWithRotatedText(win1)
button[butSize*butSize+2] {
setgeometry(60+(butSize-1)*40,60+(butSize+1)*40,40,40)
setstylesheet("background-color:yellow")
nDegreeRight = (nDegreeRight+90)%360
nDegree = nDegreeRight
btnDegree[butSize*butSize+2][2] = nDegree
emptysave = empty
empty = butSize*butSize+2
btnDegree[empty][1] = temp
button[butSize*butSize+2]{settext(temp)}
}
empty = emptysave
ok
 
/* ------------------------------------------------------------------------------------------------------ */
func newsize curBut
win1{
sizenew = curBut%4
win1.resize(360+sizenew*40,640+sizenew*40)
if flaginit != 0
for nb = 1 to butSize*butSize+3
button[nb] {close()}
next
btnMoves.close()
ok
scramblebtn.close()
resetbtn.close()
savebtn.close()
playbtn.close()
btnMoves.close()
sleepbtn.close()
decbtn.close()
incbtn.close()
rightbtn.close()
timebtn.close()
 
class facts
for n = 1 to curBut*curBut
cell1 : vpiDomains::windowHandle := erroneous.
col = n%curBut
cell2 : vpiDomains::windowHandle := erroneous.
if col = 0 col = curBut ok
cell3 : vpiDomains::windowHandle := erroneous.
row = ceil(n/curBut)
cell4 : vpiDomains::windowHandle := erroneous.
button[n] = new ButtonWithRotatedText(win1)
cell5 : vpiDomains::windowHandle := erroneous.
button[n] {
cell6 : vpiDomains::windowHandle := erroneous.
setgeometry(60+col*40,60+row*40,40,40)
cell7 : vpiDomains::windowHandle := erroneous.
button[n].setbuttoncolor("yellow")
cell8 : vpiDomains::windowHandle := erroneous.
nDegree = 0
cell9 : vpiDomains::windowHandle := erroneous.
if n < curBut*curBut
cell10 : vpiDomains::windowHandle := erroneous.
button[n].settext(string(n))
cell11 : vpiDomains::windowHandle := erroneous.
but n = curBut*curBut
cell12 : vpiDomains::windowHandle := erroneous.
button[n].settext("")
cell13 : vpiDomains::windowHandle := erroneous.
ok
cell14 : vpiDomains::windowHandle := erroneous.
setClickEvent("movetile(" + string(n) +")")
cell15 : vpiDomains::windowHandle := erroneous.
}
cell16 : vpiDomains::windowHandle := nexterroneous.
 
predicates
btnMoves = new qpushbutton(win1)
{cell_handle:().
clauses
setgeometry(100,60+(curBut+1)*40,(curBut-3)*40,40)
cell_handle():-
setStyleSheet("text-align:center")
settextcell1:=vpi::winGetCtlHandle("0"thisWin,idc_cell1),
showcell2:=vpi::winGetCtlHandle(thisWin,idc_cell2) ,
}cell3:=vpi::winGetCtlHandle(thisWin,idc_cell3),
cell4:=vpi::winGetCtlHandle(thisWin,idc_cell4),
cell5:=vpi::winGetCtlHandle(thisWin,idc_cell5),
cell6:=vpi::winGetCtlHandle(thisWin,idc_cell6),
cell7:=vpi::winGetCtlHandle(thisWin,idc_cell7),
cell8:=vpi::winGetCtlHandle(thisWin,idc_cell8),
cell9:=vpi::winGetCtlHandle(thisWin,idc_cell9),
cell10:=vpi::winGetCtlHandle(thisWin,idc_cell10),
cell11:=vpi::winGetCtlHandle(thisWin,idc_cell11),
cell12:=vpi::winGetCtlHandle(thisWin,idc_cell12),
cell13:=vpi::winGetCtlHandle(thisWin,idc_cell13),
cell14:=vpi::winGetCtlHandle(thisWin,idc_cell14),
cell15:=vpi::winGetCtlHandle(thisWin,idc_cell15),
cell16:=vpi::winGetCtlHandle(thisWin,idc_cell16).
 
/* ------------------------------------------------------------------------------------------------------ */
button[curBut*curBut+1] = new qpushbutton(win1)
{
setgeometry(60+(curBut-2)*40,60+(curBut+1)*40,40,40)
settext("<-")
setclickevent("rotateLeft()")
show()
}
 
predicates
button[curBut*curBut+2] = new qpushbutton(win1)
{cellhandle_init:().
clauses
setgeometry(60+(curBut-1)*40,60+(curBut+1)*40,40,40)
cellhandle_init():-
settext("Here")
setclickeventretractall("pHerecell(_,_)") ,
showcell_handle() ,
}
 
assert(cell(1,cell1)),
button[curBut*curBut+3] = new qpushbutton(win1)
{assert(cell(2,cell2)),
assert(cell(3,cell3)),
setgeometry(60+curBut*40,60+(curBut+1)*40,40,40)
settextassert("->"cell(4,cell4)),
assert(cell(5,cell5)),
setclickevent("rotateRight()")
showassert(cell(6,cell6)) ,
}assert(cell(7,cell7)),
assert(cell(8,cell8)),
assert(cell(9,cell9)),
assert(cell(10,cell10)),
assert(cell(11,cell11)),
assert(cell(12,cell12)),
assert(cell(13,cell13)),
assert(cell(14,cell14)),
assert(cell(15,cell15)),
assert(cell(16,cell16)).
 
/* ------------------------------------------------------------------------------------------------------ */
scramblebtn = new qpushbutton(win1)
{
setgeometry(100,100+(curBut+1)*40,curBut*40,40)
settext("Scramble")
setclickevent("scramble()")
show()
}
 
class facts
resetbtn = new qpushbutton(win1)
{good_nr:integer:=0.
good:(integer,integer,integer) nondeterm.
setgeometry(100,100+(curBut+2)*40,curBut*40,40)
empty:integer:=16.
settext("Reset")
setclickevent("resettiles()")
show()
}
 
predicates
savebtn = new qpushbutton(win1)
good_cell:(integer) {multi.
clauses
setgeometry(100,100+(curBut+3)*40,curBut*40,40)
good_cell(16):-!.
settext("Save Game")
good_cell(Number):-
setclickevent("pSave()")
NumberNew = show() Number+1,
}good_nr:=0,
good_above(NumberNew), % movable cells above empty cell
good_before(NumberNew), % movable cells before empty cell
good_after(NumberNew), % movable cells after empty cell
good_under(NumberNew), % movable cells under empty cell
assert(cellnr(NumberNew,good_nr)), % number of movable cells around the empty cell
good_cell(NumberNew).
 
/* ------------------------------------------------------------------------------------------------------ */
playbtn = new qpushbutton(win1)
{
setgeometry(100,100+(curBut+4)*40,curBut*40,40)
settext("Resume Game")
setclickevent("pPlay()")
show()
}
 
predicates
sleepbtn = new qpushbutton(win1)
{good_above:(integer).
clauses
setgeometry(100,100+(curBut+5)*40,(curBut-2)*40,40)
good_above(Number):-
settext("Sleep Time: " + string(nrSleep) + " s")
Number > 4, show() % movable cells above empty cell
good_nr:= }good_nr+1,
assert(good(Number,good_nr,Number-4)),
fail.
good_above(_).
 
/* ------------------------------------------------------------------------------------------------------ */
decbtn = new qpushbutton(win1)
{
setgeometry(100+(curBut-2)*40,100+(curBut+5)*40,40,40)
settext("<-")
setclickevent("pDecSleep()")
show()
}
 
predicates
incbtn = new qpushbutton(win1)
{good_before:(integer).
clauses
setgeometry(100+(curBut-1)*40,100+(curBut+5)*40,40,40)
settextgood_before("->"Number) :-
(Number mod 4) <> 1, setclickevent("pIncSleep()") % movable cells before empty cell
good_nr:= show()good_nr+1,
}assert(good(Number,good_nr,Number-1)),
fail.
good_before(_).
 
/* ------------------------------------------------------------------------------------------------------ */
rightbtn = new qpushbutton(win1)
{
setgeometry(100,100+(curBut+6)*40,curBut*40,40)
settext("In the Right Place : ")
show()
}
 
predicates
timebtn = new qpushbutton(win1)
{good_after:(integer).
clauses
setgeometry(100,100+(curBut+7)*40,curBut*40,40)
good_after(Number):-
settext("Elapsed Time : ")
(Number mod 4) > 0, show() % movable cells after empty cell
good_nr:= }good_nr+1,
assert(good(Number,good_nr,Number+1)),
fail.
good_after(_).
 
/* ------------------------------------------------------------------------------------------------------ */
table1 = []
table2 = []
table3 = []
for n = 1 to butSize*butSize
add(table1, button[n].text())
add(table2, button[n].text())
add(table3, string(0))
next
add(table1, string(empty))
add(table2, string(empty))
add(table3, string(empty))
add(table1, "OK")
add(table2, "OK")
add(table3, "OK")
empty = curBut*curBut
butSize = curBut
flaginit = 1
flagsave = 0
flagmove = 0
nrMoves = 0
timebtn.settext("Elapsed Time : ")
t1 = clock()
scramble()
}
 
predicates
func pSave
textedit1 = list2strgood_under:(table1integer).
clauses
textedit2 = list2str(table2)
textedit3 = list2strgood_under(table3Number):-
Number < 13, % movable cells under empty cell
chdir(currentdir())
cName1 good_nr:= "CalmoSoftPuzzle1.txt"good_nr+1,
assert(good(Number,good_nr,Number+4)),
cName2 = "CalmoSoftPuzzle2.txt"
cName3 = "CalmoSoftPuzzle3 fail.txt"
writegood_under(cName1,textedit1_).
write(cName2,textedit2)
write(cName3,textedit3)
flagsave = 1
timebtn.settext("Elapsed Time : ")
t1 = clock()
return
 
/* ------------------------------------------------------------------------------------------------------ */
func pPlay
if flagsave = 0 or flagmove = 0
warning()
else
chdir(currentdir())
cName1 = "CalmoSoftPuzzle1.txt"
textedit1 = read(cName1)
table1 = str2list(textedit1)
cName2 = "CalmoSoftPuzzle2.txt"
textedit2 = read(cName2)
table2 = str2list(textedit2)
cName3 = "CalmoSoftPuzzle3.txt"
textedit3 = read(cName3)
table3 = str2list(textedit3)
for empty = 1 to butSize*butSize
button[empty].setbuttoncolor("yellow")
nDegree = number(table3[empty])
btnDegree[empty][1] = table1[empty]
button[empty] {settext(table1[empty])}
next
empty = number(table1[butSize*butSize + 1])
CounterMan = butSize*butSize+2
nrMoves = 0
t1 = clock()
TimerMan.start()
ok
 
predicates
func pTime()
if flagsave = 0 or flagmove = 0cell_click:(integer).
warning()
else
CounterMan++
pPlaySleep()
sleep(nrSleep*1000)
pElapsedTime()
if CounterMan = len(table1)
TimerMan.stop()
ok
ok
 
clauses
func pPlaySleep
see charcell_click(7NrCell):-
value = table1[CounterMan] good(empty,_,NrCell),
place = table2[CounterMan] cell(empty,EmptyHandle),
nDegree = number cell(table3[CounterMan]NrCell,NrCellHandle),
EmptyNr = vpi::winGetText(NrCellHandle),
btnDegree[empty][1] = value
vpi::winSetText(EmptyHandle,EmptyNr),
button[empty].setbuttoncolor("orange")
vpi::winSetText(NrCellHandle,""),
button[empty] {settext(value)}
nDegree = 0 empty:=NrCell,
step_nr := step_nr + 1,
button[number(place)].setbuttoncolor("cyan")
Bingo = vpi::winGetCtlHandle(thisWin,idc_bingo),
button[number(place)] {settext("")}
empty = number(place) vpi::winSetText( Bingo, ""),
vpi::winSetState(Bingo,[wsf_Invisible]),
nrMoves = nrMoves + 1
btnMoves.settext bingo(string(nrMoves)),
 
% VerVal = uncheckedConvert(integer, math::floor((empty-1)/4)+1),
func pIncSleep
% HorVal = uncheckedConvert(integer, math::floor((empty-1) mod 4)+1),
nrSleep = nrSleep + 1
sleepbtn.settext("Sleep Time: " + string(nrSleep) + " s")
 
VerVal = math::floor((empty-1)/4)+1,
func pDecSleep
if nrSleep > HorVal = math::floor((empty-1) mod 4)+1,
nrSleep = nrSleep - 1
sleepbtn.settext("Sleep Time: " + string(nrSleep) + " s")
ok
 
vpi::winSetScrollPos(vsbarr,sb_Ctl,VerVal),
func sleep(x)
vpi::winSetScrollPos(vsbarl,sb_Ctl,VerVal),
nTime = x
vpi::winSetScrollPos(hsbart,sb_Ctl,HorVal),
oTest = new qTest
vpi::winSetScrollPos(hsbarb,sb_Ctl,HorVal),
oTest.qsleep(nTime)
return
 
Step = vpi::winGetCtlHandle(thisWin,idc_step),
func isGameOver
vpi::winSetText(Step,toString(step_nr)),
flagend = 1
for n=1 to butSize*butSize-1
if button[n].text() != n or btnDegree[n][2] != 0
flagend = 0
exit
ok
next
if flagend = 1
new qmessagebox(win1) {
setwindowtitle("Game Over")
settext("Congratulations!")
show()
}
ok
 
assert(gameplay(step_nr,NrCell)),
func rightPlace
count = 0
for n=1 to butSize*butSize
if button[n].text() = n and btnDegree[n][2] = 0
count = count + 1
ok
next
rightbtn.settext("In the Right Place : " + count)
 
fail.
func warning
new qmessageboxcell_click(win1_) {.
setwindowtitle("Warning!")
settext("First you must play and save the game.")
show()
}
 
/* ------------------------------------------------------------------------------------------------------ */
func pElapsedTime
t2 = (clock() - t1)/1000
timebtn.settext("Elapsed Time : " + t2 + " s")
 
predicates
Class ButtonWithRotatedText
cell_click_play:(integer).
 
clauses
oButton oLabel cText="We are here" nDegree = 30 nTransX = 50 nTransY = 0
cell_click_play(NrCell):-
good(empty,_,NrCell),
cell(empty,EmptyHandle),
cell(NrCell,NrCellHandle),
EmptyNr = vpi::winGetText(NrCellHandle),
vpi::winSetText(EmptyHandle,EmptyNr),
vpi::winSetText(NrCellHandle,""),
empty:=NrCell,
Bingo = vpi::winGetCtlHandle(thisWin,idc_bingo),
vpi::winSetText(Bingo, ""),
vpi::winSetState(Bingo,[wsf_Invisible]),
bingo(),
 
% VerVal = uncheckedConvert(integer,math::floor((empty-1)/4)+1),
func init( oParent)
% HorVal = uncheckedConvert(integer,math::floor((empty-1) mod 4)+1),
oButton = new qPushButton(oParent)
oLabel = new qLabel(oParent)
oLabel.setAttribute(Qt_WA_TransparentForMouseEvents,True)
oLabel.setAttribute(Qt_WA_DeleteOnClose, True)
oButton.setAttribute(Qt_WA_DeleteOnClose, True)
oButton.Show()
return
func close()
oLabel.close()
oButton.close()
return
 
VerVal = math::floor((empty-1)/4)+1,
func setstylesheet(x)
HorVal = math::floor((empty-1) mod 4)+1,
oButton.setstylesheet(x)
 
vpi::winSetScrollPos(vsbarr,sb_Ctl,VerVal),
func setgeometry( x,y,width,height)
vpi::winSetScrollPos(vsbarl,sb_Ctl,VerVal),
oButton.setgeometry(x,y,width,height)
vpi::winSetScrollPos(hsbart,sb_Ctl,HorVal),
oLabel.setgeometry( x,y,width,height)
vpi::winSetScrollPos(hsbarb,sb_Ctl,HorVal),
func setText( cValue)
cText = cValue
return
func Text()
return cText
 
programControl::sleep(1000),
func setTranslate( x,y )
nTransX = x
nTransY = y
return
 
fail.
func TranslateOffsetX()
return nTransX cell_click_play(_).
 
/* ------------------------------------------------------------------------------------------------------ */
func TranslateOffsetY()
return nTransY
func setRotationDegree( nValue)
nDegree = nValue
return
func RotationDegree()
return nDegree
 
predicates
func setClickEvent( cEvent)
onControlmix : vpiOldDomains::controlHandler.
oButton.setClickEvent(cEvent)
returnclauses
onControlmix(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
step_nr:=0,
func braceend()
draw cell_reset() ,
return mix_cells(0),
Play = vpi::winGetCtlHandle(thisWin,idc_play),
vpi::winSetState(Play,[wsf_Disabled]),
Bingo = vpi::winGetCtlHandle(thisWin,idc_bingo),
vpi::winSetText(Bingo, ""),
vpi::winSetState(Bingo,[wsf_Invisible]),
step_nr:=0,
Step = vpi::winGetCtlHandle(thisWin,idc_step),
vpi::winSetText(Step,toString(step_nr)),
table_save(),
retractall(gameplay(_,_)),
fail.
 
onControlmix(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull).
func setEnabled(value)
oButton.setenabled(value)
return
 
/* ------------------------------------------------------------------------------------------------------ */
func setButtonColor(color)
 
colorIt = "background-color:" + color
class facts
oButton.setstylesheet(colorIt)
returnrand_nr:integer:=0.
mix_nr:integer:=300.
 
func draw()
predicates
picture = new qpicture()
mix_cells:(integer) multi.
color = new qcolor() { setrgb(0,0,255,255) }
 
pen = new qpen() { setcolor(color) setwidth(10) }
clauses
painter = new qpaintermix_cells(mix_nr) :-!.
{mix_cells(Number):-
NumberNew = begin(picture) Number+1,
setpencellnr(penempty,CellNr),
RandomNr = (math::random(1315) mod CellNr) + 1,
oFont = new qfont("Courier New",12,75,0)
rand_nr := oFont.setpointsize(20)RandomNr,
good(empty,rand_nr, setfont(oFontI),
if nDegree = 0cell_click(I),
mix_cells(NumberNew).
if btnDegree[empty] [1]="In" p1 = -8 p2=0
translatemix_cells(p1,p2_) ok ok.
 
if nDegree = 0
/* ------------------------------------------------------------------------------------------------------ */
if btnDegree[empty] [1]<10 p1 = 10 p2=10 else p1=5 p2=10 ok
 
translate(p1,p2)
predicates
but nDegree = 90
table_save:().
if btnDegree[empty] [1]<10 p=-10 else p=-15 ok
clauses
translate(10,p)
table_save():-
but nDegree = 180
retractall(table(_,_)),
if btnDegree[empty] [1]<10 p1= 30 p2=-10 else p1=35 p2=-10 ok
translateretractall(p1,p2empty_cell(_)),
but nDegree = 270assert(empty_cell(empty)),
 
if btnDegree[empty] [1]<10 p=10 else p=15 ok
translateassert(30table(1,pvpi::winGetText(cell1))),
but nDegree = -90assert(table(2,vpi::winGetText(cell2))),
assert(table(3,vpi::winGetText(cell3))),
if btnDegree[empty] [1]<10 p=10 else p=15 ok
translateassert(30table(4,pvpi::winGetText(cell4))),
but nDegree = -180assert(table(5,vpi::winGetText(cell5))),
assert(table(6,vpi::winGetText(cell6))),
if btnDegree[empty] [1]<10 p1=30 p2=-10 else p1=35 p2=-10 ok
translateassert(p1table(7,p2vpi::winGetText(cell7))),
but nDegree = -270assert(table(8,vpi::winGetText(cell8))),
assert(table(9,vpi::winGetText(cell9))),
if btnDegree[empty] [1]<10 p1=10 p2=-10 else p1=10 p2=-15 ok
translateassert(p1table(10,p2vpi::winGetText(cell10))),
ok assert(table(11,vpi::winGetText(cell11))),
rotateassert(nDegreetable(12,vpi::winGetText(cell12))),
drawtext assert(table(013,0,this.Textvpi::winGetText(cell13)) ),
endpaintassert(table(14,vpi::winGetText(cell14))),
assert(table(15,vpi::winGetText(cell15))),
}
assert(table(16,vpi::winGetText(cell16))).
oLabel {
 
setpicture(picture)
/* ------------------------------------------------------------------------------------------------------ */
show()
 
}
returnpredicates
onControlreset : vpiOldDomains::controlHandler.
clauses
onControlreset(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_reset().
 
/* ------------------------------------------------------------------------------------------------------ */
predicates
cell_reset:().
clauses
cell_reset():-
vpi::winSetText(cell1,"1"),
vpi::winSetText(cell2,"2"),
vpi::winSetText(cell3,"3"),
vpi::winSetText(cell4,"4"),
vpi::winSetText(cell5,"5"),
vpi::winSetText(cell6,"6"),
vpi::winSetText(cell7,"7"),
vpi::winSetText(cell8,"8"),
vpi::winSetText(cell9,"9"),
vpi::winSetText(cell10,"10"),
vpi::winSetText(cell11,"11"),
vpi::winSetText(cell12,"12"),
vpi::winSetText(cell13,"13"),
vpi::winSetText(cell14,"14"),
vpi::winSetText(cell15,"15"),
vpi::winSetText(cell16,""),
 
vpi::winSetScrollPos(vsbarr,sb_Ctl,4),
vpi::winSetScrollPos(vsbarl,sb_Ctl,4),
vpi::winSetScrollPos(hsbart,sb_Ctl,4),
vpi::winSetScrollPos(hsbarb,sb_Ctl,4),
 
empty:=16,
step_nr:=0,
Step = vpi::winGetCtlHandle(thisWin,idc_step),
vpi::winSetText(Step,toString(step_nr)),
Bingo = vpi::winGetCtlHandle(thisWin,idc_bingo),
vpi::winSetText(Bingo, ""),
vpi::winSetState(Bingo,[wsf_Invisible]),
Play = vpi::winGetCtlHandle(thisWin,idc_play),
vpi::winSetState(Play,[wsf_Disabled]),
retractall(gameplay(_,_)),
table_save().
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
bingo:().
 
clauses
bingo():-
toString(1) = vpi::winGetText(cell1),
toString(2) = vpi::winGetText(cell2),
toString(3) = vpi::winGetText(cell3),
toString(4) = vpi::winGetText(cell4),
toString(5) = vpi::winGetText(cell5),
toString(6) = vpi::winGetText(cell6),
toString(7) = vpi::winGetText(cell7),
toString(8) = vpi::winGetText(cell8),
toString(9) = vpi::winGetText(cell9),
toString(10) = vpi::winGetText(cell10),
toString(11) = vpi::winGetText(cell11),
toString(12) = vpi::winGetText(cell12),
toString(13) = vpi::winGetText(cell13),
toString(14) = vpi::winGetText(cell14),
toString(15) = vpi::winGetText(cell15),
"" = vpi::winGetText(cell16),
 
Bingo = vpi::winGetCtlHandle(thisWin,idc_bingo),
vpi::winSetState(Bingo,[wsf_Visible]),
vpi::winSetText(Bingo, "BINGO !"),
 
Step = vpi::winGetCtlHandle(thisWin,idc_step),
vpi::winSetText(Step,toString(step_nr)),
 
fail.
bingo().
 
/* ------------------------------------------------------------------------------------------------------ */
 
facts
fileName:string:="".
 
predicates
onControlsave : vpiOldDomains::controlHandler.
clauses
onControlsave(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
try
FileName = vpiCommonDialogs::getFileName(fileName, ["All files", "*.game"], "Save game as", [dlgfn_Save], "", _)
catch _ do
fail
end try,
!,
file::save(FileName,gameDB).
 
onControlsave(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo)= vpiOldDomains::handled(gui_api::rNull).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlopen : vpiOldDomains::controlHandler.
clauses
onControlopen(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
try
FileName = vpiCommonDialogs::getFileName("game_", ["All files", "*.game"], "Open game file", [], "", _)
catch _ do
fail
end try,
!,
retractall(table(_,_)),
retractall(gameplay(_,_)),
retractall(empty_cell(_)),
file::consult(FileName,gameDB),
play_display(),
Play = vpi::winGetCtlHandle(thisWin,idc_play),
vpi::winSetState(Play,[wsf_Enabled]),
Bingo = vpi::winGetCtlHandle(thisWin,idc_bingo),
vpi::winSetState(Bingo,[wsf_Invisible]),
vpi::winSetText(Bingo, ""),
step_nr:=0,
Step = vpi::winGetCtlHandle(thisWin,idc_step),
vpi::winSetText(Step,toString(step_nr)).
 
onControlopen(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
play_display:().
clauses
play_display():-
 
table(1,Cell1),
table(2,Cell2),
table(3,Cell3),
table(4,Cell4),
table(5,Cell5),
table(6,Cell6),
table(7,Cell7),
table(8,Cell8),
table(9,Cell9),
table(10,Cell10),
table(11,Cell11),
table(12,Cell12),
table(13,Cell13),
table(14,Cell14),
table(15,Cell15),
table(16,Cell16),
 
vpi::winSetText(cell1,Cell1),
vpi::winSetText(cell2,Cell2),
vpi::winSetText(cell3,Cell3),
vpi::winSetText(cell4,Cell4),
vpi::winSetText(cell5,Cell5),
vpi::winSetText(cell6,Cell6),
vpi::winSetText(cell7,Cell7),
vpi::winSetText(cell8,Cell8),
vpi::winSetText(cell9,Cell9),
vpi::winSetText(cell10,Cell10),
vpi::winSetText(cell11,Cell11),
vpi::winSetText(cell12,Cell12),
vpi::winSetText(cell13,Cell13),
vpi::winSetText(cell14,Cell14),
vpi::winSetText(cell15,Cell15),
vpi::winSetText(cell16,Cell16),
 
empty_cell(Empty_Cell),
empty:=Empty_Cell,
 
fail.
play_display().
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlplay : vpiOldDomains::controlHandler.
clauses
 
onControlplay(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
Play = vpi::winGetCtlHandle(thisWin,idc_play),
vpi::winSetState(Play,[wsf_Disabled]),
gameplay(Nr,Nr_cell),
cell_click_play(Nr_cell),
Step = vpi::winGetCtlHandle(thisWin,idc_step),
vpi::winSetText(Step,toString(Nr)),
fail.
 
onControlplay(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlsbvr : vpiOldDomains::controlHandler. % Sets the right vertical scrollbar
clauses
onControlsbvr(_CtrlID, _CtrlType, _CtrlWin,scroll(sc_LineDown,_)) = vpiOldDomains::handled(gui_api::rNull):-
Sbarvalr = vpi::winGetScrollPos(vsbarr,sb_Ctl)+1,
Sbarvalr < 5,
cell_click(empty+4),
vpi::winSetScrollPos(vsbarr,sb_Ctl, Sbarvalr),
vpi::winSetScrollPos(vsbarl,sb_Ctl, Sbarvalr),
fail.
 
onControlsbvr(_CtrlID, _CtrlType, _CtrlWin,scroll(sc_LineUp,_)) = vpiOldDomains::handled(gui_api::rNull):-
Sbarvalr = vpi::winGetScrollPos(vsbarr,sb_Ctl)-1,
Sbarvalr > 0,
cell_click(empty-4),
vpi::winSetScrollPos(vsbarr,sb_Ctl, Sbarvalr),
vpi::winSetScrollPos(vsbarl,sb_Ctl, Sbarvalr),
fail.
 
onControlsbvr(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull).
 
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlsbvl : vpiOldDomains::controlHandler. % Sets the left vertical scrollbar
clauses
onControlsbvl(_CtrlID, _CtrlType, _CtrlWin,scroll(sc_LineDown,_)) = vpiOldDomains::handled(gui_api::rNull):-
Sbarvall = vpi::winGetScrollPos(vsbarl,sb_Ctl)+1,
Sbarvall < 5,
cell_click(empty+4),
vpi::winSetScrollPos(vsbarl,sb_Ctl, Sbarvall),
vpi::winSetScrollPos(vsbarr,sb_Ctl, Sbarvall),
fail.
 
onControlsbvl(_CtrlID, _CtrlType, _CtrlWin,scroll(sc_LineUp,_)) = vpiOldDomains::handled(gui_api::rNull):-
Sbarvall = vpi::winGetScrollPos(vsbarl,sb_Ctl)-1,
Sbarvall > 0,
cell_click(empty-4),
vpi::winSetScrollPos(vsbarl,sb_Ctl, Sbarvall),
vpi::winSetScrollPos(vsbarr,sb_Ctl, Sbarvall),
fail.
 
onControlsbvl(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlsbht : vpiOldDomains::controlHandler. % Sets the top horizontal scrollbar
clauses
onControlsbht(_CtrlID, _CtrlType, _CtrlWin,scroll(sc_LineDown,_)) = vpiOldDomains::handled(gui_api::rNull):-
Sbarvalt = vpi::winGetScrollPos(hsbart,sb_Ctl)+1,
Sbarvalt < 5,
cell_click(empty+1),
vpi::winSetScrollPos(hsbart,sb_Ctl, Sbarvalt),
vpi::winSetScrollPos(hsbarb,sb_Ctl, Sbarvalt),
fail.
 
onControlsbht(_CtrlID, _CtrlType, _CtrlWin,scroll(sc_LineUp,_)) = vpiOldDomains::handled(gui_api::rNull):-
Sbarvalt = vpi::winGetScrollPos(hsbart,sb_Ctl)-1,
Sbarvalt > 0,
cell_click(empty-1),
vpi::winSetScrollPos(hsbart,sb_Ctl, Sbarvalt),
vpi::winSetScrollPos(hsbarb,sb_Ctl, Sbarvalt),
fail.
 
onControlsbht(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlsbhb : vpiOldDomains::controlHandler. % Sets the bottom horizontal scrollbar
clauses
onControlsbhb(_CtrlID, _CtrlType, _CtrlWin,scroll(sc_LineDown,_)) = vpiOldDomains::handled(gui_api::rNull):-
Sbarvalb = vpi::winGetScrollPos(hsbarb,sb_Ctl)+1,
Sbarvalb < 5,
cell_click(empty+1),
vpi::winSetScrollPos(hsbarb,sb_Ctl, Sbarvalb),
vpi::winSetScrollPos(hsbart,sb_Ctl, Sbarvalb),
fail.
 
onControlsbhb(_CtrlID, _CtrlType, _CtrlWin,scroll(sc_LineUp,_)) = vpiOldDomains::handled(gui_api::rNull):-
Sbarvalb = vpi::winGetScrollPos(hsbarb,sb_Ctl)-1,
Sbarvalb > 0,
cell_click(empty-1),
vpi::winSetScrollPos(hsbarb,sb_Ctl, Sbarvalb),
vpi::winSetScrollPos(hsbart,sb_Ctl, Sbarvalb),
fail.
 
onControlsbhb(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell1 : vpiOldDomains::controlHandler.
clauses
onControlcell1(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(1).
 
/* ------------------------------------------------------------------------------------------------------ */
 
 
predicates
onControlcell2 : vpiOldDomains::controlHandler.
clauses
onControlcell2(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(2).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell3 : vpiOldDomains::controlHandler.
clauses
onControlcell3(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(3).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell4 : vpiOldDomains::controlHandler.
clauses
onControlcell4(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(4).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell5 : vpiOldDomains::controlHandler.
clauses
onControlcell5(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(5).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell6 : vpiOldDomains::controlHandler.
clauses
onControlcell6(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(6).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell7 : vpiOldDomains::controlHandler.
clauses
onControlcell7(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(7).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell8 : vpiOldDomains::controlHandler.
clauses
onControlcell8(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(8).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell9 : vpiOldDomains::controlHandler.
clauses
onControlcell9(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(9).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell10 : vpiOldDomains::controlHandler.
clauses
onControlcell10(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(10).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell11 : vpiOldDomains::controlHandler.
clauses
onControlcell11(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(11).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell12 : vpiOldDomains::controlHandler.
clauses
onControlcell12(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(12).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell13 : vpiOldDomains::controlHandler.
clauses
onControlcell13(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(13).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell14 : vpiOldDomains::controlHandler.
clauses
onControlcell14(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(14).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell15 : vpiOldDomains::controlHandler.
clauses
onControlcell15(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(15).
 
/* ------------------------------------------------------------------------------------------------------ */
 
predicates
onControlcell16 : vpiOldDomains::controlHandler.
clauses
onControlcell16(_CtrlID, _CtrlType, _CtrlWin, _CtrlInfo) = vpiOldDomains::handled(gui_api::rNull):-
cell_click(16).
 
/* ------------------------------------------------------------------------------------------------------ */
 
% This code is maintained by the VDE do not update it manually, 22:12:35-14.3.2004
constants
dialogType : vpiDomains::wintype = wd_Modal.
title : string = "playDialog".
rectangle : vpiDomains::rct = rct(200,40,359,263).
dialogFlags : vpiDomains::wsflags = [wsf_Close,wsf_TitleBar].
dialogFont = "MS Sans Serif".
dialogFontSize = 8.
 
constants
controlList : vpiDomains::windef_list =
[
dlgFont(wdef(dialogType, rectangle, title, u_DlgBase),
dialogFont, dialogFontSize, dialogFlags),
ctl(wdef(wc_PushButton,rct(40,166,67,178),"&Mix",u_DlgBase),idc_mix,[wsf_Group,wsf_TabStop]),
ctl(wdef(wc_PushButton,rct(67,166,94,178),"&Reset",u_DlgBase),idc_reset,[wsf_Group,wsf_TabStop]),
ctl(wdef(wc_PushButton,rct(40,178,67,190),"&Save",u_DlgBase),idc_save,[wsf_Group,wsf_TabStop]),
ctl(wdef(wc_PushButton,rct(94,178,121,190),"&Open",u_DlgBase),idc_open,[wsf_Group,wsf_TabStop]),
ctl(wdef(wc_PushButton,rct(40,190,121,202),"&Play",u_DlgBase),idc_play,[wsf_Group,wsf_TabStop,wsf_Disabled]),
ctl(wdef(wc_PushButton,rct(94,166,121,178),"&Exit",u_DlgBase),idc_cancel,[wsf_Group,wsf_TabStop]),
ctl(wdef(wc_PushButton,rct(40,40,60,60),"1",u_DlgBase),idc_cell1,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(60,40,80,60),"2",u_DlgBase),idc_cell2,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(80,40,100,60),"3",u_DlgBase),idc_cell3,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(100,40,120,60),"4",u_DlgBase),idc_cell4,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(40,60,60,80),"5",u_DlgBase),idc_cell5,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(60,60,80,80),"6",u_DlgBase),idc_cell6,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(80,60,100,80),"7",u_DlgBase),idc_cell7,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(100,60,120,80),"8",u_DlgBase),idc_cell8,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(40,80,60,100),"9",u_DlgBase),idc_cell9,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(60,80,80,100),"10",u_DlgBase),idc_cell10,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(80,80,100,100),"11",u_DlgBase),idc_cell11,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(100,80,120,100),"12",u_DlgBase),idc_cell12,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(40,100,60,120),"13",u_DlgBase),idc_cell13,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(60,100,80,120),"14",u_DlgBase),idc_cell14,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(80,100,100,120),"15",u_DlgBase),idc_cell15,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(100,100,120,120),"",u_DlgBase),idc_cell16,[wsf_Group]),
ctl(wdef(wc_HScroll,rct(30,18,130,30),"",u_DlgBase),idc_sbht,[]),
ctl(wdef(wc_VScroll,rct(130,30,142,130),"",u_DlgBase),idc_sbvr,[]),
ctl(wdef(wc_HScroll,rct(30,130,130,142),"",u_DlgBase),idc_sbhb,[]),
ctl(wdef(wc_VScroll,rct(18,30,30,130),"",u_DlgBase),idc_sbvl,[]),
ctl(wdef(wc_PushButton,rct(67,178,94,190),"",u_DlgBase),idc_step,[wsf_Group]),
ctl(wdef(wc_PushButton,rct(40,154,121,166),"",u_DlgBase),idc_bingo,[wsf_Group,wsf_Invisible])
].
 
predicates
generatedEventHandler : vpiDomains::ehandler.
clauses
generatedEventHandler(Win, e_create(_)) = _ :-
thisWin := Win,
fail.
generatedEventHandler(_Win, e_Create(CreationData)) = Result :-
handled(Result) = onCreate(CreationData).
generatedEventHandler(_Win, e_Update(Rectangle)) = Result :-
handled(Result) = onUpdate(Rectangle).
generatedEventHandler(_Win, e_Control(idc_cancel, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlCancel(idc_cancel, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_mix, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlmix(idc_mix, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_reset, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlreset(idc_reset, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_sbvr, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlsbvr(idc_sbvr, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_sbvl, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlsbvl(idc_sbvl, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_sbhb, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlsbhb(idc_sbhb, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_sbht, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlsbht(idc_sbht, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_save, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlsave(idc_save, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_open, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlopen(idc_open, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_play, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlplay(idc_play, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell1, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell1(idc_cell1, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell10, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell10(idc_cell10, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell11, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell11(idc_cell11, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell12, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell12(idc_cell12, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell13, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell13(idc_cell13, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell14, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell14(idc_cell14, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell15, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell15(idc_cell15, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell16, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell16(idc_cell16, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell2, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell2(idc_cell2, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell3, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell3(idc_cell3, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell4, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell4(idc_cell4, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell5, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell5(idc_cell5, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell6, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell6(idc_cell6, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell7, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell7(idc_cell7, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell8, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell8(idc_cell8, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Control(idc_cell9, CtrlType, CtrlWin, CtlInfo)) = Result :-
handled(Result) = onControlcell9(idc_cell9, CtrlType, CtrlWin, CtlInfo).
generatedEventHandler(_Win, e_Destroy()) = Result :-
handled(Result) = onDestroy().
% end of automatic code
end implement playDialog
</lang>
 
'''Output:'''
 
[https://www.youtube.com/watch?v=rWy3AX5HjXM CalmoSoft Fifteen Puzzle Game in Visual Prolog - video]
 
=={{header|Ruby}}==
CalmoSoft
2,468

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/264464"