mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-09 06:04:59 +00:00
Yet more script rearranging
This commit is contained in:
Maruno17
582
Data/Scripts/017_Minigames/007_Minigame_TilePuzzles.rb
Normal file
582
Data/Scripts/017_Minigames/007_Minigame_TilePuzzles.rb
Normal file
@@ -0,0 +1,582 @@
|
||||
################################################################################
|
||||
# "Tile Puzzle" mini-games
|
||||
# By Maruno
|
||||
# Graphics by the__end
|
||||
#-------------------------------------------------------------------------------
|
||||
# Run with: pbTilePuzzle(game,board,width,height)
|
||||
# game = 1 (Ruins of Alph puzzle),
|
||||
# 2 (Ruins of Alph puzzle plus tile rotations),
|
||||
# 3 (Mystic Square),
|
||||
# 4 (swap two adjacent tiles),
|
||||
# 5 (swap two adjacent tiles plus tile rotations),
|
||||
# 6 (Rubik's square),
|
||||
# 7 (rotate selected tile plus adjacent tiles at once).
|
||||
# board = The name/number of the graphics to be used.
|
||||
# width,height = Optional, the number of tiles wide/high the puzzle is (0 for
|
||||
# the default value of 4).
|
||||
################################################################################
|
||||
class TilePuzzleCursor < BitmapSprite
|
||||
attr_accessor :game
|
||||
attr_accessor :position
|
||||
attr_accessor :arrows
|
||||
attr_accessor :selected
|
||||
attr_accessor :holding
|
||||
|
||||
def initialize(game,position,tilewidth,tileheight,boardwidth,boardheight)
|
||||
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
|
||||
@viewport.z=99999
|
||||
super(Graphics.width,Graphics.height,@viewport)
|
||||
@game=game
|
||||
@position=position
|
||||
@tilewidth=tilewidth
|
||||
@tileheight=tileheight
|
||||
@boardwidth=boardwidth
|
||||
@boardheight=boardheight
|
||||
@arrows=[]
|
||||
@selected=false
|
||||
@holding=false
|
||||
@cursorbitmap=AnimatedBitmap.new(_INTL("Graphics/Pictures/Tile Puzzle/cursor"))
|
||||
update
|
||||
end
|
||||
|
||||
def update
|
||||
self.bitmap.clear
|
||||
x=(Graphics.width-(@tilewidth*@boardwidth))/2
|
||||
if @position>=@boardwidth*@boardheight
|
||||
x=(x-(@tilewidth*(@boardwidth/2).ceil))/2-10
|
||||
if (@position%@boardwidth)>=(@boardwidth/2).ceil
|
||||
x=Graphics.width-x-@tilewidth*@boardwidth
|
||||
end
|
||||
end
|
||||
x+=@tilewidth*(@position%@boardwidth)
|
||||
y=(Graphics.height-(@tileheight*@boardheight))/2-32
|
||||
y+=@tileheight*((@position%(@boardwidth*@boardheight))/@boardwidth)
|
||||
self.tone=Tone.new(0,(@holding ? 64 : 0),(@holding ? 64 : 0),0)
|
||||
# Cursor
|
||||
if @game!=3
|
||||
expand=(@holding) ? 0 : 4
|
||||
for i in 0...4
|
||||
self.bitmap.blt(x+(i%2)*(@tilewidth-@cursorbitmap.width/4)+expand*(((i%2)*2)-1),
|
||||
y+(i/2)*(@tileheight-@cursorbitmap.height/2)+expand*(((i/2)*2)-1),
|
||||
@cursorbitmap.bitmap,Rect.new(
|
||||
(i%2)*@cursorbitmap.width/4,(i/2)*@cursorbitmap.height/2,
|
||||
@cursorbitmap.width/4,@cursorbitmap.height/2))
|
||||
end
|
||||
end
|
||||
# Arrows
|
||||
if @selected || @game==3
|
||||
expand=(@game==3) ? 0 : 4
|
||||
xin=[(@tilewidth-@cursorbitmap.width/4)/2,-expand,
|
||||
@tilewidth-@cursorbitmap.width/4+expand,(@tilewidth-@cursorbitmap.width/4)/2]
|
||||
yin=[@tileheight-@cursorbitmap.height/2+expand,(@tileheight-@cursorbitmap.height/2)/2,
|
||||
(@tileheight-@cursorbitmap.height/2)/2,-expand]
|
||||
for i in 0...4
|
||||
if @arrows[i]
|
||||
self.bitmap.blt(x+xin[i],y+yin[i],@cursorbitmap.bitmap,Rect.new(
|
||||
@cursorbitmap.width/2+(i%2)*(@cursorbitmap.width/4),
|
||||
(i/2)*(@cursorbitmap.height/2),
|
||||
@cursorbitmap.width/4,@cursorbitmap.height/2))
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
class TilePuzzleScene
|
||||
def initialize(game,board,width,height)
|
||||
@game=game
|
||||
@board=board
|
||||
@boardwidth=(width>0) ? width : 4
|
||||
@boardheight=(height>0) ? height : 4
|
||||
end
|
||||
|
||||
def update
|
||||
xtop=(Graphics.width-(@tilewidth*@boardwidth))/2
|
||||
ytop=(Graphics.height-(@tileheight*@boardheight))/2+@tileheight/2-32
|
||||
for i in 0...@boardwidth*@boardheight
|
||||
pos=-1
|
||||
for j in 0...@tiles.length
|
||||
pos=j if @tiles[j]==i
|
||||
end
|
||||
@sprites["tile#{i}"].z=0
|
||||
@sprites["tile#{i}"].tone=Tone.new(0,0,0,0)
|
||||
if @heldtile==i
|
||||
pos=@sprites["cursor"].position
|
||||
@sprites["tile#{i}"].z=1
|
||||
@sprites["tile#{i}"].tone=Tone.new(64,0,0,0) if @tiles[pos]>=0
|
||||
end
|
||||
thisx=xtop
|
||||
if pos>=0
|
||||
if pos>=@boardwidth*@boardheight
|
||||
thisx=(xtop-(@tilewidth*(@boardwidth/2).ceil))/2-10
|
||||
if (pos%@boardwidth)>=(@boardwidth/2).ceil
|
||||
thisx=Graphics.width-thisx-@tilewidth*@boardwidth
|
||||
end
|
||||
end
|
||||
@sprites["tile#{i}"].x=thisx+@tilewidth*(pos%@boardwidth)+@tilewidth/2
|
||||
@sprites["tile#{i}"].y=ytop+@tileheight*((pos%(@boardwidth*@boardheight))/@boardwidth)
|
||||
next if @game==3
|
||||
rotatebitmaps=[@tilebitmap,@tilebitmap1,@tilebitmap2,@tilebitmap3]
|
||||
@sprites["tile#{i}"].bitmap.clear
|
||||
if rotatebitmaps[@angles[i]]
|
||||
@sprites["tile#{i}"].bitmap.blt(0,0,rotatebitmaps[@angles[i]].bitmap,
|
||||
Rect.new(@tilewidth*(i%@boardwidth),@tileheight*(i/@boardwidth),@tilewidth,@tileheight))
|
||||
@sprites["tile#{i}"].angle=0
|
||||
else
|
||||
@sprites["tile#{i}"].bitmap.blt(0,0,@tilebitmap.bitmap,
|
||||
Rect.new(@tilewidth*(i%@boardwidth),@tileheight*(i/@boardwidth),@tilewidth,@tileheight))
|
||||
@sprites["tile#{i}"].angle=@angles[i]*90
|
||||
end
|
||||
end
|
||||
end
|
||||
updateCursor
|
||||
pbUpdateSpriteHash(@sprites)
|
||||
end
|
||||
|
||||
def updateCursor
|
||||
arrows=[]
|
||||
for i in 0...4
|
||||
arrows.push(pbCanMoveInDir?(@sprites["cursor"].position,(i+1)*2,@game==6))
|
||||
end
|
||||
@sprites["cursor"].arrows=arrows
|
||||
end
|
||||
|
||||
def pbStartScene
|
||||
@sprites={}
|
||||
@viewport=Viewport.new(0,0,Graphics.width,Graphics.height)
|
||||
@viewport.z=99999
|
||||
if pbResolveBitmap("Graphics/Pictures/Tile Puzzle/bg#{@board}")
|
||||
addBackgroundPlane(@sprites,"bg","Tile Puzzle/bg#{@board}",@viewport)
|
||||
else
|
||||
addBackgroundPlane(@sprites,"bg","Tile Puzzle/bg",@viewport)
|
||||
end
|
||||
@tilebitmap=AnimatedBitmap.new("Graphics/Pictures/Tile Puzzle/tiles#{@board}")
|
||||
@tilebitmap1=nil; @tilebitmap2=nil; @tilebitmap3=nil
|
||||
if pbResolveBitmap("Graphics/Pictures/Tile Puzzle/tiles#{@board}_1")
|
||||
@tilebitmap1=AnimatedBitmap.new("Graphics/Pictures/Tile Puzzle/tiles#{@board}_1")
|
||||
end
|
||||
if pbResolveBitmap("Graphics/Pictures/Tile Puzzle/tiles#{@board}_2")
|
||||
@tilebitmap2=AnimatedBitmap.new("Graphics/Pictures/Tile Puzzle/tiles#{@board}_2")
|
||||
end
|
||||
if pbResolveBitmap("Graphics/Pictures/Tile Puzzle/tiles#{@board}_3")
|
||||
@tilebitmap3=AnimatedBitmap.new("Graphics/Pictures/Tile Puzzle/tiles#{@board}_3")
|
||||
end
|
||||
@tilewidth=@tilebitmap.width/@boardwidth
|
||||
@tileheight=@tilebitmap.height/@boardheight
|
||||
for i in 0...@boardwidth*@boardheight
|
||||
@sprites["tile#{i}"]=BitmapSprite.new(@tilewidth,@tileheight,@viewport)
|
||||
@sprites["tile#{i}"].ox=@tilewidth/2
|
||||
@sprites["tile#{i}"].oy=@tileheight/2
|
||||
break if @game==3 && i>=@boardwidth*@boardheight-1
|
||||
@sprites["tile#{i}"].bitmap.blt(0,0,@tilebitmap.bitmap,
|
||||
Rect.new(@tilewidth*(i%@boardwidth),@tileheight*(i/@boardwidth),@tilewidth,@tileheight))
|
||||
end
|
||||
@heldtile=-1
|
||||
@angles=[]
|
||||
@tiles=pbShuffleTiles
|
||||
@sprites["cursor"]=TilePuzzleCursor.new(@game,pbDefaultCursorPosition,
|
||||
@tilewidth,@tileheight,@boardwidth,@boardheight)
|
||||
update
|
||||
pbFadeInAndShow(@sprites)
|
||||
end
|
||||
|
||||
def pbShuffleTiles
|
||||
ret=[]
|
||||
for i in 0...@boardwidth*@boardheight; ret.push(i); @angles.push(0); end
|
||||
if @game==6
|
||||
@tiles=ret
|
||||
5.times do
|
||||
pbShiftLine([2,4,6,8][rand(4)],rand(@boardwidth*@boardheight),false)
|
||||
end
|
||||
return @tiles
|
||||
elsif @game==7
|
||||
@tiles=ret
|
||||
5.times do
|
||||
pbRotateTile(rand(@boardwidth*@boardheight),false)
|
||||
end
|
||||
else
|
||||
ret.shuffle!
|
||||
if @game==3 # Make sure only solvable Mystic Squares are allowed.
|
||||
num=0; blank=-1
|
||||
for i in 0...ret.length-1
|
||||
blank=i if ret[i]==@boardwidth*@boardheight-1
|
||||
for j in i...ret.length
|
||||
num+=1 if ret[j]<ret[i] && ret[i]!=@boardwidth*@boardheight-1 &&
|
||||
ret[j]!=@boardwidth*@boardheight-1
|
||||
end
|
||||
end
|
||||
if @boardwidth%2==1
|
||||
ret=pbShuffleTiles if num%2==1
|
||||
else
|
||||
ret=pbShuffleTiles if !((num%2==0 && (@boardheight-(blank/@boardwidth))%2==1) ||
|
||||
(num%2==1 && (@boardheight-(blank/@boardwidth))%2==0))
|
||||
end
|
||||
end
|
||||
if @game==1 || @game==2
|
||||
ret2=[]
|
||||
for i in 0...@boardwidth*@boardheight; ret2.push(-1); end
|
||||
ret=ret2+ret
|
||||
end
|
||||
if @game==2 || @game==5
|
||||
for i in 0...@angles.length; @angles[i]=rand(4); end
|
||||
end
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
def pbDefaultCursorPosition
|
||||
if @game==3
|
||||
for i in 0...@boardwidth*@boardheight
|
||||
return i if @tiles[i]==@boardwidth*@boardheight-1
|
||||
end
|
||||
return 0
|
||||
else
|
||||
return 0
|
||||
end
|
||||
end
|
||||
|
||||
def pbMoveCursor(pos,dir)
|
||||
if dir==2
|
||||
pos+=@boardwidth
|
||||
elsif dir==4
|
||||
if pos>=@boardwidth*@boardheight
|
||||
if pos%@boardwidth==(@boardwidth/2).ceil
|
||||
pos=((pos%(@boardwidth*@boardheight))/@boardwidth)*@boardwidth+@boardwidth-1
|
||||
else
|
||||
pos-=1
|
||||
end
|
||||
else
|
||||
if (pos%@boardwidth)==0
|
||||
pos=(((pos/@boardwidth)+@boardheight)*@boardwidth)+(@boardwidth/2).ceil-1
|
||||
else
|
||||
pos-=1
|
||||
end
|
||||
end
|
||||
elsif dir==6
|
||||
if pos>=@boardwidth*@boardheight
|
||||
if pos%@boardwidth==(@boardwidth/2).ceil-1
|
||||
pos=((pos%(@boardwidth*@boardheight))/@boardwidth)*@boardwidth
|
||||
else
|
||||
pos+=1
|
||||
end
|
||||
else
|
||||
if pos%@boardwidth>=@boardwidth-1
|
||||
pos=(((pos/@boardwidth)+@boardheight)*@boardwidth)+(@boardwidth/2).ceil
|
||||
else
|
||||
pos+=1
|
||||
end
|
||||
end
|
||||
elsif dir==8
|
||||
pos-=@boardwidth
|
||||
end
|
||||
return pos
|
||||
end
|
||||
|
||||
def pbCanMoveInDir?(pos,dir,swapping)
|
||||
return true if @game==6 && swapping
|
||||
if dir==2
|
||||
return false if (pos/@boardwidth)%@boardheight>=@boardheight-1
|
||||
elsif dir==4
|
||||
if @game==1 || @game==2
|
||||
return false if pos>=@boardwidth*@boardheight && pos%@boardwidth==0
|
||||
else
|
||||
return false if pos%@boardwidth==0
|
||||
end
|
||||
elsif dir==6
|
||||
if @game==1 || @game==2
|
||||
return false if pos>=@boardwidth*@boardheight && pos%@boardwidth>=@boardwidth-1
|
||||
else
|
||||
return false if pos%@boardwidth>=@boardwidth-1
|
||||
end
|
||||
elsif dir==8
|
||||
return false if (pos/@boardwidth)%@boardheight==0
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
def pbRotateTile(pos,anim=true)
|
||||
if @heldtile>=0
|
||||
if anim
|
||||
@sprites["cursor"].visible=false
|
||||
@sprites["tile#{@heldtile}"].z = 1
|
||||
oldAngle = @sprites["tile#{@heldtile}"].angle
|
||||
rotateTime = Graphics.frame_rate/4
|
||||
angleDiff = 90.0/rotateTime
|
||||
rotateTime.times do
|
||||
@sprites["tile#{@heldtile}"].angle -= angleDiff
|
||||
pbUpdateSpriteHash(@sprites)
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
@sprites["tile#{@heldtile}"].z = 0
|
||||
@sprites["tile#{@heldtile}"].angle = oldAngle-90
|
||||
@sprites["cursor"].visible=true if !pbCheckWin
|
||||
end
|
||||
@angles[@heldtile]-=1
|
||||
@angles[@heldtile]+=4 if @angles[@heldtile]<0
|
||||
else
|
||||
return if @tiles[pos]<0
|
||||
group=pbGetNearTiles(pos)
|
||||
if anim
|
||||
@sprites["cursor"].visible=false
|
||||
oldAngles = []
|
||||
for i in group
|
||||
@sprites["tile#{@tiles[i]}"].z = 1
|
||||
oldAngles[i] = @sprites["tile#{@tiles[i]}"].angle
|
||||
end
|
||||
rotateTime = Graphics.frame_rate/4
|
||||
angleDiff = 90.0/rotateTime
|
||||
rotateTime.times do
|
||||
for i in group
|
||||
@sprites["tile#{@tiles[i]}"].angle -= angleDiff
|
||||
end
|
||||
pbUpdateSpriteHash(@sprites)
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
for i in group
|
||||
@sprites["tile#{@tiles[i]}"].z = 0
|
||||
@sprites["tile#{@tiles[i]}"].angle = oldAngles[i]-90
|
||||
end
|
||||
@sprites["cursor"].visible=true if !pbCheckWin
|
||||
end
|
||||
for i in group
|
||||
tile=@tiles[i]
|
||||
@angles[tile]-=1
|
||||
@angles[tile]+=4 if @angles[tile]<0
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def pbGetNearTiles(pos)
|
||||
ret=[pos]
|
||||
if @game==7
|
||||
for i in [2,4,6,8]
|
||||
ret.push(pbMoveCursor(pos,i)) if pbCanMoveInDir?(pos,i,true)
|
||||
end
|
||||
end
|
||||
return ret
|
||||
end
|
||||
|
||||
def pbSwapTiles(dir)
|
||||
cursor=@sprites["cursor"].position
|
||||
return pbShiftLine(dir,cursor) if @game==6
|
||||
movetile=pbMoveCursor(cursor,dir)
|
||||
@sprites["cursor"].visible=false
|
||||
@sprites["tile#{@tiles[cursor]}"].z=1
|
||||
if dir==2 || dir==8 # Swap vertically
|
||||
swapTime = Graphics.frame_rate*3/10
|
||||
distancePerFrame = (@tileheight.to_f/swapTime).ceil
|
||||
dist = (dir/4).floor-1
|
||||
swapTime.times do
|
||||
@sprites["tile#{@tiles[movetile]}"].y += dist*distancePerFrame
|
||||
@sprites["tile#{@tiles[cursor]}"].y -= dist*distancePerFrame
|
||||
pbUpdateSpriteHash(@sprites)
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
else # Swap horizontally
|
||||
swapTime = Graphics.frame_rate*3/10
|
||||
distancePerFrame = (@tilewidth.to_f/swapTime).ceil
|
||||
dist = dir-5
|
||||
swapTime.times do
|
||||
@sprites["tile#{@tiles[movetile]}"].x -= dist*distancePerFrame
|
||||
@sprites["tile#{@tiles[cursor]}"].x += dist*distancePerFrame
|
||||
pbUpdateSpriteHash(@sprites)
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
end
|
||||
@tiles[cursor], @tiles[movetile]=@tiles[movetile], @tiles[cursor]
|
||||
@sprites["tile#{@tiles[cursor]}"].z=0
|
||||
@sprites["cursor"].position=movetile
|
||||
@sprites["cursor"].selected=false
|
||||
@sprites["cursor"].visible=true if !pbCheckWin
|
||||
return true
|
||||
end
|
||||
|
||||
def pbShiftLine(dir,cursor,anim=true)
|
||||
# Get tiles involved
|
||||
tiles=[]; dist=0
|
||||
if dir==2 || dir==8
|
||||
dist=(dir/4).floor-1
|
||||
while (dist>0 && cursor<(@boardwidth-1)*@boardheight) ||
|
||||
(dist<0 && cursor>=@boardwidth)
|
||||
cursor+=(@boardwidth*dist)
|
||||
end
|
||||
for i in 0...@boardheight
|
||||
tiles.push(cursor-i*dist*@boardwidth)
|
||||
end
|
||||
else
|
||||
dist=dir-5
|
||||
while (dist>0 && cursor%@boardwidth>0) ||
|
||||
(dist<0 && cursor%@boardwidth<@boardwidth-1)
|
||||
cursor-=dist
|
||||
end
|
||||
for i in 0...@boardwidth
|
||||
tiles.push(cursor+i*dist)
|
||||
end
|
||||
end
|
||||
# Shift tiles
|
||||
fadeTime = Graphics.frame_rate*4/10
|
||||
fadeDiff = (255.0/fadeTime).ceil
|
||||
if anim
|
||||
@sprites["cursor"].visible=false
|
||||
fadeTime.times do
|
||||
@sprites["tile#{@tiles[tiles[tiles.length-1]]}"].opacity-=fadeDiff
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
shiftTime = Graphics.frame_rate*3/10
|
||||
if dir==2 || dir==8
|
||||
distancePerFrame = (@tileheight.to_f/shiftTime).ceil
|
||||
shiftTime.times do
|
||||
for i in tiles
|
||||
@sprites["tile#{@tiles[i]}"].y -= dist*distancePerFrame
|
||||
end
|
||||
pbUpdateSpriteHash(@sprites)
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
else
|
||||
distancePerFrame = (@tilewidth.to_f/shiftTime).ceil
|
||||
shiftTime.times do
|
||||
for i in tiles
|
||||
@sprites["tile#{@tiles[i]}"].x += dist*distancePerFrame
|
||||
end
|
||||
pbUpdateSpriteHash(@sprites)
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
end
|
||||
end
|
||||
temp=[]
|
||||
for i in tiles; temp.push(@tiles[i]); end
|
||||
for i in 0...temp.length
|
||||
@tiles[tiles[(i+1)%(temp.length)]]=temp[i]
|
||||
end
|
||||
if anim
|
||||
update
|
||||
fadeTime.times do
|
||||
@sprites["tile#{@tiles[tiles[0]]}"].opacity+=fadeDiff
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
@sprites["cursor"].selected=false
|
||||
@sprites["cursor"].visible=true if !pbCheckWin
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
def pbGrabTile(pos)
|
||||
@heldtile, @tiles[pos] = @tiles[pos], @heldtile
|
||||
@sprites["cursor"].holding=(@heldtile>=0)
|
||||
@sprites["cursor"].visible=false if pbCheckWin
|
||||
end
|
||||
|
||||
def pbCheckWin
|
||||
for i in 0...@boardwidth*@boardheight
|
||||
return false if @tiles[i]!=i
|
||||
return false if @angles[i]!=0
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
def pbMain
|
||||
loop do
|
||||
update
|
||||
Graphics.update
|
||||
Input.update
|
||||
# Check end conditions
|
||||
if pbCheckWin
|
||||
@sprites["cursor"].visible=false
|
||||
if @game==3
|
||||
extratile=@sprites["tile#{@boardwidth*@boardheight-1}"]
|
||||
extratile.bitmap.clear
|
||||
extratile.bitmap.blt(0,0,@tilebitmap.bitmap,
|
||||
Rect.new(@tilewidth*(@boardwidth-1),@tileheight*(@boardheight-1),
|
||||
@tilewidth,@tileheight))
|
||||
extratile.opacity=0
|
||||
appearTime = Graphics.frame_rate*8/10
|
||||
opacityDiff = (255.0/appearTime).ceil
|
||||
appearTime.times do
|
||||
extratile.opacity += opacityDiff
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
else
|
||||
pbWait(Graphics.frame_rate/2)
|
||||
end
|
||||
loop do
|
||||
Graphics.update
|
||||
Input.update
|
||||
break if Input.trigger?(Input::USE) || Input.trigger?(Input::BACK)
|
||||
end
|
||||
return true
|
||||
end
|
||||
# Input
|
||||
@sprites["cursor"].selected=(Input.press?(Input::USE) && @game>=3 && @game<=6)
|
||||
dir=0
|
||||
dir=2 if Input.trigger?(Input::DOWN) || Input.repeat?(Input::DOWN)
|
||||
dir=4 if Input.trigger?(Input::LEFT) || Input.repeat?(Input::LEFT)
|
||||
dir=6 if Input.trigger?(Input::RIGHT) || Input.repeat?(Input::RIGHT)
|
||||
dir=8 if Input.trigger?(Input::UP) || Input.repeat?(Input::UP)
|
||||
if dir>0
|
||||
if @game==3 || (@game!=3 && @sprites["cursor"].selected)
|
||||
if pbCanMoveInDir?(@sprites["cursor"].position,dir,true)
|
||||
pbSEPlay("Tile Game cursor")
|
||||
pbSwapTiles(dir)
|
||||
end
|
||||
else
|
||||
if pbCanMoveInDir?(@sprites["cursor"].position,dir,false)
|
||||
pbSEPlay("Tile Game cursor")
|
||||
@sprites["cursor"].position=pbMoveCursor(@sprites["cursor"].position,dir)
|
||||
end
|
||||
end
|
||||
elsif (@game==1 || @game==2) && Input.trigger?(Input::USE)
|
||||
pbGrabTile(@sprites["cursor"].position)
|
||||
elsif (@game==2 && Input.trigger?(Input::ACTION)) ||
|
||||
(@game==5 && Input.trigger?(Input::ACTION)) ||
|
||||
(@game==7 && Input.trigger?(Input::USE))
|
||||
pbRotateTile(@sprites["cursor"].position)
|
||||
elsif Input.trigger?(Input::BACK)
|
||||
return false
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def pbEndScene
|
||||
pbFadeOutAndHide(@sprites)
|
||||
pbDisposeSpriteHash(@sprites)
|
||||
@viewport.dispose
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
class TilePuzzle
|
||||
def initialize(scene)
|
||||
@scene=scene
|
||||
end
|
||||
|
||||
def pbStartScreen
|
||||
@scene.pbStartScene
|
||||
ret=@scene.pbMain
|
||||
@scene.pbEndScene
|
||||
return ret
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
|
||||
def pbTilePuzzle(game,board,width=0,height=0)
|
||||
ret = false
|
||||
pbFadeOutIn {
|
||||
scene = TilePuzzleScene.new(game,board,width,height)
|
||||
screen = TilePuzzle.new(scene)
|
||||
ret = screen.pbStartScreen
|
||||
}
|
||||
return ret
|
||||
end
|
||||
Reference in New Issue
Block a user