Rozhraní API pro hry s iOSem v Xamarin.iOS

Tento článek popisuje nová herní vylepšení, která poskytuje iOS 9 a která je možné použít ke zlepšení grafických a zvukových funkcí vaší hry Xamarin.iOS.

Apple provedl několik technologických vylepšení herních rozhraní API v iOSu 9, která usnadňují implementaci herní grafiky a zvuku v aplikaci Xamarin.iOS. Patří mezi ně jak snadný vývoj prostřednictvím architektur vysoké úrovně, tak využití výkonu GPU zařízení s iOSem pro lepší rychlost a grafické schopnosti.

Patří sem NapříkladKit, ReplayKit, Model I/O, MetalKit a Metal Performance Shadery a nové vylepšené funkce pro metal, SceneKit a SpriteKit.

Tento článek vám představí všechny způsoby, jak vylepšit hru Xamarin.iOS s novými vylepšeními hry pro iOS 9:

PředstaveníKitu Prosítku

Nová rozhraní OdysítKit společnosti Apple poskytuje sadu technologií, které usnadňuje vytváření her pro zařízení s iOSem tím, že zmenšuje množství opakujících se běžných kódů požadovaných k implementaci. K rychlému dodání dokončené hry poskytujeKit pro vývoj herní mechaniky nástroje, které je možné snadno kombinovat s grafickým strojem (například SceneKit nebo SpriteKit).

UchovákKit obsahuje několik běžných herních algoritmů, mezi které patří:

• Simulace agenta založená na chování, která umožňuje definovat pohyby a cíle, které bude AI automaticky provádět.
• Minimální umělá inteligence pro hru na tahu.
• Systém pravidel pro logiku hry řízenou daty s přibližnou zdůvodnění, která poskytuje vznikající chování.

Kromě toho Sekit používá přístup stavebních bloků k vývoji her pomocí modulární architektury, která poskytuje následující funkce:

• Stavový stroj pro zpracování složitých systémů založených na procedurálním kódu ve hře.
• Nástroje pro poskytování randomizovaných her a nepředvídatelnosti, aniž by to způsobilo problémy s laděním.
• Znovu použitelné, componentizované architektury založené na entitě.

Další informace o jazyceČísiKit najdete v průvodci programováním proKit a v referenčních informacích k frameworku ProsítěKitod Applu.

Příklady ProKit

Pojďme se rychle podívat na implementaci některé jednoduché mechanismy hraní her v aplikaci Xamarin.iOS pomocí sady herních her.

Pathfinding

Pathfinding je schopnost, aby prvek AI hry našel cestu kolem herní desky. Například 2D sádměstečka, která hledá cestu přes věštce nebo 3D postavu přes světovou krajinu první osoby.

Představte si následující mapu:

Pomocí cesty při hledání tohoto kódu jazyka C# můžete najít cestu přes mapu:

var a = GKGraphNode2D.FromPoint (new Vector2 (0, 5));
var b = GKGraphNode2D.FromPoint (new Vector2 (3, 0));
var c = GKGraphNode2D.FromPoint (new Vector2 (2, 6));
var d = GKGraphNode2D.FromPoint (new Vector2 (4, 6));
var e = GKGraphNode2D.FromPoint (new Vector2 (6, 5));
var f = GKGraphNode2D.FromPoint (new Vector2 (6, 0));

a.AddConnections (new [] { b, c }, false);
b.AddConnections (new [] { e, f }, false);
c.AddConnections (new [] { d }, false);
d.AddConnections (new [] { e, f }, false);

var graph = GKGraph.FromNodes(new [] { a, b, c, d, e, f });

var a2e = graph.FindPath (a, e); // [ a, c, d, e ]
var a2f = graph.FindPath (a, f); // [ a, b, f ]

Console.WriteLine(String.Join ("->", (object[]) a2e));
Console.WriteLine(String.Join ("->", (object[]) a2f));

Klasický systém expertů

Následující fragment kódu jazyka C# ukazuje, jak lze Pomocí Sady Prosíkit implementovat klasický systém odborníků:

string output = "";
bool reset = false;
int input = 15;

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    /*
    If reset is true, clear the output and set reset to false
    */
    var clearRule = GKRule.FromPredicate ((rules) => reset, rules => {
        output = "";
        reset = false;
    });
    clearRule.Salience = 1;

    var fizzRule = GKRule.FromPredicate (mod (3), rules => {
        output += "fizz";
    });
    fizzRule.Salience = 2;

    var buzzRule = GKRule.FromPredicate (mod (5), rules => {
        output += "buzz";
    });
    buzzRule.Salience = 2;

    /*
    This *always* evaluates to true, but is higher Salience, so evaluates after lower-salience items
    (which is counter-intuitive). Print the output, and reset (thus triggering "ResetRule" next time)
    */
    var outputRule = GKRule.FromPredicate (rules => true, rules => {
        System.Console.WriteLine(output == "" ? input.ToString() : output);
        reset = true;
    });
    outputRule.Salience = 3;

    var rs = new GKRuleSystem ();
    rs.AddRules (new [] {
        clearRule,
        fizzRule,
        buzzRule,
        outputRule
    });

    for (input = 1; input < 16; input++) {
        rs.Evaluate ();
        rs.Reset ();
    }
}

protected Func<GKRuleSystem, bool> mod(int m)
{
    Func<GKRuleSystem,bool> partiallyApplied = (rs) => input % m == 0;
    return partiallyApplied;
}

Na základě dané sady pravidel ( ) a známé sady vstupů vytvoří expertní systém ( ) předvídatelný výstup ( pro GKRuleGKRuleSystem náš příklad fizzbuzz výše).

Flockovacích

Posouvání umožňuje, aby se skupina entit her řízených pomocí AI chovala jako namákající se, kde skupina reaguje na pohyby a akce hlavní entity, jako je ptáčky na letu nebo škola ptačích pluků.

Následující fragment kódu jazyka C# implementuje chování při dešimování pomocíKitu a sady SpriteKit pro grafické zobrazení:

using System;
using SpriteKit;
using CoreGraphics;
using UIKit;
using GameplayKit;
using Foundation;
using System.Collections.Generic;
using System.Linq;
using OpenTK;

namespace FieldBehaviorExplorer
{
    public static class FlockRandom
    {
        private static GKARC4RandomSource rand = new GKARC4RandomSource ();

        static FlockRandom ()
        {
            rand.DropValues (769);
        }

        public static float NextUniform ()
        {
            return rand.GetNextUniform ();
        }
    }

    public class FlockingScene : SKScene
    {
        List<Boid> boids = new List<Boid> ();
        GKComponentSystem componentSystem;
        GKAgent2D trackingAgent; //Tracks finger on screen
        double lastUpdateTime = Double.NaN;
        //Hold on to behavior so it doesn't get GC'ed
        static GKBehavior flockingBehavior;
        static GKGoal seekGoal;

        public FlockingScene (CGSize size) : base (size)
        {
            AddRandomBoids (20);

            var scale = 0.4f;
            //Flocking system
            componentSystem = new GKComponentSystem (typeof(GKAgent2D));
            var behavior = DefineFlockingBehavior (boids.Select (boid => boid.Agent).ToArray<GKAgent2D>(), scale);
            boids.ForEach (boid => {
                boid.Agent.Behavior = behavior;
                componentSystem.AddComponent(boid.Agent);
            });

            trackingAgent = new GKAgent2D ();
            trackingAgent.Position = new Vector2 ((float) size.Width / 2.0f, (float) size.Height / 2.0f);
            seekGoal = GKGoal.GetGoalToSeekAgent (trackingAgent);
        }

        public override void TouchesBegan (NSSet touches, UIEvent evt)
        {
            boids.ForEach(boid => boid.Agent.Behavior.SetWeight(1.0f, seekGoal));
        }

        public override void TouchesEnded (NSSet touches, UIEvent evt)
        {
            boids.ForEach (boid => boid.Agent.Behavior.SetWeight (0.0f, seekGoal));
        }

        public override void TouchesMoved (NSSet touches, UIEvent evt)
        {
            var touch = (UITouch) touches.First();
            var loc = touch.LocationInNode (this);
            trackingAgent.Position = new Vector2((float) loc.X, (float) loc.Y);
        }

        private void AddRandomBoids (int count)
        {
            var scale = 0.4f;
            for (var i = 0; i < count; i++) {
                var b = new Boid (UIColor.Red, this.Size, scale);
                boids.Add (b);
                this.AddChild (b);
            }
        }

