Hur man gör en anpassad spelkontroll med Arduino och Unity

Hur man gör en anpassad spelkontroll med Arduino och Unity

Har du någonsin velat designa din egen spelkontroll? Det är lättare än du tror!





I detta korta projekt kommer vi att bygga en enkel anpassad spelkontroll för användning med Unity -spelmotorn. Denna handkontroll kommer att drivas av en Arduino Uno, även om du också kan använda ett av de många alternativen som finns för detta projekt. Vi kommer också att skapa ett grundläggande spel där du kommer att använda din handkontroll för att undvika fallande föremål och sakta ner tiden.



För detta projekt behöver du

  • Arduino eller liknande mikrokontroller
  • 1 x 10k Ohm motstånd
  • 1 x tillfällig omkopplare
  • 1 x Potentiometer
  • Anslutningskablar
  • En brödbräda
  • Enhetens spelmotor
  • Uniduino -plugin från Unity Asset Store ($ 30)
  • Komplett projektkod, om du inte vill skriva ut den (inkluderar inte Uniduino -plugin)

De flesta av dessa saker finns i ett Arduino -startpaket. Om du inte har ett startpaket, kolla in vår guide för att välja det bästa för dig.





Du kan göra din styrenhet så komplicerad som du vill, men för detta exempel kommer vi att sätta upp en potentiometer och en knapp - perfekt för att styra ett enkelt arkadspel.

Montering av din controller

Ställ in din brödbräda och Arduino enligt bilden nedan. Detta är vad vi kommer att använda som vår spelkontroll, även om du kan använda nästan exakt samma inställning som en DIY midi controller för!



Förbereda din Arduino

När allt är anslutet ansluter du din Arduino via USB. I Arduino Software IDE gå till Verktyg> Styrelse och Verktyg> Port för att välja vilken mikrokontroller och port du använder. Arduino IDE levereras med den skiss vi behöver, och du hittar den under Arkiv> Exempel> Firmata> StandardFirmata . Klicka på Ladda upp så är du redo att börja.

Om du är ny på Arduino och ditt huvud smälter något, kolla in vår Nybörjarguide för att hjälpa dig att få det att prata med din dator snyggt.



Upprätta ditt enhetsprojekt

I Unity, öppna Fönster> Tillgångsbutik för att komma åt Unity's Asset Store från Unity Editor. Sök i Asset Store efter Uniduino -plugin. Med det här tillägget kan du ta emot och skicka data till och från dina Arduino -pins i Unity. Pluggen i skrivande stund kostar $ 30. Det är möjligt att göra det här projektet utan att köpa plugin, även om det är ganska mer komplicerat och du kan tycka att plugin är mer bekvämt runt om.

Denna video från skaparna av pluginet tar dig genom processen att testa allt fungerar, tillsammans med första gången installation. Observera att du kanske också måste återställa Unity -redigeraren på Windows.



Vi kan använda samma testpanel för att testa vår controller. Ställ in stift D2 på INPUT och Digital. Längre ner, ställ in stift A5 på ANALOG. Din potentiometer och -knapp bör visa värden på skärmen bredvid deras pin -nummer nu. Framsteg!

Nu för att göra något vi kan kontrollera

Så vi har en controller, men vad ska vi kontrollera? Tja, möjligheterna är oändliga, men för idag ska vi skapa ett mycket enkelt dodging -spel för att testa vårt nya styrsystem. Vi kommer att gå över speluppsättningen ganska snabbt, så om du är helt ny på Unity -motorn kan du hitta vår Enhetsspelprogrammering Nybörjarguide användbart för att få dina lager.

Vi kommer att bygga ett mycket grundläggande spel där ditt mål är att undvika din sfär till vänster och höger för att undvika att falla kuber, vilket kommer att använda din nygjorda anpassade kontroller.

Skapa en ny scen och dra Uniduino -prefabriken från Tillgångar> Uniduino> Prefab in i din hieraki och dra Uniduino -prefabriken till hierarkin. Vi behöver det där för att prata mellan vårt spel och controller.

Klicka i enhetshierarkin Skapa> Sphere och använd fliken Transform i inspektören för att flytta den till botten av spelskärmen.

Det är dags att få kodning

