SGVlZnQgR2FtZUZpJ3MgRmluZXN0IEhvdXIgUmV0dXJuZWQ/IFdlbGtlIFByb2plY3RlbiB6aWpuIGhldCB3YWFyZCBvbSBpbiBkZSBnYXRlbiB0ZSBob3VkZW4/

2023-11-29, 15:27

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-Introductie399152"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Naarmate het einde van november nadert, vertoont GameFi tekenen van een ‘lente-terugkeer’, met een stijging van tokens en talloze project releases, community discussies en KOLs die de weg wijzen. Het nieuws blijft constant opduiken.</p>
<p>Na het zien van te veel slechte projecten lijkt ‘spelen om te verdienen’ niet langer een aantrekkelijke slogan. Dus, is deze oproep voor GameFi echt ‘iets om te spelen’ of verbruikt het de energie van spelers opnieuw met verouderde spelinhoud en tokenuitgiftemodellen? Laten we kort kijken naar de problemen waarmee GameFi te maken heeft en enkele representatieve projecten van de afgelopen tijd.<br><img src="https://gimg2.gateimg.com/image/article/170127142015581701260310_.pic 1.jpg" alt=""><br>Bron: unsplash</p>
<h2 id="h2-GameFiuitdaging20Hoe20economische20modellen20en20speelbaarheid20decentralisatie20en20spelerservaring20in20evenwicht20te20brengen575242"><a name="GameFi-uitdaging: Hoe economische modellen en speelbaarheid, decentralisatie en spelerservaring in evenwicht te brengen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GameFi-uitdaging: Hoe economische modellen en speelbaarheid, decentralisatie en spelerservaring in evenwicht te brengen</h2><p>De explosie van de gamingsector in deze ronde is niet verrassend, aangezien gaming in de vorige cyclus de sector was met de meeste financiering op de primaire markt, maar het is moeilijk te zeggen of deze trend zal aanhouden.</p>
<p>Terugkijkend op de geschiedenis van GameFi, waren games bedoeld als het meest diverse en gemakkelijk te begrijpen gebied voor gebruikers om aan deel te nemen. Maar in werkelijkheid heeft GameFi geen stabiele en langetermijnprojecten zoals DeFi voortgebracht.</p>
<p>De reden kan ook eenvoudig zijn: de ontwerplogica van DeFi is zelf consistent, terwijl GameFi worstelt om een balans te vinden tussen financiële en gamingkenmerken.<br><img src="https://gimg2.gateimg.com/image/article/170127145315591701260335_.pic 1.jpg" alt=""><br>Bron: unsplash</p>
<p>Het doel van DeFi is zeer duidelijk: gedecentraliseerde financiële activiteiten stellen ontwikkelaars en gebruikers in staat om hun behoeften en belangen op elkaar af te stemmen en in balans te brengen, terwijl games veel complexer zijn - voor ontwikkelaars zijn de moeilijkheid en kosten hoog, de ontwikkelingscyclus lang, testen en lanceringswerk omslachtig, maar na investering kunnen traditionele web2 game winstmodellen niet worden gevolgd.</p>
<p>Voor spelers zijn de kenmerken van financiële instrumenten en entertainmentproducten eigenlijk tegenstrijdig, en het is moeilijk om ze in evenwicht te brengen; Zodra entertainment een manier wordt om geld te verdienen en te werken, zal elk nieuw spel snel worden gladgestreken, en spelen om te verdienen is eigenlijk gewoon een slogan.</p>
<p>Op het gebied van economische modellen moet bij het balanceren van de schaarste van game-assets met de in-uitverhouding die wordt verkregen door deelname, nog steeds rekening worden gehouden met factoren zoals tokenwaarde en NFT-veilingen. Als de drempel te hoog en de tijdsinvestering te groot is, kunnen gebruikers niet behouden blijven. Als de drempel te laag is, ontstaan er echter makkelijk projecten van lage duurzaamheid.</p>
<p>Tenminste voorheen richtte de meeste GameFi zich op ‘verdienen,’ inclusief succesvolle glen zoals rennen om geld te verdienen en elektronische huisdieren, die ook zeer basisontwerpen zijn die kunnen worden ingewisseld voor activa zoals tokens of NFT’s met relatief eenvoudige investeringen. Op deze manier, als er projecten zijn met meer volwassen stimuleringsmodellen die gebruikers meer geld kunnen opleveren, zal het spel natuurlijk zijn aantrekkingskracht verliezen en genegeerd worden. Dus, hoewel het moeilijk is, heeft een GameFi-project dat spelers in staat stelt om een verlangen te behouden en een ‘speel’-kenmerk heeft dat hen niet tegenhoudt, op de lange termijn potentieel.</p>
<p>Naast het spel zelf kan GameFi ook andere samenwerkingsprojecten stimuleren. Spelontwikkeling, aggregatieplatforms en communicatieforums zijn ook goede ideeën, maar deze zijn nauw verbonden met de ontwikkelingsfase van de gehele GameFi en de stabiliteit van het publiek. Daarom zorgen stabiele projecten ervoor dat spelers bereid zijn om op lange termijn te investeren, en het gehele GameFi-ecosysteem gezond kan zijn.<br><img src="https://gimg2.gateimg.com/image/article/170127147915601701260363_.pic 1.jpg" alt=""><br>Bron: unsplash</p>
<h2 id="h2-Welke20recente20GameFitracks20zijn20het20waard20om20in20de20gaten20te20houden800311"><a name="Welke recente GameFi-tracks zijn het waard om in de gaten te houden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke recente GameFi-tracks zijn het waard om in de gaten te houden?</h2><p>SHARPNEL<br>Misschien wel een van de meest opvallende games van de laatste tijd, SHARPNEL is een FPS game ontwikkeld door een team van 3A game-ontwikkelaars die nauwkeurige overwegingen hebben voor het ontwerp van het economische model. Het hoogtepunt van deze game is de uitstekende productie, die het potentieel heeft voor langdurige aandacht.</p>
<p>Groots<br>Toen het BIGTIME-token in de eerste twee maanden werd gelanceerd, was er een meer dan 20-voudige toename, wat kan worden beschouwd als een project dat enthousiasme aanwakkerde in een bearmarkt. Het hoogtepunt ligt ook in de gegarandeerde productiekwaliteit, die door gameliefhebbers wordt beschouwd als een zeldzaam “orthodox” type met een hoge gameplay. Dienovereenkomstig vereist het echter een bepaalde hoeveelheid tijd en investering om te begrijpen en te investeren, en er zijn enkele speldrempels.</p>
<p><a href="/price/gala-gala" rel="nofollow noopener noreferrer" target="_blank">GALA</a> en Wemix<br>Deze twee zijn aggregatie- en ontwikkelingsplatforms met bepaalde kwalificaties, en de hoeveelheid en kwaliteit van geïntegreerde games hebben duidelijke voordelen. Wat betreft het game-ontwikkelingsteam is het <a href="/price/gala-gala" target="_blank" class="blog_inner_link">Gala</a> Games-team een van de weinige bekende ontwikkelaars in de traditionele game-industrie in het GameFi-veld. De ontwikkelingscyclus is over het algemeen langer, maar heeft ook over het algemeen meer langetermijnpotentieel.</p>
<p>Gas Hero<br>Geproduceerd door het STEPEN-team, met GMT als het governance-token, is dit een plaatsingsspel zonder problemen op productieniveau en met een lage drempel voor gameplay en begrip. Gecombineerd met de reputatie van het team kan het een groot aantal gebruikers aantrekken, wat ook de bron is van de recente toename in GMT.<br><img src="https://gimg2.gateimg.com/image/article/170127152815611701260383_.pic.jpg" alt=""><br>Bron: Gate.io</p>
<p>Ondertussen, veteraan sterprojecten zoals Axie, <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STEPN</a>, en Star Atlas blijven ook inspanningen leveren.</p>
<h2 id="h2-Wanneer20we20het20hebben20over20GameFi20waar20zijn20we20dan20naar20op20zoek975572"><a name="Wanneer we het hebben over GameFi, waar zijn we dan naar op zoek" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wanneer we het hebben over GameFi, waar zijn we dan naar op zoek</h2><p>Hoewel sommigen misschien schertsend zeggen dat “liefhebbers in de cryptoruimte alleen maar geld willen verdienen”, ongeacht hoeveel moeite er wordt gedaan om gebruikers aan te trekken om geld te verdienen, moet het wezen van het spel nog steeds zijn om deelnemers zich interessant te laten voelen, emotionele waarde te krijgen en resoneren met discussies onder liefhebbers.</p>
<p>Dus naast het creëren van buzz, welke andere aspecten moet GameFi goed doen? Het meest cruciale aspect is nog steeds de speelbaarheid. Tegenwoordig zien mensen meer complexe grootschalige producties, maar uiteindelijk vereisen leuke games niet per se enorme databases of zeer frequente realtime interacties. Ontwikkelaars kunnen hun oorsprong traceren en inspiratie zoeken in klassieke bordspellen of vorige generaties singleplayer-games, waardoor een flexibel en interessant interactieontwerp en kernmechanisme ontstaat.<br><img src="https://gimg2.gateimg.com/image/article/170127156715621701260395_.pic_hd 1.jpg" alt=""><br>Bron: unsplash</p>
<p>Daarna komt artistiek of audiovisueel ontwerp. Als de ‘negende kunst’ is de combinatie van geluid, licht, schaduw en interactiviteit de meest intuïtieve aantrekkingskracht van games. Het verfijnen van kunst en muziek en het creëren van een goede visuele ervaring berusten meer op de esthetiek en creativiteit van het team, zonder dat er sterke netwerkprestaties nodig zijn. Spelers zullen altijd stoppen voor uitstekende werken.</p>
<p>Redelijk bestuur is een belangrijke reservekracht, die direct verband houdt met de omgeving en rechtvaardigheid, en is de sleutel tot langdurige vitaliteit. Op basis hiervan is het het beste om het spel een bepaald niveau van sociale interactie te laten hebben, en discussies kunnen verbindingen creëren tussen enthousiastelingen, wat natuurlijk de gemeenschap stimuleert.</p>
<p>Hoewel Web3-spellen nog in een vroeg stadium zijn vanwege vertragingen in de netwerkdoorvoer en andere problemen, zullen <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> en spellen een perfecte combinatie worden naarmate nieuwe technologieën de schaalbaarheidsproblemen geleidelijk verminderen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<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 voor 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 auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>