Tworzenie gier - #3 - Przygotowania

H1M4W4R1 · Marzec 13, 2021

Ten artykuł jest częścią serii "Tworzenie gier"

O czym w tym rozdziale?

W tym rozdziale zajmiemy się przygotowaniami do stworzenia gry - przemyślimy koncepcję i wybierzemy odpowiednie rozwiązania na konkretne problemy.

Pomysł?

Pomysłem jest stworzenie gry prezentującej API, które było pokazane w poprzednim artykule w rzeczywistym projekcie. Będzie to prosta gierka, w której sterujemy magiem i możemy rzucać zaklęcia. Zaklęcia powinny być możliwe do łatwej edycji przez deweloperów.

Wybór silnika?

Jako, że mam doświadczenie wybiorę Unity3D - początkującym również go polecam, gdyż jest bardzo prosty w nauce oraz posiada zestaw kursów, który opisuje wszystkie zagadnienia jakie możesz tutaj napotkać (no może poza paroma bardziej złożonymi. Dodatkowo powyższe API było pod ten silnik projektowane, więc automatycznie ten wybór jest narzucony.

Filary rozgrywki i monetyzacja

Jako, że jest to projekt przykładowy nie będzie w nim skomplikowanych mechanik czy monetyzacji. W osobnym rozdziale bądź sekcji postaram się poruszyć najczęściej używane API, aczkolwiek w tym projekcie nie będzie ani integracji z Facebookiem czy Google, ani zakupów czy reklam. Będzie to prosta, zwykła gierka do pobawienia się.

Głównym filarem rozgrywki będzie możliwość rzucania zaklęć za pomocą odpowiednich klawiszy oraz poruszania postacią w sposób zbliżony do gier pokroju Path of Exile, Pillars of Eternity czy Diablo. W grze widok na postać będzie rzutem izometrycznym, kamera będzie podążała za postacią (postać zawsze będzie w centrum). Gracz będzie miał do wyboru kilka zaklęć pod klawiszami cyfr na klawiaturze. Klawisze będą przypisane na stałe.

Grafika? Assety?

Do grafiki zostanie wykorzystany gotowy asset Simple Fantasy od Synty Studios.

Z dodatkowych assetów wykorzystane zostanie API Spellie. Prawdopodobnie oprócz tego skorzystamy z Odin Inspector'a oraz DOTween PRO. Oprócz tego prawdopodobnie "w praniu" dojdą jeszcze jakieś Assety, aczkolwiek to jest nasza "baza" dla gry.

Dla animacji skorzystamy z zasobów Mixamo.

Co będzie trzeba zrobić?

Będzie trzeba zaprojektować poziom. To jest ta przyjemniejsza część zadania. Potem należy przygotować programistyczny opis gracza oraz przeciwnika, zaimplementować życie postaci oraz otrzymywanie obrażeń. Prawdopodobnie również pasek UI od życia. Po tym ruszanie się postaci w określone miejsce, AI przeciwników, NavMesh'a, animacje oraz rzucanie zaklęć. Czegoś nie rozumiesz? Spokojnie, wszystko wyjaśni się w odpowiednim momencie

Wygląda skomplikowanie? To jest dość prosta gierka, a sam opis jest "znacząco uproszczony", by nie utrudniać czytania artykułu

Taki krótki ten artykuł?

A czy zauważyłeś, że aż dwa artykuły zostały poświęcone zanim napisałeś pierwszą linijkę kodu? Każdy myśli, że programowanie gier zaczyna się od napisania kodu... wbrew pozorom najpierw trzeba wszystko rozplanować. Gdy piszesz "na pałę" prostą grę tworzysz około 2 miesięcy. Aktualnie prototypy pod CTR są u nas tworzone w czasie 7-10 dni, z czego przed tym 2 dni są poświęcane na dyskusje n/t gry. Dyskusje po 4-6 godzin dziennie! To pokazuje ogromny przemiał tytułów i informacji, z których wybierane są ziarna. Z tych ziaren potem ma szansę wyrosnąć plon, aczkolwiek nawet plon czasem może zwiędnąć przez niewłaściwe decyzje rolników (projektantów).

Już obiecuję, że następny artykuł będzie bezpośrednio powiązany z tworzeniem gry... (pewnie dlatego, że mam limit na 5 artykułów, a już napisałem trzy ).

Czy bez znajomości programowania mogę zacząć z Unity?

Tak i nie. Są dwie ścieżki - wykorzystujesz system do programowania wizualnego (np. Playmaker), albo uczysz się programować. Podstawy programowania opanujesz w (niezbyt dobrze opracowanym, aczkolwiek zupełnie darmowym) kursie, albo możesz na własną rękę również poszukać materiałów o języku C#.

Są jakieś "Assety" do Unity, które warto posiadać?

Oczywiście - Odin Inspector, DOTween PRO - z tych dwóch korzystam praktycznie w każdym projekcie. Reszta to głównie assety graficzne dobierane pod projekt. Po pewnym czasie się ich tyle gromadzi, że jest z czego wybierać

Treker · Marzec 18, 2021

@H1M4W4R1 wpis został właśnie zaakceptowany, więc jest już widoczny publicznie

wn2001 · Marzec 18, 2021

@H1M4W4R1 Ciekawa seria artykułów, nietuzinkowa biorąc pod uwagę tematykę forum Czyli w sumie, jeśli ma się możliwość zakupu gotowego krajobrazu, to Ty jako programista może się skupić na "tym, co w środku"? Zawsze zastanawiało mnie (nie gram właściwie), czy taki kod gry uwzględnia "każdy pixel" osobno, czy właśnie jest to rozdzielone na warstwy - i widzę, że jest to bardziej budowa "modułowa", czyli Twój kod połączony z multimediami (głównie grafiką, która może być gotowa), a nad wszystkim czuwa silnik?

I jeszcze nawiązując do robotyki - czy w Unity byłoby skomplikowane stworzenie symulacji ramienia robota w 3D, najlepiej jeszcze, aby możliwa była komunikacja przez UART? Coś takiego - czy łatwiej zabrać się do tego inną metodą?

H1M4W4R1 · Marzec 18, 2021

3 minuty temu, wn2001 napisał:

czy taki kod gry uwzględnia "każdy pixel" osobno, czy właśnie jest to rozdzielone na warstwy

Jest to jak najbardziej rozdzielone na warstwy - jeszcze więcej tych warstw jest pełno

Sam silnik odpowiada za ułatwianie pracy dla programistów i projektantów - pozwala na banalne umieszczenie modelu w przestrzeni. Konkurencyjnym przykładem z zajęć informatyki w liceum może być PovRay, który jest silnikiem renderującym 3D (nie do gier), aczkolwiek pokazuje, jak to wygląda w bardziej zaawansowanym świecie. Oczywiście są też dużo niższe poziomy dostępne zarówno w jednym jak i w drugim miejscu - w Unity np. możesz tworzyć świat zbliżony do MineCrafta z vertexów, triangli, quadów etc., aczkolwiek to treść na kolejny artykuł-kobyłę (3500 słów+). Wtedy możesz operować na dużo bardziej skomplikowanych matematycznie elementach. W przykładzie jest tworzenie prostej kostki na niskim poziomie w Unity

7 minut temu, wn2001 napisał:

I jeszcze nawiązując do robotyki - czy w Unity byłoby skomplikowane stworzenie symulacji ramienia robota w 3D,

Oczywiście - symulacja właściwie nie jest trudna - musisz tylko odpowiednio ustawić elementy (najlepiej rozbić je na fragmenty takie jak silnik, oś silnika). Do osi silnika podpinasz ramię i wtedy obracając oś obraca się też podpięte do niej ramię. Możesz też ograniczyć kąty obrotu. Tutaj podrzucę fragment jednego z moich uniwersalnych skryptów do obsługi kamery, która patrzy na obiekt pod określonym kątem

using System;
using System.Collections.Generic;
using Lean.Touch;
using Sirenix.OdinInspector;
using UnityEngine;

namespace Gameplay
{
    public class CameraView : MonoBehaviour
    {
        /// <summary>
        /// Percentage of screen reserved for camera rotation
        /// </summary>
        [Header("Screen")]
        public float rotationHeightPercentage = 0.1f;

        [Header("Camera")] public Transform mainCamera;
        
        /// <summary>
        /// Object to follow
        /// </summary>
        public Transform targetObject;

        /// <summary>
        /// Distance of camera
        /// </summary>
        public float distance;

        /// <summary>
        /// Radius of camera rotation zone
        /// </summary>
        public float radius;

        /// <summary>
        /// Defines if camera should be finger rotatable
        /// </summary>
        public bool fingerRotate;
        
        /// <summary>
        /// Angle of camera - X axis (height rotation)
        /// </summary>
        [Header("Camera angles")] public float angleX;
        
        /// <summary>
        /// Angle of camera - Y axis (around rotation)
        /// </summary>
        public float angleY;

        /// <summary>
        /// Min X Angle
        /// </summary>
        public float minXAngle = 15;
        
        /// <summary>
        /// Max X Angle
        /// </summary>
        public float maxXAngle = 75;

        /// <summary>
        /// Describes full rotation around x-axis in screens value :D 
        /// </summary>
        [Header("Sensitivity")] [InfoBox("Sensitivity describes how many screens are required to rotate around 360 degrees")]
        [ShowIf("fingerRotate")] public float xSensitivity = 2f;
        
        /// <summary>
        /// Describes full rotation around y-axis in screens value :D
        /// </summary>
        [ShowIf("fingerRotate")]
        public float ySensitivity = 2f;
        
        /// <summary>
        /// Local finger storage
        /// </summary>
        private List<LeanFinger> _fingers = new List<LeanFinger>();

        [Header("Sponge Follow")] public bool followSpongeRotation = false;
        private WashingSponge _sponge;
        
        private void Awake()
        {
            _sponge = FindObjectOfType<WashingSponge>();

            // Rotation lock height
            var screenPixels = rotationHeightPercentage * Screen.height;
            
            // On finger down add finger to list
            if (fingerRotate)
            {
               /* ... */
            }
        }

        private void Update()
        {
            if (followSpongeRotation)
                angleY = _sponge.transform.eulerAngles.y;
            
            // Rotate camera first
            var euler = mainCamera.eulerAngles;
            if (angleX < minXAngle) angleX = minXAngle;
            if (angleX > maxXAngle) angleX = maxXAngle;
            
            euler.x = angleX;
            euler.y = angleY;
            mainCamera.eulerAngles = euler;
            
            // Calculate camera position
            var tX = Mathf.Cos(Mathf.Deg2Rad * angleY) * radius;
            var tY = Mathf.Sin(Mathf.Deg2Rad * angleY) * radius;
            
            var cPos = new Vector3(-tY, 0, -tX) + targetObject.position - mainCamera.forward * distance;

            // Move camera to position
            mainCamera.position = cPos;

        }
    }
}

Jak widać możemy bez problemu posługiwać się kątami Eulera. Oprócz tego również mamy dostęp do macierzy rotacji oraz szeregu narzędzi pozwalających np. na obliczenie macierzy rotacji np. obracającej dany obiekt o x stopni wokół osi X oraz y stopni wokół osi Y. Wtedy wystarczy, że przemnożymy rotację obiektu przez obrót wynikający z wyznaczonej macierzy rotacyjnej i sam obiekt się obraca (to dla tych co spali na matematyce ). Ale z reguły w 99.999% przypadków korzysta się z kątów Eulera

12 minut temu, wn2001 napisał:

aby możliwa była komunikacja przez UART

Unity obecnie korzysta z .NET 4.5.1 (bodajże o ile dobrze pamiętam, na pewno 4.X.X, może nawet 5.X.X). Dostępne są więc praktycznie wszystkie funkcje systemu

public class Sample : MonoBehaviour
{
    private SerialPort port = new SerialPort();


    private void Start()
    {
        port.BaudRate = 115200;
        port.PortName = "COM21";
        port.Open();
        
        port.WriteLine("125");
        
    }

}