Ivara blogs : XNA, Lidinators

Čukča nav lasītājs! Čukča rakstnieks! Lidinators v0.7

ivars.arins — Mon, 04 May 2009 12:25:00 GMT

Nu ko, labs laiciņš pagājis, kopš pēdējās Lidinatora sērijas. Pienācis laiks seriālu atdzīvināt un šodienas sērijas tēma – teksta izvadīšana uz ekrāna.

Teksta izvadīšanai XNA neizmanto vektoru šrifta tehnoloģijas (piem., OpenType), bet atgriežas pie rastra šriftiem. Nē, tas nenozīmē, ka izstrādātājam ir jāizzīmē katra rakstzīme, vienkārši XNA satura konveijers kompilācijas laikā nodrošina vektoru šrifta pārveidošanu par rastra šriftu, kuru atspoguļo SpriteFont klase.

Šajā vietā laikam jāievieto juridiskā atruna. Ir kāds fakts, kuru varbūt ne visi zina, bet šrifti, gluži kā programmatūra, tiek izplatīti ar kādu licenci. Un ne vienmēr šī licence pieļauj tālāku šrifta izplatīšanu. Tātad, lai nesanāktu juridiskas dabas problēmas ir ieteicams noskaidrot, kas izmantotā šrifta licencē ir minēts par tā tālāku izplatīšanu. Microsoft XNA Game Studio ir iekļāvis dažus šriftus, kuru izplatīšana ir atļauta (pieejami arī atsevišķai lejupielādei), tāpat, cik es saprotu, Open Font Library pieejamos šriftus var izplatīt.

Pēc tam, kad ir noskaidrots, kādu šriftu izmantot, nepieciešams to pievienot XNA projekta saturam, “Content” sadaļā izvēloties "Add” –> “New Item”. Dialoga logā izvēlamies tipu “Sprite Font” un ierakstam nosaukumu kāds šriftam tiks izmantots kodā.

Atverot SpriteFont failu Visual Studio redaktorā, var redzēt, ka tas ir XML fails, kurā tiek definēts izmantotais šrifts un tā īpašības. Mainot FontName elementu, var nomainīt izmantoto šriftu:

<FontName>Miramonte</FontName>

Tālāk nedaudz jāpapildina resursu ielādēšanas kods:

        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            baseFont = this.Content.Load<SpriteFont>("BaseFont");
            
            base.LoadContent();
        }

Un kadra zīmēšanas kods, izmantojot SpriteBatch.DrawString metodi:

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(backgroundColor);
            base.Draw(gameTime);
            this.spriteBatch.Begin();
            for (int i = 0; i < this.ships.Count; i++)
            {
                string text = String.Concat(
                    "Ship ",
                    (i + 1),
                    " HP: ",
                    this.ships[i].Health);

                this.spriteBatch.DrawString(
                    this.baseFont, 
                    text, 
                    new Vector2(0, i * 50), 
                    this.ships[i].Tint);
            }
            
            this.spriteBatch.End();
        }

Rezultāts:

Manuprāt, atstarpe starp teksta rindām ir pārāk liela, bet to var labot. Viens no variantiem būtu izmainīt maģisko konstanti 50 zīmēšanas metodes kodā, bet šāds risinājums nebūtu pārāk elastīgs. Piemēram, izmainot šrifta lielumu, izmainītos arī atstarpe starp rindām. Labāk būtu izmantot pārnešanu jaunā rindā, vai arī noteikt teksta izmēru ar SpriteFont.MeasureString metodi, un aprēķināt nākošās rindas pozīciju. Pirmais variants būs labāks gadījumos, kad teksts ir jāizvada vairākās rindās pēc kārtas, savukārt otrais ļauj daudz precīzāk pozicionēt tekstu gan pa horizontāli, gan vertikāli.

Izvēlējos otro variantu, jo tas nākotnē paver plašākas pozicionēšanas iespējas.

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(backgroundColor);
            base.Draw(gameTime);
            this.spriteBatch.Begin();
            float textY = 0;
            for (int i = 0; i < this.ships.Count; i++)
            {
                string text = String.Concat(
                    "Ship ",
                    (i + 1),
                    " HP: ",
                    this.ships[i].Health);
                this.spriteBatch.DrawString(
                    this.baseFont, 
                    text, 
                    new Vector2(0, textY), 
                    this.ships[i].Tint);
                
                textY += this.baseFont.MeasureString(text).Y;
            }
            
            this.spriteBatch.End();
        }

Piekrītat, ka izskatās labāk?

Līdz nākošajai sērijai!

pirmkods

Bang! Bang! They shoot in a space! Lidinators v0.6

ivars.arins — Mon, 22 Dec 2008 07:53:00 GMT

Sveiki! Tuvojas ziemas saulgrieži, un Ziemassvētku noskaņā nolēmu iemācīt Lidinatora raķetēm “pikoties”. Liekot lietā visu savu zīmēšanas talantu, izveidoju grafikas gariņu, kuru izmantot.

