Reborn

hat beim Stromkonzern schon Rabatt

  • »Reborn« ist der Autor dieses Themas

Motto: Wer noch was vom Wochenende weis, hat es nie erlebt!

  • Nachricht senden

1

Sonntag, 11. Januar 2009, 02:19

Kisten Finder 2.0

Es ist soweit^^, mein Script ist fertig, hab jetzt noch nicht alle Varianten getestet aba ich denke jetzt mal das es geht, fals nicht - plz melden.

Hier das was ihr damit machen könnt:
Diese Scripte machen das dir Ununterbrochen ein Event hinterherdackelt, wenn es eine Kiste mit einem bestimmten namen in einem gewissen festzulegenden Radius findet geht es zu dieser hin und öffnet diese.

Also hier das was ihr bzw. du machen müsst/musst:

Das hier bei Game Player einfügen:
Spoiler

Quellcode

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  This class handles the player. Its functions include event starting
#  determinants and map scrolling. Refer to "$game_player" for the one
#  instance of this class.
#==============================================================================
 
class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # * Invariables
  #--------------------------------------------------------------------------
  CENTER_X = (320 - 16) * 4   # Center screen x-coordinate * 4
  CENTER_Y = (240 - 16) * 4   # Center screen y-coordinate * 4
  #--------------------------------------------------------------------------
  # * Passable Determinants
  # x : x-coordinate
  # y : y-coordinate
  # d : direction (0,2,4,6,8)
  #     * 0 = Determines if all directions are impassable (for jumping)
  #--------------------------------------------------------------------------
  def passable?(x, y, d)
# Get new coordinates
new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
# If coordinates are outside of map
unless $game_map.valid?(new_x, new_y)
  # Impassable
  return false
end
# If debug mode is ON and ctrl key was pressed
if $DEBUG and Input.press?(Input::CTRL)
  # Passable
  return true
end
super
  end
  #--------------------------------------------------------------------------
  # * Set Map Display Position to Center of Screen
  #--------------------------------------------------------------------------
  def center(x, y)
max_x = ($game_map.width - 20) * 128
max_y = ($game_map.height - 15) * 128
$game_map.display_x = [0, [x * 128 - CENTER_X, max_x].min].max
$game_map.display_y = [0, [y * 128 - CENTER_Y, max_y].min].max
  end
  #--------------------------------------------------------------------------
  # * Move to Designated Position
  # x : x-coordinate
  # y : y-coordinate
  #--------------------------------------------------------------------------
  def moveto(x, y)
super
# Centering
center(x, y)
# Make encounter count
make_encounter_count
  end
  #--------------------------------------------------------------------------
  # * Increaase Steps
  #--------------------------------------------------------------------------
  def increase_steps
super
# If move route is not forcing
unless @move_route_forcing
  # Increase steps
  $game_party.increase_steps
  # Number of steps are an even number
  if $game_party.steps % 2 == 0
    # Slip damage check
    $game_party.check_map_slip_damage
  end
end
  end
  #--------------------------------------------------------------------------
  # * Get Encounter Count
  #--------------------------------------------------------------------------
  def encounter_count
return @encounter_count
  end
  #--------------------------------------------------------------------------
  # * Make Encounter Count
  #--------------------------------------------------------------------------
  def make_encounter_count
# Image of two dice rolling
if $game_map.map_id != 0
  n = $game_map.encounter_step
  @encounter_count = rand(n) + rand(n) + 1
end
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
# If party members = 0
if $game_party.actors.size == 0
  # Clear character file name and hue
  @character_name = ""
  @character_hue = 0
  # End method
  return
end
# Get lead actor
actor = $game_party.actors[0]
# Set character file name and hue
@character_name = actor.character_name
@character_hue = actor.character_hue
# Initialize opacity level and blending method
@opacity = 255
@blend_type = 0
  end
  #--------------------------------------------------------------------------
  # * Same Position Starting Determinant
  #--------------------------------------------------------------------------
  def check_event_trigger_here(triggers)