        internal static GKBehavior DefineFlockingBehavior(GKAgent2D[] boidBrains, float scale)
        {
            if (flockingBehavior == null) {
                var flockingGoals = new GKGoal[3];
                flockingGoals [0] = GKGoal.GetGoalToSeparate (boidBrains, 100.0f * scale, (float)Math.PI * 8.0f);
                flockingGoals [1] = GKGoal.GetGoalToAlign (boidBrains, 40.0f * scale, (float)Math.PI * 8.0f);
                flockingGoals [2] = GKGoal.GetGoalToCohere (boidBrains, 40.0f * scale, (float)Math.PI * 8.0f);

                flockingBehavior = new GKBehavior ();
                flockingBehavior.SetWeight (25.0f, flockingGoals [0]);
                flockingBehavior.SetWeight (10.0f, flockingGoals [1]);
                flockingBehavior.SetWeight (10.0f, flockingGoals [2]);
            }
            return flockingBehavior;
        }

        public override void Update (double currentTime)
        {
            base.Update (currentTime);
            if (Double.IsNaN(lastUpdateTime)) {
                lastUpdateTime = currentTime;
            }
            var delta = currentTime - lastUpdateTime;
            componentSystem.Update (delta);
        }
    }

    public class Boid : SKNode, IGKAgentDelegate
    {
        public GKAgent2D Agent { get { return brains; } }
        public SKShapeNode Sprite { get { return sprite; } }

        class BoidSprite : SKShapeNode
        {
            public BoidSprite (UIColor color, float scale)
            {
                var rot = CGAffineTransform.MakeRotation((float) (Math.PI / 2.0f));
                var path = new CGPath ();
                path.MoveToPoint (rot, new CGPoint (10.0, 0.0));
                path.AddLineToPoint (rot, new CGPoint (0.0, 30.0));
                path.AddLineToPoint (rot, new CGPoint (10.0, 20.0));
                path.AddLineToPoint (rot, new CGPoint (20.0, 30.0));
                path.AddLineToPoint (rot, new CGPoint (10.0, 0.0));
                path.CloseSubpath ();

                this.SetScale (scale);
                this.Path = path;
                this.FillColor = color;
                this.StrokeColor = UIColor.White;

            }
        }

        private GKAgent2D brains;
        private BoidSprite sprite;
        private static int boidId = 0;

        public Boid (UIColor color, CGSize size, float scale)
        {
            brains = BoidBrains (size, scale);
            sprite = new BoidSprite (color, scale);
            sprite.Position = new CGPoint(brains.Position.X, brains.Position.Y);
            sprite.ZRotation = brains.Rotation;
            sprite.Name = boidId++.ToString ();

            brains.Delegate = this;

            this.AddChild (sprite);
        }

        private GKAgent2D BoidBrains(CGSize size, float scale)
        {
            var brains = new GKAgent2D ();
            var x = (float) (FlockRandom.NextUniform () * size.Width);
            var y = (float) (FlockRandom.NextUniform () * size.Height);
            brains.Position = new Vector2 (x, y);

            brains.Rotation = (float)(FlockRandom.NextUniform () * Math.PI * 2.0);
            brains.Radius = 30.0f * scale;
            brains.MaxSpeed = 0.5f;
            return brains;
        }

        [Export ("agentDidUpdate:")]
        public void AgentDidUpdate (GameplayKit.GKAgent agent)
        {
        }

        [Export ("agentWillUpdate:")]
        public void AgentWillUpdate (GameplayKit.GKAgent agent)
        {
            var brainsIn = (GKAgent2D) agent;
            sprite.Position = new CGPoint(brainsIn.Position.X, brainsIn.Position.Y);
            sprite.ZRotation = brainsIn.Rotation;
            Console.WriteLine ($"{sprite.Name} -> [{sprite.Position}], {sprite.ZRotation}");
        }
    }
}

Dále implementujte tuto scénu v kontroleru zobrazení:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();
        // Perform any additional setup after loading the view, typically from a nib.
        this.View = new SKView {
        ShowsFPS = true,
        ShowsNodeCount = true,
        ShowsDrawCount = true
    };
}