Nākošais solis ir izveidot klasi, kas atspoguļos lodes īpašības un uzvedību. Absolūtais minimums ir no SpriteComponent (kas ir SpriteComponent, var izlasīt 5ajā sērijā) mantota klase, kas konstruktorā norāda attēlošanai izmantoto klasi. Sperot vēl vienu soli uz priekšu, izveidoju konstruktoru, kuram kā papildus parametri ir kuģa koordinātes un leņķis. Šie mainīgie tiks izmantoti, lai noteiktu lodes sākumpozīciju un virzienu. No kuģa klases Update() metodes nokopēju koordināšu izmaiņu daļu (jā, zinu, ka tā darīt ir slikti, bet pamazām jau sāku saprast, kā to nāksies refaktorēt). Visu šo darbību rezultātā ieguvu Bullet klasi:

    class Bullet : SpriteComponent
    {
        private float speed;

        public Bullet(Game game)
            : this(game, new Vector2(), 0)
        {
        }

        public Bullet(Game game, Vector2 location, float angle) : base(game)
        {
            this.textureAsset = "bullet_sprite";
            this.location = location;
            this.angle = angle;
            this.speed = 20;
        }
        /// <summary>
        /// Allows the game component to perform any initialization it needs to before starting
        /// to run.  This is where it can query for any required services and load content.
        /// </summary>
        public override void Initialize()
        {
            // TODO: Add your initialization code here

            base.Initialize();
        }

        /// <summary>
        /// Allows the game component to update itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        public override void Update(GameTime gameTime)
        {
            // TODO: Add your update code here
            location.X += speed * (float)Math.Sin(angle / 180 * Math.PI);
            location.Y -= speed * (float)Math.Cos(angle / 180 * Math.PI);

            base.Update(gameTime);
        }

Ship klase ir jāpapildina ar jauniem mainīgajiem – šaušanas taustiņu un izšauto šāviņu kolekciju, kā arī Update() metodē jāpievieno izšaušanas loģika.

            if (currentState.IsKeyDown(FireKey))
            {
                var bullet = new Bullet(this.Game, this.location, this.angle);
                this.bullets.Add(bullet);
                this.Game.Components.Add(bullet);
            }

Sākumam ar to pietiek un šobrīd jau var papriecāties par šaujošiem kuģiem.

Tomēr šai relizācijai ir viens būtisks trūkums, t.i., tā neaizvāc lodes, kuras ir izlidojušas ārpus ekrāna robežām. Lai to izdarītu, nāksies nedaudz piestrādāt gan Bullet, gan Ship klasēs. Kuģa klasei izveidoju papildus metodi, kas veic lodes izvākšanu no kuģa ložu kolekcijas un spēles komponentu kolekcijas.

        internal void RemoveBullet(Bullet bullet)
        {
            this.bullets.Remove(bullet);
            Game.Components.Remove(bullet);
        }

Ložu klasei papildināju konstruktoru, lai tam tiktu nodots kuģis, kurš izšāvā lodi, kā arī Update() metodi ar lodes iznīcināšanas loģiku.

            if (Math.Abs(location.X) > Game.Window.ClientBounds.Width / 2
                || Math.Abs(location.Y) > Game.Window.ClientBounds.Height / 2)
            {
                // remove bullet if out of screen bounds
                parent.RemoveBullet(this);
                this.Dispose();
                return;
            }

Lai būtu interesantāk, kuģa izšaušanas mehānismu var papildināt ar maksimālā ložu skaita ierobežojumu.

            if (currentState.IsKeyDown(FireKey) && this.bullets.Count < 11)
            {
                var bullet = new Bullet(this.Game, this, this.location, this.angle);
                this.bullets.Add(bullet);
                this.Game.Components.Add(bullet);
            }

Tagad atkal var paspēlēties un paskatīties, kas no visa ir sanācis. Šodienai vēl ir atlicis tikai izveidot tādu “sīkumu”, kā iespēju iznīcināt otru kuģi. Lai to realizētu pēc iespējas universālāk, papildināsim SpriteComponent klasi, pievienojot dažus mainīgos:

Destroyable – norāda, vai objekts ir iznīcināms
Damage – norāda, cik lielus bojājumus objekts nodara otram objektam pie sadursmes
Health – norāda, cik daudz “dzīvības” objektam ir atlicis

Savukārt objektu konstruktoros inicializēsim šos mainīgos ar atbilstošajām vērtībām.

Lai veiktu sadursmju noteikšanu Game klases Update() metode ir jāpapildina ar dubultu ciklu, kurā pārbauda, vai Components kolekcijā esošie objekti saduras un sadursmes gadījumā atbilstoši izmaina to stāvokli. Jāpiebilst, ka objektu kopu atlasīšanai lieliski noderēja LINQ-to-objects.

            var gameObjects = from component in this.Components
                              where component is SpriteComponent
                              select component;
            
            foreach (SpriteComponent gameObject in gameObjects)
            {
                var otherObjects = from component in this.Components
                                  where component is SpriteComponent
                                        && component != gameObject
                                  select component;
                foreach (SpriteComponent otherObject in otherObjects)
                {
                    BoundingSphere sphere = gameObject.GetBoundingSphere();
                    if (sphere.Intersects(otherObject.GetBoundingSphere()) 
                        && otherObject.Destroyable)
                    {
                        otherObject.Health -= gameObject.Damage;
                    }
                }
            }

Iznīcinātie objekti ir korekti jāaizvāc, tādēļ SpriteComponent papildināsim ir virtuālo metodi objektu aizvākšanai.

        internal virtual void Destroy()
        {
            this.Game.Components.Remove(this);
            this.Dispose();
        }

Bullet klasei šo operāciju ir jāpārraksta, lai lodi izvāktu no kuģa izšauto ložu kolekcijas.

        internal override void Destroy()
        {
            this.parent.RemoveBullet(this);
            base.Destroy();
        }

Un vēlreiz jāpapildina Game.Update() metode, lai veiktu objektu iznīcināšanu:

            var destroyedObjects = new List<SpriteComponent>();
            foreach (SpriteComponent gameObject in gameObjects)
            {
                if (gameObject.Health <= 0)
                {
                    destroyedObjects.Add(gameObject);
                }
            }

            foreach (SpriteComponent item in destroyedObjects)
            {
                item.Destroy();
            }
            
            destroyedObjects = null;

Ja tagad mēģinās spēlēt Lidinatoru, tad varēs novērot dīvainību – izšautās lodes uzreiz pazūd, efektīvi pašiznīcinot kuģi. Iemesls tam ir izšauto ložu inicializācija, kur tās pārklājas ar kuģi. Lai no šīs problēmas izvairītos ir jāizmaina Bullet konstruktors.

        public Bullet(Game game, Ship parent, Vector2 location, float angle) : base(game)
        {
            this.textureAsset = "bullet_sprite";
            this.parent = parent;
            this.location = location;
            this.angle = angle;
            this.speed = 20;
            this.Destroyable = false;
            this.Health = 1;
            this.Damage = 10;

            float shipRadius = parent.GetBoundingSphere().Radius;
            this.location.X -= shipRadius * 1.25f;
            this.location.Y -= shipRadius * 1.25f;
            this.location.X += (shipRadius * 2) * (float)Math.Sin(this.AngleInRads);
            this.location.Y -= (shipRadius * 2) * (float)Math.Cos(this.AngleInRads);
        }

Jāatzīst, ka šis koda fragments nav labas programmēšanas paraugs, bet tas darbojas :)

