Z2F0ZUxpdmUgQU1BIFJlY2FwLUd1aWxkIG9mIEd1YXJkaWFucw==

2024-04-30, 06:48

<p><img src="https://gimg2.gateimg.com/image/article/1714459632AMA_BlogGOG.jpg" alt=""></p>
<h2 id="h2-Q120Geef20ons20de20details20van20wat20Guild20of20Guardians20is306448"><a name="Q1: Geef ons de details van wat Guild of Guardians is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Geef ons de details van wat Guild of Guardians is?</h2><p>Guild of Guardians is een <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> squad RPG Mobile Game. Het spel draait om het verkennen van dungeons. Terwijl je door deze dungeons vordert, verzamel je buit die gebruikt kan worden om je Guardians te upgraden of extra Guardians te summonen. Uiteindelijk is je doel om de wereld van Elder te redden van The Dread.</p>
<p>Het spel zelf is eenvoudig, maar het heeft een boeiende haak die je betrokken houdt. De afgelopen 9 maanden hebben de ontwikkelaars van Mineloader zich gericht op het bouwen van de kernengine van het spel, waarbij ervoor wordt gezorgd dat het doorlopen van dungeons leuk en boeiend is, met belangrijke keuzes om onderweg te maken. Ze willen dat Guild of Guardians een leuk metgezelschapsspel is dat je kunt spelen terwijl je je dagelijkse bezigheden doet.</p>
<p>Een van de dingen die me aantrokken tot Guild of Guardians toen ik bij het team kwam, was het vermogen om het te spelen naast andere activiteiten. Het is een spel dat je een paar minuten in de trein kunt spelen, gemakkelijk kunt oppakken en neerleggen, of zelfs kunt spelen terwijl je tv kijkt met de kinderen. Guild of Guardians vindt zijn niche als een spel dat naadloos geïntegreerd kan worden in je leven, en dat is geweldig.</p>
<h2 id="h2-Q220Wat20is20het20verhaal20achter20de20Guild20of20Guardians20Wat20is20tot20nu20toe20de20reis20van20de20Guild20of20Guardian20geweest311389"><a name="Q2: Wat is het verhaal achter de Guild of Guardians? Wat is tot nu toe de reis van de Guild of Guardian geweest?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat is het verhaal achter de Guild of Guardians? Wat is tot nu toe de reis van de Guild of Guardian geweest?</h2><p>Bij het instappen in het project was het aanvankelijk slechts een dag per week om het moment-tot-moment gameplay van Guild of Guardians als een actie-RPG te beoordelen. De kernelementen waren aanwezig, maar ze kwamen niet samen in een leuke ervaring. We werkten een paar maanden aan de kerngameplay, en hoewel we vooruitgang boekten, was het duidelijk dat de kernengine van het spel niet werkte. Actie-RPG’s eisen volledige aandacht; als je niet volledig afgestemd bent, kan het aanvoelen als drukwerk. Na een paar maanden van iteratie, met meer dan 20 jaar ervaring in het maken van spellen, werd het duidelijk dat we niet op schema lagen om binnen een redelijke termijn uit te brengen.</p>
<p>Aan het begin van het jaar werd een herstart van het spel voorgesteld. We hebben een snelle marktanalyse gedaan. In games is er meestal een winnaar in een categorie, zoals World of Warcraft in MMO RPG’s. Dan is er de tweede plaats, een verre derde en alle andere deelnemers. De top drie games omvatten doorgaans meer dan 50, 60, 70% van het marktaandeel. Toen we naar de mobiele markt keken, vormen AR RPG’s een relatief klein percentage, enkele cijfers. Squad RPG’s zitten rond de 25% range. En wanneer we naar die segmentatie kijken, omvatten de top vijf games in squad-gebaseerde RPG’s slechts ongeveer 20% van het marktaandeel. Dit liet ons zien dat als we deze ruimte kunnen betreden met een overtuigend spel, we een goede kans hebben om te winnen omdat het nog niet geconsolideerd is. Terwijl in ARPG’s Diablo Immortal een groot deel van dat marktaandeel inneemt.</p>
<p>Dit leidde ons naar squad-gebaseerde RPG’s te kijken voor een goede kernlus die ons daar kon brengen, en de overstap naar waar we nu zijn, de overstap van stapsgewijze naar beurtgebaseerde gevechten. Dat was ook een lange reis. We hebben meer dan 20 potentiële partners onderzocht en Minloader kwam als beste uit de bus. Samenwerken met hen is geweldig geweest, daarom zijn we zo ver gekomen. Het is pas ongeveer 6 maanden geleden dat we aan het project zijn begonnen en het spel is al verder dan je zou verwachten van iets dat 6 maanden oud is. Er is veel werk gestoken in Guild of Guardians voordat ik meedeed, wat ons een solide kern van kunst en andere dingen gaf die we snel konden aanpassen. Dat zouden we niet hebben kunnen doen als we vanaf nul waren begonnen, dus complimenten aan het oorspronkelijke team voor het werk dat ze op dat gebied hebben verricht.</p>
<h2 id="h2-Q320Hoe20wordt20de20web3component20gentegreerd20in20het20spel20Hoe20heb20je20nagedacht20over20de20integratie20hiervan20zonder20dat20het20ten20koste20gaat20van20het20plezier497767"><a name="Q3: Hoe wordt de web3-component geïntegreerd in het spel? Hoe heb je nagedacht over de integratie hiervan zonder dat het ten koste gaat van het plezier?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Hoe wordt de web3-component geïntegreerd in het spel? Hoe heb je nagedacht over de integratie hiervan zonder dat het ten koste gaat van het plezier?</h2><p>Het meest uitdagende deel op dit moment is het implementeren van in-game functies. Een van de moeilijke beslissingen die we hebben genomen, was om uitrustingssmeedwerk op basis van Web2 te maken. Hoewel het op het eerste gezicht logisch lijkt dat uitrusting NFT’s zijn, veroorzaakt dit problemen met progressie en gameplay-lus. Als uitrusting NFT’s zijn, kunnen spelers de inhoud omzeilen en hun voortgang versnellen, wat schadelijk kan zijn voor het spel. Een klassiek voorbeeld is de veilinghuis van Diablo 3, waar het direct kopen van kracht het spel vernietigde.</p>
<p>Onze aanpak van de economie van de Guild of Guardians is anders. Je kunt het spelen als een traditioneel Web2-spel, maar voor meer efficiëntie kun je in de loop van de tijd de Web Three-ruimte betreden. Dit is cruciaal omdat het ons in staat stelt om traditionele gamers aan boord te brengen in een Web2-vriendelijk spel en hen geleidelijk kennis te laten maken met Web Three-concepten via tutorials en gidsen. Spelers kunnen dan leren om specifieke items rechtstreeks op de markt te targeten, waardoor ze mechanismen zoals het oproepen van talloze Guardians om de gewenste te krijgen, kunnen vermijden. In plaats daarvan kunnen ze de Guardian die ze willen rechtstreeks van de markt kopen.</p>
<p>Op dit moment zijn Guardians de belangrijkste NFT’s in het ecosysteem en zullen ze een belangrijk onderdeel blijven vormen. Het maken van uitrusting zal echter volledig Web2-gebaseerd zijn in het begin. Naarmate spelers vorderen, zullen er geavanceerde crafting-componenten zijn die kunnen worden gebruikt om uitrusting te maken. Deze geavanceerde crafting-componenten zijn waar we ons op richten voor het handelsecosysteem. Dus, hoewel je de uitrusting zelf niet zult kopen, kun je je voortgang versnellen door specifieke componenten te verwerven. Dit hangt ook samen met hoe ik games speel; ik voel een sterkere verbinding met uitrusting die ik zelf maak in vergelijking met het kopen ervan van iemand anders.</p>
<h2 id="h2-Q420Is20de20Guild20of20Guardians20beschikbaar20Wanneer20wordt20de20Guild20of20Guardians20gelanceerd488917"><a name="Q4: Is de Guild of Guardians beschikbaar? Wanneer wordt de Guild of Guardians gelanceerd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Is de Guild of Guardians beschikbaar? Wanneer wordt de Guild of Guardians gelanceerd?</h2><p>Guild of Guardian is momenteel beschikbaar als Pre-Launch Testen in Australië, Indonesië en Canada. Het spel wordt wereldwijd gelanceerd op 15 mei 2024!</p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Team van Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>