Nu för att lägga till lite kod till den här festen. Med den sfär som är markerad i hierarkin klickar du på Lägg till komponent> Nytt skript längst ner i inspektörsfönstret. Namnge det sfärMover och välj Ciss från rullgardinsmenyn. Klick Skapa och lägg till och skriptet läggs till i GameObject. Dubbelklicka på det för att öppna skriptet och ange den här koden:

using UnityEngine;
using System.Collections;
using Uniduino;
public class sphereMover : MonoBehaviour
{
//Headers aren't scrictly neccesary, but they make life easier back in the Inspector.
[Header('Arduino Variables')]
//we need to declare the Arduino as a variable
public Arduino arduino;
//we need to declare an integer for the pin number of our potentiometer,
//making these variables public means we can change them in the editor later
//if we change the layout of our arduino
public int potPinNumber;
//a float variable to hold the potentiometer value (0 - 1023)
public float potValue;
//we will later remap that potValue to the y position of our capsule and hold it in this variable
public float mappedPot;
//public int for our button pin
public int buttonPinNumber;
[Header('Sphere Variables')]
//variables to hold the values we noted earlier for the sides of our screen
public float leftEdge;
public float rightEdge;
// Use this for initialization
void Start ()
{//and initialize we shall, starting with the Arduino Variable.
//we are only using one arduino, so we can use Arduino.global to grab it.
arduino = Arduino.global;
arduino.Setup(ConfigurePins);
}
void ConfigurePins()
{
//configure the Arduino pin to be analog for our potentiometer
arduino.pinMode(potPinNumber, PinMode.ANALOG);
//Tell the Arduino to report any changes in the value of our potentiometer
arduino.reportAnalog(5, 1);
//configure our Button pin
arduino.pinMode(buttonPinNumber, PinMode.INPUT);
arduino.reportDigital((byte)(buttonPinNumber / 8), 1);
}
}

Ta en stund att läsa igenom kodkommentarer. Hittills har vi deklarerat några variabler för vår Arduino, dess stift och vår sfär. Vi har också använt

Starta och konfigureraPins -metoder för att initiera vår Arduino vid körtid. Låt oss spara vårt skript och gå tillbaka till Unity -redigeraren och se vad som har ändrats.

Vi kan nu se våra offentliga variabler i inspektörsfönstret. Låt oss se vad vi kan ange i detta skede för att hjälpa oss senare. Vi vet vilka stift vi använder på Arduino från vår byggnad tidigare, vi kan ange dem. Vi vet också från vårt experiment tidigare hur långt vi vill att vår sfär ska kunna färdas åt vänster och höger så att den inte ramlar av skärmen. Låt oss ange dessa värden nu.

Första tecken på liv

Det är dags att faktiskt se värden från vår Arduino inuti Unity Editor. För tillfället kan vi lägga till en kodrad till vårt sphereMover -skripts uppdateringsfunktion och spara skriptet igen.

void Update ()
{
//We assign the value the arduino is reading from our potentionmeter to our potValue variable
potValue = arduino.analogRead(potPinNumber);
}

Nu när vi har vår potValue -variabel uppdaterad varje ram, kan vi se dess värde i realtid i Unity Inspector. Innan vi testar det skulle det vara en bra tid att kontrollera att Uniduino -kontakten lyssnar på rätt port. Klicka på Uniduino i Heirarchy och kontrollera portnamnet i inspektören. Om det är tomt, fyll i rätt portnummer för din Arduino. I det här fallet var det COM4, ​​även om det kan vara annorlunda för dig. Kontrollera att använda Arduino IDE om du inte är säker.

Välj din sfär i hierarkin och klicka på knappen Spela högst upp på skärmen. Systemet behöver några sekunder för att initiera, varefter du bör börja se Pot Value -variabeln förändras i inspektören när du flyttar potentiometern.

Nu snackar vi! Tja, strikt sett talar Unity och Arduino, men vem räknar? Om du har kommit så långt och inte ser värdeförändringen i inspektören, kolla igenom installationsstegen och se till att du har rätt port vald för din Arduino.

Låt oss flytta denna sfär

