• Anmelden

1

Sonntag, 4. September 2011, 09:10

Teleport per Menüpunkt zum "Sphärobrett" des gewählten Charakters

Guten Morgen ,

Wie bereits in der Überschrift zu lesen suche ich eine Möglichkeit im Menü einen Charakter zu wählen und das man dann zu der jeweiligen Map des Charakters(seinem "Sphärobrett") wechseln kann.
Ich habe zwar selber schon ein bisschen rumprobiert , aber habe es bisher nur hingekriegt ,das man immer zu dem gleichem "Sphärobrett" teleportiert wird.Die X & Y Variablen sowie die MAP-ID , auf der ich mich zu dem Zeitpunkt befand habe ich gespeichert und kann mit einem weiteren auswählen des Menüpunkts wieder zu der normalen Map zurückwechseln.(wobei dann auch die X & Y variablen gespeichert werden , die man auf dem "Sphärobrett" hatte)

So wie ich mir das vorstelle sollte das aber so ablaufen :
Im Menü wählt man einen Charakter und teleportiert sich nun zu dem jeweiligen Sphärobrett
Wenn man nun zurück möchte in die normale Welt muss man nur den Menüpunkt erneut anwählen.
Dabei benutze ich auch einen Team-Change Script , sodass ich im Endeffekt nachher 6 verschiedene Charaktere habe (wovon aber nur 4 gleichzeitig im Team sind)

Ich hoffe , dass mir da jemand bei helfen kann.

MfG Tychondryus

2

Sonntag, 4. September 2011, 09:20

Wie sieht denn dein Menüscript aus? Benutzt du das Standardscript?

Und wie sehen deine eigenen Versuche aus? Vielleicht reicht es dir ein paar Tipps in die richtige Richtung zu geben, anstatt dir ein fertiges System vorzusetzen.

3

Sonntag, 4. September 2011, 10:15

Ich hab jetzt einfach mal den Teil von Scene_Menu genommen , den ich geändert hab , da hab ich am ende einfach mal in der Hoffnung , dasses funktioniert was eingefügt.
(Wollte dann halt wenn man den menüpunkt "Aufstiegsebene" auswählt , dass man dann noch einen Charakter dazu auswählt (also wie bei status screen , nur das halt kein statusscreen aufgerufen wird)und dann wollte ich vergleichen , welcher charakter gewählt wurde. Je nachdem welcher charakter gewählt wurde wird dann halt zum jeweiligen "Sphärobrett" geportet)
Das Problem (neben dem , dasses absolut unübersichtlich gestaltet ist :D ) ist , dass ich zwar bis zu der stelle komme , wo ich ein Teammitglied wählen kann ,aber weiterhin passiert nichts , weil @actor sich nicht ändert

Jo , da isser nun , der Chaos kram , den ich da zusammenkopiert und geschrieben hab
Ich weiß net ma , ob ihr da überhaupt noch hoffnung drin erkennt , aber deswegen frag ich ja auch nach :3


Spoiler: Code

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
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
when 5  # Aufstiegsebene
 
    	# Play decision SE
 
 
$game_system.se_play($data_system.decision_se)
 
 
 
 	# Make status window active
 
    	@command_window.active = false
 
    	@status_window.active = true
 
    	@status_window.index = 0
 
 
 
  	when 6 
# end game
 
    	# Play decision SE
 
 
$game_system.se_play($data_system.decision_se)
 
    	# Switch to end game screen
 
    	$scene = Scene_End.new
 
  	end
 
 
 
  end
 
  #--------------------------------------------------------------------------
 
  # * Frame Update (when status window is active)
 
 
#--------------------------------------------------------------------------
 
  def update_status
 
	# If B button was pressed
 
	if Input.trigger?(Input::B)
 
  	# Play cancel SE
 
 
$game_system.se_play($data_system.cancel_se)
 
  	# Make command window active
 
  	@command_window.active = true
 
  	@status_window.active = false
 
  	@status_window.index = -1
 
  	return
 
	end
 
	# If C button was pressed
 
	if Input.trigger?(Input::C)
 
  	# Branch by command window cursor position
 
  	case @command_window.index
 
  	when 1 
# skill
 
    	# If this actor's action limit is 2 or more
 
    	if $game_party.actors[@status_window.index].restriction >= 2
 
      	# Play buzzer SE
 
 
$game_system.se_play($data_system.buzzer_se)
 
      	return
 
    	end
 
    	# Play decision SE
 
 
$game_system.se_play($data_system.decision_se)
 
    	# Switch to skill screen
 
    	$scene =