Neiztrūkstošais pirmkods

Viens kuģis labi, divi vēl labāk. Lidinators v0.5

ivars.arins — Thu, 04 Dec 2008 06:33:00 GMT

Kā minēju iepriekšējā “Lidinatora” sērijas rakstā, viena no tuvākajā laikā īstenojamajām lietām ir vairākspēlētāju režīms, kuru tad iesākšu realizēt šajā sērijā.

Kopš iepriekšējā raksta esmu nedaudz pārstrādājis kodu, izveidojot bāzes komponentu SpriteComponent, kurā ir iznestas LoadContent(), Draw() un GetBoundingSphere() metodes, kas bija kopīgas gan planētām, gan kuģim. Līdz ar to, klasēs, kuras reprezentē minētos objektus ir palicis tikai stāvokļa izmaiņas kods. Detalizētāk to varēs apskatīt raksta beigās pievienotajā pirmkodā.

Atgriežoties pie vairākspēlētāju režīma varu pavēstīt priecīgu ziņu – pamatā kods jau uztur iespēju izmantot vairākus kuģus vienlaicīgi. Vienīgi viņi sāks vienā un tajā pašā punktā un vienādi reaģēs uz nospiestajiem taustiņiem un tādēļ nebūs atšķirami. Tātad, ir trīs risināmi jautājumi:

Kuģa sākuma koordinātes
Dažādi vadības taustiņi
Kuģu atšķirības zīmes

Pirmo punktu var atrisināt, papildinot kuģa konstruktora metodi, piedāvājot iespēju norādīt sākumpunkta koordinātes.

        public Ship(Game game, Vector2 startLocation): base(game)
        {
            this.location = startLocation;
            this.textureAsset = "ship_sprite";
        }
        
        public Ship(Game game)
            : this(game, new Vector2())
        {
        }

Kā redzams, ir atstāts arī vecais konstruktors, kurš inicializē kuģi ekrāna centrā. Papildināsim spēles klases konstruktoru, lai redzētu, kā izskatās vairāki kuģi uz viena ekrāna.

            ships = new List<Ship>();
            for (int i = 0; i < 4; i++)
            {
                var shipLocation = new Vector2(
                    (i + 1) * Window.ClientBounds.Width / 5 - Window.ClientBounds.Width / 2,
                    0);
                var ship = new Ship(this, shipLocation);
                ships.Add(ship);
                Components.Add(ship);
            }

Lai varētu paspēlēties, pagaidām atkal ir jāizkomentē sadursmju noteikšana. Toties, spriežot pēc attēla, ne vienai vien lidotāju vienībai skauž cik sinhroni šie puši prot lidot.

Problēmu saraksts ir saīsināts par vienu punktu. Turpināšu ar trešo punktu, t.i. kuģu atšķiršanu. Ar šo punktu ne tikai tāpēc, ka to ir vieglāk realizēt, bet arī tādēļ, ka esmu ieplānojis to izmantot pārveidotajā sadursmju noteikšanā.

Lai atšķirtu kuģus, iekrāsosim tos dažādos toņos. Savukārt, lai varētu kuģus iekrāsot, nepieciešams papildināt bāzes komponentu ar īpašību toņa glabāšanai un jaunu konstruktoru, kuram var nodot toni.

        public Color Tint {get; set;}
        
        public SpriteComponent(Game game, Color tint)
            : base(game)
        {
            this.Tint = tint;
        }

Bāzes objektu papildināt nākas divu iemeslu pēc. Pirmkārt, tajā ir realizēta gariņa zīmēšana. Otrkārt, nākotnē varētu būt vēlme zīmēt tonētas planētas. Savukārt tonis ir publisks tikai tāpēc, lai pie sadursmju noteikšanas varētu mainīt fona krāsu uz vainīgā kuģa krāsu.

Lai redzētu izmaiņas, nepieciešams izmainīt zīmēšanas metodi, un Color.White vietā izmantot iepriekš norādīto toņa vērtību. Jāņem vērā, ka norādītais tonis tiek lietots kā maska, tādēļ vēlams izmantot ļoti gaišas krāsas, lai saglabātu vismaz daļēju oriģinālo krāsojumu.

            spriteBatch.Draw(
                sprite,
                center + location - spriteCenter,
                null,
                Tint,
                angle * (float)Math.PI / 180,
                spriteCenter,
                1,
                SpriteEffects.None,
                0);

Un atkal jāmaina kuģu inicializācija, tagad jau izmantojot krāsas:

            ships = new List<Ship>();
            var colors = new[] 
            {
                Color.White,
                new Color(255,164,164),
                new Color(164,255,164),
                new Color(164,164,255)
            };
            
            for (int i = 0; i < 4; i++)
            {
                var shipLocation = new Vector2(
                    (i + 1) * Window.ClientBounds.Width / 5 - Window.ClientBounds.Width / 2,
                    0);
                var ship = new Ship(this, shipLocation, colors[i]);
                ships.Add(ship);
                Components.Add(ship);
            }

Un sadursmju noteikšana:

            backgroundColor = Color.CornflowerBlue;
            foreach (var ship in this.ships)
            {
                BoundingSphere shipSphere = ship.GetBoundingSphere();
                foreach (var planet in planets)
                {
                    if (shipSphere.Intersects(planet.GetBoundingSphere()))
                    {
                        backgroundColor = ship.Tint;
                    }
                }
            }

Domāju, ka ir pienācis brīdis, kad var papriecāties par rezultātu.

