R29kcyBVbmNoYWluZWQncyBFdGhlcmV1bSBORlQgQ2FyZCBHYW1lIHdvcmR0IGdlbGFuY2VlcmQgb3AgaU9TIGVuIEFuZHJvaWQ=

2024-03-12, 09:08

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR412175"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Immutable X heeft een mobiele applicatie gelanceerd voor Gods Unchained die compatibel is met iOS en Android.</p>
<p>Gods Unchained is een play-to-earn-spel waar spelers digitale in-game activa kunnen verdienen die ze kunnen inwisselen voor GODs-tokens.</p>
<p>NFT’s zijn unieke digitale activa die bestaan op de blockchain.</p>
<h2 id="h2-Introductie202224"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Gods Unchained, een op blockchain gebaseerd ruilkaartspel, kreeg veel aandacht tijdens 2023 en blijft om goede redenen in de schijnwerpers staan. Net als bij de meeste play-to-earn crypto NFT-spellen, zijn veel spelers samengekomen. <a href="https://www.gate.io/price/gods-unchained-gods" target="_blank">naar Gods Unchained</a> om te genieten van de fantasie en zeldzame kaarten te verdienen die een echte waarde hebben in de echte wereld.</p>
<p>In feite, de spelers <a href="https://www.gate.io/price/view/play-to-earn" target="_blank">kan de kaarten verkopen voor GODS</a>, de native digitale valuta van het platform. Het doel van dit artikel is om Gods Unchained’s recente ontwikkelingen te onderzoeken, inclusief de lancering van de mobiele app. We zullen ook de historische ontwikkeling van het gaming platform en het schalen van het netwerk bespreken.</p>
<h2 id="h2-Immutable20Games20brengt20wereldwijd20Fantasy20tactisch20spel20uit20op20iOS20en20Android20apparaten721311"><a name="Immutable Games brengt wereldwijd Fantasy tactisch spel uit op iOS en Android apparaten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Immutable Games brengt wereldwijd Fantasy tactisch spel uit op iOS en Android apparaten</h2><p>De Goden Ontketend <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Games hebben de eerste versie van een mobiele game-applicatie gelanceerd die beschikbaar is op Android- en iOS-apparaten. Spelers kunnen respectievelijk de iOS- en Android-game-applicaties downloaden via de App Store en de Play Store.</p>
<p>De huidige versie geeft spelers toegang tot verschillende functies, waaronder Ranked, Casual en Solo-modi, evenals Immutable Passport. Zeker, deze toepassing zal het NFT-tradingkaartspel toegankelijker maken voor mensen op wereldschaal.</p>
<p>De andere belangrijke kenmerken die de gebruikerservaring (UX) verhogen, zijn in-game mobiele UI, de AppsFlyer, de deckbuilder, Arenascherm, instellingen, pack opening en beloningen na de wedstrijd. Het is belangrijk om te beseffen dat de mobiele versie van het spel er is om de ervaring op de pc aan te vullen.</p>
<p>Desalniettemin hebben de spelaanbieders beloofd meer functies toe te voegen om de spelervaring te verbeteren. De verwachte functies zijn onder meer een premium valuta voor in-app-aankopen, UI/UX, loadouts, Braze-ondersteuning, prestatieverbeteringen, NFT-muntfaciliteit en ondersteuning voor Firebase/Notifications. Sommige van deze functies bestaan al op de pc- en Mac NFT-gameversies.</p>
<p>De uitvoerend producent van het spel, Daniel Paez, heeft onlangs gereageerd op de reden voor het aanbieden van mobiele apps voor het fantasiegebaseerde tactische spel. Daniel Paez <a href="https://www.linkedin.com/pulse/immutable-games-gods-unchained-global-mobile-release-gam3sgg-j6uoe/?trk=organization_guest_main-feed-card_feed-article-content" rel="nofollow noopener noreferrer" target="_blank">zei</a>, “Uw mobiele telefoon is waarschijnlijk een van uw belangrijkste apparaten, daarom was het voor ons belangrijk om spelers de vrijheid te geven om te kiezen waar ze willen spelen, wanneer ze maar willen.”</p>
<p>Hij voegde eraan toe. “Voor iedereen die ooit een snel spel heeft willen spelen onderweg, maakt Gods Unchained Mobile het nu mogelijk.” Na een succesvolle gesloten testperiode op Android kondigde het team achter het NFT Card Game aan dat het binnenkort een mobiel NFT-spel zal lanceren.</p>
<h2 id="h2-De20reden20achter20de20uitrol20van20Fantasy20tactisch20spel20op20iOS20en20Android376379"><a name="De reden achter de uitrol van Fantasy tactisch spel op iOS en Android" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De reden achter de uitrol van Fantasy tactisch spel op iOS en Android</h2><p>Wat het mogelijk heeft gemaakt voor de lancering van Gods Unchained <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> NFT kaartspel op iOS en Android is de verandering van het inhoudsbeleid van de Epic Games Store.</p>
<p>Lees nieuws: <a href="https://www.gate.io/blog_detail/1602/epic-games-introduces-nft-based-games-on-epic-game-stores" target="_blank">Epic Games introduceert op NFT gebaseerde spellen in de Epic Game Stores</a></p>
<p>Hoewel Gods Unchained eerder op de Epic Games Store bestond, werd het verwijderd nadat de Entertainment Software Rating Board (ESRB) zijn NFT Mobile Game ‘Alleen voor volwassenen’ beoordeelde. Voordat Epic Games Store zijn inhoudsbeleid veranderde, was het niet mogelijk om games met AO-beoordelingen aan boord te brengen.</p>
<h2 id="h2-Immutable20X20Scaling20Netwerk662897"><a name="Immutable X Scaling Netwerk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Immutable X Scaling Netwerk</h2><p>Immutable X, aangedreven door StarkWare’s Starkey - een revolutionaire technologie voor zero-knowledge-proof - en gelanceerd in 2018, is een platform dat NFT- en game-ontwikkelaars de mogelijkheid biedt om hun projecten te ontwikkelen. Veel blockchain-games die op de blockchain zijn gevestigd, profiteren van lage gasprijzen, hoge schaalbaarheid en een koolstofneutrale omgeving.</p>
<p>Bovendien biedt het protocol een hoogwaardige beveiliging en transparantie waardoor de gebruikers kunnen genieten van een naadloze ervaring bij het slaan en verhandelen van digitale activa zoals NFT-kaarten. Als voorbeeld kunnen de gebruikers ERC-721 en ERC-20 tokens slaan en verhandelen op het platform.</p>
<p>Als feit hebben James en Robbie Ferguson samen met Alex Connolly Immutable X opgericht, dat begon als een layer-2 oplossing voor NFT’s. Het bestond aanvankelijk op Ethereum als een toonaangevende blockchain voor gedecentraliseerde applicaties (dApps) voordat het migreerde naar zijn eigen mainnet.</p>
<p>Op dit moment heeft de blockchain verschillende NFT-games, waaronder Gods Unchained, Illuvium, Ember Sword en Guild of Guardians. Het is belangrijk op te merken dat Immutable X verschillende Ethereum-wallets ondersteunt, zoals MetaMask en Coinbase Wallet.</p>
<p>Gods Unchained is een trading card game (TCG) waarmee spelers tegen elkaar kunnen strijden via multiplayer-wedstrijden. Met behulp van het play-to-earn-model biedt het gamingprotocol mensen over de hele wereld de kans om digitale activa te verdienen in de vorm van NFT’s. In eenvoudige bewoordingen kunnen spelers NFT-kaarten verdienen, kopen, verhandelen en verkopen die worden gebruikt voor vaardigheidsgerichte multiplayer-gevechten en strategische deckbuilding.</p>
<p>Lees ook hoe <a href="https://www.gate.io/how-to-buy/gods-unchained-gods" target="_blank">God Unchained kopen op Gate.io</a>.</p>
<h2 id="h2-Wat20is20een20NFTspel90154"><a name="Wat is een NFT-spel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een NFT-spel?</h2><p>Vanaf het begin van dit artikel hebben we het gehad over spelen om geld te verdienen spellen. In feite, de meeste, zo niet alle, <a href="https://www.gate.io/learn/articles/top-10-best-play-to-earn-web3-games/1515" target="_blank">Play-to-earn games zijn NFT-games</a>, gebaseerd op de blockchain. Dus, wat zijn NFT-games precies?</p>
<p>NFT-games zijn videospellen waarbij niet-vervangbare tokens een fundamenteel onderdeel vormen van hun architectuur en digitale economieën. In de context van een NFT-ruilkaartspel zijn NFT’s unieke digitale activa gebaseerd op blockchain, identificeerbaar aan de hand van speciale codes die ze onvervangbaar maken.</p>
<p>De NFT’s kunnen verschillende in-game items vertegenwoordigen, zoals personages, wapens en virtueel land of landgoed. Mensen die NFT-games spelen, verdienen deze unieke tokens die deel uitmaken van in-game activa. Daarom zijn er onbeperkte mogelijkheden voor het gebruik van NFT’s in play-to-earn-games.</p>
<h2 id="h2-Conclusie559987"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Immutable X heeft een mobiele gaming-applicatie gelanceerd voor zijn play-to-earn spel Gods Unchained, beschikbaar op Android- en iOS-apparaten. Het heeft verschillende functies, waaronder in-app aankopen, UI/UX, uitrusting, Braze ondersteuning en een NFT-mintfaciliteit. Spelers hebben de kans om in-game assets te verdienen die ze kunnen ruilen met de inheemse cryptocurrency genaamd GODs.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>