Steg 7 - Så här ser hela koden ut nu:
Vi är klara & all kod bör se ut så här nu:
Kod:
package com.turtorial.game;
import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Vector3;
public class turtorial_class extends ApplicationAdapter {
// deklarera objekt
SpriteBatch vår_batch;
Texture vår_bild;
int X, Y;
float scrw = 1280, scrh = 720;
OrthographicCamera camera;
Vector3 cords; // vector att lagra våra nya korrigerade cordinater från touch imput
@Override
public void create () {
vår_batch = new SpriteBatch(); // skapa vårt batch objekt
vår_bild = new Texture("objekt1.png"); // skapa vårt textur objekt
// skapa en ortographic camera & sätt dess width & height till den upplösning vi vill ha
camera = new OrthographicCamera();
camera.viewportHeight = scrh;
camera.viewportWidth = scrw;
cords = new Vector3(); // skapa vectorn för input
}
@Override
public void render () {
Gdx.gl.glClearColor(1, 0, 0, 1); // ange röd bakgrund
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
camera.position.set(camera.viewportWidth * .5f, camera.viewportHeight * .5f, 0f);
camera.update();
input(); // anropa vår metod för input
vår_batch.begin();
vår_batch.setProjectionMatrix(camera.combined);
vår_batch.draw(vår_bild, cords.x, cords.y); // visa vår bild på skärmen
vår_batch.end();
}
public void input(){
// hämtar input från användaren & lagrar i variablerna X & Y som vi skapat tidigare
cords = new Vector3(Gdx.input.getX() , Gdx.input.getY(), 0);
camera.unproject(cords);
}
}
Youtubessnutt:
Nu till nästa avsnitt!
----------------------------------------------------------------------------------
5.0 - Collision Detection
I detta avsnitt ska vi arbeta med Collision Detection! Som är ett av de viktigare momenten inom spelprogrammering!
Det finns nästan inga grafiska spel som inte använder sig utav det(kanske något text baserat spel).
Vad är Collision Detection?
Enkelt förklarat är det att tala om för datorn när ett eller flera objekt kolliderar med varandra!
Nu har LibGDX en inbyggd simpel class/metoder för att ta reda på när objekt kolliderar med varandra.
Kod:
if(rectangle1.overlaps(rectangle2)){
//objekt har kolliderat
};
Ovanstående kod kollar om Rektangel 1 har kolliderat med Rektangel 2
Givetvis gör denna kod ingenting i dagsläget.
Vi kommer inte att använda LibGDX färdiga metoder för collision Detection utan vi kommer skapa en helt egen Class för detta ändamål!
Steg 1 - Skapa en ny class för collision Detection!
- I Android Studio högerklicka på din mainclass & skapa en ny klass
- Döp klassen till collision_detection
Steg 2 - konfigurera den nya klassen
Nu måste vi tänka hur vår klass ska vara uppbyggd!
Vår klass för collision detection kommer att bestå av en konstruktor, samt en metod för att uträkna om kollision har skett.
Konstruktorn kommer inte att ta några argument, utan vår metod för kollidering kommer att göra det(den kommer att ta X & Y värde för objekt och spelare)
Konstruktorn kommer endast att skapa våra Rektanglar för det objekt som ska kollidera. Samt ange dess bredd
Tryck på vår nya class och skriv följande kod:
Kod:
public class collision_detection {
// deklarering
Rectangle Object_rectangle;
Rectangle Player_rectangle;
//skapa
collision_detection(){
// skapa våra rektanglar
Object_rectangle = new Rectangle();
Player_rectangle = new Rectangle();
// Ange bredd & höjd på rektanglar
Object_rectangle.width = 100;
Object_rectangle.height = 100;
Player_rectangle.width = 100;
Player_rectangle.height = 100;
}
Har konfigurerar vi konstruktorn att skapa 2 Rektanglar & anger dess bredd & höjd i pixlar.
Vad ska vi ha dessa Rektanglar till?
Rektanglarna kommer att placeras med EXAKT position över våra objekt/texturer, så att vi sedan kan räkna ut om objekten har kolliderat.
Steg 3 - Skapa vår Metod för uträkning om kollision har skett
Nu måste vi skapa en ny metod för uträkning! Skapa en metod under konstruktorn döp den till "check_collision"()
Vår metod kommer att ta X, & Y värde som argument från vår Main_class(vår turtorial_class). X & Y värdena kommer att representera Position för användarens touch samt possitionen för det objektet vi ska kollidera med.
Vi kommer även att skapa lokala variabler inom klassen, som jag inte tror att jag behöver förklara.
Vår metod:
Kod:
public boolean check_collision(Vector3 cords_player, float object_X, float object_Y){
// Applicera våra uppdaterade kordinater på vårt objekt som vi ska kollidera med
Player_rectangle.x = cords_player.x; Player_rectangle.y = cords_player.y;
Object_rectangle.x = object_X; Object_rectangle.y = object_Y;
//användare, objekt
float leftA, leftB;
float rightA, rightB;
float topA, topB;
float bottomA, bottomB;
boolean check = false;
// Beräkna sidor för Spelare
leftA = Player_rectangle.x;
rightA = Player_rectangle.x + Player_rectangle.width;
topA = Player_rectangle.y + Player_rectangle.height;
bottomA = Player_rectangle.y;
//Beräkna sidor för objektet
leftB = Object_rectangle.x;
rightB = Object_rectangle.x + Object_rectangle.width;
topB = Object_rectangle.y + Object_rectangle.height;
bottomB = Object_rectangle.y;
// kolla om en sida överskrider en sida av objekt. Om så är fallet har en kollision skett!
if (topA >= bottomB && bottomA <= topB && rightA >= leftB && leftA <= rightB)
{
check = true;
Gdx.app.exit();
}
return check;
}
Vad gör nu vår metod?
Kolla kommentarer ovan!
För att beskriva lite snabbt, så hämtar vi spelarens kordinater från vår main klass, samt objektets kordinater.
Sedan kalkylerar vi bredd, sidor o.s.v.
Dessa använder vi sedan för att kolla om spelaren har kolliderat med objektet!
Nu är vår klass för en simpel collision detection klar!
Kod för hela klassen:
Kod:
public class collision_detection {
// deklarering
Rectangle Object_rectangle;
Rectangle Player_rectangle;
//skapa
collision_detection(){
// skapa våra rektanglar
Object_rectangle = new Rectangle();
Player_rectangle = new Rectangle();
// Ange bredd på rektanglar
Object_rectangle.width = 100;
Object_rectangle.height = 100;
Player_rectangle.width = 100;
Player_rectangle.height = 100;
}
public boolean check_collision(Vector3 cords_player, float object_X, float object_Y){
// Applicera våra uppdaterade kordinater på vårt objekt som vi ska kollidera med
Player_rectangle.x = cords_player.x; Player_rectangle.y = cords_player.y;
Object_rectangle.x = object_X; Object_rectangle.y = object_Y;
// Skapar lite onödiga vraibler för att det ska bli lättare att förstå
//användare, objekt
float leftA, leftB;
float rightA, rightB;
float topA, topB;
float bottomA, bottomB;
boolean check = false;
// Beräkna sidor för Spelare
leftA = Player_rectangle.x;
rightA = Player_rectangle.x + Player_rectangle.width;
topA = Player_rectangle.y + Player_rectangle.height;
bottomA = Player_rectangle.y;
//Beräkna sidor för objektet
leftB = Object_rectangle.x;
rightB = Object_rectangle.x + Object_rectangle.width;
topB = Object_rectangle.y + Object_rectangle.height;
bottomB = Object_rectangle.y;
// kolla om en sida överskrider en sida av objekt. Om så är fallet har en kollision skett!
if (topA >= bottomB && bottomA <= topB && rightA >= leftB && leftA <= rightB)
{
check = true;
Gdx.app.exit(); // avsluta progarmmet om kollision sker
}
return check;
}
}
Japp klassen är helt klar & fungerande!
MEN!
För att få allt att fungera måste vi koppla ihop den & anropa medtoden från vår main_class.
Detta gör vi i steg 4!
Steg 4 - Modifiera din main_class d.v.s. din turtorial_class. För att aktivera collision detection
Innan vi kan använda vår collision_detection klass måste vi skapa ett objekt av denna. Detta gör vi genom att först deklarera vårat objekt, och sedan skapa det i metoden create.
Kod:
public class turtorial_class extends ApplicationAdapter {
// deklarera objekt
SpriteBatch vår_batch;
Texture vår_bild;
int X, Y;
float scrw = 1280, scrh = 720;
OrthographicCamera camera;
// vector att lagra våra nya korrigerade cordinater från touch imput
Vector3 cords;
// deklarera ett objektet vi ska använda för collision detection
collision_detection COLLISION;
Ovan deklarerar vi ett objekt för collision detection(detta gör vi i vår turtorial_class)
Kod:
public void create () {
vår_batch = new SpriteBatch(); // skapa vårt batch objekt
vår_bild = new Texture("objekt1.png"); // skapa vårt textur objekt
// skapa en ortographic camera & sätt dess width & height till den upplösning vi vill ha
camera = new OrthographicCamera();
camera.viewportHeight = scrh;
camera.viewportWidth = scrw;
cords = new Vector3(); // skapa vectorn för input
COLLISION = new collision_detection(); // skapa objekt för collision detection
}
Ovan skapar vi vårat objekt för collision detection
STEG 5 - Det är dags att anropa vår metod för Collision Detection!
Nu ska vi anropa metoden check_collision från vår metod collision_detection & skapa ett objekt att kollidera med.
Vi börjar med att skapa 2 variabler för det objekt vi ska kollidera med. Variablerna är X & Y kordinaterna för det objekt vi ska kollidera med
Vi lägger till variablerna som fält:
Kod:
public class turtorial_class extends ApplicationAdapter {
// deklarera objekt
SpriteBatch vår_batch;
Texture vår_bild;
int X, Y;
float OBJECT_X, OBJECT_Y; // kordinater för objektet vi ska kollidera med
boolean COLLIDED = false;
float scrw = 1280, scrh = 720;
Vi har lagt till variablerna OBJECT_X & OBJECT_Y, samt COLLIDED
Nu kan vi anropa vår metod från klassen collision_detection. I vår Render metod lägger vi till följande:
Kod:
public void render () {
Gdx.gl.glClearColor(1, 0, 0, 1); // ange röd bakgrund
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
camera.position.set(camera.viewportWidth * .5f, camera.viewportHeight * .5f, 0f);
camera.update();
input(); // anropa vår metod för input
COLLIDED = COLLISION.check_collision(cords, OBJECT_X, OBJECT_Y); // kolla om kollision sker
vår_batch.begin();
vår_batch.setProjectionMatrix(camera.combined);
vår_batch.draw(vår_bild, cords.x, cords.y); // visa vår bild på skärmen
vår_batch.end();
}
Vi kollar kollision genom att ha lagt till följande:
Kod:
COLLIDED = COLLISION.check_collision(cords, OBJECT_X,OBJECT_Y);
Nu är allt klart & vi har en fungerande collision detection!
Steg 6 - vi lägger till ett objekt att kollidera med
Nu vet vi hur vi skapar texturer, ritar ut dem på skärmen. Därför kommer jag snabbt skapa ett till objekt att kollidera med.
Jag kommer inte att förklara denna kod då jag i princip kopierar delar av det jag gjort innan.
Kod med fungerande collision detection mellan användare och objekt:
Vår turtorial class ser nu ut så här:
Kod:
package com.turtorial.game;
import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Vector3;
public class turtorial_class extends ApplicationAdapter {
// deklarera objekt
SpriteBatch vår_batch;
Texture vår_bild, objekt_bild;
float scrw = 1280, scrh = 720;
float OBJECT_X = scrw / 2 - 50 , OBJECT_Y = scrh / 2 - 50 ; // kordinater för objektet vi ska kollidera med. Vi anger dess kordinater till mitten av skärmen
boolean COLLIDED = false;
OrthographicCamera camera;
Vector3 cords; // vector att lagra våra nya korrigerade cordinater från touch imput
// deklarera ett objektet vi ska använda för collision detection
collision_detection COLLISION;
@Override
public void create () {
vår_batch = new SpriteBatch(); // skapa vårt batch objekt
vår_bild = new Texture("objekt1.png"); // skapa vårt textur objekt
objekt_bild = new Texture("objekt2.png"); // skapa vårt textur objekt
// skapa en ortographic camera & sätt dess width & height till den upplösning vi vill ha
camera = new OrthographicCamera();
camera.viewportHeight = scrh;
camera.viewportWidth = scrw;
cords = new Vector3(); // skapa vectorn för input
COLLISION = new collision_detection(); // skapa objekt av klassen collision_detection
}
@Override
public void render () {
Gdx.gl.glClearColor(0, 0, 0, 0); // ange svart bakgrund
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
camera.position.set(camera.viewportWidth * .5f, camera.viewportHeight * .5f, 0f);
camera.update();
input(); // anropa vår metod för input
COLLIDED = COLLISION.check_collision(cords, OBJECT_X, OBJECT_Y); // kolla om kollision sker
vår_batch.begin();
vår_batch.setProjectionMatrix(camera.combined);
vår_batch.draw(vår_bild, cords.x, cords.y); // visa vår bild på skärmen
vår_batch.draw(objekt_bild, OBJECT_X, OBJECT_Y); // visa vår bild på skärmen
vår_batch.end();
}
public void input(){
// hämtar input från användaren & lagrar i variablerna X & Y som vi skapat tidigare
cords = new Vector3(Gdx.input.getX()-50 , Gdx.input.getY()+50, 0);
camera.unproject(cords);
}
}
Vår collision_Detection klass ser nu ut så här:
Kod:
public class collision_detection {
// deklarering
Rectangle Object_rectangle;
Rectangle Player_rectangle;
//skapa
collision_detection(){
// skapa våra rektanglar
Object_rectangle = new Rectangle();
Player_rectangle = new Rectangle();
// Ange bredd på rektanglar
Object_rectangle.width = 100;
Object_rectangle.height = 100;
Player_rectangle.width = 100;
Player_rectangle.height = 100;
}
public boolean check_collision(Vector3 cords_player, float object_X, float object_Y){
// Applicera våra uppdaterade kordinater på spelare samt det objekt som vi ska kollidera med
Player_rectangle.x = cords_player.x; Player_rectangle.y = cords_player.y;
Object_rectangle.x = object_X; Object_rectangle.y = object_Y;
//användare, objekt
float leftA, leftB;
float rightA, rightB;
float topA, topB;
float bottomA, bottomB;
boolean check = false;
// Beräkna sidor för Spelare
leftA = Player_rectangle.x;
rightA = Player_rectangle.x + Player_rectangle.width;
topA = Player_rectangle.y + Player_rectangle.height;
bottomA = Player_rectangle.y;
//Beräkna sidor för objektet
leftB = Object_rectangle.x;
rightB = Object_rectangle.x + Object_rectangle.width;
topB = Object_rectangle.y + Object_rectangle.height;
bottomB = Object_rectangle.y;
// kolla om en sida överskrider en sida av objekt. Om så är fallet har en kollision skett!
if (topA >= bottomB && bottomA <= topB && rightA >= leftB && leftA <= rightB)
{
check = true;
Gdx.app.exit();
}
return check;
}
}
Det som händer vid kollision är att programmet avslutas med kommandot Gdx.app.exit();
Här har vi nu ett helt fungerande "spel" ovan!
RESULTAT:
Vi i princip med alla huvudfunktioner för ett spel & det enda som fattas är att bygga på spelet.
Med dessa grunder är det i princip bara kopiera, och klistra in. Då allt bygger på samma princip!
Det man vill göra för att få ett lite roligare spel är att t.e.x. lägga till hur objekten ska uppföra sig. D.v.s. om dom ska röra sig, hoppa, studsa, snurra osv...
Kopiera gärna senaste koden ovan d.v.s. koden från klassen turtorial & koden från klassen collsision detection!
Nu går vi över till enklare saker!
----------------------------------------------------------------------------------
6.0 - Musik & ljudeffekter
I detta kapitel lägger vi till musik & ljudeffekter! Jag kommer att gå igenom detta kapitel fort, då jag inte tror att jag behöver förklara det jag gör.
Steg 1 - skapa en ny Java klass & döp den till sounds
Gör en konstruktor för den nya klassen:
Kod:
package com.turtorial.game;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.audio.Music;
import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.files.FileHandle;
/**
* Created by GoseTech2 on 2015-12-20.
*/
public class sounds {
// deklarera ljudeffekter & musik
public Sound VÅR_LJUDEFFEKT;
public Music VÅR_MUSIK;
sounds(){
// ladda in effekter
VÅR_LJUDEFFEKT = Gdx.audio.newSound(Gdx.files.internal("ljudeffekt.wav"));
VÅR_MUSIK = Gdx.audio.newMusic(Gdx.files.internal("musik.wav"));
}
}
För att spela upp musiken deklarerar vi & skapar ett objekt för vår nya klass(objektet deklareras ovanför create & skapas inom metoden create, detta i vår felstavade turtorial_class)
Deklarera:
Kod:
public class turtorial_class extends ApplicationAdapter {
// deklarera objekt
SpriteBatch vår_batch;
Texture vår_bild, objekt_bild;
// Deklarera objekt för hantering av ljud
sounds playsound;
float scrw = 1280, scrh = 720;
...
Ovan har vi deklarerat vårat objekt för ljudhantering
Skapa sedan vårat objekt för hantering av ljud:
Kod:
public void create () {
vår_batch = new SpriteBatch(); // skapa vårt batch objekt
vår_bild = new Texture("objekt1.png"); // skapa vårt textur objekt
objekt_bild = new Texture("objekt2.png"); // skapa vårt textur objekt
// skapa en ortographic camera & sätt dess width & height till den upplösning vi vill ha
camera = new OrthographicCamera();
camera.viewportHeight = scrh;
camera.viewportWidth = scrw;
cords = new Vector3(); // skapa vectorn för input
COLLISION = new collision_detection();
// skapa objekt för hantering av ljud
playsound = new sounds();
Ovan har vi skapat vårat objekt genom att lägga till följande i metoden create: playsound = new sounds();
Vi spelar sedan upp ljuden såhär(vartsomhelst ifrån vår turtorial_class
Kod:
public void render () {
Gdx.gl.glClearColor(0, 0, 0, 0); // ange röd bakgrund
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
camera.position.set(camera.viewportWidth * .5f, camera.viewportHeight * .5f, 0f);
camera.update();
input(); // anropa vår metod för input
COLLIDED = COLLISION.check_collision(cords, OBJECT_X, OBJECT_Y); // kolla om kollision sker
if(COLLIDED){
playsound.VÅR_LJUDEFFEKT.play();
}
Ovan spelar vi upp vår ljudeffekt genom: playsound.VÅR_LJUDEFFEKT.play();
Man spelar även upp musik likadant.
---------------------------------------------------------------------------------------------------