Šobrīd no sākotnējā saraksta ir atlicis tikai viens punkts, dažādu vadības taustiņu definēšana. Vienkāršākajā variantā nepieciešams kuģa objektam nodefinēt četras īpašības, kur katra atbilst vienai no darbībām un atbilstoši izmainīt kuģa Update() metodes pārbaudes. Tas izskatās šādi:

        public Keys LeftKey { get; set; }
        public Keys RightKey { get; set; }
        public Keys DownKey { get; set; }
        public Keys UpKey { get; set; }

tad ir nedaudz izlaista koda un pārbaudes bloks ir mainīts pēc šāda principa:

            if (currentState.IsKeyDown(UpKey))
            {
                speed += 3;
            }

Atkal izmainam daudz cietušo kuģu inicializācijas bloku:

            ships = new List<Ship>();
            var colors = new[] 
            {
                Color.White,
                new Color(255,164,164),
                new Color(164,255,164),
                new Color(164,164,255)
            };
            
            var shipLocation = new Vector2(
                Window.ClientBounds.Width / (-4),
                0);
            var ship = new Ship(this, shipLocation, colors[0])
                {
                    UpKey = Keys.Up,
                    DownKey = Keys.Down,
                    LeftKey = Keys.Left,
                    RightKey = Keys.Right
                };
            ships.Add(ship);
            Components.Add(ship);

            shipLocation = new Vector2(Window.ClientBounds.Width / 4, 0);
            ship = new Ship(this, shipLocation, colors[2])
                {
                    UpKey = Keys.I,
                    DownKey = Keys.K,
                    LeftKey = Keys.J,
                    RightKey = Keys.L
                };
            ships.Add(ship);
            Components.Add(ship);

Un divspēlētāju “Lidinators” ir gatavs. Tagad divreiz labāks par to pašu cenu! :)

Pirmkods

Iesaiņojums. Daudz iesaiņojuma. Lidinators v0.4

ivars.arins — Tue, 02 Dec 2008 17:00:00 GMT

Gandrīz nedēļa pagājusi, kopš pēdējās “Lidinatora” sērijas, kuras beigas vēl nav tik drīz paredzamas. Šodienas sērijā Kamila raudot pastāsta Himēnai, ka Vasko taču ir Bernabes draugs un, tā kā viņš ir Ursulas mīļākais, tad būtu varējis iekļūt pilī un nozagt vēstuli. esmu paredzējis nedaudz satīrīt esošo pirmkodu, tajā pašā laikā apskatot klāt jaunu XNA apgabalu.

Ja paskatās uz spēles Update() un Draw() metodēm, kļūst skaidrs, ka šādi turpinot neko daudz papildināt nevarēs. Pareizāk sakot – varēs, bet kods kļūs pavisam nepārskatāms, jo katrs jaunais objekts, visticamāk, “uzpūtīs” šīs metodes. Savukārt, manā galvā esošā vīzija par to, kā vajadzētu izskatīties pabeigtam “Lidinatoram”, nepārprotami liecina, ka papildināt vajadzēs un viena no tuvākajā laikā realizējamajām lietām ir vairākspēlētāju režīms. Tāpēc sākšu ar kuģa “iesaiņošanu” atsevišķā klasē.

Tā kā XNA platforma ir paredzēta, lai atvieglotu spēļu izstrādi tiem, kam tas ir tikai hobijs, tad šeit jau ir iepriekš padomāts par darba vienkāršošanu. Tā vietā, lai izstrādātājs sāktu no tukšas vietas veidot savu klašu hierarhiju, tiek piedāvāti bāzes objekti GameComponent un DrawableGameComponent. Kāpēc izmantot šos komponentus? Kaut vai tādēļ, ka kopā ar Game klases GameComponentCollection saraksta palīdzību var automātiski izpildīt komponentes stāvokļa atjaunošanas vai zīmēšanas (tikai DrawableGameComponent) metodes, nerakstot papildus kodu.

Tātad, pievienojam jaunu sastāvdaļu projektam, izvēloties jaunu XNA komponentu

un mūsu rīcībā ir komponenta skelets ar sagatavēm Initialize() un Update() metodēm:

/// <summary>
/// This is a game component that implements IUpdateable.
/// </summary>
public class Ship : Microsoft.Xna.Framework.GameComponent
{
    public Ship(Game game)
        : base(game)
    {
        // TODO: Construct any child components here
    }

    /// <summary>
    /// Allows the game component to perform any initialization it needs to before starting
    /// to run.  This is where it can query for any required services and load content.
    /// </summary>
    public override void Initialize()
    {
        // TODO: Add your initialization code here

        base.Initialize();
    }

    /// <summary>
    /// Allows the game component to update itself.
    /// </summary>
    /// <param name="gameTime">Provides a snapshot of timing values.</param>
    public override void Update(GameTime gameTime)
    {
        // TODO: Add your update code here

        base.Update(gameTime);
    }
}

Tā bija uzdevuma vieglākā daļa. Tagad jāsāk pārnest loģika no spēles pamatklases uz šejieni. Pirmkārt, visi mainīgie, kurā glabājās informācija par kuģa stāvokli:

        Vector2 location;
        Texture2D sprite;
        float speed, rotationSpeed, angle;
        const float MaxSpeed = 10;
        const float MaxRotationSpeed = 3;

Inicializācijas metodē norādam kuģa sākumstāvokli:

        public override void Initialize()
        {
            location = new Vector2(0, 0);
            base.Initialize();
        }

Savukārt Update() metode saņem visu kuģa pārvietošanas kodu, kuru šeit neievietošu.

Kā jau nedaudz augstāk rakstīju, objektiem, kuri tiek attēloti uz ekrāna, nepieciešams, lai to “sencis” būtu DrawableGameComponent. Diemžēl, XNA nepiedāvā sagatavi šādam objektam, tādēļ nepieciešams izmainīt klases defīnīciju, lai tā mantotos no pareizā tipa, kā arī pievienot Draw() metodi (pēc Game klases ģīmja un līdzības)

        public override void Draw(GameTime gameTime)
        {
            Vector2 center = new Vector2(
                Game.Window.ClientBounds.Width / 2,
                Game.Window.ClientBounds.Height / 2);
            Vector2 shipCenter = new Vector2(sprite.Width / 2, sprite.Height / 2);

            spriteBatch.Begin();
            spriteBatch.Draw(
                sprite,
                center + location - shipCenter,
                null,
                Color.White,
                angle * (float)Math.PI / 180,
                shipCenter,
                1,
                SpriteEffects.None,
                0);
            spriteBatch.End();
            base.Draw(gameTime);
        }

