TnVvdmEgZGlyZXppb25lIC0gR2FtZUZpISBBbmFsaXNpIGRlbCBwb3RlbnppYWxlIGRpIGNyZXNjaXRhIGRlbCB2YWxvcmUgaW4gdW4gY29udGVzdG8gZGkgcHJlenppIGFsbGUgc3RlbGxl

2023-12-01, 05:38

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR175150"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Recentemente, una serie di giochi GameFi hanno scatenato una frenesia guidata da GMT, diventando il centro dell’attenzione della popolarità recente dopo settori come la catena pubblica L1, la catena pubblica L2, i bot e l’IA.</p>
<p>Fondamentalmente, i giochi GameFi che sono diventati virali nel round precedente avevano tutti evidenti caratteristiche Ponzi, e l’approccio comune dei proprietari del progetto era quello di attirare i giocatori attraverso alti rendimenti, ma man mano che i rischi si accumulavano, alla fine collassavano.</p>
<p>Con l’emergere di nuove innovazioni nel paradigma dell’esperienza di gioco, nei modelli di token e nella promozione del traffico in <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> GameFi, l’era del GameFi 2.0 potrebbe essere alle porte.</p>
<h2 id="h2-Introduzione198203"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dopo l’ultimo scoppio del mercato Mavericks, il settore GameFi lungo e noioso ha finalmente ricevuto il testimone di una staffetta, guadagnando l’attenzione del mercato con un aumento medio dell’11%. Ciò è guidato sia dalla speculazione di rotazione del capitale a breve termine che dal supporto logico per il miglioramento dei fondamentali della pista.</p>
<p>In questo articolo esamineremo il processo di sviluppo di Web3 GameFi, esplorando la direzione e l’osservazione del valore dello sviluppo di GameFi nel nuovo paradigma.</p>
<h2 id="h2-I20token20GameFi20sono20aumentati20accelerando20la20ripresa20del20mercato752925"><a name="I token GameFi sono aumentati, accelerando la ripresa del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I token GameFi sono aumentati, accelerando la ripresa del mercato</h2><p>GameFi si riferisce a un gioco blockchain play-to-earn che fornisce ai giocatori incentivi economici, anche noto come Web3 GameFi.</p>
<p>Recentemente, una serie di giochi GameFi hanno avviato una frenesia guidata da GMT, diventando il centro dell’attenzione della popolarità recente dopo settori come la catena pubblica L1, la catena pubblica L2, Bots e AI.</p>
<p>Secondo i dati di CoinMarketCap, i settori Play To Earn e Gaming hanno registrato il maggior aumento dei prezzi dei token sul mercato, mentre il settore degli Sport, che ha anche attributi di gioco, attualmente si posiziona al primo posto in termini di crescita.<br><img src="https://gimg2.gateimg.com/image/article/170140890315791701408824_.pic.jpg" alt=""><br>Origine: CoinMarketCap</p>
<p>Prendendo il settore dei giochi come esempio, il valore di mercato totale dei token in questo settore è attualmente di quasi 14 miliardi di dollari, con un aumento medio di oltre il 10% in 24 ore. Il volume delle transazioni è pari a 1,8 miliardi di dollari, con un totale di 502 token di gioco e 141 token in attesa di essere lanciati.</p>
<p>Alla data di scrittura, secondo i dati di mercato di Gate.io, i token GameFi sono stati tra i migliori performer, con i token di gioco come GGG (Good Games Guild), RAINI (Raini) e ATLAS (Star Atlas) che hanno registrato un aumento del 30% nell’arco di 24 ore.<br><img src="https://gimg2.gateimg.com/image/article/170140892615801701408840_.pic.jpg" alt=""><br>Fonte: Gate.io</p>
<h2 id="h2-Introduzione20a20numerosi20progetti20GameFi20in20tendenza522709"><a name="Introduzione a numerosi progetti GameFi in tendenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione a numerosi progetti GameFi in tendenza</h2><p><strong>GasHero (GMT)</strong><br>Credo che molti giocatori esperti siano familiari con <a href="/price/stepn-gmt" target="_blank" class="blog_inner_link">StepN</a> del precedente mercato rialzista. Questo progetto consente ai giocatori di guadagnare token GST o GMT attraverso passeggiate, jogging o corsa all’aperto, aumentando così il reddito. Un progetto Ponzi molto standard ha guidato il nuovo modello GameFi di Move To Earn.</p>
<p>Di recente, il nuovo gioco GasHero lanciato dal team originale StepN ha iniziato i test della community dal 27 novembre all’11 dicembre. La regola specifica prevede che i giocatori riceveranno 30 monete di prova GMT ogni giorno per esplorare il gioco e i primi 100 giocatori riceveranno premi, inclusi buoni Creation Hero, che richiedono qualifiche per i test interni per entrare nel gioco. Inoltre, ci sono anche alcune attività su Twitter ufficiale e canali DC a cui è possibile continuare a partecipare.<br><img src="https://gimg2.gateimg.com/image/article/170140895815811701408855_.pic.jpg" alt=""><br>Fonte: X@GasHeroOfficial</p>
<p>Il nuovo gioco utilizza ancora il token GMT originale e l’APY ufficiale di 20 giorni è fondamentalmente intorno al 30%, il che senza dubbio dà al mercato sufficienti motivi per la speculazione. Secondo il mercato di Gate.io, GMT è aumentato fino al 170% dalla fine del mese scorso ed è stato abbassato da quando GasHero è entrato nel periodo beta pubblico.</p>
<p><strong>Echelon Prime（Prime）</strong><br>Echelon Prime è una piattaforma GameFi che attualmente sta lanciando due giochi molto popolari.</p>
<p>Il suo primo gioco, Parallel TCG, è un gioco collezionabile NFT di fantascienza (TCG) GameFi basato su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> chain. I giocatori possono acquistare e collezionare carte, e utilizzare in modo flessibile carte diverse per combinare set che rispettano le regole per guadagnare ricompense nel gioco.</p>
<p>L’altro è Parallel Colony (un gioco di simulazione), e TCG ha appena completato il testing interno della B-round. Colony è anche nella fase concettuale.</p>
<p>Vale la pena menzionare che molti rapporti si riferiscono scherzosamente a questo gioco, insieme a BigTime e Illuvium, come i tre giganti del nuovo GameFi web3, corrispondenti alla precedente triade di mercato toro di Sand, Axie e <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a>.</p>
<p><strong>SuperVerse（Super）</strong><br>SuperVerse (precedentemente noto come Superfarm) è un marketplace NFT cross chain e piattaforma di videogiochi con due prodotti principali: GigaMart, un marketplace NFT di nuova generazione con strumenti avanzati di analisi e caratteristiche sociali uniche, e Imposters, un mondo virtuale di giochi sociali.</p>
<p>Diamo un’occhiata agli Imposters. Questo gioco è un gioco di competizione tattica online multiplayer uscito da Epic Games. I giocatori devono collaborare con altri giocatori nel gioco, utilizzare varie abilità strategiche per completare compiti, raccogliere informazioni e assassinare bersagli. La forma di attuazione è fingere di essere un altro giocatore e giocare come un impostore, simile al ben noto gioco del lupo mannaro nello spazio.</p>
<p>Il gioco ha recentemente completato i test alpha chiusi e lanciato il token di impegno, ma in termini di giocabilità e qualità visiva, differisce dalla direzione dei giochi 3A mainstream. La sostenibilità di Super, che è aumentata sei volte nella scorsa settimana, resta da osservare ulteriormente.</p>
<p>Inoltre, ci sono Mahjong GameFi Mahjong Meta, piattaforma di dinamiche di gioco ed ecosistema Immutable su Ethereum, piattaforma di supporto all’ecosistema di giochi web3 NakamotoGames, piattaforma di giochi <a href="/price/gala-gala" target="_blank" class="blog_inner_link">Gala</a> Games che lancia le catene pubbliche dei giochi, il gioco Web3 di tipo ARPG Seraph con temi oscuri e un gioco sandbox di sviluppo di fantascienza Earth From Another Sun sui cavalieri e i tagli. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosistema. A causa dello spazio limitato, non verrà ripetuto qui.</p>
<h2 id="h2-Web320GameFi20Vacating20Cage20to20Change20Bird20Abbraccia20un20Nuovo20Paradigma270893"><a name="Web3 GameFi “Vacating Cage to Change Bird” Abbraccia un Nuovo Paradigma" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Web3 GameFi “Vacating Cage to Change Bird” Abbraccia un Nuovo Paradigma</h2><p>Retrocedendo nella storia dello sviluppo di GameFi, non è difficile notare che il recente aumento nel settore GameFi non è semplicemente una rotazione di fondi. Nel contesto di un sentimento speculativo a breve termine, molti progetti in questo settore stanno esplorando e sviluppando nuovi modelli in uno stile di “scambio di gabbia”.</p>
<p>Nel mercato rialzista dal 2020 al 2021, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> (AXS) ha innescato un boom generale nel mercato GameFi con il concetto di Play to Earn (P2E). In meno di un anno dal lancio di AXS, è schizzato da $0.14 a $140, diventando una vera moneta mille volte.</p>
<p>Sotto l’effetto straordinario della ricchezza, molti progetti hanno iniziato a seguire la tendenza e a creare vari concetti X to Earn, guadagnando un’ampia enfasi di mercato. Tuttavia, con l’arrivo di un mercato al ribasso, molti giochi che si basano esclusivamente su concetti anziché giocabilità sono crollati.</p>
<p>In sostanza, i progetti GameFi che sono diventati viral nella precedente fase presentavano tutti evidenti caratteristiche Ponzi. L’approccio comune utilizzato dai proprietari dei progetti era quello di attirare giocatori attraverso rendimenti elevati e, successivamente, mentre i giocatori continuavano ad entrare, la piattaforma utilizzava i rendimenti potenziali per ritardare il ciclo di vita. Ma nel tempo, il rischio si accumula gradualmente fino al collasso.</p>
<p>Tuttavia, dallo scorso anno, abbiamo osservato nuovi cambiamenti in molti progetti GameFi. Molte piattaforme GameFi e gilde di gioco hanno iniziato a ridefinire il loro brand, cercando di sviluppare catene di gioco indipendenti, espandere la cooperazione commerciale e migliorare l’esperienza di gioco in modalità specifiche. Hanno inoltre attivamente migliorato l’utilità dei token, come ad esempio espandere gli scenari di applicazione dei token verso l’astrazione degli account, supportare il token staking per ottenere dividendi in-game, e così via.</p>
<p>Si può prevedere che rispetto all’era precedente dei giochi concettuali, l’era del GameFi 2.0 sarà più prospera, per le seguenti ragioni specifiche:</p>
<p>(1) Molti progetti Web3 hanno attraversato un periodo di recessione di mercato e molti progetti GameFi sono stati completamente sviluppati e migliorati. L’anno prossimo, verrà lanciata una nuova ondata di progetti GameFi di alta qualità e è molto probabile un miglioramento in termini di qualità e quantità della partecipazione.</p>
<p>(2) Le aziende tradizionali di giochi Web2 hanno dimostrato una passione per la blockchain e GameFi e sembrano abbracciare attivamente questo cambiamento.</p>
<p>(3) Rispetto ai progetti nativi di criptovalute come DeFi, DAO e NFT, i progetti GameFi hanno una base potenziale di giocatori più ampia, barriere all’utente più basse, maggiore adesione e sono più propensi a ottenere una trasmissione virale.<br><img src="https://gimg2.gateimg.com/image/article/170140905015821701408870_.pic.jpg" alt=""><br>Origine: Analisi delle impronte</p>
<p>Si può prevedere che con l’emergere di nuove innovazioni nel paradigma dell’esperienza di gioco, nei modelli di token, nella promozione del traffico e in altri aspetti del Web3 GameFi, una sfida di lunga data nel campo del GameFi nel precedente mercato rialzista potrebbe avere nuovi sbocchi - su cosa altro possono fare affidamento i giocatori di blockchain per ottenere accettazione e fedeltà dai giocatori Web3?</p>
<p>La nuova era di GameFi potrebbe essere in arrivo, e naturalmente dobbiamo osservare attentamente se il mercato attuale in rapida crescita possa continuare. Tuttavia, se guardiamo oltre, potrebbero essere in arrivo altri giochi paradigma simili ad Axie, vediamo e attendiamo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>