Nuförtiden är det väldigt svårt att hitta en person som inte har spelat mobilspel, kom ihåg åtminstone den klassiska "Snake". Men har du någonsin tänkt på att skapa ditt eget spel, där det kommer att finnas dina egna hjältar, uppfunna bara av dig?
För att börja skapa även det enklaste mobilspel du behöver ha vissa färdigheter. Vad exakt krävs?
- Du måste tänka över manuset, kanske till och med skriva det, visa det för vänner eller familj. När allt kommer omkring, vad är poängen med att börja skapa om det inte finns någon handling ännu?
- Jag vill genast notera att att skapa ett spel utan programmeringskunskaper är en ganska lång, komplicerad och tråkig process. Även om, med kunskapen om det senare, ingenting kommer att förändras mycket, kommer processen inte att bli roligare. Ha tålamod!
- Och slutligen behöver du programvara, eller snarare en speldesigner, kanske till och med mer än en. Vilken man ska välja kommer jag att berätta nedan.
Vad är en konstruktör och hur väljer man rätt?
Detta är ett program som skapades för att göra livet enklare för användarna. Men det har också ett syfte till - designern ska ge möjligheten att skapa applikationer inte bara för personer med vissa programmeringskunskaper, utan också för dem som inte har en aning om vad det är. Det vill säga, med hjälp av designern kan vem som helst skapa sitt eget spel.
Hur väljer man rätt designer? Konstigt nog, men du måste börja välja det och fokusera främst på dina kunskaper - från programmeringsfärdigheter till färdighetsnivån engelska språket. Om din första poäng är noll, så rekommenderar jag att du väljer program för nybörjare, de är lättare att använda. Det andra urvalskriteriet är den nödvändiga funktionaliteten. Det är här vi behöver vårt exakt komponerade manus, vi måste läsa det igen "från pärm till pärm" och förstå hur svårt det framtida spelet kommer att bli. Ju mer komplext projektet är, desto fler "prylar" kommer du att behöva använda, vilket innebär att designern måste vara mer kraftfull och mer professionell.
Nedan kommer jag att ge några exempel på de vanligaste konstruktörerna som proffs ger råd till nybörjare.
Konstruera 2
Denna applikation har välförtjänt inkluderats i TOPPEN av listan över mjukvarukonstruktörer i många år i rad, eftersom den gör det möjligt att skapa spel för nästan alla möjliga plattformar och i alla genrer. Construct-gränssnittet är så enkelt som möjligt, men det finns ingen russifiering ännu. En uppsättning verktyg som är tillräckliga för att skapa alla tvådimensionella spel. Ett annat plus är att det inte är nödvändigt att köpa en licens för programmet, du klarar dig enkelt med den funktionalitet som erbjuds i gratisversionen.
Ladda ner: Konstruera 2
Videosjälvstudier om Construct 2
Stencyl
Denna byggare är också designad för nybörjare som inte förstår programmering. Det är perfekt för att skapa enkla 2D-spel och kommer att ge en möjlighet att starta ett projekt med ett anständigt grafiskt gränssnitt.
Dessutom, om du fortfarande har åtminstone viss kunskap inom programmeringsområdet, kommer Stencyl att ge dig möjligheten att skriva din egen kod i blocken. En uppsättning verktyg låter dig skapa spel av nästan vilken genre som helst, men funktionaliteten är mer anpassad för att skapa "shooters".
Programmet är gratis, men om du vill konvertera din skapelse till format som den "förstår" Personlig dator, då måste du köpa ett licensierat abonnemang, och detta är utan tvekan ett minus, eftersom detta abonnemang inte är billigt, det kostar nästan 100 $ per år. Tja, om du i framtiden ser dig själv som en professionell skapare av mobilspel, gör dig redo att betala $ 200 per år, det här är hur mycket programmet kommer att kosta med möjligheten att spara projektet i formatet av mobila operativsystem.
Ladda ner: Stencyl
Videohandledning om Stencyl
Unity 3D
Jag tror att många människor har hört detta namn och sett den här logotypen på skärmarna på sina mobila enheter. Saken är att företaget som producerar mjukvara för att skapa spel också är engagerat i släppandet av applikationer av sin egen design.
Unity 3D är den mest kraftfulla byggaren för att skapa 3D-applikationer. Nivån som du kan ta ditt projekt till är anständig (titta bara på skärmdumpen ovan). Det här är inte en bearbetad bild, utan en riktig skärmdump av ett spel som ännu inte är färdigt! Håller med, när det gäller ett mobilspel är detta en mycket hög nivå.
Men ett sådant resultat kräver redan vissa färdigheter. Även om programmet är placerat som en applikation för nybörjare, är det snarare utformat för amatörer och proffs, för att arbeta med det behöver du grundläggande kunskap programmering och 3D-modellering. Och naturligtvis, i Unity kan du skapa ett projekt av vilken komplexitet och vilken genre som helst, uppsättningen verktyg är helt enkelt enorm.
Ladda ner: Unity 3D
Videohandledning om Unity 3D
Hur använder man konstruktörer?
Det finns inga specifika instruktioner för att skapa ett spel. Allt beror på vilken genre du väljer, dina färdigheter och, naturligtvis, på vilket program du ska göra allt detta med. I detta avseende rekommenderar jag att du, som ett startprojekt, försöker göra något som redan har gjorts av mer erfarna personer, YouTube för att hjälpa. Detta kommer att hjälpa dig att bli bekväm i spelutvecklingsmiljön, förstå hur de viktigaste verktygen fungerar och eventuellt ändra scenariot för din utveckling.
När du gör ett "prov"-projekt och bestämmer dig exakt på egen hand, välj ett program och leta sedan på Internet efter videor om konstruktören som du ska använda.
Var inte rädd för att experimentera, leta efter information på Internet och försök. Endast på detta sätt kommer du att lära dig och utvecklas. Lycka till med ditt mästerverk.
Instruktion
Välj den plattform som ditt spel ska användas för. Eftersom marknaden för mobila operativsystem är mycket varierande, och varje system har sina egna funktioner för att skapa applikationer. De mest populära just nu är: iOS-system, Android, Symbian OS och Windows-telefon 7. Windows Phone 7 är det bästa operativsystemet att börja med. Det har en bekväm utvecklingsmiljö som stöder olika teknologier som XNA och Silverlight.
Lär dig ett programmeringsspråk. Detta stora scenen när du skapar något program. Och ju fler programmeringskunskaper, desto fler möjligheter att implementera idéer. Ett av de kraftfulla men lättlärda programmeringsspråken är C#. Designad av Microsoft som ett alternativ till Java-språket har detta språk stor potential.
Kom med din idé till ett spel. Skriv ner på ett papper eller i ett separat dokument allt du vill implementera i ditt spel. Men överväg dina alternativ. Inget behov av att göra planer som är svåra att genomföra. Tänk på alla punkter och lyft fram bland dem de som du inte kan utföra utifrån dina kunskaper. För att lösa svåra problem, registrera dig på utvecklarforum. Där kan du alltid ställa en fråga till mer erfarna programmerare.
Installera utvecklingsmiljön. För att skapa spel för Windows Phone 7 behöver du Visual Studio 2010 och Windows Phone Developer Tools. Båda produkterna är helt gratis.
Börja utveckla ditt spel. Bestäm vilken typ av projekt, ytterligare tekniker och klasser. Bestäm omedelbart typen av spelkontroll. Kanske kommer dessa att bli det enkla klick som involverar en eller båda händerna. Eller så kanske olika positionssensorer och en kamera är inblandade. Tänk på spelets logik och dess implementering.
Kom in i speldesign. En del av applikationens innehåll såsom: texturer, bilder, typsnitt och ljud kan hittas på Internet. Du kan rita resten själv eller fråga någon annan.
Börja testa spelet. Detta sista steget applikationsutveckling. Skapa tester för applikationslogiken och spåra fel som uppstår. Försök att hålla deras antal till ett minimum.
Om spelet är klart, publicera det. Lägg upp det Fri tillgång eller registrera dig i appbutiken och försök tjäna pengar på det. Överge inte ditt idébarn, utan försök stödja det genom att förbättra och introducera något nytt.
Relaterade videoklipp
Källor:
- Allt för att skapa spel
- onlinespel på telefonen
Spel för telefoner skapas av utvecklaren, som vanligtvis representeras av företaget. Men det finns också fall då en person är engagerad i en sådan process.
Instruktion
Bestäm vilket mobiloperativsystem som spelet ska designas för. Faktum är att det idag i världen inte finns någon mobil plattform, som undertrycker dess kvantitativa majoritet (till exempel som datorer, där Windows utan tvekan är i täten). Varje tillverkare marknadsför något annat, och som ett resultat har marknaden ett tiotal operativsystem. De mest använda operativsystemen är Android, Symbian OS, iOS och Windows Phone 7.
I början måste du utveckla spelet för en av dessa plattformar, och först efter det måste du göra om (porta) spelet för andra. En sådan process är inte trivial och kräver ett djärvt tillvägagångssätt, eftersom ibland är skillnaden mellan plattformar ganska betydande.
Lär dig ett programmeringsspråk. Programmering är den viktigaste delen i skapandet av alla datorprogram, och programmeraren är dess huvudskapare, och nivån på hans professionalism är direkt proportionell mot framgången för det framtida spelet.
Java är det perfekta språket för utveckling för mobila enheter. Det kommer att vara svårt för nybörjare att förstå dess grunder. Det blir mer korrekt och lättare att börja med grunderna i programmering, först ha behärskat Läroplanen informatik.
Skapa en idé för ett framtida spel. Skapa ett speciellt dokument där du beskriver allt som har med projektet att göra, men utan fanatism. Du behöver inte göra storslagna planer, men du måste ändå göra dem till verklighet genom att tillämpa dina programmeringskunskaper. Tänk igenom konceptet, kom ihåg litteraturen om programmering, tänk på allt från en logisk synvinkel.
Denna handledning startar en serie artiklar om att skriva arkadspel för Android. Cykeln togs som grund, som han skrev och publicerade på sin blogg Tamas Jano. Materialet riktar sig i första hand till nybörjare som vill prova på att skapa spel för Android. Jag satte mig som mål att på vår webbplats skapa den mest begripliga och lättillgängliga läroboken för en ung rysktalande publik, så jag hoppas verkligen på din kritik, frågor och kommentarer. Materialet som publiceras i denna cykel kommer ständigt att revideras med hänsyn till dina frågor, önskemål och kommentarer. Jag hoppas att vi tillsammans kan framgångsrikt genomföra detta lilla experiment.
Alexander Ledkov
Idé och arkitektur
Innan vi går vidare direkt till programmering, låt oss definiera våra uppgifter och beskriva dem i generella termer vårt framtida spel. Tanken är enkel: huvudkaraktär slåss mot horder av robotar som vill förgöra honom. Han har tre liv och en laserpistol. Robotar kan inte skjuta. Allt de kan göra är att fånga vår hjälte och slita av honom huvudet... ja, eller något annat. Karaktären styrs med två "touch joysticks" Du har förmodligen träffat dem i liknande spel. En joystick kommer att placeras i det nedre vänstra hörnet, som är ansvarig för att flytta hjälten. I det nedre högra hörnet - för vapnet.
Låt oss simulera en spelsituation. Vår karaktär är i mitten av skärmen. Robotarna kommer närmare honom var 1/10:e sekund. var tionde sekund kontrollerar vi även om skärmen har berörts. Om det hände flyttar vi vår karaktär i önskad riktning eller gör ett skott. om skottet avlossas kontrollerar vi varje bock (1/10 av en sekund) för att se om kulan träffar fienderna. Om kulan träffar roboten exploderar både roboten och kulan, om inte flyttar sig robotarna och kulan till nya positioner (roboten flyttar sig 5 pixlar per bock och kulan rör sig 50 pixlar). Vi kollar också om roboten har fångat vår hjälte. Om du fångas så slutar spelet.
I det enklaste fallet kan spelarkitekturen representeras som följande moduler, som kallas cykliskt:
- kontrollmodul. Här läses koordinaterna för beröring av skärmen.
- Spelmotor. Här måste vi uppdatera tillståndet för spelobjekt, det vill säga beräkna deras nya koordinater, kontrollera hälsa, kollisioner och liknande.
- Ljudmodul.
- Grafisk modul. Här på grundval nuvarande tillstånd en ny ram bildas och visas på skärmen.
Låt oss ta en närmare titt på våra moduler.
kontrollmodul
I vårt spel genereras meddelanden när användaren rör vid två områden på skärmen. Programmet lyssnar efter onTouch-händelser och registrerar koordinaterna för varje beröring. Om koordinaterna är inom kontrollområdet skickar vi motsvarande kommando till spelmotorn. Till exempel, om det fanns en beröring på sidan av cirkeln, måste vi flytta vår karaktär i rätt riktning. Om det fanns en beröring av cirkeln som styr vapnet, skickar vi ett kommando till motorn för att bearbeta skotthändelsen.
Spelmotor
Spellogikmodulen är ansvarig för att ändra tillstånden för alla spelkaraktärer, med vilket jag menar varje objekt som har ett tillstånd (Vår hjälte, robotar, laserskott). 
Låt oss titta på interaktionen mellan kontrollmodulen och spelmotorn. Bilden ovan visar en cirkelkontroller. Den ljusgröna fläcken symboliserar beröringsområdet. Kontrollmodulen berättar för spelmotorn koordinaterna för beröringen (dx och dy är avstånd i pixlar från cirkelns mitt). Baserat på dessa koordinater spelmotor beräknar riktningen och hastigheten för vår hjältes rörelse. Till exempel, om dx>0, flyttas vår karaktär till höger, om dy>0 - till toppen.
Ljudmodul
Denna modul styr uppspelningen av ljud beroende på spelsituation. Ljud kan genereras av olika spelobjekt, men eftersom antalet ljudkanaler är begränsat (antalet ljudkanaler motsvarar antalet ljudfiler som kan spelas samtidigt) måste ljudmodulen bestämma vilka ljud som ska spelas upp och vilka inte. Till exempel utgör en robot en enorm fara för vår hjälte, så vi måste fästa spelarens uppmärksamhet på dess utseende, till exempel slå på ljudet av en siren, och naturligtvis måste vi helt enkelt uttrycka alla skott av vår karaktär.
Grafisk modul
Denna modul är ansvarig för att visa spelsituationen på telefonskärmen. I Android finns det flera sätt att rendera en bild på skärmen. Du kan rita direkt på duken som tas emot från vyn, eller använda en separat grafikbuffert och du, och sedan skicka den till vyn, eller så kan du använda funktionerna i OpenGL-biblioteket. Det är användbart när man utvecklar ett spel att hela tiden mäta FPS – antalet bilder per sekund som din grafikmotor producerar. Ett värde på 30 FPS betyder att vårt program på en sekund lyckas uppdatera skärmen 30 gånger. När vi ser framåt kommer jag att säga att för en mobil enhet är 30 FPS mer än en anständig indikator.
Vi skapar ett utkast till ett projekt för ett framtida Android-spel
Jag kommer inte att beskriva processen i detalj här. Android installationer SDK och Eclipse, jag lämnar de elementära stegen för att skapa ett Android-projekt utanför berättelsens omfattning. Ligger på Internet stor mängd lektioner och artiklar om detta ämne.
Skapa nytt projekt. Ange i fältet Projektnamn Droidz. Välj Android 2.2 eller senare som målplattform. I paketnamn - " en.mobilab.gamesample". Glöm inte att markera rutan bredvid Skapa aktivitet. För namnet på huvudaktiviteten anger du DroidzActivity.
Öppna filen src/ru.mobilab.gamesample/DroidzActivity.java
importera android.app.Activity;
importera android.os.Bundle;
public class DroidzActivity utökar Activity(
/** Anropas när aktiviteten först skapas. */
@Åsidosätta
public void onCreate(Bundle savedInstanceState) (
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
OnCreate-metoden anropas när en aktivitet skapas under applikationsstart. Denna metod kan betraktas som en ingångspunkt till programmet. Klassen R.java genereras automatiskt av Eclipse och innehåller referenser till resurser. Varje gång du ändrar resurser i Eclipse, byggs R-klassen om.
Huvudspelslinga
Alla spel bör ha en loop som kommer att fånga användarens kommandon, bearbeta dem, ändra tillståndet för spelobjekt i enlighet med dem, visa en ny ram på skärmen och spela upp ljud. Vi har redan skapat ett enkelt Android-projekt. Låt oss nu skapa spelloopimplementeringen.
Som du minns, i Android händer allt i en aktivitet. Aktivitet skapar en vy - ett objekt där allt det roliga händer. Det är genom den vi kan få information om beröring på skärmen, här kan du även visa en bild på skärmen.
Låt oss öppna filen DroidzActivity.java. I klasskonstruktorn ser du linjen
SetContentView(R.layout.main);
denna rad väljer det aktuella View-objektet för aktiviteten. Låt oss skapa ett nytt View-objekt. Mest på ett enkelt sätt få en vy – skapa din egen klass baserad på SurfaceView. I vår klass implementerar vi SurfaceHolder.Callback-gränssnittet för att påskynda åtkomsten till ytförändringar, till exempel när ytan förstörs när enhetens orientering ändras.
MainGamePanel.java
paket en.mobilab.gamesample;
SurfaceHolder.Callback(
super(sammanhang);
// Lägg till denna klass som innehåller en omvänd funktion
// samtal för att interagera med händelser
// gör GamePanel fokuserbart så att det kan bearbeta meddelanden
setFocusable(true);
}
@Åsidosätta
}
@Åsidosätta
}
@Åsidosätta
}
@Åsidosätta
}
@Åsidosätta
}
}
Listan ovan visar klassmallen som vi behöver implementera. Låt oss ta en närmare titt på innehållet i konstruktören. Linje
GetHolder().addCallback(detta);
Ställer in den aktuella klassen (MainGamePanel) som ythändelsehanterare.
SetFocusable(true);
Denna linje gör vår klass fokuserbar. Detta innebär att den kan ta emot fokus, och därmed händelser.
Låt oss skapa en tråd där vår spelloop faktiskt kommer att implementeras. Att dela upp ett spel i flera trådar som löper parallellt är en vanlig praxis inom modern spelutveckling. Låt oss skapa en MainThread.java-klass för vår tråd
Package en.mobilab.gamesample;
public class MainThread utökar tråden(
//flagga som indikerar att spelet körs.
privat boolesk löpning;
public void setRunning(boolesk körning) (
this.running = körs;
}
@Åsidosätta
public void run() (
medan man springer) (
// uppdatera status för spelobjekt
// visa grafik på skärmen
}
}
}
Som du kan se är denna klass mycket enklare än den föregående. Internt har vi åsidosatt run()-metoden. Tråden körs så länge den här metoden körs, så vi organiserade en oändlig loop inuti den. Vi har lagt till en boolesk variabel som kallas löpning för att fungera som en utgångsindikator för slingan. Nu, för att avsluta tråden, behöver du bara ändra värdet på denna variabel till false någonstans.
Efter att vi har skapat trådklassen måste vi köra den. Låt oss köra det på skärmladdning. Ändra klassen MainGamePanel
Package en.mobilab.gamesample;
importera android.content.Context;
importera android.graphics.Canvas;
importera android.view.MotionEvent;
importera android.view.SurfaceHolder;
importera android.view.SurfaceView;
public class MainGamePanel utökar SurfaceView-implementer
SurfaceHolder.Callback(
Privat huvudtrådstråd;
Public MainGamePanel(Kontextkontext) (
super(sammanhang);
getHolder().addCallback(detta);
// skapa en tråd för spelslingan
thread = new MainThread();
SetFocusable(true);
}
@Åsidosätta
public void surfaceChanged(SurfaceHolder-hållare, int format, int bredd, int höjd) (
}
@Åsidosätta
public void surfaceCreated(SurfaceHolder-hållare) (
thread.setRunning(true);
thread.start();
}
@Åsidosätta
public void ytaDestroyed(SurfaceHolder-hållare) (
//skicka kommandot för att stänga tråden och vänta,
//tills strömmen är stängd.
booleskt försök igen = sant;
medan (försök igen) (
Prova(
thread.join();
försök igen=falskt;
) catch (InterruptedException e) (
// försök att stoppa tråden igen
}
}
}
@Åsidosätta
public boolean onTouchEvent(MotionEvent-händelse) (
returnera super.onTouchEvent(händelse);
}
@Åsidosätta
skyddad void onDraw(Canvas canvas) (
}
}
Vi deklarerade trådobjektet
Privat huvudtrådstråd;
och skapade den i konstruktorn
Tråd = ny Huvudtråd();
i metoden surfaceCreated satte vi löpflaggan till true och startade tråden. Vid det här laget har trådobjektet redan skapats och vi kan köra det säkert.
SurfaceDestroyed-metoden anropas innan ytan stängs. Det räcker inte att bara ta bort den löpande flaggan här. Vi måste se till att strömmen verkligen stängdes. Vi blockerar bara tråden och väntar tills den dör.
Lägger till skärminteraktion
Låt oss skriva ett litet exempel för att visa hur man hanterar beröringar i Android. Vi avslutar programmet när användaren rör vid botten av skärmen. Om beröringen hände någonstans högre, kommer vi helt enkelt att mata ut motsvarande koordinater till loggen. Lägg till följande rader till MainThread-klassen:
Privat SurfaceHolder surfaceHolder;
privat MainGamePanel gamePanel;
public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) (
super();
this.surfaceHolder = ythållare;
this.gamePanel = gamePanel;
}
sålunda har vi definierat gamePanel- och surfaceHolder-variablerna, med de lämpliga värdena från konstruktorparametrarna. Vi måste komma ihåg dessa värden så att vi senare kan blockera ytan under hela ritningen, och detta kan bara göras genom surfaceHolder.
Ändra raden i klassen MainGamePanel för att lägga till de nyligen deklarerade parametrarna till konstruktorn
Tråd = ny Huvudtråd(getHolder(), detta);
Vi skickar den nuvarande hanteraren och panelen till den nya konstruktören. Detta gör att vi kan komma åt det från strömmen. I gamePanel kommer vi att skapa en uppdateringsmetod och vi kommer att byta den från tråden, men för tillfället lämnar vi allt som det är.
Skogsavverkning
Nedan kommer vi att skriva en hjälpkod som utför loggning - att skriva speciella felsökningsrader med text som speglar tillståndet för vårt program till en speciell fil, som sedan kan ses och försöka förstå vad som hände i programmet. Låt oss lägga till TAG-konstanten till MainThread-klassen. Varje klass kommer att ha sin egen konstant som kallas TAG, som kommer att innehålla namnet på motsvarande klass. Vi kommer att använda Android-loggningsramverket för att logga, inom detta bibliotek måste varje logg ha två parametrar. Den första parametern anger platsen där loggen skrivs från. Det är för dessa ändamål som vi skapade TAG-konstanten. Den andra parametern är det faktiska meddelandet som vi vill skriva till loggen. Att använda klassnamn som den första parametern är en ganska vanlig praxis bland java-programmerare.
För att se loggarna som registrerats under körningen av programmet, välj menyn
Windows -> Visa vy -> Annat...
och sedan i den öppnade dialogrutan
Android -> Logcat
I fönstret som öppnas kan du inte bara se loggarna, utan även filtrera och söka.
Låt oss återgå till vår kod. Låt oss göra ändringar i MainThread.java
Paket sv. mobilab. spelexempel; importera android. util. Logga ; importera android. se. Ythållare; public class MainThreadextends Thread( private static final String TAG= MainThread. class . getSimpleName() ; privat SurfaceHolder surfaceHolder; privat MainGamePanel gamePanel; privat boolean körning; public void setRunning(boolean körs) ( this. running= running; ) public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) ( super() ; this. surfaceHolder= surfaceHolder; this. gamePanel= gamePanel; ) @ Åsidosätt public void run() ( long tickCount= 0L; Log . d(TAG, "Starting game loop" ); while (kör) ( tickCount++; // spelstatus kommer att uppdateras här // och bildar en ram för visning) Logga. d(TAG, "Spelslinga körd" + tickCount+ "tider" ); ))
Som du kan se har vi definierat en TAG och kallat kommandot Log inuti körmetoden, vilket gör motsvarande post i loggfilen. Vi matar ut värdet på variabeln tickCount till loggen, som egentligen är en spelloopräknare och visar hur många gånger spelslingan har exekveras under programmets drift.
Låt oss gå till filen MainGamePanel.java och hitta metoden onTouchEvent, som är pekhanteraren på skärmen.
public boolean onTouchEvent(MotionEvent event) ( if (event. getAction() == MotionEvent. ACTION_DOWN) ( if (event. getY() > getHeight() - 50 ) ( thread. setRunning(false ) ; ((Activity) getContext( ) ) .finish() ; ) else ( Logga .d(TAG, "Coords: x=" + event.getX() + ",y=" + event.getY() ) ; ) ) return super.onTouchEvent(event ) ;)Först kontrollerar vi om en skärmpekningshändelse har inträffat (MotionEvent.ACTION_DOWN). Om så är fallet kontrollerar vi y-koordinaten och om den är längst ner på skärmen (50 pixlar från botten) skickar vi tråden ett kommando för att avsluta (genom att ställa in den löpande variabeln till false), och sedan anropar vi finishen ()-metoden på huvudaktiviteten, som stänger hela vårt program .
Kommentar. Ursprunget för skärmens koordinatsystem finns i det övre vänstra hörnet. Y-axeln är nedåt, x-axeln är till höger. Skärmens bredd och höjd kan erhållas med metoderna getWidth() respektive getHeight().
Ändra DroidzActivity.java genom att lägga till loggningskommandon
Paket sv. mobilab. spelexempel; importera android. app. aktivitet; importera android. os. bunt; importera android. util. Logga ; importera android. se. Fönster; importera android. se. fönsterhanterare; public class DroidzActivityextendsActivity( /** Anropas när aktiviteten skapas. */ privat statisk slutsträng TAG= DroidzActivity. klass. getSimpleName() ; @Override public void onCreate(Bundle savedInstanceState) ( super. onCreate(savedInstanceState) ; // begär att inaktivera titelraden requestWindowFeature(Window.FEATURE_NO_TITLE) ; // sätt applikationen i helskärmsläge getWindow() . setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN) ; // ställ in MainGamePanel som View setContentView(nytt MainGamePanel(detta) ); logga. d(TAG, "Visa tillagd" ); ) @ Override protected void onDestroy() ( Log . d(TAG, "Förstör..." ); super. onDestroy() ; ) @ Override protected void onStop() ( Log . d(TAG, "Stoppar..." ); super.onStop() ; ) )
Låt oss köra programmet. Efter start bör du se en svart skärm. Klicka några gånger längst upp på skärmen och sedan längst ned. programmet stängs. Det är dags att kolla loggen.
Genom att titta på loggen får du en tydlig uppfattning om i vilken ordning metoderna körs. Du kan också se hur många gånger spelslingan har körts under programmets körning. Denna siffra betyder ingenting, nästa gång loggar vi mer användbar information: FPS och UPS (uppdateringar per sekund).
Sammanfatta. Vi har skapat en helskärmsapplikation. Vi skrev en klass som körs i en separat tråd och kommer att innehålla spelmotorn. Skrev enklaste metoden bearbetar skärmberöring och stängde applikationen på ett kompetent sätt.
Nästa gång går vi vidare till att rita. Källkoden för denna handledning kan laddas ner.
Översättning och anpassning: Alexander Ledkov
Skriva ett spel i HTML5/JS
javascript gamedev html5 duk
Jag fick lite ledig tid under helgen och bestämde mig för att träna utveckling. Länge tänkte jag skriva någon sorts leksak, men alla händer nådde inte.
Hur man skapar ett Android-spel från början själv
Jag skummade igenom nätet på jakt efter hur riktiga gurus gör det. Jag gillade den här artikeln. Jag tog ramen för artikelförfattaren som grund för mitt framtida spel.
Start
- - bibliotek för att arbeta med sprites
- - ladda resurser
- - tangentbordsinmatningsbibliotek
- - huvudspelsfil
För smidig animering kommer vi att använda. Du kan ta reda på mer om det här
Låt oss dela upp utvecklingen av vårt spel i flera steg:
- Skapa och initialisera en duk (canvas) på en sida
- Lägger till huvudspelets loop-funktion
- Hantera användarinmatningshändelser
- Matematik och beräkning av kollisioner av föremål i spelet
Steg 1: Skapa och initiera duken
Det första vi behöver göra är att skapa ett element och lägga till det i spelets huvudtagg.
- Skapa ett objekt
- Vi anger att vi skapar ett 2D-spel (vi kommer att använda objektet överallt i koden)
- Ställ in måtten på duken
- Lägga till en arbetsyta till en tagg på en sida
Steg 2. Lägga till huvudslingfunktionen
Huvudslingan behövs för att uppdatera och rendera spelet.
Här kallar vi requestAnimFrame-funktionen (stöds tyvärr inte i alla webbläsare), som genererar 60 bildrutor/sekund (som beskrivits ovan).
Steg 3. Initialisering och rendering av spelobjekt och resurser
Används för att ladda resurser i spelet. bra regelär att lägga till alla bilder till 1 sprite, men för att jag inte ritade själv, utan tog färdiga bilder, så jag bestämde mig för att inte besvära mig med det här, särskilt sedan i det här fallet det är inte så kritiskt. Så här ser det ut i koden
I funktionen laddar du världen och lägger till en knapphanterare efter att spelet är över.
Initialtillstånd
Uppdatering av spelets framsteg
Enligt vår idé ska spindlar krypa ut från alla fyra sidor av spelplanen. För att detta ska ske slumpmässigt använder vi getRandomInt-funktionen.
Här använder vi. Hela funktionen kan ses i källkoden.
Steg 4: Hantering av användarinmatningshändelser
Vår hjälte måste kunna röra sig upp, ner, vänster, höger. Följaktligen ger jag nedan implementeringen av denna lösning.
När du klickar på gapet, enligt idén, bör torn placeras som kommer att skjuta slumpmässigt åt alla håll. För att komplicera processen att spela tornet lite är det tillåtet att placera det på ett visst avstånd från varandra. I det här fallet är det så.
Steg 5. Matematik och beräkning av kollisioner av föremål i spelet
Karaktärsanimering, kulrörelsematematik och NPC-rörelselogik i spelet beskrivs i funktionen. Det är här vi behöver grundläggande kunskaper i linjär algebra.
Tower sprite-animationsuppdateringslogik. Och vi skapar patroner för varje torn i vår array.
Turret Bullet Dynamics:
Som en påminnelse var vårt mål att tornen skulle skjuta slumpmässigt i alla riktningar.
Vi försåg spindlar med ett enkelt intellekt och därför kryper de alltid efter oss för att bita oss.
Funktionens fullständiga kod kan ses i källkoden på GitHub.
Matematiken för kollisionsberäkning är väl beskriven i författarens artikel (avsnittet Collision Detection) av den 2d bootstrap jag använder.
Steg 6. Game Over och starta om
När spindlarna kryper fram till vår hjälte kommer slutet på spelet.
Vi visar fönstret GAME OVER och knappen "Börja om". Klicka på den och allt börjar om 🙂
Slutsats
Som ett resultat insåg jag själv att det finns många fördelar:
- Ha kul och intressant tid
- Du upprepar kursen i skolans geometri. Om spelet är mer seriöst, kommer du ihåg universitetet 🙂
- Spelprogrammeringsövningar
- Arbetstillfredsställelse
Du kan se källkoden här, spela upp den här.
Utveckling av ett typiskt spel
Att skapa spel är en spännande aktivitet för en programmerare. Men alla spel är byggda enligt ett vanligt scenario. Det finns flera skärmar för användarinteraktion:
Startskärm Startskärm med företagslogotyp, spelscen, version, etc. Visas i några sekunder och försvinner sedan. Bakgrundsmusik kan spelas Meny Den andra skärmen där användaren kan navigera genom menyalternativen, till exempel Spela, Konto, Inställningar, Hjälp Huvudskärm Det är här den faktiska spelprocessen Inställningar Spelinställningar Skärmpoängfönster som kan nås från menyn. Här kan du visa statistik över prestationer, en tabell med rekord Hjälp Visar instruktioner för spelet: beskrivning, kontroller, tips
Detta typiska exempel standardspel. Naturligtvis kan du vägra vissa skärmar eller, tvärtom, lägga till fler, men i allmänhet är bilden tydlig. Därför måste vi genomföra sex aktiviteter:
- SplashActivity är standardaktiviteten. Visas i några sekunder. Efter det ska aktiviteten MenuActivity visas
- MenuActivity - innehåller knappar, bilder och andra element som du kan starta andra aktiviteter med
- GameActivity - huvudskärmen i spelet, där grafik visas, poäng beräknas etc.
- SettingsActivity - spara olika inställningar för spelet
- ScoresActivity - laddar ner data om spelarnas prestationer och visar dem för användaren för visning
- HelpActivity - visas bakgrundsinformation. Om texten är stor bör rullning också tillhandahållas.
Varje aktivitetsklass bör ha sin egen uppmärkningsfil med sin egen uppsättning element. Din uppgift är att lära dig hur du hanterar applikationens tillstånd, använder inställningarna, startar nödvändiga aktiviteter.
Det är också bekvämt att skapa en annan Activity-basklass med publika komponenter, som BaseActivity.
Ansökningssammanhang
Applikationskontexten är grunden för driften av alla program, inklusive spel. Den används för att komma åt inställningarna och resurserna som används av flera aktivitetsinstanser.
Du kan komma åt applikationskontexten för den aktuella processen genom metoden getApplicationContext():
Eftersom aktivitetsklassen härrör från kontextklassen kan du använda nyckelord detta istället för att explicit specificera applikationskontexten.
Efter att ha tagit itu med funktionaliteten i det framtida spelet kan du börja implementera det.
Vi vet att aktivitetsklassen är huvudklassen i alla Android-applikationer. Så vi behöver fem olika aktivitetsklasser för vårt syfte. Under spelet kommer användaren att flytta från en aktivitet till en annan (förutom den första aktiviteten, där en automatisk övergång kommer att tillhandahållas).
Det finns flera alternativ för att starta aktiviteter
- Genom en indikation i manifestfilen - så startas standardaktiviteten. I vårt fall är detta en Splash-skärmsläckare.
- Använda applikationskontexten med startActivity
- Starta barnaktivitet från föräldraaktivitet
startbild
Själva startskärmen bör visas i några sekunder. Vanligtvis sätter de en bild, namnet på spelet, versionsnumret, författaren etc. på den. I vissa fall är det lämpligt att använda en liten animation.
Spelmeny
Spelmenyskärmen används för att navigera genom de olika spelskärmarna.
Utveckling av ett typiskt spel
Menyn visas omedelbart efter startskärmen och ger användaren ett val av ytterligare åtgärder - gå direkt till spelet, läs instruktionerna, se tabellen med högsta poäng, och så vidare.
Hjälpskärm
På den här skärmen kan användaren bekanta sig med spelets regler. Därför bör den rullningsbara hjälptexten visas här.
Tabell för poäng eller höga poäng
I tabellen med rekord kan användaren se den aktuella spelpoängen med en lista över spelare som har tjänat det största antalet poäng. Med andra ord, statistik över de bästa spelprestationerna eller den aktuella poängen visas här.
Inställningsskärm
På den här skärmen kan användaren redigera och spara olika alternativ, såsom deras namn eller avatar.
Huvudskärm
Det är här spelets huvudhandling äger rum. Om spelet är klart måste du gå till tabellskärmen med höga poäng för att se resultatet av spelet.
Implementering av applikationsprototyp
Låt oss skapa ett nytt projekt med en SplashActivity som kommer att anropas först. Därefter måste vi skapa layoutfiler för varje aktivitet. Eftersom startskärmen kommer att anropas först, byt namn på filen main.xml till splash.xml. Du kan sedan göra fem kopior av splash.xml och ge dem nya namn: game.xml, help.xml, menu.xml, scores.xml och settings.xml.
Öppna nu varje uppmärkningsfil och ändra raden android:text="@string/hej" på android:text="@string/splash" etc.
Efter denna operation kommer du inte att bli förvirrad på skärmarna.
Du kan omedelbart ta hand om en ny ikon för spelet och lägga till den i mappen /drawable.
Vi har redan kommit överens om att vi ska ha huvudklassen BaseActivity. Skapa en klassfil BaseActivity.java och klistra in den minimala koden:
Gå tillbaka till filen SplashActivity.java och utöka den från klassen BaseActivity istället för klassen Activity.
Kopiera SplashActivity och skapa nya klasser MenuActivity, HelpActivity, ScoresActivity, SettingsActivity och GameActivity.
I varje skapad klass måste du ersätta i raden setContentView(R.layout.splash); layoutresurs till lämplig, t.ex. för inställningsskärmen, skulle detta vara R.layout.inställningar.
För att kontrollera kan du köra projektet på emulatorn. Om allt är gjort korrekt kommer välkomstskärmen att visas i emulatorfönstret, som innehåller texten välkomstskärm.
Skapa en startskärm
Vår uppgift är att skapa en skärm som försvinner av sig själv efter en kort paus. Du kan använda ett animerat intro för spelet, samt visa information om version, utvecklare etc. Jag påminner dig om att för splash-layouten använder vi filen splash.xml i layoutmappen.
Efter animeringen måste du starta en ny skärm med en meny och stänga den aktuella skärmen.
Reklam
Artikeln betalades av katter - världsberömda kattungeproducenter.
Om du gillade artikeln kan du stödja projektet.
Hur skapar man ett spel på Android?
Skapa ett spel för vem som helst operativ system förutsätter kunskaper i programmering. Även för de enklaste spelen som Flappy Bird behöver du känna till grunderna. Låt oss titta på hur spelet skapas med Android-operativsystemet som ett exempel.
motor
Det första steget i att skriva ett spel är att installera motorn. Det finns många motorer på webben inskrivna olika språk programmering. Självklart har betalda motorer fler funktioner, är stabilare och öppnar upp för fler möjligheter. Deras kostnad kan dock vara mycket hög. Därför kommer vi att ta den gratis LibGDX-motorn som ett exempel.
Denna motor har en hel del funktioner och har instruktioner för användning på ryska. Motorn är multiplattform, och därför kan spelet som kommer att skrivas på den installeras på andra plattformar.
Programmeringsmiljö
Också mycket viktig poängär att använda programmeringsmiljön. Denna term hänvisar till verktyget som spelet kommer att skrivas i. När det gäller LibGDX-motorn kommer programmeringsmiljön att vara Exlipce. Eftersom spelmotorn skrevs på språket java programmering, sedan för att kunna använda programmeringsmiljön måste du använda de grundläggande färdigheterna och kunskaperna om programmering på just detta språk. Därför, om du inte kan grunderna måste du lära dig dem.
Skapa ett projekt
För att skriva ett spel för Android, såväl som för någon annan plattform, måste du först skapa ett projekt. Det är lätt att göra. När det gäller LibGDX räcker det att packa upp motorn i en mapp och hitta filen med samma namn i den. Därefter måste du klicka på knappen "Skapa ett projekt", och du är redan ett steg bort från att skapa ett projekt. Sedan behöver du bara välja en plattform för spelet och ange namnet på projektet. I konfigurationen måste du ange var spelet ska placeras i programmeringsmiljön. Motorn skapar själva projektet och berättar om du har gjort något fel. Därefter kan du gå till programmeringsmiljön och börja skriva spelet.
Som du kan se är det helt enkelt omöjligt att skapa ett spel för Android och alla andra operativsystem utan kunskap om grunderna i programmeringsspråk. Men nu blir motorerna bättre och bekvämare även för dem som precis har börjat sin resa i den här branschen. Ett exempel på en sådan motor är också Game Maker. Du kan läsa om den här motorn och om att skapa ett spel på den i artikeln.