Šajā posmā nācās atrisināt vēl divas problēmas. Pirmā – nav pieejams SpriteBatch, ar kura palīdzību zīmēt, otrā – nav ielādēta gariņa tekstūra. Šeit izdevās nošaut divus zaķus ar vienu šāvienu, t.i. abas problēmas atrisinājās ar LoadContent() metodes pievienošanu:

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
            sprite = Game.Content.Load<Texture2D>("ship_sprite");
            base.LoadContent();
        }

Žēl, jo es jau biju paspējis izdomāt viltīgu mehānismu ar tekstūru ielādēšanu spēles pamatklasē un tekstūru kolekcijas nodošanu objektiem. Eh…

Ja tagad papildina spēles konstruktoru ar kuģa objekta izveidi un tā ievietošanu spēles sastāvdaļu kolekcijā, tad var palaist spēli un pārliecināties, ka tā būtiski nav mainījusies. Tik vien, kā nāksies izkomentēt (vai pārrakstīt) sadursmju noteikšanu. Turpinot uzkopšanas darbus, izveidoju līdzīgu klasi planētai. Šajā brīdī tapa skaidrs, ka sava bāzes klase, kas būtu mantota no DrawableGameComponent, būtu noderējusi, jo vairākas metodes abām klasēm ir praktiski vienādas. Tomēr šo soli atstāšu vēlākam laikam.

Šobrīd kods joprojām darbojas bez sadursmju noteikšanas, tādēļ papildināsim abas klases (kuģim un planētai), lai varētu piekļūt to ierobežojošajām BoundingSphere lodēm. Šī ir kārtējā metode, kas dublējas abām klasēm:

        public BoundingSphere GetBoundingSphere()
        {
            return new BoundingSphere(
                new Vector3(location, 0), 
                (float)(sprite.Width / 2.5));
        }

Beidzot ir pienācis laiks parādīt, kādi tad tagad ir spēles pamatklases lauki un konstruktors:

        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Ship ship;
        Planet planet;
        bool crashed;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            ship = new Ship(this);
            planet = new Planet(this);
            Components.Add(planet);
            Components.Add(ship);
        }

Update() ir vienkāršojusies līdz:

        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            crashed = ship.GetBoundingSphere().Intersects(
                planet.GetBoundingSphere());

            base.Update(gameTime);
        }

Tagad spēle darbojas tāpat, kā bija pirms tika uzsākta pārveidošana. Kāda no tā jēga, ja koda ir palicis vairāk un tas ir pat sarežģītāks? Viens no ieguvumiem – ar pavisam nelieliem pārveidojumiem varam uz ekrāna izvietot vairākas planētas. Ir tikai nedaudz jāizmaina konstruktors:

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            ship = new Ship(this);
            planets = new List<Planet>();
            for (int i = 0; i < 3; i++)
            {
                var planet = new Planet(this);
                planets.Add(planet);
                Components.Add(planet);
            }

            Components.Add(ship);
        }

un sadursmju noteikšana:

            crashed = false;
            BoundingSphere shipSphere = ship.GetBoundingSphere();
            foreach (var planet in planets)
            {
                if (shipSphere.Intersects(planet.GetBoundingSphere()))
                {
                    crashed = true;
                }
            }

            base.Update(gameTime);

Un spēlētāja rīcībā ir vairākas planētas.

Līdzīgā veidā var pievienot vairākus spēlētājus, lai īstenotu daudzspēlētāju režīmu. Tas gan būs nedaudz sarežģītāk, jo būs nepieciešams definēt dažādus vadības taustiņus katram spēlētājam, bet par to kādā no nākošajām sērijām.

Pirmkods

Kur planētām nav vietas. Lidinators v0.3

ivars.arins — Thu, 27 Nov 2008 06:30:00 GMT

Nupat sapratu, ka lidināšanās apkārt nav nemaz tik interesanta. Tāpēc, turpinot lidinatora attīstību, nāksies to papildināt ar ko jaunu. Pirmais, kas man jau sākotnēji nepatika, ir tas, ka ļoti viegli nomaldīties un pazaudēt raķeti. Šo var risināt divejādi:

Izdarīt tā, lai pie kāda taustiņa nospiešanas kuģis atgrieztos sākotnējā stāvoklī. Neforši, bet ļoti vienkārši.
Neļaut kuģim izlidot ārpus ekrāna robežām. Nedaudz sarežģītāk, toties Īstu vīru solution™.

Lieki nedomājot izvēlējos otro variantu. Tā kā visa dzīve ir izvēlēšanās starp variantiem, tad arī šeit ir divi varianti, kā rīkoties gadījumā, ja kuģis sasniedz ekrāna malu. Viens būtu to "atsist" pret malu, kā biljarda bumbiņu, savukārt otrs veido "bezgalīgu" telpu, kad kuģis sasniedzot vienu malu parādās otrā. Ieraduma pēc atkal nolēmu, ka ir jāizvēlas otrais variants.

Nekas daudz jau šeit nav jādara, tik vien, kā jāizmaina kuģa koordinātes gadījumā, ja tā centrs ir aiz kādas no ekrāna robežām. Nedaudz jāpapildina Update() metode un lieta darīta

            if (Math.Abs(shipLocation.X) > Window.ClientBounds.Width / 2)
            {
                shipLocation.X *= -1;
            }
            if (Math.Abs(shipLocation.Y) > Window.ClientBounds.Height /2 )
            {
                shipLocation.Y *= -1;
            }

Tā, kā koordinātu sākumpunkts ir ekrāna centrā, tad pārbaude un koordināšu maiņa ir ļoti vienkārša. Pārbaudam, vai kādas koordinātes absolūtā vērtība nepārsniedz pusi atbilstošā ekrāna izmēra. Gadījumā, ja pārsniedz, tad šo koordināti pareizinot ar -1 kuģis tiek pārvietots uz otru ekrāna malu.