Scene_Skill.new(@status_window.index)
 
  	when 2 
# equipment
 
    	# Play decision SE
 
 
$game_system.se_play($data_system.decision_se)
 
    	# Switch to equipment screen
 
    	$scene =
Scene_Equip.new(@status_window.index)
 
  	when 3 
# status
 
    	# Play decision SE
 
 
$game_system.se_play($data_system.decision_se)
 
    	# Switch to status screen
 
    	$scene =
Scene_Status.new(@status_window.index)
 
 	# ------------
 
    	when 5 # Aufstiegsebene
 
    	# Play decision SE
 
 
$game_system.se_play($data_system.decision_se)
 
    	# Switch to Aufstiegsebene
 
    	if
$game_switches[1] == true	# Checkt , ob man bereits in einer aufstiegsebene ist
 
      	$game_switches[1]= false
 
      	if $game_map.map_id ==
$game_variables[7]  	#bei der Ebene des Aufstiegs von Held 1
 
      	$game_variables[3]=$game_player.x
 
      	$game_variables[4]=$game_player.y
 
    	else
 
      	if $game_map.map_id ==
$game_variables[19]  	#bei der Ebene des Aufstiegs von Held 2   	
 
      	$game_variables[9]=$game_player.x
 
      	$game_variables[10]=$game_player.y
 
    	else
 
      	if $game_map.map_id ==
$game_variables[20]	#bei der Ebene des Aufstiegs von Held 3
 
      	$game_variables[11]=$game_player.x
 
      	$game_variables[12]=$game_player.y
 
    	else
 
      	if $game_map.map_id ==
$game_variables[21] 	#bei der Ebene des Aufstiegs von Held 4
 
      	$game_variables[13]=$game_player.x
 
      	$game_variables[14]=$game_player.y
 
    	else
 
      	if $game_map.map_id ==
$game_variables[22] 	#bei der Ebene des Aufstiegs von Held 5
 
      	$game_variables[15]=$game_player.x
 
      	$game_variables[16]=$game_player.y
 
    	else
 
      	if $game_map.map_id ==
$game_variables[23]  	#bei der Ebene des Aufstiegs von Held 6
 
      	$game_variables[17]=$game_player.x
 
      	$game_variables[18]=$game_player.y
 
      	end
 
end
 
end
 
end
 
end
 
end
 
#Teleport zurück zur normalen Map#
 
  	$game_temp.player_transferring = true
 
	        	# Trag die neuen Koordinaten hier ein: (oder $game_variables[x] wenn dus variabel willst)
 
	        	$game_temp.player_new_map_id = $game_variables[6]
 
	        	$game_temp.player_new_x = $game_variables[1]
 
	        	$game_temp.player_new_y = $game_variables[2]
 
	        	$game_temp.player_new_direction = 8
 
	        	# wenn du Übergang haben willst noch folgenden Code ergänzen
 
	        	# Prepare for transition
 
	        	Graphics.freeze
 
	        	# Set transition processing flag (using default transition)
 
            	$game_temp.transition_processing = true
 
	        	$game_temp.transition_name = ""
 
	        	$scene = Scene_Map.new
 
 
 
	else
 
 
 
  	$game_variables[1]=$game_player.x #x Position des Spielers auf der norm. Map
 
  	$game_variables[2]=$game_player.y #y Position des Spielers auf der norm. Map
 
  	$game_variables[6]=$game_map.map_id# Map ID speichern
 
 
 
  	@actor =
$game_party.actors[@actor_index]  #Actor finden
 
 
 
  	if @actor == [1]                        	#wenn Actor 1
 
      	$game_temp.player_transferring = true
 
	        	#Trag die neuen Koordinaten hier ein: (oder $game_variables[x] wenn dus variabel willst)
 
	        	$game_temp.player_new_map_id = $game_variables[7]   # Teleport zur Aufstiegsebene 1
 
	        	$game_temp.player_new_x = $game_variables[3]
 
	        	$game_temp.player_new_y = $game_variables[4]
 
	        	$game_temp.player_new_direction