public override void ViewWillLayoutSubviews ()
{
    base.ViewWillLayoutSubviews ();

    var v = (SKView)View;
    if (v.Scene == null) {
        var scene = new FlockingScene (View.Bounds.Size);
        scene.ScaleMode = SKSceneScaleMode.AspectFill;
        v.PresentScene (scene);
    }
}

Při spuštění nám malé animované "Boids" poklyne po klepnutích prstem:

Další příklady Apple

Kromě výše uvedených ukázek poskytuje Apple následující ukázkové aplikace, které je možné překódovat do C# a Xamarin.iOS:

• FourInARow: Použití strategisty s minmaxem ze sady Přisudky k AI
• AgentsCatalog: Použití systému Agents v předsudku
• DemoBots: Sestavení hry pro více platforem pomocí sady SpriteKit a Sady pro předsudky

Metal

V iOSu 9 provedl Apple několik změn a doplnění systému, aby poskytoval přístup k GPU s nízkou režií. Použitím systému Metal můžete maximalizovat grafický a výpočetní potenciál vašich aplikací pro iOS.

Kovová rozhraní obsahuje následující nové funkce:

• Nové textury privátních vzorníků a šablon hloubky pro OS X
• Vylepšená kvalita stínu s hloubkovým uchytěním a oddělenými hodnotami vzorníku zepředu a zpět.
• Vylepšení knihovny Metal Shading Language a Metal Standard Library
• Výpočetní shadery podporují širší rozsah formátů pixelů.

The MetalKit Framework

Rozhraní MetalKit poskytuje sadu tříd nástrojů a funkcí, které snižují množství práce potřebné k používání systému Metal v aplikaci pro iOS. MetalKit poskytuje podporu ve třech klíčových oblastech:

1. Asynchronní načítání textur z různých zdrojů, včetně běžných formátů, jako jsou PNG, JPEG, KTX a PVR.
2. Snadný přístup k prostředkům založeným na vstupně-výstupních modelech pro zpracování modelů specifických pro kov. Tyto funkce jsou vysoce optimalizované tak, aby poskytovaly efektivní přenos dat mezi V/V sítěmi modelu a vyrovnávacími paměťmi systému.
3. Předdefinovaná zobrazení systému a správa zobrazení, která výrazně snižují množství kódu potřebného k zobrazení grafických vykreslování v aplikaci pro iOS.

Další informace o metalkitu najdete v referenčních informacích k rozhraní MetalKitspolečnosti Apple,průvodci programováním pro kov, referenční příručce k metalovém rozhraní a jazykovém stínování systémuspolečnosti Apple.

Metal Performance Shaders Framework

Rozhraní Metal Performance Shader poskytuje vysoce optimalizovanou sadu grafických a výpočetních shaderů pro použití v aplikacích pro iOS založených na systému Metal. Každý shader v rozhraní Metal Performance Shader byl vyladěný tak, aby poskytoval vysoký výkon na grafickém procesorech iOS s podporou systému Metal.

Pomocí tříd Metal Performance Shader můžete dosáhnout nejvyššího možného výkonu na každém konkrétním iOS GPU, aniž byste museli cílit na jednotlivé základy kódu a udržovat je. Shadery výkonu systému je možné použít s libovolnými prostředky systému, jako jsou textury a vyrovnávací paměti.

Rozhraní Metal Performance Shader poskytuje sadu běžných shaderů, jako jsou:

• Gaussovo rozostření ( )
• Detekce Sobel Edge ( )
• Histogram obrázku ( )

Další informace najdete v průvodci jazykem pro stínovánísystému společnosti Apple.

Představení V/V modelů

Rozhraní Apple Model I/O poskytuje hlubší porozumění 3D prostředkům (například modelům a souvisejícím prostředkům). Model I/O poskytuje vašim herm pro iOS fyzické materiály, modely a osvětlení, které je možné používat sKitem, metalem a SceneKitem.

S modelem V/V můžete podporovat následující typy úloh:

• Importujte osvětlení, materiály, data ze sítě, nastavení fotoaparátu a další informace založené na scéně z nejrůznějších oblíbených formátů softwaru a herních motorů.
• Zpracování nebo generování informací založených na scéně, jako je vytvoření procedurálně texturovaných kouli nebo zapečených osvětlení do sítě.
• Spolupracuje s MetalKitem, SceneKitem a GLKitem a efektivně načítá herní prostředky do vyrovnávacích pamětí GPU pro vykreslování.
• Exportujte informace založené na scéně do nejrůznějších oblíbených formátů softwaru a herních motorů.