result = false
# If event is running
if $game_system.map_interpreter.running?
  return result
end
# All event loops
for event in $game_map.events.values
  # If event coordinates and triggers are consistent
  if event.x == @x and event.y == @y and triggers.include?(event.trigger)
    # If starting determinant is same position event (other than jumping)
    if not event.jumping? and event.over_trigger?
      event.start
      result = true
    end
  end
end
return result
  end
  #--------------------------------------------------------------------------
  # * Front Envent Starting Determinant
  #--------------------------------------------------------------------------
  def check_event_trigger_there(triggers)
result = false
# If event is running
if $game_system.map_interpreter.running?
  return result
end
# Calculate front event coordinates
new_x = @x + (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
new_y = @y + (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
# All event loops
for event in $game_map.events.values
  # If event coordinates and triggers are consistent
  if event.x == new_x and event.y == new_y and
     triggers.include?(event.trigger)
    # If starting determinant is front event (other than jumping)
    if not event.jumping? and not event.over_trigger?
      event.start
      result = true
    end
  end
end
# If fitting event is not found
if result == false
  # If front tile is a counter
  if $game_map.counter?(new_x, new_y)
    # Calculate 1 tile inside coordinates
    new_x += (@direction == 6 ? 1 : @direction == 4 ? -1 : 0)
    new_y += (@direction == 2 ? 1 : @direction == 8 ? -1 : 0)
    # All event loops
    for event in $game_map.events.values
      # If event coordinates and triggers are consistent
      if event.x == new_x and event.y == new_y and
         triggers.include?(event.trigger)
        # If starting determinant is front event (other than jumping)
        if not event.jumping? and not event.over_trigger?
          event.start
          result = true
        end
      end
    end
  end
end
return result
  end
  #--------------------------------------------------------------------------
  # * Touch Event Starting Determinant
  #--------------------------------------------------------------------------
  def check_event_trigger_touch(x, y)
result = false
# If event is running
if $game_system.map_interpreter.running?
  return result
end
# All event loops
for event in $game_map.events.values
  # If event coordinates and triggers are consistent
  if event.x == x and event.y == y and [1,2].include?(event.trigger)
    # If starting determinant is front event (other than jumping)
    if not event.jumping? and not event.over_trigger?
      event.start
      result = true
    end
  end
end
return result
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
if $var == nil
  $move1 = 4
  $var = 4
end
# Remember whether or not moving in local variables
last_moving = moving?
# If moving, event running, move route forcing, and message window
# display are all not occurring
unless moving? or $game_system.map_interpreter.running? or
       @move_route_forcing or $game_temp.message_window_showing
  # Move player in the direction the directional button is being pressed
  @moved = 0
  for i in $game_map.map.events.keys
    if $game_map.map.events[i].name == "Verfolger"
      $die_gewuenschte_id = i
    end
  end
  case Input.dir4
  when 2
    move_down
    unless moving?
    else
      if $die_gewuenschte_id != nil  
        if @moved != 1
          if $laufen != true
            $move = RPG::MoveRoute.new
            $move.list = 
            [RPG::MoveCommand.new($move1)]
            $game_map.events[$die_gewuenschte_id].force_move_route($move)
            $move1 = 1
            @moved = 1
            $die_gewuenschte_id = nil
          end
        end
      end
    end
  when 4
    move_left
    unless moving?
    else
      if $die_gewuenschte_id != nil  
        if @moved != 1
          if $laufen != true
            $move = RPG::MoveRoute.new
            $move.list = 
            [RPG::MoveCommand.new($move1)]
            $game_map.events[$die_gewuenschte_id].force_move_route($move)
            $move1 = 2
            @moved = 1
            $die_gewuenschte_id = nil
          end
        end
      end
    end
  when 6
    move_right
    unless moving?
    else
      if $die_gewuenschte_id != nil  
        if @moved != 1
          if $laufen != true
            $move = RPG::MoveRoute.new
            $move.list = 
            [RPG::MoveCommand.new($move1)]
            $game_map.events[$die_gewuenschte_id].force_move_route($move)
            $move1 = 3
            @moved = 1
            $die_gewuenschte_id = nil
          end
        end
      end
    end
  when 8
    move_up
    unless moving?
    else
      if $die_gewuenschte_id != nil  
        if @moved != 1
          if $laufen != true
            $move = RPG::MoveRoute.new
            $move.list = 
            [RPG::MoveCommand.new($move1)]
            $game_map.events[$die_gewuenschte_id].force_move_route($move)
            $move1 = 4
            @moved = 1
            $die_gewuenschte_id = nil
          end
        end
      end
    end
  end
end
# Remember coordinates in local variables
last_real_x = @real_x
last_real_y = @real_y
super
# If character moves down and is positioned lower than the center
# of the screen
if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
  # Scroll map down
  $game_map.scroll_down(@real_y - last_real_y)
end
# If character moves left and is positioned more let on-screen than
# center
if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
  # Scroll map left
  $game_map.scroll_left(last_real_x - @real_x)
end
# If character moves right and is positioned more right on-screen than
# center
if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
  # Scroll map right
  $game_map.scroll_right(@real_x - last_real_x)
end
# If character moves up and is positioned higher than the center
# of the screen
if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
  # Scroll map up
  $game_map.scroll_up(last_real_y - @real_y)
end
# If not moving
unless moving?
  # If player was moving last time
  if last_moving
    # Event determinant is via touch of same position event
    result = check_event_trigger_here([1,2])
    # If event which started does not exist
    if result == false
      # Disregard if debug mode is ON and ctrl key was pressed
      unless $DEBUG and Input.press?(Input::CTRL)
        # Encounter countdown
        if @encounter_count > 0
          @encounter_count -= 1
        end
      end
    end
  end
  # If C button was pressed
  if Input.trigger?(Input::C)
    # Same position and front event determinant
    check_event_trigger_here([0])
    check_event_trigger_there([0,1,2])
  end
end
  end
end
zum Lesen den Text mit der Maus markieren


Dann den Pathfinder von Near Fantastica (Den füg(s)t ihr/du am besten Direkt über Main ein):

Spoiler

Quellcode

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#==============================================================================
#   ¦ Path Finding
#   By: Near Fantastica
#   Date: 24.09.05
#   Version: 1
#
#   Player :: $game_player.find_path(x,y)
#   Event Script Call :: self.event.find_path(x,y)
#   Event Movement Script Call :: self.find_path(x,y)
#==============================================================================
 
class Game_Character
  #--------------------------------------------------------------------------
  alias pf_game_character_initialize initialize
  alias pf_game_character_update update
  #--------------------------------------------------------------------------
  attr_accessor :map
  attr_accessor :runpath
  #--------------------------------------------------------------------------
  def initialize
pf_game_character_initialize
@map = nil
@runpath = false
  end
  #--------------------------------------------------------------------------
  def update
run_path if @runpath == true
pf_game_character_update
  end
  #--------------------------------------------------------------------------
  def run_path
return if moving?
step = @map[@x,@y]
if step == 1
  @map = nil
  @runpath = false
  return
end
dir = rand(2)
case dir
when 0
  move_right if @map[@x+1,@y] == step - 1 and step != 0
  move_down if @map[@x,@y+1] == step - 1 and step != 0
  move_left if @map[@x-1,@y] == step -1 and step != 0
  move_up if @map[@x,@y-1] == step - 1 and step != 0
when 1
  move_up if @map[@x,@y-1] == step - 1 and step != 0
  move_left if @map[@x-1,@y] == step -1 and step != 0
  move_down if @map[@x,@y+1] == step - 1 and step != 0
  move_right if @map[@x+1,@y] == step - 1 and step != 0
end
  end
  #--------------------------------------------------------------------------
  def find_path(x,y)
sx, sy = @x, @y
result = setup_map(sx,sy,x,y)
@runpath = result[0]
@map = result[1]
@map[sx,sy] = result[2] if result[2] != nil
  end
  #--------------------------------------------------------------------------
  def setup_map(sx,sy,ex,ey)
map = Table.new($game_map.width, $game_map.height)
map[ex,ey] = 1
old_positions = []
new_positions = []
old_positions.push([ex, ey])
depth = 2
depth.upto(100){|step|
  loop do
    break if old_positions[0] == nil
    x,y = old_positions.shift
    return [true, map, step] if x == sx and y+1 == sy
    if $game_player.passable?(x, y, 2) and map[x,y + 1] == 0
      map[x,y + 1] = step
      new_positions.push([x,y + 1])
    end
    return [true, map, step] if x-1 == sx and y == sy
    if $game_player.passable?(x, y, 4) and map[x - 1,y] == 0
      map[x - 1,y] = step
      new_positions.push([x - 1,y])
    end
    return [true, map, step] if x+1 == sx and y == sy
    if $game_player.passable?(x, y, 6) and map[x + 1,y] == 0
      map[x + 1,y] = step
      new_positions.push([x + 1,y])
    end
    return [true, map, step] if x == sx and y-1 == sy
    if $game_player.passable?(x, y, 8) and map[x,y - 1] == 0
      map[x,y - 1] = step
      new_positions.push([x,y - 1])
    end
  end
  old_positions = new_positions
  new_positions = []
}
return [false, nil, nil]
  end
end
 
class Interpreter
  #--------------------------------------------------------------------------
  def event
return $game_map.events[@event_id]
return $game_map.events[@event_id]
return $game_map.events[@event_id]
  end
end
zum Lesen den Text mit der Maus markieren


Dann hier noch mein Script (auch am besten Direkt über Main):

Spoiler
[php]#----------------------|
#Kistenfinger by Hindi |
#----------------------|
#Voller Zugriff auf alle Events
class Game_Map
attr_reader :map
end
#Das Modul:
module EventSteuern
#Event dazu bringen das es einer Kiste folgt:
def self.kiste_verfolgen(my_name, felder_radius, self_switch)
if $game_map.events[1] != nil && $game_player.x != nil && $game_map.map.events.keys != nil
#Die wichtigsten Variablen:
#Arrays erstellen
@kisten_ids = []
@kisten_x = []
@kisten_y = []
@differenz = []
@differenz_x = []
@differenz_y = []
@kisten_differenz = []
@kisten_differenz_x = []
@kisten_differenz_y = []
#x und y Koordinaten vom spieler:
@player_x = $game_player.x
@player_y = $game_player.y
#x und y Koordinaten des Verfolgers + ID des Verfolgers
for i in $game_map.map.events.keys
if $game_map.map.events.name == "Verfolger"
@id_verfolger = i
end
end
@verfolger_x = $game_map.events[@id_verfolger].x
@verfolger_y = $game_map.events[@id_verfolger].y
#x und y Koordinaten + ID's aller Kisten in einer Array abgespeichert:
for i in $game_map.map.events.keys
if $game_map.map.events[i].name == my_name
@kisten_ids.push(i)
end
end
for i in 0..@kisten_ids.size
if @kisten_ids[i] != nil
@kisten_x.push($game_map.events[@kisten_ids[i]].x)
@kisten_y.push($game_map.events[@kisten_ids[i]].y)
end
end
#Die Differenzen zum vergleichen (für verfolgung der Kisten):
for i in 0..@kisten_ids.size
if @player_x != nil && @kisten_x[i] != nil
@differenz_x.push(@verfolger_x - @kisten_x[i])
@differenz_y.push(@verfolger_y - @kisten_y[i])
#Fals differenz_x oder differenz_y Negativ ist, wird sie Postivit gemacht
x = @differenz_x[i]
x < 0 ? x *= -1 : x
@differenz_x[i] = x
y = @differenz_y[i]
y < 0 ? y *= -1 : y
@differenz_y[i] = y
#Bildet die Summe zum vergleichen:
@differenz.push(@differenz_x[i] + @differenz_y[i])
end
end
#Überprüfen ob der Verfolger direkt hiter dem Hero ist:
for i in 0..@kisten_ids.size
if @player_x != nil && @verfolger_x != nil
@differenz_player_x = @player_x - @verfolger_x
@differenz_player_y = @player_x - @verfolger_x
#Fals differenz_x oder differenz_y Negativ ist, wird sie Postivit gemacht
x = @differenz_player_x
x < 0 ? x *= -1 : x
@differenz_player_x = x
y = @differenz_player_y
y < 0 ? y *= -1 : y
@differenz_player_y = y
#Bildet die Summe zum vergleichen:
@differenz_player = @differenz_player_x + @differenz_player_y
end
end
end

#ID's und Koordinaten
#Player: ID: - x: @player_x y: @player_y
#Verfolger: ID: @id_verfolger x: @verfolger_x y: @verfolger_y
#Kisten: ID: @kisten_ids[] x: @kisten_x[] y: @kisten_y[]

#Der Code
#Überprüft ob der Verfolger hinter dem Held steht.
if @differenz_player <= 1
@zurueck = false
end
#Überprüfen ob der Verfolger bereits bei einer Truhe ist, fals ja läuft er zurück zum Held:
for i in 0..@kisten_ids.size
if @differenz[i] != nil && @differenz_player != nil && @differenz[i] <= 1
@zurueck = true
$game_self_switches[[$game_map.map_id,@kisten_ids[i],self_switch]] = true
$game_map.need_refresh = true
if $game_player.direction == 2 && $die_gewuenschte_id != nil
$game_map.events[@id_verfolger].find_path($game_player.x,$game_player.y - 1)
end
if $game_player.direction == 4 && $die_gewuenschte_id != nil
$game_map.events[@id_verfolger].find_path($game_player.x + 1,$game_player.y)
end
if $game_player.direction == 6 && $die_gewuenschte_id != nil
$game_map.events[@id_verfolger].find_path($game_player.x - 1,$game_player.y)
end
if $game_player.direction == 8 && $die_gewuenschte_id != nil
$game_map.events[@id_verfolger].find_path($game_player.x,$game_player.y + 1)
end
@fuer_self_switch = nil
end
end
#Vergleicht alle Koordinaten:
for i in 0..@kisten_ids.size
if $game_self_switches[[$game_map.map_id,@kisten_ids[i],self_switch]] == false
if @zurueck != true
if @differenz != 0
if @differenz[i] != nil && felder_radius != nil && @differenz[i] <= felder_radius
$game_map.events[@id_verfolger].find_path(@kisten_x[i],@kisten_y[i])
@fuer_self_switch = @kisten_ids[i]
end
end
end
end
end
end
end[/php]
zum Lesen den Text mit der Maus markieren


Und jetzt die Regeln die du/ihr beachten müsst, die leider sehr umfangreich sind, aber man muss da dazu sagen das es mein 1. Script ist^^, naja hier das was ihr beachten müsst:

Ihr müsst erstmal ein Event erstellen und es direcht unterhalb des Heros stellen müsst und diese Event nennt ihr dann am besten Verfolger, damit es euch auch verfolgt. Wenn ihr euch auf eine andere Map Teleporiter müsst ihr das Event auch mit Teleportieren. So veil zum von mir Modifiziertem Game_player-Script.

Jetzt zum Kisten-Sucher Script:
Ihr fügt einfach diesen Code hier in Common Events als Call-Script ein:

Quellcode

1
EventSteuern.kiste_verfolgen(der name, felder Radius, self Switch)

Im 1. kommt rein bei welchem Name eines Objekts der Verfolger hinlaufen soll. Dann wenn ihr/du eine Kiste auch so bennen(s)t läuft der Verfolger dort hin. Beim 2. (felder radius) kommt rein wie viele Felder der Verfolger vom Objekt entfernt sein kann. Und wenn der Verfolger eine Kiste gefunden hat, wird sich von dem Event auf dem die Kiste ist der Self Switch A aktiviert, also m(ü/u)sst ihr/du noch ein wenig selber machen^^. Das 3. ist der self Switch, dort könnt ihr euren Self Switch eintragen der aktiviert werden soll, wer wird z.B. so eingegeben:

Ruby Quellcode

1
'A'


Ok das war eiggentlich alles, ich hoffe es geht, ansonsten wisst ihr was ihr zu tun habt ;-)

mfg und viel Spaß
Mehr als a Allgäuer ka a Mensch it wera.


Wie soll ich wissen was ich denke, bevor ich nicht höre was ich sage?


Spoiler: OpenSource-Projects
NES-Emulator - a simple NES-Emulator
ERDL - a embedded Ruby Interpreter with the abilltiy to render images with DirectX ERDL shall be 100% compatible to RPGXP-Ruby Scripts
zum Lesen den Text mit der Maus markieren

Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von »Reborn« (11. Januar 2009, 23:25)


Evrey

Oberschurke im Ruhestand

Motto: "Satzzeichen sind keine Rudeltiere." - Chesra

  • Nachricht senden

2

Sonntag, 11. Januar 2009, 02:29

Hmm... der Code ist zwar sehr klobig geworden und hat nur eingeschränkte Möglichkeiten, aber ist benutzerfreundlicher als meines xD Ein Vorschlag noch: Ersetze deinen ersten Spoiler durch:
Spoiler: Game_Player-Erweiterung

Ruby Quellcode

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
class Game_Player
 alias old_Hindi_update update
 def update
if $var == nil
  $move1 = 4
  $var = 4
end
# Remember whether or not moving in local variables
last_moving = moving?
# If moving, event running, move route forcing, and message window
# display are all not occurring
unless moving? or $game_system.map_interpreter.running? or
       @move_route_forcing or $game_temp.message_window_showing
  # Move player in the direction the directional button is being pressed
  @moved = 0
  for i in $game_map.map.events.keys
    if $game_map.map.events[i].name == "Verfolger"
      $die_gewuenschte_id = i
    end
  end
  case Input.dir4
  when 2
    move_down
    unless moving?
    else
      if $die_gewuenschte_id != nil  
        if @moved != 1
          if $laufen != true
            $move = RPG::MoveRoute.new
            $move.list = 
            [RPG::MoveCommand.new($move1)]
            $game_map.events[$die_gewuenschte_id].force_move_route($move)
            $move1 = 1
            @moved = 1
            $die_gewuenschte_id = nil
          end
        end
      end
    end
  when 4
    move_left
    unless moving?
    else
      if $die_gewuenschte_id != nil  
        if @moved != 1
          if $laufen != true
            $move = RPG::MoveRoute.new
            $move.list = 
            [RPG::MoveCommand.new($move1)]
            $game_map.events[$die_gewuenschte_id].force_move_route($move)
            $move1 = 2
            @moved = 1
            $die_gewuenschte_id = nil
          end
        end
      end
    end
  when 6
    move_right
    unless moving?
    else
      if $die_gewuenschte_id != nil  
        if @moved != 1
          if $laufen != true
            $move = RPG::MoveRoute.new
            $move.list = 
            [RPG::MoveCommand.new($move1)]
            $game_map.events[$die_gewuenschte_id].force_move_route($move)
            $move1 = 3
            @moved = 1
            $die_gewuenschte_id = nil
          end
        end
      end
    end
  when 8
    move_up
    unless moving?
    else
      if $die_gewuenschte_id != nil  
        if @moved != 1
          if $laufen != true
            $move = RPG::MoveRoute.new
            $move.list = 
            [RPG::MoveCommand.new($move1)]
            $game_map.events[$die_gewuenschte_id].force_move_route($move)
            $move1 = 4
            @moved = 1
            $die_gewuenschte_id = nil
          end
        end
      end
    end
  end
end
# Remember coordinates in local variables
last_real_x = @real_x
last_real_y = @real_y
super
# If character moves down and is positioned lower than the center
# of the screen
if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
  # Scroll map down
  $game_map.scroll_down(@real_y - last_real_y)
end
# If character moves left and is positioned more let on-screen than
# center
if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
  # Scroll map left
  $game_map.scroll_left(last_real_x - @real_x)
end
# If character moves right and is positioned more right on-screen than
# center
if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
  # Scroll map right
  $game_map.scroll_right(@real_x - last_real_x)
end
# If character moves up and is positioned higher than the center
# of the screen
if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
  # Scroll map up
  $game_map.scroll_up(last_real_y - @real_y)
end
# If not moving
unless moving?
  # If player was moving last time
  if last_moving
    # Event determinant is via touch of same position event
    result = check_event_trigger_here([1,2])
    # If event which started does not exist
    if result == false
      # Disregard if debug mode is ON and ctrl key was pressed
      unless $DEBUG and Input.press?(Input::CTRL)
        # Encounter countdown
        if @encounter_count > 0
          @encounter_count -= 1
        end
      end
    end
  end
  # If C button was pressed
  if Input.trigger?(Input::C)
    # Same position and front event determinant
    check_event_trigger_here([0])
    check_event_trigger_there([0,1,2])
  end
end
  end
end
zum Lesen den Text mit der Maus markieren

Der Tag macht's wie immer kaputt, aber ist nun kleiner. Mit dem großen Klotz muss man das ganze Script austauschen, das Alias-Script hingegen kann man einfach i-wo über Main und unter Game_Player einfügen ;) Amsonsten habe ich erstmal noch keine Bugs gefunden.

P.S.: Für den Geschmack eines Ruby-Scripters zu viele "$" ;)
  • :medal: Werbung

    Bild

    Cpp Quellcode

    1
    
    #define TRUE FALSE //Happy debugging suckers
    (Einfach nur wundervoll.)
  • :palette: 1plus3 :cake:

    Bild
  • :fires: Nuuuhminaaah

    Bild
  • :medal: compétences

    mes compétences
    :heart_full: :heart_full: :heart_full: :heart_full: :heart_full: max.
    :ruler-triangle: Maps machen :heart_full: :heart-empty: :heart-empty: :heart-empty: :heart-empty:
    :media-player: Musik machen :heart_full: :heart-half: :heart-empty: :heart-empty: :heart-empty:
    :cup: Scripts machen :heart_full: :heart_full: :heart_full: :heart_full: :heart-break:
    :paper: Story ausdenken :heart_full: :heart_full: :heart_full: :heart-empty: :heart-empty:
    :cut: Pixeln und so :heart-empty: :heart-empty: :heart-empty: :heart-empty: :heart-empty:
    :game: Events proggen :heart_full: :heart_full: :heart_full: :heart_full: :heart_full:
    (Dieser Tab ist rein satirisch.)
  • :folder-open: mes projets

    • :addressbook: Silentium
      :book: Name: Silentium
      :rmxp: Maker: Eigenbau (C++, x86-SSE/AVX-Assembly, Ruby/Lua)

      :paper: Story
      :game: NPCs
      :cup: Scripts
      :drill: Ressis
      :ruler-triangle: Maps
      :compile: Gesamt
      (3+4)% 42 69% 0815 -17.438 103.38% ± 6.3mm²

      (Die Tabelle erfüllt lediglich satirische Zwecke.)
    • :compile: Onyx
      Eine in C++ implementierte, modulare, plattformunabhängige, virtuelle Maschine. Die Test-Version ist bereits halb fertig. Ab dann gibt es vielleicht mehr Infos. Sie soll die auf dem ersten Blick LISP-artige und eigens dafür konstruierte Sprache Obsidian ausführen können. Experimentell wird auch ein Lua-Compiler für Onyx gebaut. Ziel ist eine leistungsfähige, virtuelle Maschine für beliebige Scriptsprachen. Theoretisch gesehen müsste man bloß noch einen kompatiblen Compiler schreiben, der Quellcode jener Sprache in Onyx-Assembly, oder direkt in Onyx-Bytecode übersetzt. Ob die jemand nutzen wird, ist eine andere Frage und nur ein sekundäres... nein, eher tertiäres Ziel dieser VM. Primär dient es mir lediglich dazu, mein Verständnis von Hardware, ISA, und Assembly zu vertiefen, sowie eigene Grenzen auszutesten.

      :exclamation: Warnung!
      Das Entwickeln einer virtuellen Maschine oder Programmiersprache (im wahnsinnigsten Fall beides) ist eine höchst komplizierte Tätigkeit, aus der viel Frust und Hirnmatsche hervor gehen. Sollte sich dennoch ein ähnlich wahnsinniger finden, der sowas zusammen schustern will, so lege ich ihm/ihr die folgenden Bücher ans Herz:
      • Compiler - Das Drachenbuch [978-3-8273-7097-6]
        Dieses Buch schlachtet ausführlich und leicht verständlich die Grundlagen bis hoch zu den Experten-Techniken des Compilerbaus aus. Es fängt mit der Automaten-Theorie und formalen Sprachen an, arbeitet sich durch Analysetechniken vor, und landet schließlich bei Techniken wie Optimierung und Register-Zuweisung. Das Buch wiegt 3Kg oder 4Kg. Hab's mal gewogen. Ist also nicht gerade die Lektüre für unterwegs.

      • Computerarchitektur [3-8273-7016-7]
        Hier werden leicht verständlich die wichtigsten Entwicklungen der Rechnerarchitekturen erklärt (Gut, das Buch ist in die Jahre gekommen, aber der Weg zu heute ist ein winziger Schritt, den man sich nach diesem Buch selbst erdenken kann). Hauptbestandteil des Buchs ist eine relativ umfassende Betrachtung der Funktionsweise dreier gänzlich unterschiedlicher, aber dominierender Prozessor-Typen am Beispiel des Pentium II, UltraSPARC II, sowie picoJava. Die meisten Elemente dieses Buchs sind zwar für die Konstruktion einer virtuellen Maschine irrelevant, oder aufgrund der Tatsache, dass die VM Software ist und z.B. Byte-Grenzen hat, sogar zu Leistungseinbußen führen kann, doch ist ein hinreichendes Verständnis dieser Maschinen, mit denen wir arbeiten, äußerst hilfreich für die Überlegungen, wie die VM arbeiten soll.

      Es kann sehr hilfreich und inspirierend sein, den Code quelloffener, virtueller Maschinen anderer Sprachen zu überfliegen. Meine Lieblings-Quelle war und ist stets die VM von Lua. Sie ist schlank, verständlich, in C implementiert, und basiert im Gegensatz zu vielen anderen Scriptsprachen-VMs auf einer Register-Maschine statt einer Stapelmaschine. Es wäre natürlich vorteilhaft, die entsprechende Sprache zu verstehen, in der man auch die eigene VM implementieren will. Weiterhin ist es äußerst vorteilhaft, eine leistungsstarke und bequeme Sprache wie C++ zu beherrschen, um die VM zu implementieren. Und bevor irgendwer auf die Idee kommt: Assembly ist NICHT als dominierende Sprache für den Bau einer VM geeignet. Wer die Frage des "Warum?" nicht beantworten kann, sollte zunächst die gewählte Sprache und Assembly hinreichend verstehen lernen, und es dann erneut mit der Frage versuchen. Es lohnt sich dennoch, Assembly zu lernen. Allein schon, um erneut das Verständnis zu vertiefen, zumal ihr mehr oder weniger gezwungen seid, auch für eure VM eine Assembler-Sprache zu entwickeln (Außer natürlich ihr schreibt eure Test-Programme Bit für Bit ;3).
  • :locale: enfin

    Je ne peux pas parler français.
    C'est tout ce que Goodle et les restes de cours de français.
Signaturstand: 24.07.2013

Social Bookmarks