= 8
 
	        	# wenn du Übergang haben willst noch folgenden Code ergänzen
 
	        	# Prepare for transition
 
	        	Graphics.freeze
 
	        	# Set transition processing flag (using default transition)
 
	        	$game_temp.transition_processing = true
 
	        	$game_temp.transition_name = ""
 
	        	$scene = Scene_Map.new
 
  	else
 
	if @actor == [2]                         	#wenn Actor 2
 
      	$game_temp.player_transferring = true
 
	        	# Trag die neuen Koordinaten hier ein: (oder $game_variables[x] wenn dus variabel willst)
 
	        	$game_temp.player_new_map_id = $game_variables[19]   # Teleport zur aufstiegsebene 2
 
	        	$game_temp.player_new_x = $game_variables[3]
 
	        	$game_temp.player_new_y = $game_variables[4]
 
	        	$game_temp.player_new_direction = 8
 
	        	# wenn du Übergang haben willst noch folgenden Code ergänzen
 
	        	# Prepare for transition
 
	        	Graphics.freeze
 
	        	# Set transition processing flag (using default transition)
 
	        	$game_temp.transition_processing = true
 
	        	$game_temp.transition_name = ""
 
	        	$scene = Scene_Map.new
 
 
 
  	end
 
  	return
 
	end
 
  end
 
end
 
end
 
end
 
end
 
end
 
zum Lesen den Text mit der Maus markieren

4

Montag, 5. September 2011, 13:51

Du hast das Menüsystem schon ganz richtig durchschaut.
Beim Drücken der Actionstaste (Input::C) wird geguckt, auf welcher Position der Cursor steht und dementsprechend gehandelt. Der Wechsel zur Charakterauswahl stimmt schonmal, aber dann wird es konfus.

Erst nach neuformatieren des Codes habe ich durchgeblickt ^^"

Falls der Spieler schon auf einer LevelMap ist (dies gibt ein Switch an) so wird die Position auf dieser Map in zwei Spielvariablen gespeichert, wobei jede LevelMap ihr eigenes Paar hat. Dieser Prozess könnte der übersichtshalber ausgelagert werden. Da du ausserdem eine Fallunterscheidung je nach Wert einer Variable (der MapID) machst, bietet sich eine case-Struktur an.
Eine einfache Methode könnte dann so aussehen:

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
  #--------------------------------------------------------------------------
  # * Speichere in SpielVariablen die Position auf der jeweiligen LevelMap
  #--------------------------------------------------------------------------
  def save_position_on_levelmap
    # Fallunterscheidung je nach MapID
    case $game_map.map_id
    when $game_variables[7]   # bei der Ebene des Aufstiegs von Held 1
      $game_variables[ 3] = $game_player.x
      $game_variables[ 4] = $game_player.y
    when $game_variables[19]  # bei der Ebene des Aufstiegs von Held 2
      $game_variables[ 9] = $game_player.x
      $game_variables[10] = $game_player.y
    when $game_variables[20]  # bei der Ebene des Aufstiegs von Held 3
      $game_variables[11] = $game_player.x
      $game_variables[12] = $game_player.y
    when $game_variables[21]  # bei der Ebene des Aufstiegs von Held 4
      $game_variables[13] = $game_player.x
      $game_variables[14] = $game_player.y
    when $game_variables[22]  # bei der Ebene des Aufstiegs von Held 5
      $game_variables[15] = $game_player.x
      $game_variables[16] = $game_player.y
    when $game_variables[23]  # bei der Ebene des Aufstiegs von Held 6
      $game_variables[17] = $game_player.x
      $game_variables[18] = $game_player.y
    else
      msg = 'Fehler in der Methode "save_position_on_levelmap"\n'
      msg+= 'die MapID %03d entspricht keiner der Variablen.'%$game_map.map_id
      print(msg)
    end
  end

Im Übrigen kannst du allen Code den du fast 1:1 mehrfach drin hast, auslagern. Zum Beispiel der Teleport - lagere ihn einfach in eine Methode aus, die als Parameter die entsprechenden Werte bekommt.
Zum Beispiel so:

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  #--------------------------------------------------------------------------
  # * Teleportiere den Spieler auf eine Map und Position
  #     varid_map : Die ID der Spielvariable, die die MapID speichert
  #     varid_x   : Die ID der Spielvariable, die die X Position speichert
  #     varid_y   : Die ID der Spielvariable, die die Y Position speichert
  #     dir       : [optional] Die Ausrichtung des Players nach dem transfer
  #--------------------------------------------------------------------------
  def tranfer_appoint_with_variables( varid_map, varid_x, varid_y, dir=8 )
    $game_temp.player_transferring  = true        # Teleport-Flag setzen
    # Neue Map und Position setzen
    $game_temp.player_new_map_id    = $game_variables[varid_map]
    $game_temp.player_new_x         = $game_variables[varid_x  ]
    $game_temp.player_new_y         = $game_variables[varid_y  ]
    $game_temp.player_new_direction = dir         # Ausrichtung setzen
    Graphics.freeze                               # Überblenden vorbereiten
    $game_temp.transition_processing= true        # Überblenden-Flag setzen
    $game_temp.transition_name      = ""          # effektloser Wechsel
    $scene = Scene_Map.new                        # wieder zur Map wechseln
  end