Další informace o V/V modelu najdete v referenčních informacích k modelové V/V framework společnosti Apple.

Představujeme ReplayKit

Nová rozhraní ReplayKit společnosti Apple umožňuje snadno přidat záznam hry do vaší hry pro iOS a umožnit uživateli rychle a snadno upravovat a sdílet toto video z aplikace.

Další informace najdete v článku Apple's Going Social with ReplayKit (Sociální sítě Apple s ReplayKitem) a ve videu o Game Center a v jejich ukázkové aplikaci DemoBots: Building a Cross Platform Game with SpriteKit and Xbox.

SceneKit

Scene Kit je rozhraní API pro 3D graf scény, které zjednodušuje práci s 3D grafikou. Poprvé byla představena v OS X 10.8 a nyní přichází na iOS 8. Sada Scene Kit vytváří imerzivní 3D vizualizace a běžné 3D hry nevyžadují zkušenosti s OpenGL. Sada Scene Kit, která staví na běžných konceptech grafu scény, abstrahuje od složitostí OpenGL a OpenGL ES, což velmi usnadňuje přidávání 3D obsahu do aplikace. Pokud jste ale odborníkem na OpenGL, sada Scene Kit nabízí skvělou podporu pro vázání přímo na OpenGL. Obsahuje také řadu funkcí, které doplňují 3D grafiku, jako je fyzika, a velmi dobře se integruje s několika dalšími rozhraními Apple, jako jsou základní animace, základní obrázek a sada Sprite.

Další informace najdete v naší dokumentaci k SceneKitu.

Změny sady SceneKit

Apple přidal do sady SceneKit pro iOS 9 následující nové funkce:

• Xcode teď poskytuje editor scén, který umožňuje rychle vytvářet hry a interaktivní 3D aplikace úpravou scén přímo v rámci Xcode.
• Třídy SCNViewSCNSceneRenderer a je možné použít k povolení vykreslování systému (na podporovaných zařízeních s iOSem).
• Třídy SCNAudioPlayerSCNNode a lze použít k přidání prostorových zvukových efektů, které automaticky sledují pozici přehrávače do aplikace pro iOS.

Další informace najdete v naší dokumentaci k SceneKitu a v referenčních informacích k rozhraní SceneKit od Applu a v článku Fox: Building a SceneKit Game with the Xcode Scene Editor sample project (Fox: Sestavení hry SceneKit pomocí ukázkového projektu editoru scén Xcode).

SpriteKit

Sada Sprite Kit, 2D herní rozhraní od společnosti Apple, obsahuje několik zajímavých nových funkcí v iOSu 8 a OS X Yosemite. Patří mezi ně integrace se sadou Scene Kit, podpora shaderu, osvětlení, stíny, omezení, normální generování map a vylepšení fyziky. Konkrétně nové fyzikální funkce velmi usnadňuje přidání realistických efektů do hry.

Další informace najdete v naší dokumentaci k SpriteKitu.

SpriteKit změny

Společnost Apple přidala do SpriteKit pro iOS 9 tyto nové funkce:

• Prostorový zvukový efekt, který automaticky sleduje polohu přehrávače pomocí SKAudioNode třídy.
• Xcode nyní obsahuje editor scény a editor akcí pro snadnou tvorbu 2D her a aplikací.
• Snadná posouvaný podpora her s novými objekty kamery ( SKCameraNode )
• V zařízeních se systémem iOS, která podporují kov, ji SpriteKit automaticky použije pro vykreslování, i když už používáte vlastní shadery OpenGL ES.

Další informace najdete v dokumentaci k SpriteKit společnosti Apple SpriteKit Framework a jejich DemoBots: vytváření her pro různé platformy s ukázkovou aplikací SpriteKit a GameplayKit .

Souhrn

Tento článek pojednává o nových herních funkcích, které iOS 9 poskytuje pro vaše aplikace Xamarin. iOS. Představil GameplayKit a model I/O; Hlavní vylepšení kovů; a nové funkce SceneKit a SpriteKit.

Související odkazy

• Ukázky pro iOS 9
• iOS 9 pro vývojáře
• iOS 9,0