Nu när vi har uppdaterat potValue -variabeln, vill vi använda detta värde för att flytta vår sfär. När potentiometern är hela vägen till vänster vill vi att sfären ska vara på vänster sida av skärmen, och vice versa. Objekt i enhet placeras vid en punkt i vektorutrymmet, bestämt av dess värden Transform. Position . På bilden nedan, där sfären är längst till vänster vi skulle vilja ha den, kan du se att dess positionsvektor är 9,5, -4, 0.

Vi vill påverka sfärens X -position. Tyvärr fungerar inte värdena från vår potentiometer direkt, eftersom när potentiometern är helt till vänster ger den ett värde på 0 - vilket skulle sätta vår sfär mitt i skärmen. I den andra ytterligheten skulle potentiometerns högsta värde, 1023, placera kuben långt till höger om vår skärm. Ej användbar. Det vi behöver här är lite matte.

Varför gör matematik när enhet gör det för dig?

För er där ute som fruktar och stirrar på ett papper täckt med meningslösa siffror (även om det finns några bra webbplatser som kan hjälpa dig att lära dig matematik), var inte rädd. Vi behöver ett sätt att få våra potentiometervärden att överensstämma med vår sfärs X -position. Lyckligtvis kan vi använda en Förlängningsmetod .

En förlängningsmetod är ett skript som gör ett specifikt jobb för oss. I det här fallet ger vi det de värden vi har, och det returnerar dem mappade till varandra, redo att användas i våra sfärMover manus. Klicka på högst upp på projektpanelen Skapa> C# Script och namnge det ExtensionMethods. Ange koden nedan i skriptet:

using UnityEngine;
using System.Collections;
public static class ExtensionMethods {

//our handy dandy Remapper function
public static float Remap (this float value, float from1, float to1, float from2, float to2)
{
return (value - from1) / (to1 - from1) * (to2 - from2) + from2;
}
}

Spara skriptet och gå tillbaka till ditt sphereMover -skript. Vi kan nu använda denna Remap -funktion i vårt ExtensionMethods -skript i vår uppdateringsfunktion för att konvertera våra potentiometervärden till användbara värden i vårt spel. Under där vi just tilldelade variabeln potValue skriver du följande:

Uppmaningen visar oss att vår ombildning tar två uppsättningar från och till -värden och kartlägger dem tillsammans. Vi kan skriva in våra värderingar i detta.

mappedPot = potValue.Remap(0, 1023, leftEdge, rightEdge);

Spara ditt manus, gå tillbaka till Unity -redigeraren och tryck på play -knappen. Du bör nu se att Mapped Pot -variabeln ändras när du flyttar potentiometern för att motsvara de värden vi bestämde för våra vänstra och högra kanter. Luta dig tillbaka och tacka ditt ExtensionMethods -manus. Inte en räknare i sikte.

Obs! Om du märker att dina värden är omvända, så när din potentiometer är hela vägen till höger får du ett negativt värde för din Mapped Pot -variabel, du kan ha din potentiometer inställd på fel sätt. Lyckligtvis kan du fixa detta utan att göra några kablar. Du kan helt enkelt byta värden när du gör om dem:

Nu har vi äntligen användbara värden. Nu återstår bara att tilldela dessa värden till vår sfärs X -position:

hur du får tillbaka din snap -rad
//Assign the mapped pot value to the sphere's x position
transform.position = new Vector3(mappedPot, transform.position.y, transform.position.z);

Spara ditt manus, gå tillbaka till Unity -redigeraren och tryck på play. Du bör nu kunna flytta din sfär till vänster och höger med din potentiometer!

Att sätta knappen på jobbet

Nu när vi har vår sfär i rörelse, skulle det inte vara trevligt att ha ett sätt att sakta ner sakerna lite när vi kommer i en trång plats? Vi kommer att använda vår knapp för att sakta ner tiden i vårt spel. Öppna ditt sphereMover -skript och lägg till den här koden i din uppdateringsfunktion

//if Unity detects the button is being pressed, the time scale slows down
if (arduino.digitalRead(buttonPinNumber) == 1){
Time.timeScale = 0.4f;
}
else Time.timeScale = 1.0f;

