mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-10 06:34:59 +00:00
Added support for large events, allowed field move-related event names to have other text in their names
This commit is contained in:
Maruno17
@@ -325,14 +325,17 @@ Events.onStepTakenFieldMovement += proc { |_sender,e|
|
||||
Events.onStepTakenFieldMovement += proc { |_sender, e|
|
||||
event = e[0] # Get the event affected by field movement
|
||||
if $scene.is_a?(Scene_Map)
|
||||
if pbGetTerrainTag(event, true).shows_grass_rustle # Won't show if under bridge
|
||||
$scene.spriteset.addUserAnimation(Settings::GRASS_ANIMATION_ID, event.x, event.y, true, 1)
|
||||
elsif event == $game_player
|
||||
currentTag = pbGetTerrainTag(event)
|
||||
event.each_occupied_tile do |x, y|
|
||||
if $MapFactory.getTerrainTag(event.map.map_id, x, y, true).shows_grass_rustle
|
||||
$scene.spriteset.addUserAnimation(Settings::GRASS_ANIMATION_ID, x, y, true, 1)
|
||||
end
|
||||
end
|
||||
if event == $game_player
|
||||
currentTag = $game_player.pbTerrainTag
|
||||
if currentTag.waterfall_crest
|
||||
pbDescendWaterfall(event)
|
||||
pbDescendWaterfall
|
||||
elsif currentTag.ice && !$PokemonGlobal.sliding
|
||||
pbSlideOnIce(event)
|
||||
pbSlideOnIce
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -483,129 +486,84 @@ Events.onMapSceneChange += proc { |_sender, e|
|
||||
#===============================================================================
|
||||
# Event locations, terrain tags
|
||||
#===============================================================================
|
||||
def pbEventFacesPlayer?(event,player,distance)
|
||||
return false if distance<=0
|
||||
# Event can't reach player if no coordinates coincide
|
||||
return false if event.x!=player.x && event.y!=player.y
|
||||
deltaX = (event.direction==6) ? 1 : (event.direction==4) ? -1 : 0
|
||||
deltaY = (event.direction==2) ? 1 : (event.direction==8) ? -1 : 0
|
||||
# Check for existence of player
|
||||
curx = event.x
|
||||
cury = event.y
|
||||
found = false
|
||||
distance.times do
|
||||
curx += deltaX
|
||||
cury += deltaY
|
||||
if player.x==curx && player.y==cury
|
||||
found = true
|
||||
break
|
||||
end
|
||||
end
|
||||
return found
|
||||
end
|
||||
|
||||
def pbEventCanReachPlayer?(event,player,distance)
|
||||
return false if distance<=0
|
||||
# Event can't reach player if no coordinates coincide
|
||||
return false if event.x!=player.x && event.y!=player.y
|
||||
deltaX = (event.direction==6) ? 1 : (event.direction==4) ? -1 : 0
|
||||
deltaY = (event.direction==2) ? 1 : (event.direction==8) ? -1 : 0
|
||||
# Check for existence of player
|
||||
curx = event.x
|
||||
cury = event.y
|
||||
found = false
|
||||
realdist = 0
|
||||
distance.times do
|
||||
curx += deltaX
|
||||
cury += deltaY
|
||||
if player.x==curx && player.y==cury
|
||||
found = true
|
||||
break
|
||||
end
|
||||
realdist += 1
|
||||
end
|
||||
return false if !found
|
||||
# Check passibility
|
||||
curx = event.x
|
||||
cury = event.y
|
||||
realdist.times do
|
||||
return false if !event.passable?(curx,cury,event.direction)
|
||||
curx += deltaX
|
||||
cury += deltaY
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
def pbFacingTileRegular(direction=nil,event=nil)
|
||||
event = $game_player if !event
|
||||
return [0,0,0] if !event
|
||||
x = event.x
|
||||
y = event.y
|
||||
direction = event.direction if !direction
|
||||
case direction
|
||||
when 1
|
||||
y += 1
|
||||
x -= 1
|
||||
when 2
|
||||
y += 1
|
||||
when 3
|
||||
y += 1
|
||||
x += 1
|
||||
when 4
|
||||
x -= 1
|
||||
when 6
|
||||
x += 1
|
||||
when 7
|
||||
y -= 1
|
||||
x -= 1
|
||||
when 8
|
||||
y -= 1
|
||||
when 9
|
||||
y -= 1
|
||||
x += 1
|
||||
end
|
||||
return [$game_map.map_id,x,y]
|
||||
end
|
||||
|
||||
# NOTE: Assumes the event is 1x1 tile in size. Only returns one tile.
|
||||
def pbFacingTile(direction=nil,event=nil)
|
||||
return $MapFactory.getFacingTile(direction,event) if $MapFactory
|
||||
return pbFacingTileRegular(direction,event)
|
||||
end
|
||||
|
||||
def pbFacingEachOther(event1,event2)
|
||||
return false if !event1 || !event2
|
||||
if $MapFactory
|
||||
tile1 = $MapFactory.getFacingTile(nil,event1)
|
||||
tile2 = $MapFactory.getFacingTile(nil,event2)
|
||||
return false if !tile1 || !tile2
|
||||
return tile1[0]==event2.map.map_id &&
|
||||
tile1[1]==event2.x && tile1[2]==event2.y &&
|
||||
tile2[0]==event1.map.map_id &&
|
||||
tile2[1]==event1.x && tile2[2]==event1.y
|
||||
# NOTE: Assumes the event is 1x1 tile in size. Only returns one tile.
|
||||
def pbFacingTileRegular(direction = nil, event = nil)
|
||||
event = $game_player if !event
|
||||
return [0, 0, 0] if !event
|
||||
x = event.x
|
||||
y = event.y
|
||||
direction = event.direction if !direction
|
||||
x_offset = [0, -1, 0, 1, -1, 0, 1, -1, 0, 1][direction]
|
||||
y_offset = [0, 1, 1, 1, 0, 0, 0, -1, -1, -1][direction]
|
||||
return [$game_map.map_id, x + x_offset, y + y_offset]
|
||||
end
|
||||
|
||||
# Returns whether event is in line with the player, is facing the player and is
|
||||
# within distance tiles of the player.
|
||||
def pbEventFacesPlayer?(event, player, distance)
|
||||
return false if !event || !player || distance <= 0
|
||||
x_min = x_max = y_min = y_max = -1
|
||||
case direction
|
||||
when 2 # Down
|
||||
x_min = event.x
|
||||
x_max = event.x + event.width - 1
|
||||
y_min = event.y + 1
|
||||
y_max = event.y + distance
|
||||
when 4 # Left
|
||||
x_min = event.x - distance
|
||||
x_max = event.x - 1
|
||||
y_min = event.y - event.height + 1
|
||||
y_max = event.y
|
||||
when 6 # Right
|
||||
x_min = event.x + event.width
|
||||
x_max = event.x + event.width - 1 + distance
|
||||
y_min = event.y - event.height + 1
|
||||
y_max = event.y
|
||||
when 8 # Up
|
||||
x_min = event.x
|
||||
x_max = event.x + event.width - 1
|
||||
y_min = event.y - event.height + 1 - distance
|
||||
y_max = event.y - event.height
|
||||
else
|
||||
tile1 = pbFacingTile(nil,event1)
|
||||
tile2 = pbFacingTile(nil,event2)
|
||||
return false if !tile1 || !tile2
|
||||
return tile1[1]==event2.x && tile1[2]==event2.y &&
|
||||
tile2[1]==event1.x && tile2[2]==event1.y
|
||||
return false
|
||||
end
|
||||
return player.x >= x_min && player.x <= x_max &&
|
||||
player.y >= y_min && player.y <= y_max
|
||||
end
|
||||
|
||||
def pbGetTerrainTag(event=nil,countBridge=false)
|
||||
event = $game_player if !event
|
||||
return GameData::TerrainTag.get(:None) if !event
|
||||
if $MapFactory
|
||||
return $MapFactory.getTerrainTag(event.map.map_id,event.x,event.y,countBridge)
|
||||
# Returns whether event is able to walk up to the player.
|
||||
def pbEventCanReachPlayer?(event, player, distance)
|
||||
return false if !pbEventFacesPlayer?(event, player, distance)
|
||||
delta_x = (event.direction == 6) ? 1 : (event.direction == 4) ? -1 : 0
|
||||
delta_y = (event.direction == 2) ? 1 : (event.direction == 8) ? -1 : 0
|
||||
case event.direction
|
||||
when 2 # Down
|
||||
real_distance = player.y - event.y - 1
|
||||
when 4 # Left
|
||||
real_distance = event.x - player.x + 1
|
||||
when 6 # Right
|
||||
real_distance = player.x - event.x - event.width
|
||||
when 8 # Up
|
||||
real_distance = event.y - event.height - player.y
|
||||
end
|
||||
return $game_map.terrain_tag(event.x,event.y,countBridge)
|
||||
if real_distance > 0
|
||||
real_distance.times do |i|
|
||||
return false if !event.can_move_from_coordinate?(event.x + i * delta_x, event.y + i * delta_y, event.direction)
|
||||
end
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
def pbFacingTerrainTag(event=nil,dir=nil)
|
||||
return $MapFactory.getFacingTerrainTag(dir,event) if $MapFactory
|
||||
event = $game_player if !event
|
||||
return GameData::TerrainTag.get(:None) if !event
|
||||
facing = pbFacingTile(dir,event)
|
||||
return $game_map.terrain_tag(facing[1],facing[2])
|
||||
# Returns whether the two events are standing next to each other and facing each
|
||||
# other.
|
||||
def pbFacingEachOther(event1, event2)
|
||||
return pbEventFacesPlayer?(event1, event2, 1) && pbEventFacesPlayer?(event2, event1, 1)
|
||||
end
|
||||
|
||||
|
||||
@@ -754,7 +712,7 @@ end
|
||||
# Player/event movement in the field
|
||||
#===============================================================================
|
||||
def pbLedge(_xOffset,_yOffset)
|
||||
if pbFacingTerrainTag.ledge
|
||||
if $game_player.pbFacingTerrainTag.ledge
|
||||
if pbJumpToward(2,true)
|
||||
$scene.spriteset.addUserAnimation(Settings::DUST_ANIMATION_ID,$game_player.x,$game_player.y,true,1)
|
||||
$game_player.increase_steps
|
||||
@@ -765,33 +723,32 @@ def pbLedge(_xOffset,_yOffset)
|
||||
return false
|
||||
end
|
||||
|
||||
def pbSlideOnIce(event=nil)
|
||||
event = $game_player if !event
|
||||
return if !event
|
||||
return if !pbGetTerrainTag(event).ice
|
||||
def pbSlideOnIce
|
||||
return if !$game_player.pbTerrainTag.ice
|
||||
$PokemonGlobal.sliding = true
|
||||
direction = event.direction
|
||||
oldwalkanime = event.walk_anime
|
||||
event.straighten
|
||||
event.walk_anime = false
|
||||
direction = $game_player.direction
|
||||
oldwalkanime = $game_player.walk_anime
|
||||
$game_player.straighten
|
||||
$game_player.walk_anime = false
|
||||
loop do
|
||||
break if !event.passable?(event.x,event.y,direction)
|
||||
break if !pbGetTerrainTag(event).ice
|
||||
event.move_forward
|
||||
while event.moving?
|
||||
break if !$game_player.can_move_in_direction?(direction)
|
||||
break if !$game_player.pbTerrainTag.ice
|
||||
$game_player.move_forward
|
||||
while $game_player.moving?
|
||||
pbUpdateSceneMap
|
||||
Graphics.update
|
||||
Input.update
|
||||
end
|
||||
end
|
||||
event.center(event.x,event.y)
|
||||
event.straighten
|
||||
event.walk_anime = oldwalkanime
|
||||
$game_player.center($game_player.x, $game_player.y)
|
||||
$game_player.straighten
|
||||
$game_player.walk_anime = oldwalkanime
|
||||
$PokemonGlobal.sliding = false
|
||||
end
|
||||
|
||||
def pbTurnTowardEvent(event,otherEvent)
|
||||
sx = 0; sy = 0
|
||||
sx = 0
|
||||
sy = 0
|
||||
if $MapFactory
|
||||
relativePos = $MapFactory.getThisAndOtherEventRelativePos(otherEvent,event)
|
||||
sx = relativePos[0]
|
||||
@@ -800,6 +757,8 @@ def pbTurnTowardEvent(event,otherEvent)
|
||||
sx = event.x - otherEvent.x
|
||||
sy = event.y - otherEvent.y
|
||||
end
|
||||
sx += (event.width - otherEvent.width) / 2.0
|
||||
sy -= (event.height - otherEvent.height) / 2.0
|
||||
return if sx == 0 and sy == 0
|
||||
if sx.abs > sy.abs
|
||||
(sx > 0) ? event.turn_left : event.turn_right
|
||||
@@ -809,13 +768,13 @@ def pbTurnTowardEvent(event,otherEvent)
|
||||
end
|
||||
|
||||
def pbMoveTowardPlayer(event)
|
||||
maxsize = [$game_map.width,$game_map.height].max
|
||||
return if !pbEventCanReachPlayer?(event,$game_player,maxsize)
|
||||
maxsize = [$game_map.width, $game_map.height].max
|
||||
return if !pbEventCanReachPlayer?(event, $game_player, maxsize)
|
||||
loop do
|
||||
x = event.x
|
||||
y = event.y
|
||||
event.move_toward_player
|
||||
break if event.x==x && event.y==y
|
||||
break if event.x == x && event.y == y
|
||||
while event.moving?
|
||||
Graphics.update
|
||||
Input.update
|
||||
|
||||
@@ -170,7 +170,7 @@ def pbGetEnvironment
|
||||
map_metadata = GameData::MapMetadata.try_get($game_map.map_id)
|
||||
ret = map_metadata.battle_environment if map_metadata && map_metadata.battle_environment
|
||||
if GameData::EncounterType.get($PokemonTemp.encounterType).type == :fishing
|
||||
terrainTag = pbFacingTerrainTag
|
||||
terrainTag = $game_player.pbFacingTerrainTag
|
||||
else
|
||||
terrainTag = $game_player.terrain_tag
|
||||
end
|
||||
|
||||
@@ -203,7 +203,7 @@ class PokemonEncounters
|
||||
return false if pbInSafari?
|
||||
return true if $PokemonGlobal.partner
|
||||
return false if $Trainer.able_pokemon_count <= 1
|
||||
return true if pbGetTerrainTag.double_wild_encounters && rand(100) < 30
|
||||
return true if $game_player.pbTerrainTag.double_wild_encounters && rand(100) < 30
|
||||
return false
|
||||
end
|
||||
|
||||
|
||||
@@ -205,7 +205,7 @@ end
|
||||
HiddenMoveHandlers::CanUseMove.add(:CUT,proc { |move,pkmn,showmsg|
|
||||
next false if !pbCheckHiddenMoveBadge(Settings::BADGE_FOR_CUT,showmsg)
|
||||
facingEvent = $game_player.pbFacingEvent
|
||||
if !facingEvent || facingEvent.name.downcase!="tree"
|
||||
if !facingEvent || !facingEvent.name[/tree/i]
|
||||
pbMessage(_INTL("Can't use that here.")) if showmsg
|
||||
next false
|
||||
end
|
||||
@@ -225,8 +225,8 @@ HiddenMoveHandlers::UseMove.add(:CUT,proc { |move,pokemon|
|
||||
|
||||
def pbSmashEvent(event)
|
||||
return if !event
|
||||
if event.name.downcase=="tree"; pbSEPlay("Cut",80)
|
||||
elsif event.name.downcase=="rock"; pbSEPlay("Rock Smash",80)
|
||||
if event.name[/tree/i]; pbSEPlay("Cut",80)
|
||||
elsif event.name[/rock/i]; pbSEPlay("Rock Smash",80)
|
||||
end
|
||||
pbMoveRoute(event,[
|
||||
PBMoveRoute::Wait,2,
|
||||
@@ -294,6 +294,7 @@ HiddenMoveHandlers::UseMove.add(:DIG,proc { |move,pokemon|
|
||||
# Dive
|
||||
#===============================================================================
|
||||
def pbDive
|
||||
return false if $game_player.pbFacingEvent
|
||||
map_metadata = GameData::MapMetadata.try_get($game_map.map_id)
|
||||
return false if !map_metadata || !map_metadata.dive_map_id
|
||||
move = :DIVE
|
||||
@@ -325,6 +326,7 @@ end
|
||||
|
||||
def pbSurfacing
|
||||
return if !$PokemonGlobal.diving
|
||||
return false if $game_player.pbFacingEvent
|
||||
surface_map_id = nil
|
||||
GameData::MapMetadata.each do |map_data|
|
||||
next if !map_data.dive_map_id || map_data.dive_map_id != $game_map.map_id
|
||||
@@ -571,7 +573,7 @@ end
|
||||
|
||||
HiddenMoveHandlers::CanUseMove.add(:HEADBUTT,proc { |move,pkmn,showmsg|
|
||||
facingEvent = $game_player.pbFacingEvent
|
||||
if !facingEvent || facingEvent.name.downcase!="headbutttree"
|
||||
if !facingEvent || !facingEvent.name[/headbutttree/i]
|
||||
pbMessage(_INTL("Can't use that here.")) if showmsg
|
||||
next false
|
||||
end
|
||||
@@ -616,7 +618,7 @@ end
|
||||
HiddenMoveHandlers::CanUseMove.add(:ROCKSMASH,proc { |move,pkmn,showmsg|
|
||||
next false if !pbCheckHiddenMoveBadge(Settings::BADGE_FOR_ROCKSMASH,showmsg)
|
||||
facingEvent = $game_player.pbFacingEvent
|
||||
if !facingEvent || facingEvent.name.downcase!="rock"
|
||||
if !facingEvent || !facingEvent.name[/rock/i]
|
||||
pbMessage(_INTL("Can't use that here.")) if showmsg
|
||||
next false
|
||||
end
|
||||
@@ -665,7 +667,7 @@ end
|
||||
|
||||
Events.onAction += proc { |_sender,_e|
|
||||
facingEvent = $game_player.pbFacingEvent
|
||||
pbStrength if facingEvent && facingEvent.name.downcase=="boulder"
|
||||
pbStrength if facingEvent && facingEvent.name[/boulder/i]
|
||||
}
|
||||
|
||||
HiddenMoveHandlers::CanUseMove.add(:STRENGTH,proc { |move,pkmn,showmsg|
|
||||
@@ -727,7 +729,7 @@ def pbEndSurf(_xOffset,_yOffset)
|
||||
return false if !$PokemonGlobal.surfing
|
||||
x = $game_player.x
|
||||
y = $game_player.y
|
||||
if $game_map.terrain_tag(x,y).can_surf && !pbFacingTerrainTag.can_surf
|
||||
if $game_map.terrain_tag(x,y).can_surf && !$game_player.pbFacingTerrainTag.can_surf
|
||||
$PokemonTemp.surfJump = [x,y]
|
||||
if pbJumpToward(1,false,true)
|
||||
$game_map.autoplayAsCue
|
||||
@@ -757,7 +759,7 @@ Events.onAction += proc { |_sender,_e|
|
||||
next if $PokemonGlobal.surfing
|
||||
next if GameData::MapMetadata.exists?($game_map.map_id) &&
|
||||
GameData::MapMetadata.get($game_map.map_id).always_bicycle
|
||||
next if !pbFacingTerrainTag.can_surf_freely
|
||||
next if !$game_player.pbFacingTerrainTag.can_surf_freely
|
||||
next if !$game_map.passable?($game_player.x,$game_player.y,$game_player.direction,$game_player)
|
||||
pbSurf
|
||||
}
|
||||
@@ -777,7 +779,7 @@ HiddenMoveHandlers::CanUseMove.add(:SURF,proc { |move,pkmn,showmsg|
|
||||
pbMessage(_INTL("Let's enjoy cycling!")) if showmsg
|
||||
next false
|
||||
end
|
||||
if !pbFacingTerrainTag.can_surf_freely ||
|
||||
if !$game_player.pbFacingTerrainTag.can_surf_freely ||
|
||||
!$game_map.passable?($game_player.x,$game_player.y,$game_player.direction,$game_player)
|
||||
pbMessage(_INTL("No surfing here!")) if showmsg
|
||||
next false
|
||||
@@ -905,42 +907,38 @@ HiddenMoveHandlers::UseMove.add(:TELEPORT,proc { |move,pokemon|
|
||||
#===============================================================================
|
||||
# Waterfall
|
||||
#===============================================================================
|
||||
def pbAscendWaterfall(event=nil)
|
||||
event = $game_player if !event
|
||||
return if !event
|
||||
return if event.direction!=8 # can't ascend if not facing up
|
||||
oldthrough = event.through
|
||||
oldmovespeed = event.move_speed
|
||||
terrain = pbFacingTerrainTag
|
||||
def pbAscendWaterfall
|
||||
return if $game_player.direction != 8 # Can't ascend if not facing up
|
||||
terrain = $game_player.pbFacingTerrainTag
|
||||
return if !terrain.waterfall && !terrain.waterfall_crest
|
||||
event.through = true
|
||||
event.move_speed = 2
|
||||
oldthrough = $game_player.through
|
||||
oldmovespeed = $game_player.move_speed
|
||||
$game_player.through = true
|
||||
$game_player.move_speed = 2
|
||||
loop do
|
||||
event.move_up
|
||||
terrain = pbGetTerrainTag(event)
|
||||
$game_player.move_up
|
||||
terrain = $game_player.pbTerrainTag
|
||||
break if !terrain.waterfall && !terrain.waterfall_crest
|
||||
end
|
||||
event.through = oldthrough
|
||||
event.move_speed = oldmovespeed
|
||||
$game_player.through = oldthrough
|
||||
$game_player.move_speed = oldmovespeed
|
||||
end
|
||||
|
||||
def pbDescendWaterfall(event=nil)
|
||||
event = $game_player if !event
|
||||
return if !event
|
||||
return if event.direction!=2 # Can't descend if not facing down
|
||||
oldthrough = event.through
|
||||
oldmovespeed = event.move_speed
|
||||
terrain = pbFacingTerrainTag
|
||||
def pbDescendWaterfall
|
||||
return if $game_player.direction != 2 # Can't descend if not facing down
|
||||
terrain = $game_player.pbFacingTerrainTag
|
||||
return if !terrain.waterfall && !terrain.waterfall_crest
|
||||
event.through = true
|
||||
event.move_speed = 2
|
||||
oldthrough = $game_player.through
|
||||
oldmovespeed = $game_player.move_speed
|
||||
$game_player.through = true
|
||||
$game_player.move_speed = 2
|
||||
loop do
|
||||
event.move_down
|
||||
terrain = pbGetTerrainTag(event)
|
||||
$game_player.move_down
|
||||
terrain = $game_player.pbTerrainTag
|
||||
break if !terrain.waterfall && !terrain.waterfall_crest
|
||||
end
|
||||
event.through = oldthrough
|
||||
event.move_speed = oldmovespeed
|
||||
$game_player.through = oldthrough
|
||||
$game_player.move_speed = oldmovespeed
|
||||
end
|
||||
|
||||
def pbWaterfall
|
||||
@@ -961,7 +959,7 @@ def pbWaterfall
|
||||
end
|
||||
|
||||
Events.onAction += proc { |_sender,_e|
|
||||
terrain = pbFacingTerrainTag
|
||||
terrain = $game_player.pbFacingTerrainTag
|
||||
if terrain.waterfall
|
||||
pbWaterfall
|
||||
elsif terrain.waterfall_crest
|
||||
@@ -971,7 +969,7 @@ Events.onAction += proc { |_sender,_e|
|
||||
|
||||
HiddenMoveHandlers::CanUseMove.add(:WATERFALL,proc { |move,pkmn,showmsg|
|
||||
next false if !pbCheckHiddenMoveBadge(Settings::BADGE_FOR_WATERFALL,showmsg)
|
||||
if !pbFacingTerrainTag.waterfall
|
||||
if !$game_player.pbFacingTerrainTag.waterfall
|
||||
pbMessage(_INTL("Can't use that here.")) if showmsg
|
||||
next false
|
||||
end
|
||||
|
||||
@@ -203,13 +203,14 @@ class DependentEvents
|
||||
facingDirection=10-d
|
||||
if !leaderIsTrueLeader && areConnected
|
||||
relativePos=$MapFactory.getThisAndOtherEventRelativePos(leader,follower)
|
||||
if (relativePos[1]==0 && relativePos[0]==2) # 2 spaces to the right of leader
|
||||
# Assumes leader and follower are both 1x1 tile in size
|
||||
if (relativePos[1]==0 && relativePos[0]==2) # 2 spaces to the right of leader
|
||||
facingDirection=6
|
||||
elsif (relativePos[1]==0 && relativePos[0]==-2) # 2 spaces to the left of leader
|
||||
elsif (relativePos[1]==0 && relativePos[0]==-2) # 2 spaces to the left of leader
|
||||
facingDirection=4
|
||||
elsif relativePos[1]==-2 && relativePos[0]==0 # 2 spaces above leader
|
||||
elsif relativePos[1]==-2 && relativePos[0]==0 # 2 spaces above leader
|
||||
facingDirection=8
|
||||
elsif relativePos[1]==2 && relativePos[0]==0 # 2 spaces below leader
|
||||
elsif relativePos[1]==2 && relativePos[0]==0 # 2 spaces below leader
|
||||
facingDirection=2
|
||||
end
|
||||
end
|
||||
@@ -227,6 +228,7 @@ class DependentEvents
|
||||
for i in 0...facings.length
|
||||
facing=facings[i]
|
||||
tile=$MapFactory.getFacingTile(facing,leader)
|
||||
# Assumes leader is 1x1 tile in size
|
||||
passable=tile && $MapFactory.isPassableStrict?(tile[0],tile[1],tile[2],follower)
|
||||
if i==0 && !passable && tile &&
|
||||
$MapFactory.getTerrainTag(tile[0],tile[1],tile[2]).ledge
|
||||
@@ -238,6 +240,7 @@ class DependentEvents
|
||||
if passable
|
||||
relativePos=$MapFactory.getThisAndOtherPosRelativePos(
|
||||
follower,tile[0],tile[1],tile[2])
|
||||
# Assumes follower is 1x1 tile in size
|
||||
distance=Math.sqrt(relativePos[0]*relativePos[0]+relativePos[1]*relativePos[1])
|
||||
if bestRelativePos==-1 || bestRelativePos>distance
|
||||
bestRelativePos=distance
|
||||
@@ -251,6 +254,7 @@ class DependentEvents
|
||||
follower.through=oldthrough
|
||||
else
|
||||
tile=$MapFactory.getFacingTile(facings[0],leader)
|
||||
# Assumes leader is 1x1 tile in size
|
||||
passable=tile && $MapFactory.isPassableStrict?(tile[0],tile[1],tile[2],follower)
|
||||
mapTile=passable ? mapTile : nil
|
||||
end
|
||||
@@ -399,9 +403,10 @@ class DependentEvents
|
||||
!pbMapInterpreterRunning?
|
||||
# Get position of tile facing the player
|
||||
facingTile=$MapFactory.getFacingTile()
|
||||
# Assumes player is 1x1 tile in size
|
||||
self.eachEvent { |e,d|
|
||||
next if !d[9]
|
||||
if e.x==$game_player.x && e.y==$game_player.y
|
||||
if e.at_coordinate?($game_player.x, $game_player.y)
|
||||
# On same position
|
||||
if not e.jumping? && (!e.respond_to?("over_trigger") || e.over_trigger?)
|
||||
if e.list.size>1
|
||||
@@ -412,7 +417,7 @@ class DependentEvents
|
||||
end
|
||||
end
|
||||
elsif facingTile && e.map.map_id==facingTile[0] &&
|
||||
e.x==facingTile[1] && e.y==facingTile[2]
|
||||
e.at_coordinate?(facingTile[1], facingTile[2])
|
||||
# On facing tile
|
||||
if not e.jumping? && (!e.respond_to?("over_trigger") || !e.over_trigger?)
|
||||
if e.list.size>1
|
||||
|
||||
Reference in New Issue
Block a user