Šāda metode gan ir vienkāršota un gadījumā, ja kuģis apstājas tieši uz ekrāna malas, tad dabū diezgan nejauku mirgošanas efektu, tāpēc nākas to pārrakstīt nedaudz "gudrāk".

            if (Math.Abs(shipLocation.X) > Window.ClientBounds.Width / 2)
            {
                float sign = Math.Abs(shipLocation.X) / shipLocation.X;
                shipLocation.X = - 1 * sign * 
                   Math.Min(Math.Abs(shipLocation.X), Window.ClientBounds.Width / 2 - 1);
            }
            if (Math.Abs(shipLocation.Y) > Window.ClientBounds.Height /2 )
            {
                float sign = Math.Abs(shipLocation.Y) / shipLocation.Y;
                shipLocation.Y = -1 * sign * 
                   Math.Min(Math.Abs(shipLocation.Y), Window.ClientBounds.Height / 2 - 1);
            }

Nav tik saprotami, bet dara ko ļoti līdzīgu. Gadījumā, ja kuģis jāpārvieto uz otru ekrāna malu, tad izvēlas ekrāna centram tuvāko vērtību no kuģa koordinātes un punkta, kas ir par vienu vienību nost no ekrāna malas.

Tagad kuģi pazaudēt ir grūtāk, bet lidināšanās īpaši interesantāka nav palikusi. Lai nebūtu tik vientuļi, papildināsim pieejamo kosmosu ar kādu planētu.

Atkārtojot pirmajā rakstā minētās darbības, jāpievieno planētas gariņgrafiku projekta saturam. Tālāk nepieciešams izveidot mainīgos koordināšu un gariņa glabāšanai, spēles sākumā inicializēt planētas koordinātes un attēlot to uz ekrāna Draw() metodē. Tās visas ir jau apskatītas lietas, tāpēc detalizēti to neapskatīšu. Jebkurā gadījumā to var apskatīt pievienotajā pirmkodā.

Bet ja jau ir planēta, tad vajadzētu ļaut tajā ietriekties kuģim, lai lidošanai piedotu "briesmu elementu". Ja šajā spēles posmā kuģis "saduras" ar planētu, tad tas vienkārši pārlido pāri tā, it kā planēta atrastos tālumā. Šeit ir nepieciešams izmantot kādu sadursmju noteikšanas mehānismu, lai konstatētu, ka abi objekti ir sadūrušies.

XNA piedāvā vairākas struktūra, kuras var izmantot sadursmju noteikšanai. Lai gan šīs klases ir paredzētas izmantošanai 3D telpā, tās mierīgi var izmantot arī 2D spēlēs. Lidinatora piemērā tiek izmantota BoundingSphere struktūra, kas izmanto objektu aptverošu lodi. Tas gan nav precīzākais sadursmju noteikšanas veids, bet sākumā noderēs.

Update() metodē izveido divas jaunas BoundingSphere lodes, kas atbilst katram no objektiem (planētai un kuģim):

            BoundingSphere shipSphere = new BoundingSphere(
               new Vector3(shipLocation, 0), 
               (float)(shipSprite.Width / 2.5));
            BoundingSphere planetSphere = new BoundingSphere(
                new Vector3(planetLocation, 0), 
               (float)(planetSprite.Width / 2.5));

Lai pārbaudītu, vai lodes nepārklājas, jāizmanto Intersects() metode. Lai uzskatāmāk varētu redzēt kurā brīdī lodes pārklājas, nedaudz izmainīšu zīmēšanas metodi lai pārklāšanās gadījumā izmantotu sarkanu fonu. Šim nolūkam tiek izveidots jauns klases lauks kurā glabā pārbaudes rezultātu un Update() metodē to aizpilda ar pārbaudes rezultātu:

crashed = shipSphere.Intersects(planetSphere);

Un zīmēšanas izmaiņas:

GraphicsDevice.Clear(crashed ? Color.Red : Color.CornflowerBlue);

Kā rezultātā ir iespējams vērot nākošajā attēlā redzamo ainu.

Tas pirmajā tuvinājumā arī būtu viss par sadursmju noteikšanu. Katrā ziņā nākošajās sērijās ar to vēl nāksies saskarties ne vienu vien reizi.

Apsolītais pirmkods

I like to move it, move it! Lidinators v0.2

ivars.arins — Wed, 26 Nov 2008 05:10:00 GMT

Sveiki! Ir jauna diena un "Lidinators" turpina savu lidojumu. Domāju, ka vakardienas rezultāts nav pārāk iespaidīgs. Jā, varam ar dažām koda rindiņām parādīt kuģīti uz ekrāna, bet ko tas dod? Neko daudz, tikai sākumu jaunai spēlei. Turpinot tādiem pašiem maziem solīšiem, šodien pievienosim iespējas pārvietot kuģi.

Lai varētu ko pārvietot, nepieciešams zināt tā atrašanās vietu. Tāpēc papildināsim kodu ar mainīgajiem, kuros glabāt kuģa koordinātes un ātrumus. Ātrumi ir daudzskaitlī, tādēļ, ka vēlos atseviški izdalīt pārvietošanās ātrumu uz priekšu un rotācijas ātrumu. Līdz ar to pašreizējās mainīgo definīcijas būs šādas:

        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Texture2D shipSprite;
        Vector2 shipLocation;
        float speed, rotationSpeed;

Tāpat derētu nodefinēt konstantes ātruma ierobežojumiem, lai kuģis neieskrietos pārāk ātri un neizsistu caurumu monitora sānos.

        const float MaxSpeed = 10;
        const float MaxRotationSpeed = 3;

Spēles inicializācijas metodē jānovieto kuģi koordinātu sākumpunktā:

        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            shipLocation = new Vector2(0, 0);
            base.Initialize();
        }

Un jāpārveido zīmēšanas metodi, lai tā zīmētu kuģi, ņemot vērā tā atrašanās vietu.

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            spriteBatch.Begin();
            spriteBatch.Draw(
                shipSprite,
                shipLocation,
                Color.White);
            spriteBatch.End();

            base.Draw(gameTime);
        }