Nu har vi mekaniken i vårt spel, låt oss lägga till några hinder! Vi kommer att använda sfärens naturliga fiende, kuben. Klicka på i hierarkin Skapa> 3d -objekt> Kub . I kubens inspektör, Lägg till komponent> Fysik> Rigidbody . Ställ in dragvärdet för den stela kroppen på 5. Välj även Is Trigger under Box Collider -komponenten i inspektören. Detta gör att vi kan upptäcka kollisioner med vår sfär.

Skapa ett skript på kuben och kalla det kolliderar med WithSphere , öppna skriptet och ta bort Start- och uppdateringsfunktionerna eftersom vi inte kommer att behöva dem den här gången. Ange den här koden:

using UnityEngine;
using System.Collections;
public class collideWithSphere : MonoBehaviour
{
void OnTriggerEnter(Collider other)
{
Destroy(other.gameObject);
}
}

OnTriggerEnter skickar ett meddelande när triggerkollidern träffar en annan collider. I det här fallet säger vi till den att förstöra vad den än rör vid. Spara skriptet och gå tillbaka till Unity -redigeraren. Dra kuben från hierarkin till projektpanelen. Du kommer att märka att kubtexten i hierarkin har blivit blå. Detta beror på att vi har skapat en prefab och sparat den i vårt projekt. Ta bort din kub från hierarkin nu.

Allt vi behöver nu är ett manus för att leka kuberna. Klicka i hierarkin Skapa> Skapa tomt och byt namn på det till Game Manager i inspektören och lägg till ett manus till det som heter gameManager. Öppna skriptet och lägg till den här koden:

using UnityEngine;
using System.Collections;
public class gameManager : MonoBehaviour {
//a variable to hold the prefab we want to spawn
public GameObject cube;
//we want some variables to decide how any cubes to spawn
//and how high above us we want them to spawn
public int numberToSpwan;
public float lowestSpawnheight;
public float highestSpawnheight;
// Use this for initialization
void Start ()
{
for (int i = 0; i {
Instantiate(cube, new Vector3(Random.Range(-9, 9), Random.Range(lowestSpawnheight, highestSpawnheight), 0), Quaternion.identity);
}
}

// Update is called once per frame
void Update ()
{

}
}

Spara skriptet. Tillbaka i redigeraren väljer du Game Manager i hierarkin och drar din kub prefabricerad från projektpanelen till Cube -variabeln i Inspector. Fyll i värdena för din lek också här. Du kan pilla med det för att göra det så svårt eller enkelt som du vill. Observera att det är värt att ha dina lägsta kuber tillräckligt högt för att Uniduino ska kunna initialiseras - att förlora spelet innan du kan röra dig kan vara frustrerande!

Det färdiga projektet

Nu när du trycker på play kommer kuberna att leka ovanför dig och falla. Du kan använda din potentiometer för att undvika dem, och din knapp för att sakta ner tiden.

I detta projekt har vi skapat en anpassad controller med en Arduino, konfigurerat Unity och Uniduino för att kommunicera med den och skapat ett enkelt spel för att testa det. Begreppen här kan tillämpas på nästan alla projekt, och det finns till och med spelstopp som är specialiserade på anpassade kontroller .

Med Arduino och Unity kan du skapa en anpassad controller från nästan vad som helst. Har du skapat en hi-fi som styr ett rymdfarkoster? En brödrost som styr ett plattformsspel?

Om du har gjort ett projekt som det här skulle jag gärna se det! Lägg upp det i kommentarerna nedan!

Dela med sig Dela med sig Tweet E-post 6 hörbara alternativ: De bästa gratis eller billiga ljudboksapparna

Om du inte vill betala för ljudböcker, här är några bra appar som låter dig lyssna på dem gratis och lagligt.

Läs Nästa Relaterade ämnen
  • DIY
  • Programmering
  • Arduino
  • Spelkontroll
  • Spelutveckling
Om författaren Ian Buckley(216 artiklar publicerade)

Ian Buckley är frilansjournalist, musiker, artist och videoproducent som bor i Berlin, Tyskland. När han inte skriver eller på scenen, pysslar han med DIY -elektronik eller kod i hopp om att bli en galet forskare.

Mer från Ian Buckley

Prenumerera på vårt nyhetsbrev

Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!

Klicka här för att prenumerera