TmlldXdlIHJpY2h0aW5nIC0gR2FtZUZpISBBbmFseXNlIHZhbiBoZXQgcG90ZW50aWVlbCB2b29yIHdhYXJkZWdyb2VpIG9uZGVyIHNuZWwgc3RpamdlbmRlIHByaWp6ZW4=

2023-12-01, 05:38

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR24083"><a name="[TL；DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]:</h2><p>Onlangs heeft een reeks GameFi-spellen een razernij veroorzaakt door GMT, en is het de focus geworden van recente populariteit na sectoren zoals L1 publieke keten, L2 publieke keten, Bots en AI.</p>
<p>In feite hadden de GameFi-spellen die viraal gingen in de vorige ronde allemaal duidelijke Ponzi-labels, en de gebruikelijke aanpak van projecteigenaren was om spelers aan te trekken via hoge rendementen, maar naarmate de risico’s zich opstapelden, stortten ze uiteindelijk in.</p>
<p>Met de opkomst van nieuwe paradigma-innovaties in spelervaring, tokenmodellen en verkeerspromotie in <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> GameFi, zou het tijdperk van GameFi 2.0 wel eens op komst kunnen zijn.</p>
<h2 id="h2-Introductie35350"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Sinds de recente uitbraak van de Mavericks-markt heeft de langzame GameFi-sector eindelijk een estafettestokje ontvangen en krijgt het marktaandacht met een gemiddelde stijging van 11%. Dit wordt gedreven door zowel kortetermijnkapitaalrotatiespeculatie als logische ondersteuning voor de verbetering van de fundamenten van de track.</p>
<p>In dit artikel zullen we het ontwikkelingsproces van Web3 GameFi bespreken, waarbij we de richting en waardeobservatie van GameFi-ontwikkeling onder het nieuwe paradigma verkennen.</p>
<h2 id="h2-GameFitokens20zijn20gestegen20waardoor20de20markt20herstelt20versnelt687971"><a name="GameFi-tokens zijn gestegen, waardoor de markt herstelt versnelt." class="reference-link"></a><span class="header-link octicon octicon-link"></span>GameFi-tokens zijn gestegen, waardoor de markt herstelt versnelt.</h2><p>GameFi verwijst naar een blockchain play-to-earn-spel dat spelers economische prikkels biedt, ook bekend als Web3 GameFi.</p>
<p>Onlangs is er een reeks GameFi-spellen begonnen met een gekte die wordt aangedreven door GMT en die de aandacht heeft getrokken na sectoren zoals L1 openbare keten, L2 openbare keten, Bots en AI.</p>
<p>Volgens CoinMarketCap-gegevens hebben de Play To Earn- en Gamingsectoren de hoogste stijging van tokenprijzen op de markt gezien, terwijl de Sportsector, die ook Game-kenmerken heeft, momenteel de eerste plaats inneemt qua groei.<br><img src="https://gimg2.gateimg.com/image/article/170140890315791701408824_.pic.jpg" alt=""><br>Bron: CoinMarketCap</p>
<p>Neem als voorbeeld de Gaming sector, de totale marktwaarde van tokens in deze sector is momenteel bijna $14B, met een gemiddelde stijging van meer dan 10% in 24 uur. Het transactievolume is zo hoog als $1.8B, met in totaal 502 gametokens en 141 tokens die klaarstaan om gelanceerd te worden.</p>
<p>Op de schrijfdatum, volgens de marktgegevens van Gate.io, behoren GameFi-tokens tot de best presterende tokens, waarbij game-tokens zoals GGG (Good Games Guild), RAINI (Raini) en ATLAS (Star Atlas) allemaal een stijging van meer dan 30% in 24 uur hebben ervaren.<br><img src="https://gimg2.gateimg.com/image/article/170140892615801701408840_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<h2 id="h2-Kennismaking20met20tal20van20populaire20GameFiprojecten486465"><a name="Kennismaking met tal van populaire GameFi-projecten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking met tal van populaire GameFi-projecten</h2><p><strong>GasHero (GMT)</strong><br>Ik geloof dat veel ervaren spelers bekend zijn met de <a href="/price/stepn-gmt" target="_blank" class="blog_inner_link">StepN</a> van de vorige bullmarkt. Dit project stelt spelers in staat om tokens GST of GMT te verdienen door buiten te wandelen, joggen of rennen, waardoor het inkomen wordt verhoogd. Een zeer standaard Ponzi-project heeft het nieuwe GameFi-model van Move To Earn aangedreven.</p>
<p>Onlangs begon het nieuwe spel GasHero, gelanceerd door het oorspronkelijke StepN-team, met communitytests van 27 november tot 11 december. De specifieke regel is dat spelers elke dag 30 GMT-testmunten ontvangen om het spel te verkennen, en de top 100 spelers ontvangen beloningen, waaronder Creation Hero-coupons, die interne testkwalificaties vereisen om het spel binnen te gaan. Bovendien zijn er ook enkele activiteiten op de officiële Twitter en DC-kanalen waar aan kan worden deelgenomen.<br><img src="https://gimg2.gateimg.com/image/article/170140895815811701408855_.pic.jpg" alt=""><br>Bron: X@GasHeroOfficial</p>
<p>Het nieuwe spel gebruikt nog steeds de originele GMT-token, en de officiële 20-daagse APY ligt in feite rond de 30%, wat de markt ongetwijfeld voldoende redenen geeft voor speculatie. Volgens de Gate.io-markt is GMT sinds het einde van vorige maand met maar liefst 170% gestegen, en is het verlaagd sinds GasHero de openbare bètaperiode is ingegaan.</p>
<p><strong>Echelon Prime (Prime)</strong><br>Echelon Prime is een GameFi-platform dat momenteel twee games lanceert met een grote populariteit.</p>
<p>Zijn eerste spel, Parallel TCG, is een sci-fi NFT verzamelkaart (TCG) GameFi gebaseerd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> keten. Spelers kunnen kaarten kopen en verzamelen, en verschillende kaarten flexibel gebruiken om sets te combineren die voldoen aan de regels om beloningen te verdienen in het spel.</p>
<p>De andere is Parallel Colony (een simulatiespel), en TCG heeft zojuist de B-ronde van interne tests voltooid. Colony bevindt zich ook in de conceptfase.</p>
<p>Het is vermeldenswaard dat veel rapporten deze game, samen met BigTime en Illuvium, spottend de drie reuzen van de nieuwe web3 GameFi noemen, wat overeenkomt met het vorige drietal van Sand, Axie en de stierenmarkt. <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a>.</p>
<p><strong>SuperVerse（Super）</strong><br>SuperVerse (voorheen bekend als Superfarm) is een cross-chain NFT-marktplaats en videogameplatform met twee kernproducten: GigaMart, een next-generation NFT-marktplaats met geavanceerde analyse-tools en unieke sociale functies, en Imposters, een sociale gaming virtuele wereld.</p>
<p>Laten we ons richten op Imposters. Dit spel is een multiplayer online tactisch competitiespel dat is uitgebracht door Epic Games. Spelers moeten samenwerken met andere spelers in het spel, verschillende strategische vaardigheden gebruiken om taken te voltooien, informatie verzamelen en doelwitten vermoorden. De uitvoeringsvorm is om te doen alsof je een andere speler bent en een bedrieger speelt, vergelijkbaar met de bekende ruimteweerwolfmoord.</p>
<p>Het spel heeft onlangs de gesloten alfatest voltooid en de tokenbelofte gelanceerd, maar qua speelbaarheid en visuele kwaliteit verschilt het van de mainstream 3A-game richting. De duurzaamheid van Super, die de afgelopen week zes keer is gestegen, moet nog verder worden waargenomen.</p>
<p>Daarnaast zijn er Mahjong GameFi Mahjong Meta, een spel dynamiek platform en ecosysteem Immutable op Ethereum, een web3 game ecosysteem ondersteuningsplatform NakamotoGames, een game platform <a href="/price/gala-gala" target="_blank" class="blog_inner_link">Gala</a> Games dat game publieke ketens lanceert, ARPG type Web3 spel Seraph met donkere thema’s, en een sci-fi rijden en hakken ontwikkeling sandbox spel Aarde Van Een Andere Zon op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem. Vanwege beperkte ruimte zal het hier niet herhaald worden.</p>
<h2 id="h2-Web320GameFi20Verlaat20Kooi20om20Vogel20te20Veranderen20Omarmt20een20Nieuw20Paradigma181281"><a name="Web3 GameFi ‘Verlaat Kooi om Vogel te Veranderen’ Omarmt een Nieuw Paradigma" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 GameFi ‘Verlaat Kooi om Vogel te Veranderen’ Omarmt een Nieuw Paradigma</h2><p>Als we terugkijken op de ontwikkelingsgeschiedenis van GameFi, is het niet moeilijk om te vinden dat de recente opkomst in de GameFi-sector niet zo eenvoudig is als de rotatie van fondsen. In de context van korte termijn speculatieve sentiment, verkennen veel projecten in deze sector en ontwikkelen ze nieuwe modellen op een ‘kooi ruil’-achtige manier.</p>
<p>In de stierenmarkt van 2020 tot 2021, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a>(AXS) veroorzaakte een algehele boom in de GameFi-markt met het concept van Play to Earn (P2E). Binnen minder dan een jaar na de lancering van AXS steeg het van $0,14 naar $140, waarmee het een echte munt met duizendvoudige waarde werd.</p>
<p>Onder het verbluffende rijkdomseffect begonnen veel projecten de trend te volgen en verschillende X-to-Earn-concepten te creëren, wat voldoende markthype opleverde. Echter, met de komst van een bear market zijn veel spellen die alleen afhankelijk zijn van concepten in plaats van speelbaarheid, ingestort.</p>
<p>In feite hadden de GameFi-projecten die viraal gingen in de vorige ronde allemaal duidelijke Ponzi-kenmerken. De gebruikelijke aanpak die door projecteigenaren werd gebruikt, was om spelers aan te trekken door middel van hoge rendementen, en vervolgens, naarmate spelers bleven instappen, werden potentiële rendementen ingezet om de levenscyclus te vertragen. Maar na verloop van tijd stapelt het risico zich op totdat het instort.</p>
<p>Echter hebben we sinds vorig jaar nieuwe veranderingen waargenomen in veel GameFi projecten. Veel GameFi platforms en game guilds zijn begonnen met het hervormen van hun merken, met als doel het ontwikkelen van onafhankelijke game chains, het uitbreiden van zakelijke samenwerkingen en het verbeteren van de game-ervaring in specifieke gameplay. Ze hebben ook actief de functionaliteit van tokens verbeterd, zoals het uitbreiden van token toepassingsgebieden naar account abstractie, ondersteuning van token staking om in-game dividenden te verkrijgen, enzovoort.</p>
<p>Het kan worden voorzien dat in vergelijking met het vorige conceptuele gametijdperk, het tijdperk van GameFi 2.0 welvarender zal zijn, om de volgende specifieke redenen:</p>
<p>(1) Veel Web3-projecten hebben een bear market doorgemaakt, en veel GameFi-projecten zijn volledig ontwikkeld en verbeterd. Volgend jaar zullen er golf van hoogwaardige GameFi-projecten worden gelanceerd, en de verbetering in kwaliteit en kwantiteit zal zeer waarschijnlijk deelname terugwinnen.</p>
<p>(2) Traditionele Web2 gamingbedrijven hebben een passie getoond voor blockchain en GameFi en lijken deze verandering actief te omarmen.</p>
<p>(3) In vergelijking met crypto native projecten zoals DeFi, DAO en NFT hebben GameFi-projecten een breder potentieel aan spelers, lagere gebruikersdrempels, hogere betrokkenheid en hebben ze een grotere kans op virale verspreiding.<img src="https://gimg2.gateimg.com/image/article/170140905015821701408870_.pic.jpg" alt=""><br>Bron: Footprint Analytics</p>
<p>Het is te voorzien dat met de opkomst van nieuwe paradigma-innovaties in gameplay-ervaring, tokenmodellen, verkeersbevordering en andere aspecten van Web3 GameFi, een langdurige uitdaging in het GameFi-veld in de vorige bullmarkt mogelijk nieuwe doorbraken kan hebben - waar kunnen blockchain-spelers nog meer op vertrouwen om acceptatie en loyaliteit van Web3-spelers te krijgen?</p>
<p>Het nieuwe tijdperk van GameFi kan op komst zijn, en we moeten natuurlijk nauwlettend in de gaten houden of de huidige bloeiende markt kan aanhouden. Als we echter verder kijken, kunnen er mogelijk nog een of meer paradigma-spellen vergelijkbaar met Axie op het punt staan om geboren te worden, laten we afwachten en zien.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten 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 vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>