V2ViMyBHYW1pbmcgdmVkZSB1biBzb2xpZG8gaW5pemlvIGRlbCAyMDIz

2023-03-08, 08:22
<p><img src="https://gimg2.gateimg.com/image/article/16782634181.18.jpeg" alt=""></p>
<p>Molte criptovalute sono state rialziste dall’inizio del 2023 fino a febbraio.</p>
<p>L’attività on-chain per i token di gioco <a href="/web3" target="_blank" class="blog_inner_link">web3</a> è aumentata a partire da gennaio 2023.</p>
<p>I NFT di Yuga Labs’ Bored Ape Yacht Club, Mutant Ape Yacht Club e Sewer Pass hanno ottenuto buoni risultati durante gennaio e febbraio 2023.</p>
<p>Sandbox, <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a> and Otherside sono alcune delle piattaforme di gioco che hanno ottenuto buoni risultati durante gennaio e febbraio.</p>
<h2 id="h2-Introduzione740260"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nel 2022 c’è stata una grande delusione nel settore delle criptovalute poiché il mercato orso si è protratto per diversi mesi senza segni di attenuazione. Tuttavia, la situazione è cambiata dall’inizio del 2023 poiché diverse criptovalute hanno mostrato chiari segni di ripresa. Oggi parleremo del percorso di ripresa che l’industria ha già intrapreso.</p>
<h2 id="h2-Crescita20dellattivit20onchain152751"><a name="Crescita dell’attività on-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crescita dell’attività on-chain</h2><p>C’è stato un aumento dell’attività on-chain per il settore del gioco cripto, il che mostra segni di ripresa per il settore. Secondo DappRadar, la crescita dell’industria del gioco blockchain è stata del 1,31% con un record di 858.621 portafogli attivi unici giornalieri (dUAW), che rappresenta il 48% dell’attività Dapp.</p>
<p>A gennaio Alien Worlds ha registrato il livello più alto di attività di gioco on-chain, con una dominanza del 75%. Inoltre, <a href="https://www.statista.com/statistics/278181/global-gaming-market-revenue-device/" rel="nofollow noopener noreferrer" target="_blank">il settore aveva oltre 2,69 miliardi di consumatori</a> da diversi mondi virtuali. Nonostante il mercato orso del 2022, il settore dei giochi mobili ha registrato circa 103,5 miliardi di dollari di ricavi durante quell’anno.</p>
<p>L’ecosistema di Yuga Labs rimane uno dei principali attori nel settore dei giochi web3 in quanto ha registrato guadagni significativi nel gennaio e febbraio 2023. Oltre al Bored Ape Yacht Club e <a href="https://www.gate.io/nft/collection/1435/Mutant-Ape-Yacht-Club" target="_blank">NFT del Mutant Ape Yacht Club</a>, la performance di Sewer Pass è stata notevole.</p>
<p>Yuga Lab’s <a href="https://www.gate.io/learn/articles/nft-market-uation-sewer-pass-analysis/386" target="_blank">Sewer Pass è un progetto unico e innovativo</a> che consente ai giocatori di utilizzare i propri NFT durante il gioco e guadagnare ricompense per questo. Finora, le sue statistiche sono state impressionanti. Ad esempio, ha avuto un volume di scambi di $44.6 milioni che coinvolgeva 10.561 NFT in un periodo di 13 giorni che è terminato il 30 gennaio 2023. Il grafico seguente riassume le performance di Sewer Pass durante quel periodo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826354810801678263213_.pic.jpg" alt=""><br>Prestazioni di trading di Sewer Pass - DappRadar</p>
<p>Come puoi osservare nel diagramma sopra, Sewer Pass ha registrato volumi di trading NFT elevati nel periodo compreso tra il 18 e il 24 gennaio.</p>
<p>La performance di Sewer Pass è comprensibile in quanto è il requisito chiave per giocare al popolare Dookey <a href="/price/dash-dash" rel="nofollow noopener noreferrer" target="_blank">Dash</a> gioco. Ha segnato anche l’iniziativa di Yuga Lab di lanciare molti giochi NFT.</p>
<h2 id="h2-Aumento20degli20investimenti20nel20gioco20Metaverse20in20Web3819991"><a name="Aumento degli investimenti nel gioco Metaverse in Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aumento degli investimenti nel gioco Metaverse in Web3</h2><p>Un chiaro segno di crescita delle piattaforme di gioco web 3 è l’aumento degli investimenti avvenuti nel gennaio 2023. Durante quel periodo sono stati investiti complessivamente 156 miliardi di dollari in 10 piattaforme di gioco, con il maggior investimento proveniente da Courtside Ventures, che ha iniettato 100 milioni di dollari in programmi di sviluppo di giochi, benessere, sport e oggetti da collezione. Metaverse Tech è un’altra società di giochi che ha investito una cifra considerevole nello stesso periodo.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/405/so-what-is-web-3.0-the-decentralized-internet-of-the-future-explained" target="_blank">Web 3.0 - la futura Internet decentralizzata spiegata</a></p>
<h2 id="h2-Il20volume20di20trading20dei20mondi20virtuali2020aumentato20del20114104760"><a name="Il volume di trading dei mondi virtuali è aumentato del 114%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il volume di trading dei mondi virtuali è aumentato del 114%</h2><p>Un altro segno dell’aumento dell’interesse per i giochi metaversali è l’aumento recente dei volumi di trading per il settore. Il lancio di diverse dApp metaversali ha portato a una maggiore adozione dei giochi web3 rispetto al passato. Ad esempio, i mondi virtuali hanno registrato vendite per 44,6 milioni di dollari a gennaio, un aumento del 114% rispetto a dicembre 2022.</p>
<p>Al contrario, tuttavia, c’è stata una diminuzione del 19% delle vendite in gennaio come indica il grafico seguente.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826361110811678263231_.pic.jpg" alt=""><br>Volumi di trading del mondo virtuale e conteggio - DappRadar</p>
<p>Come puoi vedere da <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a>, dicembre 2022 ha avuto un conteggio delle vendite superiore a gennaio 2023. La performance di <a href="https://www.gate.io/blog_detail/638/decentraland-versus-sandbox-what-s-the-best-metaverse-project" target="_blank">Sandbox, Decentraland</a> e <a href="https://www.gate.io/blog_detail/2159/reasons-otherside-metaverse-best" target="_blank">Altro lato</a> ha contribuito alla crescita del volume di trading per il periodo indicato. Ad esempio, a gennaio, <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a> Il volume di trading di ’s è aumentato dell’83%, Sandbox del 114% e Otherside del 107%.</p>
<h2 id="h2-Crescita20dellinfrastruttura20Metaverse903672"><a name="Crescita dell’infrastruttura Metaverse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crescita dell’infrastruttura Metaverse</h2><p>C’è stato anche una crescita notevole delle piattaforme di gioco web3 come TreasureDAO, un ecosistema DeFi-NFT che esiste sulla blockchain Arbitrum. Tra i suoi prodotti di rilievo c’è un mercato che utilizza il token MAGIC.</p>
<p>Leggi anche: <a href="https://www.gate.io/uk/blog_detail/1935/how-will-the-defi-nft-perform-in-2023?lang=en" target="_blank">Come si comporteranno DeFi &amp; NFT nel 2023?</a></p>
<p>Significativamente, TreasureDAO è una piattaforma per lo sviluppo e l’hosting di progetti metaverse, gaming e NFT. Il suo token nativo, Magic, alimenta e sostiene l’intero ecosistema, comprese le piattaforme metaverse.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826368510821678263247_.pic.jpg" alt=""><br>TreasureDAO- Coincu</p>
<p>TreasureDAO ha molti contributori responsabili dello sviluppo di progetti NFT nell’economia dei giochi web3 e del metaverso. Attualmente, TreasureDAO ha 9 giochi web3 e una comunità con oltre 100.000 membri. Dalla sua creazione, circa 8 mesi fa, TreasureDAO ha avuto un volume di scambi di oltre 285 milioni di dollari.</p>
<p>Bridgeworld e Legions Genesis sono alcune delle piattaforme di metaverso e gioco che esistono su TreasureDAO. Inoltre, ha anche un mercato che supporta 10 collezioni NFT. In modo significativo, la collezione NFT di Legions Genesis è stata in tendenza, con alcune delle sue NFT più rare che hanno raggiunto un valore di oltre 70 ETH ciascuna.</p>
<h2 id="h2-Conclusione610852"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>In sintesi, c’è stato un aumento dell’attività di gioco on-chain, degli investimenti e dei volumi di trading nei mesi di gennaio e febbraio 2023. <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a>, Sandbox, Otherside e TreasureDAO sono stati alcuni dei blockchain di giochi web3 che hanno ottenuto buoni risultati a gennaio. Sulla base dell’attuale traiettoria, è probabile che l’industria dei giochi blockchain attiri più interesse da parte degli investitori.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards