Share
Realizzare giochi prototipo rapidi e semplici è un ottimo modo per testare rapidamente nuove idee di gioco, senza impegnarsi a creare un gioco in piena regola. Mi piace usare Game Maker per questo, e in questo post condividerò uno di questi giochi con te: Trainpunk, un gioco di strategia basato sul treno.
Nota dell'editore: Questo è un nuovo tipo di post che non abbiamo mai provato prima. Fateci sapere cosa ne pensate e se vorreste vedere post simili in futuro!
Ecco un video di me che abbozza il concetto originale per il gioco, e quindi di me stesso che interpreta il gioco prototipo stesso:
Mi piacerebbe mostrarmi a disegnare l'arte, ma è così semplice che non c'è una vera ragione per farlo.
Nel gioco finale, due squadre di treni cercano di attaccare la base nemica mentre vengono colpite dalle torrette. Si gioca applicando gli aggiornamenti usando i pulsanti in basso.
Si prega di scaricare il gioco finale (oltre al codice sorgente e sprite) e modificare il gameplay quanto volete! Avrai bisogno di una copia di Game Maker 8.
Ecco uno schema approssimativo dei passaggi che ho preso per costruire il gioco. Potresti seguire da capo, o usarlo per capire meglio l'intera fonte.
Scarica Game Maker 8 e aprilo.
Crea un nuovo GIOCO oggetto, con queste proprietà:
Accentsconagua
"No sprite" falso vero -999 vero (nessun genitore) (uguale a sprite) Dagli questi eventi:
#Create Event: execute code: alarm [0] = 150; # Evento di allarme per allarme 0: codice di esecuzione: allarme [0] = 150; global.points + = 1; global.pointsB + = 1,25; #Step Event: codice di esecuzione: if! Instance_exists (oUpgradeHP) if! Global.points = 0 global.points - = 1; instance_activate_object (oUpgradeHP); instance_activate_object (oUpgradeRA); instance_activate_object (oUpgradeSS); instance_activate_object (oUpgradeAS); if! global.pointsB = 0 ID = scegli (1,2,3,4); // if ID = 1 global.hp2 + = 1; if ID = 2 global.ra2 + = 4; if ID = 3 global.ss2 + = 1; if ID = 4 global.as2 = global.as2 / 1.1; // global.pointsB - = 1; if! instance_exists (oTurretA) instance_deactivate_all (true); il sonno (500); game_restart (); if! instance_exists (oTurretB) instance_deactivate_all (true); il sonno (500); game_restart (); #Other Event: Game Start: codice di esecuzione: // Train Team A global.hp1 = 5; // Health Points global.ra1 = 64; // Range global.ss1 = 6; // Shoot Speed global.as1 = 30; // Velocità d'attacco // Train Team B global.hp2 = 5; // Health Points global.ra2 = 64; // Range global.ss2 = 6; // Shoot Speed global.as2 = 30; // Attack Speed global.points = 1; global.pointsB = 1; room_goto_next (); #Draw Event: execute code: draw_set_color (c_black); draw_set_font (font0); // draw_text (x + 4, y + 4, "TEAM [PLAYER] - HP =" + stringa (global.hp1) + "- RA =" + stringa (global.ra1) + "- SS =" + stringa ( global.ss1) + "- AS =" + string (global.as1)); draw_text (x + 4, y + 18, "TEAM [ENEMY_] - HP =" + stringa (global.hp2) + "- RA =" + stringa (global.ra2) + "- SS =" + stringa (globale. ss2) + "- AS =" + stringa (global.as2));
Crea un altro nuovo oggetto, _Bloccare, e renderlo solido. È solo per l'aspetto - non fa molto se stesso.
Crea un altro nuovo oggetto, chiamato _BaseA, con queste proprietà:
_BaseA vero vero -1 falso (nessuna) (nessuna) Lo sprite è solo un blocco 16x16. Ora, dagli questi eventi:
#Create Event: execute code: hp = 100; #Step Event: codice di esecuzione: se hp < 0.9 instance_destroy();
Ecco un'immagine del gioco finale, per riferimento:
Questa volta, crea un nuovo oggetto per rappresentare uno dei treni del giocatore (un rettangolo bianco sulle tracce). Chiamalo _TrainA e dargli queste proprietà:
_TrainA falso vero 0 falso _BaseA (nessuna) Lo sprite dovrebbe essere un treno 16x16, rivolto verso destra. Dare all'oggetto questi eventi:
#Create Event: execute code: // Train Team A // Imposta le statistiche sulle variabili globali decise dagli aggiornamenti. hp = global.hp1; // Punti salute ra = global.ra1; // Range ss = global.ss1; // Shoot Speed as = global.as1; // Direzione velocità d'attacco = 360; velocità = 2; # Evento di allarme per allarme 0: uscita da questo evento #Step Event: codice di esecuzione: n = instance_nearest (x, y, oBaseB); se distance_to_point (n.x, n.y) < ra if alarm[0] < 1 i=instance_create(x,y,oBulletA); i.speed = ss; alarm[0] = as; speed = 0; else speed = 2; if hp < 0.9 instance_destroy(); /* hp = global.hp1; // Health Points ra = global.ra1; // Range ss = global.ss1; // Shoot Speed as = global.as1; // Attack Speed */
Ora faremo le torrette del giocatore. Crea un nuovo oggetto chiamato _TurretA, e dargli queste proprietà:
_TrainA falso vero 0 falso oBaseA (nessuna) Ho usato lo stesso sprite del treno del giocatore, qui, ma sentitevi liberi di cambiarlo in una torretta reale. Dovrebbe essere 16x16px. Aggiungi gli eventi:
#Create Event: execute code: hp = 25; // Punti salute ra = 128; // Range ss = 15; // Scatta velocità come = 20; // Attack Speed # Alarm Event for alarm 0: exit this event #Step Event: codice di esecuzione: n = instance_nearest (x, y, oBaseB); se distance_to_point (n.x, n.y) < ra if alarm[0] < 1 i=instance_create(x,y,oBulletA); i.speed = ss; alarm[0] = as; if hp < 0.9 instance_destroy();
Le torrette devono sparare ai proiettili, quindi crea un nuovo oggetto per rappresentarli. Chiamalo oBulletA, e dargli queste proprietà:
_BulletA // Un sottile falso vero 1 falso (nessun genitore) (uguale a sprite) Lo sprite dovrebbe essere un proiettile sottile (1px di altezza per 16px di larghezza, all'interno di un quadrato trasparente 16x16px), rivolto verso destra. Ecco i suoi eventi:
#Create Event: execute code: n = instance_nearest (x, y, oBaseB); direction = point_direction (x, y, n.x, n.y); #Step Event: codice di esecuzione: image_angle = direction; #Collision Event con oggetto o_Block: distrugge l'istanza #Collision Event con oggetto oBaseB: execute code: #instance_destroy (); other.hp - = 1;8. Crea un nuovo oggetto (oSpawnerA)
Informazioni sull'oggetto: oSpawnerA Sprite: _TrainA // Ancora usando il treno sprite Solido: falso Visibile: falso Profondità: 0 Persistente: falso Parent:Maschera: Crea evento: codice di esecuzione: allarme [0] = 180; instance_create (x, y, oTrainA); Evento di allarme per allarme 0: codice di esecuzione: allarme [0] = 180; instance_create (x, y, oTrainA);
Quando il giocatore può aggiornare i propri HP, il pulsante relativo si illumina:
Creeremo questo pulsante ora. Crea un nuovo oggetto chiamato oUpgradeHP, e dargli queste proprietà:
_UpgradeHP falso vero -99 falso (nessun genitore) (uguale a sprite) Dagli anche questi eventi:
#Create Event: execute code: image_alpha = 0.5; Evento del mouse per il rilascio a sinistra: codice di esecuzione: global.hp1 + = 1; instance_deactivate_object (oUpgradeHP); instance_deactivate_object (oUpgradeRA); instance_deactivate_object (oUpgradeSS); instance_deactivate_object (oUpgradeAS); Evento del mouse per il mouse Invio: codice di esecuzione: image_alpha = 1; Mouse Event per mouse Leave: codice di esecuzione: image_alpha = 0.5;
Duplicare oUpgradeHP tre volte in modo da avere quattro oggetti: un pulsante ciascuno per l'aggiornamento di HP, RA, SS e AS. (oUpgradeHP, oUpgradeRA, oUpgradeSS, oUpgradeAS).
Cambiare il Sinistra Rilasciata codice dell'evento per ciascuno:
oUpgradeHP -> global.hp1 + = 1; oUpgradeRA -> global.ra1 + = 4; oUpgradeSS -> global.ss1 + = 1; oUpgradeAS -> global.as1 = global.as1 / 1.1;
Duplicare oBaseA, oTrainA, oTurretA, oSpawnerA e oBulletA creare oBaseB, oTrainB, oTurretB, oSpawnerB e oBulletB.
Cambia i loro genitori (da "A" a "B") e cambia tutto il loro codice da:
n = instance_nearest (x, y, oBaseB);
… a:
n = instance_nearest (x, y, oBaseA);
… come richiesto.
Imposta anche oTrainB direzione = 180; nell'evento create, invece di direction = 360;. Infine, scegli gli sprite rivolti a sinistra per ciascuno, se necessario.
Aggiungi tutti i tuoi tileset, sprite, art e così via e crea due nuove stanze: una è rm_intro, dove dovresti solo mettere il obj_Game, e l'altra è la stanza principale (rm_main).
Costruisci il tuo rm_main così:
Potresti provare a simulare la stanza in modo che sia un po 'equa, o posizionare più torrette sul lato nemico per un gameplay più duro. Dipende da te: l'intero punto di un prototipo è testare le cose!
Ora gioca. Mentre giochi, considera ciò che deve cambiare. I treni dovrebbero essere più veloci o più lenti? Gli aggiornamenti dovrebbero venire più frequentemente? Il computer dovrebbe avere un vantaggio ingiusto? Il giocatore dovrebbe avere più input oltre all'applicazione degli aggiornamenti? Allontanare!
Spero che tu abbia imparato qualcosa sul fare giochi, ma soprattutto, spero che tu abbia imparato come qualsiasi idea può essere rapidamente sfondata in un prototipo.
Nota dell'editore: Questo è un nuovo tipo di post che non abbiamo mai provato prima. Fateci sapere cosa ne pensate! C'è qualcosa che vorresti vederci fare diversamente con il formato in futuro? Volete maggiori dettagli nel video o una serie più completa di istruzioni per la costruzione del gioco?