Palaižot spēli var redzēt, kas ir sanācis.

Domāju, ka nevienam nav pārsteigums, ka datoriem koordinātu sistēma parasti atšķiras no tās, ko mācīja skolā. T.i. koordinātu sākumpunkts ir ekrāna labajā augšējā stūrī, nevis ekrāna centrā. Līdz ar to ir nepieciešams kompensēt divas lietas:

Atšķirīgu koordinātu sākumpunktu
To, ka gariņu zīmē no stūra, nevis no centra

Lai neitralizētu pirmo punktu, pietiek izrēķināt sākuma koordinātes pēc ekrāna izmēriem. Un arī otru problēmu atrisina līdzīgi - atņemot no zīmēšanas koordinātēm kuģa centra koordinātes. Izmainītā zīmēšanas metode:

protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            
            Vector2 center = new Vector2(
                Window.ClientBounds.Width / 2,
                Window.ClientBounds.Height / 2);
            Vector2 shipCenter = new Vector2(shipSprite.Width / 2, shipSprite.Height / 2);

            spriteBatch.Begin();
            spriteBatch.Draw(
                shipSprite,
                center + shipLocation - shipCenter,
                Color.White);
            spriteBatch.End();

            base.Draw(gameTime);
        }

Un ekrānšāviņš, lai pārliecinātos, ka tas darbojas

Sagatavošanās darbi ir pabeigti, jāsāk kustināt kuģi. Spēles stāvokļa pārrēķināšanai un lietotāja ievades saņemšanai ir paredzēta spēles Update() metode, kuru tad arī ir jāpapildina ar nepieciešamo loģiku. "Lidinatora" gadījumā algoritms ir vienkāršs:

Ja ir nospiests taustiņš "uz augšu", tad palielina kuģa ātrumu par 3, bet nepārsniedzot maksimālo ātrumu;
Ja ir nospiests taustiņs "uz leju", tad samazina kuģa ātrumu par 3, bet kuģa ātrums nedrīkst būt negatīvs;
Ja ir nospiests taustiņš "pa kreisi", tad palielina kuģa rotācijas ātrumu par 2, bet tas nedrīkst pārsniegt maksimālo rotācijas ātrumu;
Ja ir nospiests taustiņš "pa labi", tad samazina kuģa rotācijas ātrumu par 2, bet tas nedrīkst būt mazāks par negatīvu maksimālo rotācijas ātrumu;

Lai uzzinātu par nospiestajiem taustiņiem, nepieciešams izmantot Keyboard klases metodi GetState(), kas atgriež KeyboardState struktūru. Savukārt KeyboardState satur metodi IsKeyDown(), ar kuras palīdzību var pārliecināties vai konkrēts taustiņš ir nospiests. Iepriekš aprakstītajam algoritmam atbilst šāds kods:

            KeyboardState currentState = Keyboard.GetState();
            if (currentState.IsKeyDown(Keys.Up))
            {
                speed += 3;
            }
            if (currentState.IsKeyDown(Keys.Down))
            {
                speed -= 3;
            }
            if (currentState.IsKeyDown(Keys.Left))
            {
                rotationSpeed += 2;
            }
            if (currentState.IsKeyDown(Keys.Right))
            {
                rotationSpeed -= 2;
            }
            if (speed < 0)
            {
                speed = 0;
            }
            if (speed > MaxSpeed)
            {
                speed = MaxSpeed;
            }
            if (rotationSpeed > MaxRotationSpeed)
            {
                rotationSpeed = MaxRotationSpeed;
            }
            if (rotationSpeed < -MaxRotationSpeed)
            {
                rotationSpeed = MaxRotationSpeed;
            }

Protams, ar ātruma rēķināšanu nepietiks, lai kuģis tiešām pārvietotos. Šajā pašā metodē ir nepieciešams uzrakstīt arī stāvokļa izmaiņu loģiku. Šajā brīdī es sapratu, ka kodā pietrūkst kuģa šābrīža leņķis un tā attēlošana. Ja pirmo trūkumu var atrisināt ar jauna mainīgā ieviešanu, tad ar otro būs nedaudz sarežģītāk, jo nāksies izmantot citu zīmēšanas metodi, kurai ir stipri vairāk parametri. Ja pirmā problēma (trūkstošais leņķis) ir atrisināta, pārvietošanās loģiku var uzrakstīt salīdzinoši vienkārši, ja neskaita, ka nepieciešams atcerēties ģeometrijas kursu. Sākumā izmainam kuģa leņķi atbilstoši rotācijas ātrumam, savukārt pēc tam izmainam kuģa koordinātes atbilstoši tā ātrumam un leņķim. Pieņemot, ka kuģa leņķis tiek glabāts grādos, tas izskatītos šādi:

            shipAngle = shipAngle - rotationSpeed;
            shipLocation.X += speed * (float)Math.Sin(shipAngle / 180 * Math.PI);
            shipLocation.Y -= speed * (float)Math.Cos(shipAngle / 180 * Math.PI);

Lai kuģis neizlidotu tālēs zilajās (vārda tiešā nozīmē), vajadzētu arī ātrumu samazināt, tāpēc metodes beigās ātrumu samazina par vienu vienību, bet rotācijas ātrumu - uz pusi:

            speed--;
            rotationSpeed /= 2;

Kad kuģis, vismaz teorētiski, ir spējīgs pārvietoties, nepieciešams izmainīt zīmēšanas kodu, lai arī leņķis būtu redzams:

            spriteBatch.Draw(
                shipSprite,                             //1
                center + shipLocation - shipCenter,     //2
                null,                                   //3
                Color.White,                            //4
                shipAngle * (float)Math.PI / 180,       //5
                shipCenter,                             //6
                1,                                      //7
                SpriteEffects.None,                     //8
                0                                       //9
                );

Kā redzams, klāt ir nākuši vairāki parametri, tāpēc paskaidrošu, ko nozīmē katrs no parametriem:

gariņš kuru zīmēt;
koordinātes, kurās zīmēt gariņu;
taisnstūra struktūra, kas nosaka, kuru daļu no gariņa zīmēt (ja norādīta null vērtībā, tad zīmē visu)
tonis, kas tiek lietots zīmēšanai (baltā krāsa nozīmē - zīmēt netonētu)
rotācijas leņķis
rotācijas centrs
mērogmaiņas koeficients
efekts (nekāds, apvēršana horizontāli, apvēršana vertikāli)
z koordināte

Domāju, ka šeit nav nekāda raķešzinātne (hmm, varbūt tomēr ir?), tāpēc vajadzētu būt skaidram. Neskaidros jautājumus droši varat uzdot komentāros, centīšos atbildēt.

Viens jautājums, kurš droši vien parādīsies, ir - kāpēc nepieciešami tik sarežģīti ātruma aprēķini, ja kuģis vienalga kustās samērā saraustīti? Patiesībā kuģim vajadzētu kustēties ar zināmu inerci, bet tas tā nenotiek tādēļ, ka Update metode notiek parāk bieži. Lai padarītu kuģa ātrumu atkarīgu no laika, izmantosim Update() metodes parametru gameTime, kuram ir tāda paša nosaukuma tips GameTime. Izmantojot dažādus šī tipa parametrus var iegūt informāciju par spēles stāvokli laikā. Nedaudz pārveidojot ātrumu izmaiņas tā, lai tās būtu atkarīgas no laika, nevis atjaunošanas biežuma, "spēle" paliek interesantāka.

            var elapsed = (float)gameTime.ElapsedGameTime.Ticks / 1000000;

            if (elapsed > 0)
            {
                speed -= elapsed;
                rotationSpeed -= (rotationSpeed / 4) * elapsed;
            }

Tas nu pagaidām būs viss. Gaidu ierosinājumus nākošajai sērijai.

Tā kā šobrīd kods jau ir nedaudz izaudzis, pievienoju pirmkodu.

Paspēlēsimies? Lidinators 0.1

ivars.arins — Tue, 25 Nov 2008 04:57:00 GMT

Kādu laiku atpakaļ rakstīju, ka ir iznākusi trešā versija XNA spēļu studijai un, ka es vēlētos par to pastāstīt sīkāk. Tas laiks nu ir pienācis un tuvākajās dienās (nedēļās? mēnešos?) centīšos pastāstīt par spēļu veidošanu izmantojot XNA.

Lai sāktu izstrādi nepieciešama Microsoft Visual Studio izstrādes vide (ekspress variants šeit) un XNA platforma (šeit). Pēc XNA uzstādīšanas, vizuālajā studijā veidojot jaunu projektu būs pieejama jauna sadaļa "XNA Game Studio 3.0".

Šīs ierakstu sērijas gaitā mēģināšu izveidot vienkāršu spēli, kurā lidināsies un šaudīsies kosmosa kuģīši, tādēļ nosaucu projektu par "Lidinatoru". Nosaukums ir par godu kādai spēlei, kuras izveidē, lai gan ļoti minimāli iznāca piedalīties laikā, kad mācījos vidusskolā (tas bija tik sen, ka datoriem operatīvās atmiņas un cieto disku apjomu vēl mērīja megabaitos).

Jaunizveidotajā projektā jau ir iekļauts "spēles" skelets, kuru tālāk ir tikai jāpapildina. Sākotnēji tas tikai attēlo rudzupuķu¹ zilu logu, kurš var tikt aizvērts ar loga aizvēršanas standarta "krustiņu", vai nospiežot "back" pogu uz XBox kontroliera.

Lai gan XNA piedāvā dažādas 3D grafikas iespējas, sākumā iemēģināšu roku 2D gariņgrafikā². Izmantojot visas savas necilās zīmēšanas spējas uzzīmēju kaut ko attāli līdzīgu kosmiskajam kuģim

Lai pievienotu bildi projekta resursiem, jāspiež ar peles labo taustiņu uz "Content" sadaļas "Solution explorer" logā un jāizvēlas "Add Existing Item" punkts no uznirstošās izvēlnes. Pēc resursa pievienošanas var pamainīt dažādus parametrus, bet šobrīd tas nav aktuāli. Vienīgais, ko vajadzētu ievērot ir resursa identifikators "Asset Name".

Lai varētu spēlē izmantot resursu, to ir nepieciešams ielādēt atmiņā. Lai to izdarītu ir nepieciešams papildināt LoadContent() metodi spēles skeletā. Sākotnēji šī metode izskatās šādi:

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: use this.Content to load your game content here
        }

Lai ielādētu jaunizveidoto resursu ir jāizmanto satura menedžeris, kurš ir inicalizēts Game klases Content īpašībā. Satura menedžeris satur "generic" metodi Load() resursu ielādēšanai.

Papildinātais LoadContent() kods:

        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            shipSprite = Content.Load<Texture2D>("ship_sprite");
        }

Spēles skeletā jau ir paredzēta metode ekrāna atjaunošana, tādēļ atliek tikai to papildināt, lai parādītu kosmosa kuģi uz ekrāna. Gariņu zīmēšana jāizmanto SpriteBatch klase, kas ir paredzēta vairāku gariņu attēlošanai vienā piegājienā. Sākumā zīmēšana ir jāuzsāk ar Begin() metodi, tad jāveic visas vajadzīgās darbības un beigās viss jāizpilda ar End() metodi. Manuprāt, vienkāršāk to ir saprast no koda:

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            spriteBatch.Begin();
            spriteBatch.Draw(
                shipSprite,
                new Vector2(100, 100),
                Color.White);
            spriteBatch.End();

            base.Draw(gameTime);
        }

Visa šī darba rezultāts redzams nākošajā attēlā.

Nākošajā turpinājumā mēģināšu "Lidinatoru" padarīt dinamiskāku.

¹ Interesanti, ka angliski rudzupuķes ir "kukurūzas puķes". Acīmredzot tās mīl augt kopā ar graudaugiem.

² Man ļoti patīk šis termins.