Dadurch wird dein Code schonmal übersichtlicher und kürzer.

Aber nun zu deinem Problem:
Du verwendest um an den ausgewählten Actor zu kommen diesen Befehl:

Ruby Quellcode

1
@actor = $game_party.actors[@actor_index]  #Actor finden

Nur ist die Variable @actor_index gar nicht initialisiert? Wenn du an den Actor ranwillst, müsstest du das so machen:

Ruby Quellcode

1
@actor = $game_party.actors[@status_window.index]

Allerdings ist es nicht nötig eine Instanzvariable zu verwenden, eine lokale reicht völlig (also ohne at-Zeichen).
Danach machst du wieder eine Fallunterscheidung mit ifs, auch hier wäre wieder ein case Block (meiner Meinung nach) besser/übersichtlicher.
Seltsam ist aber deine Abfrage. Du fragst ab, ob der Actor gleich einem Array ist, indem jeweils eine Zahl ist - warum? Das macht überhaupt keinen Sinn.
Vermutlich willst du abfragen, ob der Actor gleich dem Actor aus der DB mit dem Index so und so ist.
Nun, das geht einfacher: Jeder Actor hat eine ID (die gleich seinem Index in der Database ist). Die kannst du abfragen. Verwende einfach wieder einen case Block zur Fallunterscheidung, und teste die ActorID.
Du kommst dran mit actor.id also

Ruby Quellcode

1
2
3
4
5
6
7
8
          actor = $game_party.actors[@status_window.index]  #Actor finden
          case actor.id
          when 1 # wenn Actor#1
            game_temp.player_transferring = true
            #Trag die neuen Koordinaten hier ein: (oder $game_variables[x] wenn dus variabel willst)
            $game_temp.player_new_map_id = $game_variables[7]   # Teleport zur Aufstiegsebene 1
            $game_temp.player_new_x = $game_variables[3]
# ...

Dein Codeausschnitt könnte also so aussehen:

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
      when 5 # Aufstiegsebene
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to Aufstiegsebene
        if $game_switches[1] # Checkt , ob man bereits in einer aufstiegsebene ist
          $game_switches[1] = false
          # Speichere die Position auf der jeweiligen Levelmap
          save_position_on_levelmap
          # Teleport zurück zur normalen Map
          tranfer_appoint_with_variables( 6, 1, 2 )
        else
          $game_variables[1]=$game_player.x  # x Position des Spielers auf der norm. Map
          $game_variables[2]=$game_player.y  # y Position des Spielers auf der norm. Map
          $game_variables[6]=$game_map.map_id# Map ID speichern
          actor = $game_party.actors[@status_window.index]  #Actor finden
          case actor.id # Prüfe die Position des Actors in der DB (nicht in der Party)
          when 1 # wenn Actor#1
            tranfer_appoint_with_variables( 7, 3, 4 )
          when 2 # wenn Actor#3
            tranfer_appoint_with_variables(19, 9, 10 )
          when 3 # wenn Actor#3
# ...

Fehlt da nicht ein aktivieren des Switchs#1? Naja .-. ich habe es nicht ausprobiert, sieht aber ganz gut aus so.

Dein Fehler war halt eine fehlerhafte Ermittlung der Actorauswahl, sowie eine folgende falsche Abfrage.

Falls du gerne die Programmiersprache Ruby lernen möchtest, im Scientia Wiki gibt es ein sehr gutes Tutorial von Kai was einen leichten Einstieg in Ruby und das RGSS gibt. (Damit habe ich damals angefangen) Deine Ansätze sind schonmal ganz gut, vielleicht stellst du ja schon bald ein paar feine Menüsysteme in unserer ScriptDB zur Verfügung Bild

5

Montag, 5. September 2011, 17:01

Thx , funzt super , das einzige Problem is jetzt , dass wenn ich in der aufstiegsebene bin und zurück will erstmal im menü noch einen charakter auswählen muss (was ja in dem Fall egal ist , weil ich ja nur wieder zurück zu normalen Map möchte)
Da müsste ich doch eigentlich nur an der stelle ,wo er mich zum charakter auswählen bringt erstmal fragen , ob ich bereits in der aufstiegsebene bin oder nicht?

6

Montag, 5. September 2011, 17:18

Ja, die Abfrage des Switchs wäre in der Tat in der Methode update_command besser aufgehoben.

Social Bookmarks