gameface101
Member
Version: 1.2
Author: g@Mef@Ce
Date: 8/3/2011 (month day, year)
Version History
- GPLAT 1.0 - 7/11/2011
- GPLAT 1.1 - 7/18/2011
- GPLAT 1.2 - 8/3/2011
Planned Future Versions
- it's a surprise :'p
Gravity system for making side scrolling platformers with RMXP
Features
+ user friendly module for easy configuration +
PLAYER:- gravity (w/ disable switch)
- pixel movement & jump (on/off)
- sprite alignment
- dash button
- dash speed
- walk speed
- jump button
- jump sprite
- jump animation
- jump height
- jump sound
- air jump (double jump)
- air jump animation
Screenshot?
Instructions
Step 1.) copy the code
Step 2.) open RMXP > F11 (script database)
Step 3.) above "Main" > Insert new script
Step 4.) paste code into right side window
Step 5.) configure module to your liking
Step 6.) make your maps
*to make a platform, simply make any tile on your tileset impassable.
RMXP > F9 > Tileset tab > Passage
make the tile you are using for the platform an "X" and not an "O"
GPLAT 1 of 2 - Player gravity
Code:
#===============================================================================
# Pixel Platformer v1.2 by G@MeF@Ce 8/3/2011 "GPLAT 1 of 2"
# [url=http://www.gameface101.com]http://www.gameface101.com[/url]
#-------------------------------------------------------------------------------
# Original Pixel Movement Script by Cogwheel from 66rpg.com
# special thanks to mr_wiggles and moghunter for RGSS support
#
# *free to use, must give credit, do not post on any other site
#==============================================================================
module G101_GPLAT
#--------------------------------------------------------------------------
# * configure settings
#--------------------------------------------------------------------------
GPLAT_DISABLE_SWITCH = 2 # switch ID to disable gravity switch
#
PIXEL_MOVE = true # pixel movement & jump
#SPRITE settings
UP = 32 #default 32 (0 < UP < 64)
DOWN = 0 #default 16 (0 < DOWN <64)
SIDE = 32 #default 32 (0 < SIDE <64)
#SPEED settings
DASH_BUTTON = Input::C # dash button
WALK_SPEED = 4.8 # set the walk speed
DASH_SPEED = 5.5 # set the dash speed
#JUMP settings
JUMP_BUTTON = Input::A # jump button
JUMP_SPRITE = "" # jump graphic character name suffix
JUMP_ANIMATION_ID = 0 # animation ID when jump
JUMP_MAX = 100 # power of jump
JUMP_ADD = 4 # height of single jump
JUMP_SOUND = "" # Play Sound when jump
JUMP_VOLUME = 70 # set volume for jump sound
JUMP_PITCH = 100 # set the pitch for jump sound
#AIR JUMP settings
AIR_JUMP_VAR = 1 # variable ID to set value for air jumps
AIR_JUMP_ANIMATION_ID = 0 # aniamtion ID when air jump
end
#==============================================================================
# Game_Player
#==============================================================================
class Game_Player < Game_Character
include G101_GPLAT
#--------------------------------------------------------------------------
# ● public instance variables
#--------------------------------------------------------------------------
attr_reader :event
attr_accessor :move_speed
#--------------------------------------------------------------------------
# ● update
#--------------------------------------------------------------------------
alias :update_original :update
def update
@walk = WALK_SPEED
@dash = DASH_SPEED
@event = 4
@dot_m = PIXEL_MOVE
if @revise_x == nil and @revise_y == nil
@revise_x = 0
@revise_y = 0
end
unless @dot_m
update_original
return
end
if @move_route_forcing
last_moving = moving?
last_real_x = @real_x
last_real_y = @real_y
if (@revise_x != 0 or @revise_y != 0) and not jumping? and @move == true
if @revise_x != @real_x - @x * 128 or @revise_y != @real_y - @y * 128
@revise_x = @real_x - @x * 128
@revise_y = @real_y - @y * 128
end
distance1 = 2 ** @move_speed
distance2 = Math.sqrt(@revise_x ** 2 + @revise_y ** 2)
if distance1 > distance2
@real_x = @real_x - @revise_x
@real_y = @real_y - @revise_y
@revise_x = 0
@revise_y = 0
anime_update
else
@real_x -= (distance1 * @revise_x / distance2).round
@real_y -= (distance1 * @revise_y / distance2).round
@revise_x = @real_x - @x * 128
@revise_y = @real_y - @y * 128
anime_update
end
else
super
end
else
@move = false
unless moving? or $game_system.map_interpreter.running? or
@move_route_forcing or $game_temp.message_window_showing
@event_run = false
#-------------------------------------------------------------------------------
case Input.dir8
when 1
$game_switches[GPLAT_DISABLE_SWITCH] ? move_lower_left_p : move_left_p
when 2
move_down_p if $game_switches[GPLAT_DISABLE_SWITCH]
when 3
$game_switches[GPLAT_DISABLE_SWITCH] ? move_lower_right_p : move_right_p
when 4
move_left_p
when 6
move_right_p
when 7
$game_switches[GPLAT_DISABLE_SWITCH] ? move_upper_left_p : move_left_p
when 8
move_up_p if $game_switches[GPLAT_DISABLE_SWITCH]
when 9
$game_switches[GPLAT_DISABLE_SWITCH] ? move_upper_right_p : move_right_p
end
end
last_real_x = @real_x
last_real_y = @real_y
@real_x = @x * 128 + @revise_x
@real_y = @y * 128 + @revise_y
last_moving = moving?
move_on
if (last_real_x != @real_x or last_real_y != @real_y)
@move_distance = 0 if @move_distance == nil
@move_distance += Math.sqrt((last_real_x - @real_x) ** 2 +
(last_real_y - @real_y) ** 2)
if @move_distance >= 128
@move_distance %= 128
increase_steps
end
anime_update
else
@pattern = 0
end
end
if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
$game_map.scroll_down(@real_y - last_real_y)
end
if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
$game_map.scroll_left(last_real_x - @real_x)
end
if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
$game_map.scroll_right(@real_x - last_real_x)
end
if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
$game_map.scroll_up(last_real_y - @real_y)
end
if last_moving
result = check_event_trigger_here([1,2])
if result == true
if (last_real_x / 128.0).round != @x and
(last_real_y / 128.0).round != @y
if @direction == 2 or @direction == 8
if (last_real_x / 128.0).round > @x
turn_left
else
turn_right
end
else
if (last_real_y / 128.0).round > @y
turn_up
else
turn_down
end
end
elsif (last_real_x / 128.0).round > @x
turn_left
elsif (last_real_x / 128.0).round < @x
turn_right
elsif (last_real_y / 128.0).round > @y
turn_up
elsif (last_real_y / 128.0).round < @y
turn_down
end
end
if result == false
unless $DEBUG and Input.press?(Input::CTRL)
if @encounter_count > 0
@encounter_count -= 1
end
end
end
end
#-------------------------------------------------------------------------------
unless $game_system.map_interpreter.running? or
@move_route_forcing or $game_temp.message_window_showing
if Input.press?(JUMP_BUTTON) and not $game_switches[GPLAT_DISABLE_SWITCH]
@twojump = 1 if @twojump == 0 and down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, 5, true)
if (not @apassed) and @twojump <= $game_variables[AIR_JUMP_VAR]
if @twojump > 0
$game_player.animation_id = AIR_JUMP_ANIMATION_ID
elsif
$game_player.animation_id = JUMP_ANIMATION_ID
end
@apassed = true
@jumpnow = JUMP_MAX
@twojump += 1
$game_system.se_play(RPG::AudioFile.new(JUMP_SOUND, JUMP_VOLUME, JUMP_PITCH))
else
@jumpnow += 3
end
else
@apassed = false
end
#-------------------------------------------------------------------------------
if not $game_switches[GPLAT_DISABLE_SWITCH]
@jumpnow -= 10
if @jumpnow < 0
actor = $game_party.actors[0]
@character_name = actor.character_name #change graphic back to normal
@jumpnow = [@jumpnow, -JUMP_MAX].max
if not down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, -@jumpnow, true)
@jumpnow = 0
@twojump = 0
end
elsif @jumpnow > 0
actor = $game_party.actors[0]
@character_name = actor.character_name + JUMP_SPRITE#change to jump graphic
@jumpnow = [@jumpnow, JUMP_MAX].min
if not up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, @jumpnow, true)
@jumpnow = 0
end
end
end
end #unless
if Input.trigger?(Input::C)
check_event_trigger_here([0])
check_event_trigger_there([0,1,2])
end
end
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
def initialize
@jumpnow = 0
@twojump = 0
@apassed = false
@revise_x = 0
@revise_y = 0
@move == false
super
end
#--------------------------------------------------------------------------
# ● moving?
#--------------------------------------------------------------------------
def moving?
unless @dot_m
result = super
return result
end
if @move_route_forcing
if @move == false
return false
end
super
else
return (@x != (@real_x / 128.0).round or @y != (@real_y / 128.0).round)
end
end
#--------------------------------------------------------------------------
# ● moving_a?
#--------------------------------------------------------------------------
def moving_a?
if @move == false
if (@move_route.list[@move_route_index].code <= 14 or
@move_route.list[@move_route_index].code == 25)
@move = true
end
return false
end
moving?
end
#--------------------------------------------------------------------------
# ● update (jump)
#--------------------------------------------------------------------------
def update_jump
@jump_count -= 1
@real_x = (@real_x * @jump_count + @x * 128) / (@jump_count + 1)
@real_y = (@real_y * @jump_count + @y * 128) / (@jump_count + 1)
if @jump_count == 0
@revise_x = 0
@revise_y = 0
end
end
#--------------------------------------------------------------------------
# ● move_type custom
#--------------------------------------------------------------------------
def move_type_custom
unless @dot_m
super
return
end
if jumping? or moving_a?
return
end
while @move_route_index < @move_route.list.size
command = @move_route.list[@move_route_index]
if command.code == 0
if @move_route.repeat
@move_route_index = 0
end
unless @move_route.repeat
if @move_route_forcing and not @move_route.repeat
@move_route_forcing = false
@move_route = @original_move_route
@move_route_index = @original_move_route_index
@original_move_route = nil
end
@stop_count = 0
end
return
end
if command.code <= 14
case command.code
when 1
move_down
when 2
move_left
when 3
move_right
when 4
move_up
when 5
move_lower_left
when 6
move_lower_right
when 7
move_upper_left
when 8
move_upper_right
when 9
move_random
when 10
move_toward_player
when 11
move_away_from_player
when 12
move_forward
when 13
move_backward
when 14
jump(command.parameters[0], command.parameters[1])
end
if not @move_route.skippable and not moving? and not jumping?
return
end
@move_route_index += 1
return
end
if command.code == 15
@wait_count = command.parameters[0] * 2 - 1
@move_route_index += 1
return
end
if command.code >= 16 and command.code <= 26
case command.code
when 16
turn_down
when 17
turn_left
when 18
turn_right
when 19
turn_up
when 20
turn_right_90
when 21
turn_left_90
when 22
turn_180
when 23
turn_right_or_left_90
when 24
turn_random
when 25
turn_toward_player
when 26
turn_away_from_player
end
@move_route_index += 1
return
end
if command.code >= 27
case command.code
when 27
$game_switches[command.parameters[0]] = true
$game_map.need_refresh = true
when 28
$game_switches[command.parameters[0]] = false
$game_map.need_refresh = true
when 29
@move_speed = command.parameters[0]
when 30
@move_frequency = command.parameters[0]
when 31
@walk_anime = true
when 32
@walk_anime = false
when 33
@step_anime = true
when 34
@step_anime = false
when 35
@direction_fix = true
when 36
@direction_fix = false
when 37
@through = true
when 38
@through = false
when 39
@always_on_top = true
when 40
@always_on_top = false
when 41
@tile_id = 0
@character_name = command.parameters[0]
@character_hue = command.parameters[1]
if @original_direction != command.parameters[2]
@direction = command.parameters[2]
@original_direction = @direction
@prelock_direction = 0
end
if @original_pattern != command.parameters[3]
@pattern = command.parameters[3]
@original_pattern = @pattern
end
when 42
@opacity = command.parameters[0]
when 43
@blend_type = command.parameters[0]
when 44
$game_system.se_play(command.parameters[0])
when 45
result = eval(command.parameters[0])
end
@move_route_index += 1
return
end
end
end
#--------------------------------------------------------------------------
# ● move_down platform
#--------------------------------------------------------------------------
def move_down_p
turn_down
distance = 2 ** @move_speed
down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# ● move_down aaaagq
#--------------------------------------------------------------------------
def move_down_aaaagq
distance = 2 ** @move_speed
down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# ● down1
#--------------------------------------------------------------------------
def down1(x, y, distance, down = false)
result = down2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x, y+1)
return result
end
if @revise_x < -SIDE
result = down2(x, y + 1, distance, 4)
result &= down2(x - 1, y, distance)
if result == false
if down
move_lower_right_p
if @revise_x > SIDE
@revise_x = SIDE
end
end
return result
end
elsif @revise_x > SIDE
result = down2(x, y + 1, distance, 6)
result &= down2(x + 1, y, distance)
if result == false
if down
move_lower_left_p
if @revise_x < -SIDE
@revise_x = -SIDE
end
end
return result
end
end
@revise_y += distance
return result
end
#--------------------------------------------------------------------------
# ● down2
#--------------------------------------------------------------------------
def down2(x, y, distance, d = 2)
if @revise_y + distance > DOWN
unless passable?(x, y, d)
if @revise_y < DOWN
@revise_y = DOWN
end
return false
end
end
return true
end
#--------------------------------------------------------------------------
# ● move_left platform
#--------------------------------------------------------------------------
def move_left_p
turn_left
distance = 2 ** @move_speed
left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# ● left1
#--------------------------------------------------------------------------
def left1(x, y, distance, left = false)
result = left2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x-1, y)
return result
end
if @revise_y < -UP and $game_switches[GPLAT_DISABLE_SWITCH]
result = left2(x - 1, y, distance, 8)
result &= left2(x, y - 1, distance)
if result == false
if left
move_lower_left_p
if @revise_y > DOWN
@revise_y = DOWN
end
end
return result
end
elsif @revise_y > DOWN and $game_switches[GPLAT_DISABLE_SWITCH]
result = left2(x - 1, y, distance, 2)
result &= left2(x, y + 1, distance)
if result == false
if left
move_upper_left_p
if @revise_y < -UP
@revise_y = -UP
end
end
return result
end
end
@revise_x -= distance
return result
end
#--------------------------------------------------------------------------
# ● left2
#--------------------------------------------------------------------------
def left2(x, y, distance, d = 4)
if @revise_x - distance < -SIDE
unless passable?(x, y, d)
if @revise_x > -SIDE
@revise_x = -SIDE
end
return false
end
end
return true
end
#--------------------------------------------------------------------------
# ● move_right platform
#--------------------------------------------------------------------------
def move_right_p
turn_right
distance = 2 ** @move_speed
right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# ● right1
#--------------------------------------------------------------------------
def right1(x, y, distance, right = false)
result = right2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x+1, y)
return result
end
if @revise_y < -UP and $game_switches[GPLAT_DISABLE_SWITCH]
result = right2(x + 1, y, distance, 8)
result &= right2(x, y - 1, distance)
if result == false
if right
move_lower_right_p
if @revise_y > DOWN
@revise_y = DOWN
end
end
return result
end
elsif @revise_y > DOWN and $game_switches[GPLAT_DISABLE_SWITCH]
result = right2(x + 1, y, distance, 2)
result &= right2(x, y + 1, distance)
if result == false
if right
move_upper_right_p
if @revise_y < -UP
@revise_y = -UP
end
end
return result
end
end
@revise_x += distance
return result
end
#--------------------------------------------------------------------------
# ● right2
#--------------------------------------------------------------------------
def right2(x, y, distance, d = 6)
if @revise_x + distance > SIDE
unless passable?(x, y, d)
if @revise_x < SIDE
@revise_x = SIDE
end
return false
end
end
return true
end
#--------------------------------------------------------------------------
# ● move_up platform
#--------------------------------------------------------------------------
def move_up_p
turn_up
distance = 2 ** @move_speed
up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# ● move_up_aaaagq
#--------------------------------------------------------------------------
def move_up_aaaagq
distance = 2 ** @move_speed
up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# ● up1
#--------------------------------------------------------------------------
def up1(x, y, distance, up = false)
result = up2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x, y-1)
return result
end
if @revise_x < -SIDE
result = up2(x, y - 1, distance, 4)
result &= up2(x - 1, y, distance)
if result == false
if up
move_upper_right_p
if @revise_x > SIDE
@revise_x = SIDE
end
end
return result
end
elsif @revise_x > SIDE
result = up2(x, y - 1, distance, 6)
result &= up2(x + 1, y, distance)
if result == false
if up
move_upper_left_p
if @revise_x < -SIDE
@revise_x = -SIDE
end
end
return result
end
end
@revise_y -= distance
return result
end
#--------------------------------------------------------------------------
# ● up2
#--------------------------------------------------------------------------
def up2(x, y, distance, d = 8)
if @revise_y - distance < -UP
unless passable?(x, y, d)
if @revise_y > -UP
@revise_y = -UP
end
return false
end
end
return true
end
#--------------------------------------------------------------------------
# ● low_left platform
#--------------------------------------------------------------------------
def move_lower_left_p
unless @direction_fix
@direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
end
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 2
turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 2, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_y > DOWN and -UP > @revise_y - distance
@revise_y = DOWN
end
turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
end
else
turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 4, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_x + distance> SIDE and -SIDE > @revise_x
@revise_x = -SIDE
end
turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
end
end
end
#--------------------------------------------------------------------------
# ● low_right platform
#--------------------------------------------------------------------------
def move_lower_right_p
unless @direction_fix
@direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
end
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 2
turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 2, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_y > DOWN and -UP > @revise_y - distance
@revise_y = DOWN
end
turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
end
else
turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 6, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_x > SIDE and -SIDE > @revise_x - distance
@revise_x = SIDE
end
turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
end
end
end
#--------------------------------------------------------------------------
# ● up_left platform
#--------------------------------------------------------------------------
def move_upper_left_p
unless @direction_fix
@direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
end
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 8
turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 8, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_y + distance > DOWN and -UP > @revise_y
@revise_y = -UP
end
turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
end
else
turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 4, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_x > SIDE and -SIDE > @revise_x - distance
@revise_x = SIDE
end
turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
end
end
end
#--------------------------------------------------------------------------
# ● up_right platform
#--------------------------------------------------------------------------
def move_upper_right_p
unless @direction_fix
@direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
end
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 8
turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 8, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_y + distance > DOWN and -UP > @revise_y
@revise_y = -UP
end
turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
end
else
turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 6, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_x > SIDE and -SIDE > @revise_x - distance
@revise_x = SIDE
end
turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
end
end
end
#--------------------------------------------------------------------------
# ● check event here
#--------------------------------------------------------------------------
def check_event_trigger_here(triggers, run = true)
result = false
if $game_system.map_interpreter.running?
return result
end
for event in $game_map.events.values
if event.x == ((@x * 128 + @revise_x) / 128.0).round and
event.y == ((@y * 128 + @revise_y) / 128.0).round and
triggers.include?(event.trigger)
if not event.jumping? and event.over_trigger?
if event.list.size > 1
if run == true
event.start
end
result = true
end
end
end
end
return result
end
#--------------------------------------------------------------------------
# ● move_on
#--------------------------------------------------------------------------
def move_on
if @y < (@y + @revise_y / 128.0).round
@y += 1
@revise_y -= 128
end
if @x > (@x + @revise_x / 128.0).round
@x -= 1
@revise_x += 128
end
if @x < (@x + @revise_x / 128.0).round
@x += 1
@revise_x -= 128
end
if @y > (@y + @revise_y / 128.0).round
@y -= 1
@revise_y += 128
end
end
#--------------------------------------------------------------------------
# ● update (anime)
#--------------------------------------------------------------------------
def anime_update
if @walk_anime
@anime_count += 1.5
elsif @step_anime
@anime_count += 1
end
if @anime_count > 18 - @move_speed * 2 #@event = 4?
if not @step_anime and @stop_count > 0
@pattern = @original_pattern
else
@pattern = (@pattern + 1) % 4
end
@anime_count = 0
end
end
#--------------------------------------------------------------------------
# ● moveto (x,y)
#--------------------------------------------------------------------------
alias :moveto_original :moveto
def moveto(x, y)
@revise_x = 0
@revise_y = 0
moveto_original(x, y)
end
#--------------------------------------------------------------------------
# ● last move?
#--------------------------------------------------------------------------
def last_move?(x, y, direction, distance)
if direction == 2 or direction == 6
distance *= -1
end
if (direction == 2 or direction == 8) and
(y / 128.0).round != ((y - distance) / 128.0).round
return true
end
if (direction == 4 or direction == 6) and
(x / 128.0).round != ((x - distance) / 128.0).round
return true
end
return false
end
end
#==============================================================================
# Game_Character
#==============================================================================
class Game_Character
include G101_GPLAT
def update_move
distance = 2 ** @move_speed
if @x * 128 != @real_x and @y * 128 != @real_y
distance /= Math.sqrt(2)
end
if @y * 128 > @real_y
@real_y = [@real_y + distance, @y * 128].min
end
if @x * 128 < @real_x
@real_x = [@real_x - distance, @x * 128].max
end
if @x * 128 > @real_x
@real_x = [@real_x + distance, @x * 128].min
end
if @y * 128 < @real_y
@real_y = [@real_y - distance, @y * 128].max
end
if @walk_anime
@anime_count += 1.5
elsif @step_anime
@anime_count += 1
end
end
end
#==============================================================================
# Game_Event
#==============================================================================
class Game_Event < Game_Character
def start
if @list.size > 1
if $game_player.event != 0
$game_player.move_speed = $game_player.event
end
@starting = true
end
end
end
#end of script ^,^
Code:
#===============================================================================
# Event Gravity script by G@MeF@Ce "GPLAT 2 of 2" [url=http://www.gameface101.com]http://www.gameface101.com[/url]
# special thanks to mr_wiggles for RGSS support
# free to use, must give credit, do not post on any other site
#===============================================================================
module G_EG
GPLAT_SWITCH = 3 #switch ID to turn on/off event gravity
G_GRAVITY = 1 # Y coordinates to
G_DROP = 30 # speed of gravity pull
end
#==============================================================================
# ■ Game_Event
#==============================================================================
class Game_Event < Game_Character
include G_EG
#--------------------------------------------------------------------------
# ● Frame Update
#--------------------------------------------------------------------------
alias gravity_update update
def update
#check_jump_event if $game_switches[GPLAT_SWITCH_ID]
gravity_update
if $game_switches[GPLAT_SWITCH] and $game_map.passable?(@x, @y+1, 2)
@y += 0# if @icon_name != nil
unless @id > 999 or @air_event or @fixed_event
@y += G_GRAVITY
end
end
end
#--------------------------------------------------------------------------
# ● Refresh
#--------------------------------------------------------------------------
alias refresh_gravity refresh
def refresh
refresh_gravity
unless @page == nil
for i in @page.list
if i.code == 108 or i.code == 408
# Code for Air event
if i.parameters[0].upcase[/AIR/] != nil
@air_event = true
end
# Code for Fixed event
if i.parameters[0].upcase[/FIXED/] != nil
@fixed_event = true
end
end
end
end
if @air_event and $game_switches[GPLAT_SWITCH]
if @y != @old_y
case rand(6)
when 0..2; turn_right
when 3..6; turn_left
end
@old_y = @y
end
end
end
end
#==============================================================================
# Game_Character
#==============================================================================
class Game_Character
def update_move
distance = 2 ** @move_speed
if @y * 128 > @real_y
@real_y = [@real_y + distance, @y * 128].min
# event gravity
if self.is_a?(Game_Event) and $game_switches[G_EG::GPLAT_SWITCH] and
@air_event == nil
@real_y += G_EG::G_DROP
end
end
if @x * 128 < @real_x
@real_x = [@real_x - distance, @x * 128].max
end
if @x * 128 > @real_x
@real_x = [@real_x + distance, @x * 128].min
end
if @y * 128 < @real_y
@real_y = [@real_y - distance, @y * 128].max
end
if @walk_anime
@anime_count += 1.5
elsif @step_anime
@anime_count += 1
end
end
end
#end of script ^,^here at HBGames.org or the underground
http://www.gameface101.com
Known Compatibility Issues
? ~ let me know...
Restrictions
Do not post this script on any other site.
must give credit to http://www.gameface101.com
cogwheel for pixel movement
special thanks to mr_wiggles and moghunter for RGSS support
DEMO?
http://www.mediafire.com/?sr9n28vim1ini9j
password: shrooms
Enjoy!
^,^