mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2026-07-21 23:27:00 +00:00
chardub
760 lines
28 KiB
Ruby
760 lines
28 KiB
Ruby
class PokemonPokedex_Scene
|
|
def pbRefreshDexSearch(params, _index)
|
|
overlay = @sprites["overlay"].bitmap
|
|
overlay.clear
|
|
base = Color.new(248, 248, 248)
|
|
shadow = Color.new(72, 72, 72)
|
|
|
|
if isDarkMode
|
|
base, shadow = shadow, base
|
|
end
|
|
|
|
# Write various bits of text
|
|
textpos = [
|
|
[_INTL("Search Mode"), Graphics.width / 2, -2, 2, base, shadow],
|
|
[_INTL("Order"), 136, 52, 2, base, shadow],
|
|
[_INTL("Name"), 58, 110, 2, base, shadow],
|
|
[_INTL("Type"), 58, 162, 2, base, shadow],
|
|
[_INTL("Height"), 58, 214, 2, base, shadow],
|
|
[_INTL("Weight"), 58, 266, 2, base, shadow],
|
|
[_INTL("Color"), 326, 110, 2, base, shadow],
|
|
[_INTL("Shape"), 454, 162, 2, base, shadow],
|
|
[_INTL("Reset"), 80, 338, 2, base, shadow, 1],
|
|
[_INTL("Start"), Graphics.width / 2, 338, 2, base, shadow, 1],
|
|
[_INTL("Cancel"), Graphics.width - 80, 338, 2, base, shadow, 1]
|
|
]
|
|
# Write order, name and color parameters
|
|
textpos.push([@orderCommands[params[0]], 344, 58, 2, base, shadow, 1])
|
|
textpos.push([(params[1] < 0) ? "----" : @nameCommands[params[1]], 176, 116, 2, base, shadow, 1])
|
|
textpos.push([(params[8] < 0) ? "----" : @colorCommands[params[8]].name, 444, 116, 2, base, shadow, 1])
|
|
# Draw type icons
|
|
if params[2] >= 0
|
|
type_number = @typeCommands[params[2]].id_number
|
|
typerect = Rect.new(0, type_number * 32, 96, 32)
|
|
overlay.blt(128, 168, @typebitmap.bitmap, typerect)
|
|
else
|
|
textpos.push(["----", 176, 168, 2, base, shadow, 1])
|
|
end
|
|
if params[3] >= 0
|
|
type_number = @typeCommands[params[3]].id_number
|
|
typerect = Rect.new(0, type_number * 32, 96, 32)
|
|
overlay.blt(256, 168, @typebitmap.bitmap, typerect)
|
|
else
|
|
textpos.push(["----", 304, 168, 2, base, shadow, 1])
|
|
end
|
|
# Write height and weight limits
|
|
ht1 = (params[4] < 0) ? 0 : (params[4] >= @heightCommands.length) ? 999 : @heightCommands[params[4]]
|
|
ht2 = (params[5] < 0) ? 999 : (params[5] >= @heightCommands.length) ? 0 : @heightCommands[params[5]]
|
|
wt1 = (params[6] < 0) ? 0 : (params[6] >= @weightCommands.length) ? 9999 : @weightCommands[params[6]]
|
|
wt2 = (params[7] < 0) ? 9999 : (params[7] >= @weightCommands.length) ? 0 : @weightCommands[params[7]]
|
|
hwoffset = false
|
|
if System.user_language[3..4] == "US" # If the user is in the United States
|
|
ht1 = (params[4] >= @heightCommands.length) ? 99 * 12 : (ht1 / 0.254).round
|
|
ht2 = (params[5] < 0) ? 99 * 12 : (ht2 / 0.254).round
|
|
wt1 = (params[6] >= @weightCommands.length) ? 99990 : (wt1 / 0.254).round
|
|
wt2 = (params[7] < 0) ? 99990 : (wt2 / 0.254).round
|
|
textpos.push([sprintf("%d'%02d''", ht1 / 12, ht1 % 12), 166, 220, 2, base, shadow, 1])
|
|
textpos.push([sprintf("%d'%02d''", ht2 / 12, ht2 % 12), 294, 220, 2, base, shadow, 1])
|
|
textpos.push([sprintf("%.1f", wt1 / 10.0), 166, 272, 2, base, shadow, 1])
|
|
textpos.push([sprintf("%.1f", wt2 / 10.0), 294, 272, 2, base, shadow, 1])
|
|
hwoffset = true
|
|
else
|
|
textpos.push([sprintf("%.1f", ht1 / 10.0), 166, 220, 2, base, shadow, 1])
|
|
textpos.push([sprintf("%.1f", ht2 / 10.0), 294, 220, 2, base, shadow, 1])
|
|
textpos.push([sprintf("%.1f", wt1 / 10.0), 166, 272, 2, base, shadow, 1])
|
|
textpos.push([sprintf("%.1f", wt2 / 10.0), 294, 272, 2, base, shadow, 1])
|
|
end
|
|
overlay.blt(344, 214, @hwbitmap.bitmap, Rect.new(0, (hwoffset) ? 44 : 0, 32, 44))
|
|
overlay.blt(344, 266, @hwbitmap.bitmap, Rect.new(32, (hwoffset) ? 44 : 0, 32, 44))
|
|
# Draw shape icon
|
|
if params[9] >= 0
|
|
shape_number = @shapeCommands[params[9]].id_number
|
|
shaperect = Rect.new(0, (shape_number - 1) * 60, 60, 60)
|
|
overlay.blt(424, 218, @shapebitmap.bitmap, shaperect)
|
|
end
|
|
# Draw all text
|
|
pbDrawTextPositions(overlay, textpos)
|
|
end
|
|
|
|
def pbRefreshDexSearchParam(mode, cmds, sel, _index)
|
|
overlay = @sprites["overlay"].bitmap
|
|
overlay.clear
|
|
base = Color.new(248, 248, 248)
|
|
shadow = Color.new(72, 72, 72)
|
|
|
|
if isDarkMode
|
|
base, shadow = shadow, base
|
|
end
|
|
|
|
# Write various bits of text
|
|
textpos = [
|
|
[_INTL("Search Mode"), Graphics.width / 2, -2, 2, base, shadow],
|
|
[_INTL("OK"), 80, 338, 2, base, shadow, 1],
|
|
[_INTL("Cancel"), Graphics.width - 80, 338, 2, base, shadow, 1]
|
|
]
|
|
title = [_INTL("Order"), _INTL("Name"), _INTL("Type"), _INTL("Height"),
|
|
_INTL("Weight"), _INTL("Color"), _INTL("Shape")][mode]
|
|
textpos.push([title, 102, (mode == 6) ? 58 : 52, 0, base, shadow])
|
|
case mode
|
|
when 0 # Order
|
|
xstart = 46; ystart = 128
|
|
xgap = 236; ygap = 64
|
|
halfwidth = 92; cols = 2
|
|
selbuttony = 0; selbuttonheight = 44
|
|
when 1 # Name
|
|
xstart = 78; ystart = 114
|
|
xgap = 52; ygap = 52
|
|
halfwidth = 22; cols = 7
|
|
selbuttony = 156; selbuttonheight = 44
|
|
when 2 # Type
|
|
xstart = 8; ystart = 104
|
|
xgap = 124; ygap = 44
|
|
halfwidth = 62; cols = 4
|
|
selbuttony = 44; selbuttonheight = 44
|
|
when 3, 4 # Height, weight
|
|
xstart = 44; ystart = 110
|
|
xgap = 304 / (cmds.length + 1); ygap = 112
|
|
halfwidth = 60; cols = cmds.length + 1
|
|
when 5 # Color
|
|
xstart = 62; ystart = 114
|
|
xgap = 132; ygap = 52
|
|
halfwidth = 62; cols = 3
|
|
selbuttony = 44; selbuttonheight = 44
|
|
when 6 # Shape
|
|
xstart = 82; ystart = 116
|
|
xgap = 70; ygap = 70
|
|
halfwidth = 0; cols = 5
|
|
selbuttony = 88; selbuttonheight = 68
|
|
end
|
|
# Draw selected option(s) text in top bar
|
|
case mode
|
|
when 2 # Type icons
|
|
for i in 0...2
|
|
if !sel[i] || sel[i] < 0
|
|
textpos.push(["----", 298 + 128 * i, 58, 2, base, shadow, 1])
|
|
else
|
|
type_number = @typeCommands[sel[i]].id_number
|
|
typerect = Rect.new(0, type_number * 32, 96, 32)
|
|
overlay.blt(250 + 128 * i, 58, @typebitmap.bitmap, typerect)
|
|
end
|
|
end
|
|
when 3 # Height range
|
|
ht1 = (sel[0] < 0) ? 0 : (sel[0] >= @heightCommands.length) ? 999 : @heightCommands[sel[0]]
|
|
ht2 = (sel[1] < 0) ? 999 : (sel[1] >= @heightCommands.length) ? 0 : @heightCommands[sel[1]]
|
|
hwoffset = false
|
|
if System.user_language[3..4] == "US" # If the user is in the United States
|
|
ht1 = (sel[0] >= @heightCommands.length) ? 99 * 12 : (ht1 / 0.254).round
|
|
ht2 = (sel[1] < 0) ? 99 * 12 : (ht2 / 0.254).round
|
|
txt1 = sprintf("%d'%02d''", ht1 / 12, ht1 % 12)
|
|
txt2 = sprintf("%d'%02d''", ht2 / 12, ht2 % 12)
|
|
hwoffset = true
|
|
else
|
|
txt1 = sprintf("%.1f", ht1 / 10.0)
|
|
txt2 = sprintf("%.1f", ht2 / 10.0)
|
|
end
|
|
textpos.push([txt1, 286, 58, 2, base, shadow, 1])
|
|
textpos.push([txt2, 414, 58, 2, base, shadow, 1])
|
|
overlay.blt(462, 52, @hwbitmap.bitmap, Rect.new(0, (hwoffset) ? 44 : 0, 32, 44))
|
|
when 4 # Weight range
|
|
wt1 = (sel[0] < 0) ? 0 : (sel[0] >= @weightCommands.length) ? 9999 : @weightCommands[sel[0]]
|
|
wt2 = (sel[1] < 0) ? 9999 : (sel[1] >= @weightCommands.length) ? 0 : @weightCommands[sel[1]]
|
|
hwoffset = false
|
|
if System.user_language[3..4] == "US" # If the user is in the United States
|
|
wt1 = (sel[0] >= @weightCommands.length) ? 99990 : (wt1 / 0.254).round
|
|
wt2 = (sel[1] < 0) ? 99990 : (wt2 / 0.254).round
|
|
txt1 = sprintf("%.1f", wt1 / 10.0)
|
|
txt2 = sprintf("%.1f", wt2 / 10.0)
|
|
hwoffset = true
|
|
else
|
|
txt1 = sprintf("%.1f", wt1 / 10.0)
|
|
txt2 = sprintf("%.1f", wt2 / 10.0)
|
|
end
|
|
textpos.push([txt1, 286, 58, 2, base, shadow, 1])
|
|
textpos.push([txt2, 414, 58, 2, base, shadow, 1])
|
|
overlay.blt(462, 52, @hwbitmap.bitmap, Rect.new(32, (hwoffset) ? 44 : 0, 32, 44))
|
|
when 5 # Color
|
|
if sel[0] < 0
|
|
textpos.push(["----", 362, 58, 2, base, shadow, 1])
|
|
else
|
|
textpos.push([cmds[sel[0]].name, 362, 58, 2, base, shadow, 1])
|
|
end
|
|
when 6 # Shape icon
|
|
if sel[0] >= 0
|
|
shaperect = Rect.new(0, (@shapeCommands[sel[0]].id_number - 1) * 60, 60, 60)
|
|
overlay.blt(332, 50, @shapebitmap.bitmap, shaperect)
|
|
end
|
|
else
|
|
if sel[0] < 0
|
|
text = ["----", "-", "----", "", "", "----", ""][mode]
|
|
textpos.push([text, 362, 58, 2, base, shadow, 1])
|
|
else
|
|
textpos.push([cmds[sel[0]], 362, 58, 2, base, shadow, 1])
|
|
end
|
|
end
|
|
# Draw selected option(s) button graphic
|
|
if mode == 3 || mode == 4 # Height, weight
|
|
xpos1 = xstart + (sel[0] + 1) * xgap
|
|
xpos1 = xstart if sel[0] < -1
|
|
xpos2 = xstart + (sel[1] + 1) * xgap
|
|
xpos2 = xstart + cols * xgap if sel[1] < 0
|
|
xpos2 = xstart if sel[1] >= cols - 1
|
|
ypos1 = ystart + 172
|
|
ypos2 = ystart + 28
|
|
overlay.blt(16, 120, @searchsliderbitmap.bitmap, Rect.new(0, 192, 32, 44)) if sel[1] < cols - 1
|
|
overlay.blt(464, 120, @searchsliderbitmap.bitmap, Rect.new(32, 192, 32, 44)) if sel[1] >= 0
|
|
overlay.blt(16, 264, @searchsliderbitmap.bitmap, Rect.new(0, 192, 32, 44)) if sel[0] >= 0
|
|
overlay.blt(464, 264, @searchsliderbitmap.bitmap, Rect.new(32, 192, 32, 44)) if sel[0] < cols - 1
|
|
hwrect = Rect.new(0, 0, 120, 96)
|
|
overlay.blt(xpos2, ystart, @searchsliderbitmap.bitmap, hwrect)
|
|
hwrect.y = 96
|
|
overlay.blt(xpos1, ystart + ygap, @searchsliderbitmap.bitmap, hwrect)
|
|
textpos.push([txt1, xpos1 + halfwidth, ypos1, 2, base, nil, 1])
|
|
textpos.push([txt2, xpos2 + halfwidth, ypos2, 2, base, nil, 1])
|
|
else
|
|
for i in 0...sel.length
|
|
if sel[i] >= 0
|
|
selrect = Rect.new(0, selbuttony, @selbitmap.bitmap.width, selbuttonheight)
|
|
overlay.blt(xstart + (sel[i] % cols) * xgap, ystart + (sel[i] / cols).floor * ygap, @selbitmap.bitmap, selrect)
|
|
else
|
|
selrect = Rect.new(0, selbuttony, @selbitmap.bitmap.width, selbuttonheight)
|
|
overlay.blt(xstart + (cols - 1) * xgap, ystart + (cmds.length / cols).floor * ygap, @selbitmap.bitmap, selrect)
|
|
end
|
|
end
|
|
end
|
|
# Draw options
|
|
case mode
|
|
when 0, 1 # Order, name
|
|
for i in 0...cmds.length
|
|
x = xstart + halfwidth + (i % cols) * xgap
|
|
y = ystart + 6 + (i / cols).floor * ygap
|
|
textpos.push([cmds[i], x, y, 2, base, shadow, 1])
|
|
end
|
|
if mode != 0
|
|
textpos.push([(mode == 1) ? "-" : "----",
|
|
xstart + halfwidth + (cols - 1) * xgap, ystart + 6 + (cmds.length / cols).floor * ygap, 2, base, shadow, 1])
|
|
end
|
|
when 2 # Type
|
|
typerect = Rect.new(0, 0, 96, 32)
|
|
for i in 0...cmds.length
|
|
typerect.y = @typeCommands[i].id_number * 32
|
|
overlay.blt(xstart + 14 + (i % cols) * xgap, ystart + 6 + (i / cols).floor * ygap, @typebitmap.bitmap, typerect)
|
|
end
|
|
textpos.push(["----",
|
|
xstart + halfwidth + (cols - 1) * xgap, ystart + 6 + (cmds.length / cols).floor * ygap, 2, base, shadow, 1])
|
|
when 5 # Color
|
|
for i in 0...cmds.length
|
|
x = xstart + halfwidth + (i % cols) * xgap
|
|
y = ystart + 6 + (i / cols).floor * ygap
|
|
textpos.push([cmds[i].name, x, y, 2, base, shadow, 1])
|
|
end
|
|
textpos.push(["----",
|
|
xstart + halfwidth + (cols - 1) * xgap, ystart + 6 + (cmds.length / cols).floor * ygap, 2, base, shadow, 1])
|
|
when 6 # Shape
|
|
shaperect = Rect.new(0, 0, 60, 60)
|
|
for i in 0...cmds.length
|
|
shaperect.y = (@shapeCommands[i].id_number - 1) * 60
|
|
overlay.blt(xstart + 4 + (i % cols) * xgap, ystart + 4 + (i / cols).floor * ygap, @shapebitmap.bitmap, shaperect)
|
|
end
|
|
end
|
|
# Draw all text
|
|
pbDrawTextPositions(overlay, textpos)
|
|
end
|
|
|
|
|
|
def pbSearchDexList(params)
|
|
$PokemonGlobal.pokedexMode = params[0]
|
|
dexlist = pbGetDexList
|
|
# Filter by name
|
|
if params[1] >= 0
|
|
scanNameCommand = @nameCommands[params[1]].scan(/./)
|
|
dexlist = dexlist.find_all { |item|
|
|
next false if !$Trainer.seen?(item[0])
|
|
firstChar = item[1][0, 1]
|
|
next scanNameCommand.any? { |v| v == firstChar }
|
|
}
|
|
end
|
|
# Filter by type
|
|
if params[2] >= 0 || params[3] >= 0
|
|
stype1 = (params[2] >= 0) ? @typeCommands[params[2]].id : nil
|
|
stype2 = (params[3] >= 0) ? @typeCommands[params[3]].id : nil
|
|
dexlist = dexlist.find_all { |item|
|
|
next false if !$Trainer.owned?(item[0])
|
|
type1 = item[6]
|
|
type2 = item[7]
|
|
if stype1 && stype2
|
|
# Find species that match both types
|
|
next (type1 == stype1 && type2 == stype2) || (type1 == stype2 && type2 == stype1)
|
|
elsif stype1
|
|
# Find species that match first type entered
|
|
next type1 == stype1 || type2 == stype1
|
|
elsif stype2
|
|
# Find species that match second type entered
|
|
next type1 == stype2 || type2 == stype2
|
|
else
|
|
next false
|
|
end
|
|
}
|
|
end
|
|
# Filter by height range
|
|
if params[4] >= 0 || params[5] >= 0
|
|
minh = (params[4] < 0) ? 0 : (params[4] >= @heightCommands.length) ? 999 : @heightCommands[params[4]]
|
|
maxh = (params[5] < 0) ? 999 : (params[5] >= @heightCommands.length) ? 0 : @heightCommands[params[5]]
|
|
dexlist = dexlist.find_all { |item|
|
|
next false if !$Trainer.owned?(item[0])
|
|
height = item[2]
|
|
next height >= minh && height <= maxh
|
|
}
|
|
end
|
|
# Filter by weight range
|
|
if params[6] >= 0 || params[7] >= 0
|
|
minw = (params[6] < 0) ? 0 : (params[6] >= @weightCommands.length) ? 9999 : @weightCommands[params[6]]
|
|
maxw = (params[7] < 0) ? 9999 : (params[7] >= @weightCommands.length) ? 0 : @weightCommands[params[7]]
|
|
dexlist = dexlist.find_all { |item|
|
|
next false if !$Trainer.owned?(item[0])
|
|
weight = item[3]
|
|
next weight >= minw && weight <= maxw
|
|
}
|
|
end
|
|
# Filter by color
|
|
if params[8] >= 0
|
|
scolor = @colorCommands[params[8]].id
|
|
dexlist = dexlist.find_all { |item|
|
|
next false if !$Trainer.seen?(item[0])
|
|
next item[8] == scolor
|
|
}
|
|
end
|
|
# Filter by shape
|
|
if params[9] >= 0
|
|
sshape = @shapeCommands[params[9]].id
|
|
dexlist = dexlist.find_all { |item|
|
|
next false if !$Trainer.seen?(item[0])
|
|
next item[9] == sshape
|
|
}
|
|
end
|
|
# Remove all unseen species from the results
|
|
dexlist = dexlist.find_all { |item| next $Trainer.seen?(item[0]) }
|
|
case $PokemonGlobal.pokedexMode
|
|
when MODENUMERICAL then dexlist.sort! { |a, b| a[4] <=> b[4] }
|
|
when MODEATOZ then dexlist.sort! { |a, b| a[1] <=> b[1] }
|
|
when MODEHEAVIEST then dexlist.sort! { |a, b| b[3] <=> a[3] }
|
|
when MODELIGHTEST then dexlist.sort! { |a, b| a[3] <=> b[3] }
|
|
when MODETALLEST then dexlist.sort! { |a, b| b[2] <=> a[2] }
|
|
when MODESMALLEST then dexlist.sort! { |a, b| a[2] <=> b[2] }
|
|
end
|
|
return dexlist
|
|
end
|
|
|
|
def pbCloseSearch
|
|
oldsprites = pbFadeOutAndHide(@sprites)
|
|
oldspecies = @sprites["pokedex"].species
|
|
@searchResults = false
|
|
$PokemonGlobal.pokedexMode = MODENUMERICAL
|
|
@searchParams = [$PokemonGlobal.pokedexMode, -1, -1, -1, -1, -1, -1, -1, -1, -1]
|
|
pbRefreshDexList($PokemonGlobal.pokedexIndex[pbGetSavePositionIndex])
|
|
for i in 0...@dexlist.length
|
|
next if @dexlist[i][0] != oldspecies
|
|
@sprites["pokedex"].index = i
|
|
pbRefresh
|
|
break
|
|
end
|
|
$PokemonGlobal.pokedexIndex[pbGetSavePositionIndex] = @sprites["pokedex"].index
|
|
pbFadeInAndShow(@sprites, oldsprites)
|
|
end
|
|
|
|
def pbDexSearchCommands(mode, selitems, mainindex)
|
|
cmds = [@orderCommands, @nameCommands, @typeCommands, @heightCommands,
|
|
@weightCommands, @colorCommands, @shapeCommands][mode]
|
|
cols = [2, 7, 4, 1, 1, 3, 5][mode]
|
|
ret = nil
|
|
# Set background
|
|
case mode
|
|
when 0 then @sprites["searchbg"].setBitmap("Graphics/Pictures/Pokedex/bg_search_order")
|
|
when 1 then @sprites["searchbg"].setBitmap("Graphics/Pictures/Pokedex/bg_search_name")
|
|
when 2
|
|
count = 0
|
|
GameData::Type.each { |t| count += 1 if !t.pseudo_type && t.id != :SHADOW }
|
|
if count == 18
|
|
@sprites["searchbg"].setBitmap("Graphics/Pictures/Pokedex/bg_search_type_18")
|
|
else
|
|
@sprites["searchbg"].setBitmap("Graphics/Pictures/Pokedex/bg_search_type")
|
|
end
|
|
when 3, 4 then @sprites["searchbg"].setBitmap("Graphics/Pictures/Pokedex/bg_search_size")
|
|
when 5 then @sprites["searchbg"].setBitmap("Graphics/Pictures/Pokedex/bg_search_color")
|
|
when 6 then @sprites["searchbg"].setBitmap("Graphics/Pictures/Pokedex/bg_search_shape")
|
|
end
|
|
selindex = selitems.clone
|
|
index = selindex[0]
|
|
oldindex = index
|
|
minmax = 1
|
|
oldminmax = minmax
|
|
if mode == 3 || mode == 4
|
|
index = oldindex = selindex[minmax]
|
|
end
|
|
@sprites["searchcursor"].mode = mode
|
|
@sprites["searchcursor"].cmds = cmds.length
|
|
@sprites["searchcursor"].minmax = minmax
|
|
@sprites["searchcursor"].index = index
|
|
nextparam = cmds.length % 2
|
|
pbRefreshDexSearchParam(mode, cmds, selindex, index)
|
|
loop do
|
|
pbUpdate
|
|
if index != oldindex || minmax != oldminmax
|
|
@sprites["searchcursor"].minmax = minmax
|
|
@sprites["searchcursor"].index = index
|
|
oldindex = index
|
|
oldminmax = minmax
|
|
end
|
|
Graphics.update
|
|
Input.update
|
|
if mode == 3 || mode == 4
|
|
if Input.trigger?(Input::UP)
|
|
if index < -1;
|
|
minmax = 0; index = selindex[minmax] # From OK/Cancel
|
|
elsif minmax == 0;
|
|
minmax = 1; index = selindex[minmax]
|
|
end
|
|
if index != oldindex || minmax != oldminmax
|
|
pbPlayCursorSE
|
|
pbRefreshDexSearchParam(mode, cmds, selindex, index)
|
|
end
|
|
elsif Input.trigger?(Input::DOWN)
|
|
if minmax == 1;
|
|
minmax = 0; index = selindex[minmax]
|
|
elsif minmax == 0;
|
|
minmax = -1; index = -2
|
|
end
|
|
if index != oldindex || minmax != oldminmax
|
|
pbPlayCursorSE
|
|
pbRefreshDexSearchParam(mode, cmds, selindex, index)
|
|
end
|
|
elsif Input.repeat?(Input::LEFT)
|
|
if index == -3;
|
|
index = -2
|
|
elsif index >= -1
|
|
if minmax == 1 && index == -1
|
|
index = cmds.length - 1 if selindex[0] < cmds.length - 1
|
|
elsif minmax == 1 && index == 0
|
|
index = cmds.length if selindex[0] < 0
|
|
elsif index > -1 && !(minmax == 1 && index >= cmds.length)
|
|
index -= 1 if minmax == 0 || selindex[0] <= index - 1
|
|
end
|
|
end
|
|
if index != oldindex
|
|
selindex[minmax] = index if minmax >= 0
|
|
pbPlayCursorSE
|
|
pbRefreshDexSearchParam(mode, cmds, selindex, index)
|
|
end
|
|
elsif Input.repeat?(Input::RIGHT)
|
|
if index == -2;
|
|
index = -3
|
|
elsif index >= -1
|
|
if minmax == 1 && index >= cmds.length;
|
|
index = 0
|
|
elsif minmax == 1 && index == cmds.length - 1;
|
|
index = -1
|
|
elsif index < cmds.length && !(minmax == 1 && index < 0)
|
|
index += 1 if minmax == 1 || selindex[1] == -1 ||
|
|
(selindex[1] < cmds.length && selindex[1] >= index + 1)
|
|
end
|
|
end
|
|
if index != oldindex
|
|
selindex[minmax] = index if minmax >= 0
|
|
pbPlayCursorSE
|
|
pbRefreshDexSearchParam(mode, cmds, selindex, index)
|
|
end
|
|
end
|
|
else
|
|
if Input.trigger?(Input::UP)
|
|
if index == -1;
|
|
index = cmds.length - 1 - (cmds.length - 1) % cols - 1 # From blank
|
|
elsif index == -2;
|
|
index = ((cmds.length - 1) / cols).floor * cols # From OK
|
|
elsif index == -3 && mode == 0;
|
|
index = cmds.length - 1 # From Cancel
|
|
elsif index == -3;
|
|
index = -1 # From Cancel
|
|
elsif index >= cols;
|
|
index -= cols
|
|
end
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::DOWN)
|
|
if index == -1;
|
|
index = -3 # From blank
|
|
elsif index >= 0
|
|
if index + cols < cmds.length;
|
|
index += cols
|
|
elsif (index / cols).floor < ((cmds.length - 1) / cols).floor
|
|
index = (index % cols < cols / 2.0) ? cmds.length - 1 : -1
|
|
else
|
|
index = (index % cols < cols / 2.0) ? -2 : -3
|
|
end
|
|
end
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::LEFT)
|
|
if index == -3;
|
|
index = -2
|
|
elsif index == -1;
|
|
index = cmds.length - 1
|
|
elsif index > 0 && index % cols != 0;
|
|
index -= 1
|
|
end
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::RIGHT)
|
|
if index == -2;
|
|
index = -3
|
|
elsif index == cmds.length - 1 && mode != 0;
|
|
index = -1
|
|
elsif index >= 0 && index % cols != cols - 1;
|
|
index += 1
|
|
end
|
|
pbPlayCursorSE if index != oldindex
|
|
end
|
|
end
|
|
if Input.trigger?(Input::ACTION)
|
|
index = -2
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::BACK)
|
|
pbPlayCloseMenuSE
|
|
ret = nil
|
|
break
|
|
elsif Input.trigger?(Input::USE)
|
|
if index == -2 # OK
|
|
pbPlayDecisionSE
|
|
ret = selindex
|
|
break
|
|
elsif index == -3 # Cancel
|
|
pbPlayCloseMenuSE
|
|
ret = nil
|
|
break
|
|
elsif selindex != index && mode != 3 && mode != 4
|
|
if mode == 2
|
|
if index == -1
|
|
nextparam = (selindex[1] >= 0) ? 1 : 0
|
|
elsif index >= 0
|
|
nextparam = (selindex[0] < 0) ? 0 : (selindex[1] < 0) ? 1 : nextparam
|
|
end
|
|
if index < 0 || selindex[(nextparam + 1) % 2] != index
|
|
pbPlayDecisionSE
|
|
selindex[nextparam] = index
|
|
nextparam = (nextparam + 1) % 2
|
|
end
|
|
else
|
|
pbPlayDecisionSE
|
|
selindex[0] = index
|
|
end
|
|
pbRefreshDexSearchParam(mode, cmds, selindex, index)
|
|
end
|
|
end
|
|
end
|
|
Input.update
|
|
# Set background image
|
|
@sprites["searchbg"].setBitmap("Graphics/Pictures/Pokedex/bg_search")
|
|
@sprites["searchcursor"].mode = -1
|
|
@sprites["searchcursor"].index = mainindex
|
|
return ret
|
|
end
|
|
|
|
def pbDexSearch
|
|
oldsprites = pbFadeOutAndHide(@sprites)
|
|
params = @searchParams.clone
|
|
@orderCommands = []
|
|
@orderCommands[MODENUMERICAL] = _INTL("Numerical")
|
|
@orderCommands[MODEATOZ] = _INTL("A to Z")
|
|
@orderCommands[MODEHEAVIEST] = _INTL("Heaviest")
|
|
@orderCommands[MODELIGHTEST] = _INTL("Lightest")
|
|
@orderCommands[MODETALLEST] = _INTL("Tallest")
|
|
@orderCommands[MODESMALLEST] = _INTL("Smallest")
|
|
@nameCommands = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
|
|
@typeCommands = []
|
|
|
|
count = 0
|
|
GameData::Type.each do |t|
|
|
@typeCommands.push(t) if !t.pseudo_type && count <= 18
|
|
count += 1
|
|
end
|
|
@typeCommands.sort! { |a, b| a.id_number <=> b.id_number }
|
|
@heightCommands = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
|
|
21, 22, 23, 24, 25, 30, 35, 40, 45, 50,
|
|
55, 60, 65, 70, 80, 90, 100]
|
|
@weightCommands = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50,
|
|
55, 60, 70, 80, 90, 100, 110, 120, 140, 160,
|
|
180, 200, 250, 300, 350, 400, 500, 600, 700, 800,
|
|
900, 1000, 1250, 1500, 2000, 3000, 5000]
|
|
@colorCommands = []
|
|
GameData::BodyColor.each { |c| @colorCommands.push(c) }
|
|
@shapeCommands = []
|
|
GameData::BodyShape.each { |c| @shapeCommands.push(c) if c.id != :None }
|
|
@sprites["searchbg"].visible = true
|
|
@sprites["overlay"].visible = true
|
|
@sprites["searchcursor"].visible = true
|
|
index = 0
|
|
oldindex = index
|
|
@sprites["searchcursor"].mode = -1
|
|
@sprites["searchcursor"].index = index
|
|
pbRefreshDexSearch(params, index)
|
|
pbFadeInAndShow(@sprites)
|
|
loop do
|
|
Graphics.update
|
|
Input.update
|
|
pbUpdate
|
|
if index != oldindex
|
|
@sprites["searchcursor"].index = index
|
|
oldindex = index
|
|
end
|
|
if Input.trigger?(Input::UP)
|
|
if index >= 7;
|
|
index = 4
|
|
elsif index == 5;
|
|
index = 0
|
|
elsif index > 0;
|
|
index -= 1
|
|
end
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::DOWN)
|
|
if index == 4 || index == 6;
|
|
index = 8
|
|
elsif index < 7;
|
|
index += 1
|
|
end
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::LEFT)
|
|
if index == 5;
|
|
index = 1
|
|
elsif index == 6;
|
|
index = 3
|
|
elsif index > 7;
|
|
index -= 1
|
|
end
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::RIGHT)
|
|
if index == 1;
|
|
index = 5
|
|
elsif index >= 2 && index <= 4;
|
|
index = 6
|
|
elsif index == 7 || index == 8;
|
|
index += 1
|
|
end
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::ACTION)
|
|
index = 8
|
|
pbPlayCursorSE if index != oldindex
|
|
elsif Input.trigger?(Input::BACK)
|
|
pbPlayCloseMenuSE
|
|
break
|
|
elsif Input.trigger?(Input::USE)
|
|
pbPlayDecisionSE if index != 9
|
|
case index
|
|
when 0 # Choose sort order
|
|
newparam = pbDexSearchCommands(0, [params[0]], index)
|
|
params[0] = newparam[0] if newparam != nil
|
|
pbRefreshDexSearch(params, index)
|
|
when 1 # Filter by name
|
|
newparam = pbDexSearchCommands(1, [params[1]], index)
|
|
params[1] = newparam[0] if newparam != nil
|
|
pbRefreshDexSearch(params, index)
|
|
when 2 # Filter by type
|
|
newparam = pbDexSearchCommands(2, [params[2], params[3]], index)
|
|
if newparam != nil
|
|
params[2] = newparam[0]
|
|
params[3] = newparam[1]
|
|
end
|
|
pbRefreshDexSearch(params, index)
|
|
when 3 # Filter by height range
|
|
newparam = pbDexSearchCommands(3, [params[4], params[5]], index)
|
|
if newparam != nil
|
|
params[4] = newparam[0]
|
|
params[5] = newparam[1]
|
|
end
|
|
pbRefreshDexSearch(params, index)
|
|
when 4 # Filter by weight range
|
|
newparam = pbDexSearchCommands(4, [params[6], params[7]], index)
|
|
if newparam != nil
|
|
params[6] = newparam[0]
|
|
params[7] = newparam[1]
|
|
end
|
|
pbRefreshDexSearch(params, index)
|
|
when 5 # Filter by color filter
|
|
newparam = pbDexSearchCommands(5, [params[8]], index)
|
|
params[8] = newparam[0] if newparam != nil
|
|
pbRefreshDexSearch(params, index)
|
|
when 6 # Filter by form
|
|
newparam = pbDexSearchCommands(6, [params[9]], index)
|
|
params[9] = newparam[0] if newparam != nil
|
|
pbRefreshDexSearch(params, index)
|
|
when 7 # Clear filters
|
|
for i in 0...10
|
|
params[i] = (i == 0) ? MODENUMERICAL : -1
|
|
end
|
|
pbRefreshDexSearch(params, index)
|
|
when 8 # Start search (filter)
|
|
dexlist = pbSearchDexList(params)
|
|
if dexlist.length == 0
|
|
pbMessage(_INTL("No matching Pokémon were found."))
|
|
else
|
|
@dexlist = dexlist
|
|
@sprites["pokedex"].commands = @dexlist
|
|
@sprites["pokedex"].index = 0
|
|
@sprites["pokedex"].refresh
|
|
@searchResults = true
|
|
@searchParams = params
|
|
break
|
|
end
|
|
when 9 # Cancel
|
|
pbPlayCloseMenuSE
|
|
break
|
|
end
|
|
end
|
|
end
|
|
pbFadeOutAndHide(@sprites)
|
|
if @searchResults
|
|
@sprites["background"].setBitmap("Graphics/Pictures/Pokedex/bg_listsearch")
|
|
else
|
|
@sprites["background"].setBitmap("Graphics/Pictures/Pokedex/bg_list")
|
|
end
|
|
pbRefresh
|
|
pbFadeInAndShow(@sprites, oldsprites)
|
|
Input.update
|
|
return 0
|
|
end
|
|
|
|
def pokedexQuickSearch
|
|
|
|
if $PokemonSystem.textinput == 1 # keyboard
|
|
scene = PokedexTextEntry.new
|
|
else
|
|
# cursor
|
|
scene = PokemonEntryScene2.new
|
|
end
|
|
scene.pbStartScene(
|
|
_INTL("Search Pokémon by name."),
|
|
1, # min length
|
|
12, # max length
|
|
""
|
|
)
|
|
query = scene.pbEntry
|
|
scene.pbEndScene
|
|
|
|
if query && !query.empty?
|
|
pbApplyTextNameSearch(query)
|
|
end
|
|
end
|
|
|
|
def pbApplyTextNameSearch(query)
|
|
query = query.downcase
|
|
dexlist = pbGetDexList(@filter_owned)
|
|
|
|
dexlist = dexlist.find_all do |item|
|
|
next false if !$Trainer.seen?(item[0])
|
|
item[1].downcase.include?(query)
|
|
end
|
|
|
|
@searchResults = true
|
|
@dexlist = dexlist
|
|
@sprites["pokedex"].commands = @dexlist
|
|
@sprites["pokedex"].index = 0
|
|
@sprites["pokedex"].refresh
|
|
pbRefresh
|
|
end
|
|
end
|