UG9seWdvbiBzaSBwb3NpemlvbmEgY29tZSBpbCBzZWNvbmRvIHBpw7kgZ3JhbmRlIG5ldHdvcmsgZGkgZ2lvY2hpIGJsb2NrY2hhaW4gc3VsIG1lcmNhdG8=

<p><img src="https://gimg2.gateimg.com/image/article/1682586049RDZZ.jpeg" alt=""></p>
<h2 id="h2-TL20DR136222"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Secondo <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">criptovaluta Polygon</a> notizie, la blockchain è ora la seconda rete di gioco più grande dopo aver registrato un aumento del 53% nei portafogli attivi a marzo.</p>
<p>WAX, la blockchain che ospita diverse piattaforme di gioco web3, è la rete di gioco classificata al primo posto.</p>
<p>Yuga Labs è un attore chiave nell’industria dei giochi grazie alla sua continua innovazione e nuove partnership.</p>
<p>Gli amanti delle criptovalute possono acquistare <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> La criptovaluta nativa di Matic su Gate.io, un exchange di criptovalute centralizzato.</p>
<h2 id="h2-Introduzione591520"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Negli ultimi tre anni, il settore dei giochi basati su blockchain è stato in costante espansione. Abbiamo visto numerosi giochi decentralizzati essere introdotti anno dopo anno su diverse reti. In passato, molti giochi basati su blockchain esistevano su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Ora, ci sono diverse blockchain come <a href="https://www.gate.io/price/polygon-matic" target="_blank">Polygon</a> e WAX che ospitano giochi diversi. Oggi esploriamo come si è comportato il settore dei giochi blockchain nel primo trimestre del 2023.</p>
<h2 id="h2-Panoramica162787"><a name="Panoramica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica</h2><p>L’attività on-chain misurata dai portafogli attivi unici (UAW) mostra una crescita nei giochi basati su blockchain. Il portafoglio attivo unico si riferisce ai portafogli digitali che interagiscono con un’applicazione decentralizzata come un protocollo di gioco. Ciò non significa che il portafoglio debba essere attivo quotidianamente, ma accede occasionalmente a un contratto intelligente durante un periodo di circa un mese.</p>
<p>La variazione dei portafogli attivi unici (UAW) indica un aumento o una diminuzione delle attività di un determinato smart contract come un protocollo di gioco. Secondo DappRadar, a marzo c’è stato un calo del 3,33% dei portafogli attivi unici che si collegano alle dapp blockchain rispetto a febbraio.</p>
<p>Tuttavia, il settore dei giochi basati su blockchain è stato rialzista nel Q1 2023 poiché c’è stato un aumento della sua predominanza dal “42,87% nel Q4 del 2022 al 45,60% nel Q1 del 2023”, come indica il grafico seguente.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1682586371Polygon 1.png" alt=""></p>
<p>Come osservato, c’è stato un aumento del 46% nell’UAW nel primo trimestre del 2023.</p>
<h2 id="h2-Leader20nel20settore20dei20giochi20blockchain20per20il20primo20trimestre20del202023351180"><a name="Leader nel settore dei giochi blockchain per il primo trimestre del 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Leader nel settore dei giochi blockchain per il primo trimestre del 2023</h2><p>Durante il primo trimestre del 2023, diverse piattaforme di gioco come Alien Worlds, Splinterlands, Benji Bananas, Iskra e Yuliverse hanno avuto un ottimo rendimento. In particolare, Alien Worlds, un dapp basato su Wax, è stato uno dei migliori performer nel settore dei giochi. Con 580.000 mUAW a marzo, l’UAW di Alien Worlds è aumentato del 4% rispetto a febbraio 2023.</p>
<p>Gli altri migliori giochi NFT sono stati Splinterlands, Benji Bananas, Iskala, Uliverse, Hunters On-chain, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> e Yuga Labs. Iskara che è stato il secondo gioco con le migliori prestazioni a marzo, con 319.000 mUAW, un aumento del 708% rispetto a febbraio.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-polygon/73" target="_blank">Cos’è Polygon? Tutto ciò che devi sapere su MATIC</a></p>
<p>Hunters su-chain web3, un <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> La piattaforma di gioco, ha superato diversi altri giochi decentralizzati durante il mese di marzo. Questo popolare gioco <a href="/web3" target="_blank" class="blog_inner_link">web3</a> ha avuto 134.000 mUAW, il 15.497% in più rispetto alla cifra di febbraio.</p>
<p>D’altra parte, Yuliverse aveva 91.000 mUAW, un aumento del 2.656% rispetto all’attività di febbraio. Curiosamente, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Il volume degli scambi ha raggiunto i 93 milioni di dollari a marzo, circa il 72,15% rispetto alla cifra di febbraio. Sicuramente, le performance dei suddetti giochi web3 sono una testimonianza della popolarità e della crescita del gioco basato su blockchain.</p>
<p>Leggi anche: <a href="https://www.gate.io/ru/blog_detail/2349/polygon-and-immutable-s-historic-partnership-in-ethereum-layer-2" target="_blank">Storica collaborazione tra Immortable e Polygon sulla catena Ethereum Layer-2</a></p>
<h2 id="h2-Prestazioni20di20Yuga20Labs20nel20primo20trimestre20del202023159046"><a name="Prestazioni di Yuga Labs nel primo trimestre del 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni di Yuga Labs nel primo trimestre del 2023</h2><p>Non possiamo completare una valutazione di blockchain e giochi senza considerare le prestazioni di Yuga Labs poiché è uno dei giochi leader al momento. Yuga Labs è una piattaforma di gioco che continua a fare innovazioni e a forgiare importanti partnership per migliorare l’esperienza di gioco degli utenti.</p>
<p>Come esempio, è stato recentemente introdotto <a href="https://dappradar.com/ethereum/collectibles/sewer-pass" rel="nofollow noopener noreferrer" target="_blank">Passaggi fognari</a>, un progetto promettente NFT all’interno dell’ecosistema Bored Ape Yacht Club. Ha generato oltre 4.000 ETH nelle prime ore dopo il lancio. Ha anche lanciato HV-MTL, una collezione NFT a marzo, che ha già accumulato più di 18.028 ETH (circa 34,46 milioni di dollari) sul mercato secondario.</p>
<p>L’Otherdeed per l’Otherside è stata un’altra storia di successo per Yuga Labs. Ad esempio, il 7 marzo, 200 giocatori hanno partecipato alla prova di 90 minuti dell’Otherdeeds per Otherside. Inoltre ha collaborato con Gucci, una casa di moda di lusso.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/all-you-need-to-know-about-p2e-games/331" target="_blank">Tutto ciò che devi sapere sui giochi P2E</a></p>
<h2 id="h2-Polygon2020ha20registrato20una20crescita20del205320negli20Wallet20Attivi995392"><a name="Polygon  ha registrato una crescita del 53% negli Wallet Attivi" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> ha registrato una crescita del 53% negli Wallet Attivi</h2><p>La crescita del <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> La blockchain è un’altra ragione per la continua espansione delle reti di gioco. A marzo ha registrato 138.081 dUAW, un aumento del 53% rispetto a febbraio. Come risultato dell’aumento in <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> attività di gioco, ha superato Hive diventando la seconda blockchain con il maggior numero di attività di gioco web3.</p>
<p>La performance dei Cacciatori On-Chain di BoomLand durante il primo trimestre del 2023 ha contribuito all’aumento delle attività di blockchain e gaming su <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> A proposito, WAX rimane la blockchain con la maggior attività di gioco nonostante registri un calo dell’8,11% nei suoi portafogli attivi unici (dUAW) a marzo. Il grafico seguente mostra i cambiamenti nei portafogli attivi unici delle migliori blockchain di gioco.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1682586493Polygon 2.png" alt=""></p>
<p>Come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">Il Grafico</a> mostra WAX, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, Hive, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Catena e <a href="/price/klaytn-klay" rel="nofollow noopener noreferrer" target="_blank">Klaytn</a> sono le principali blockchain per il gioco.</p>
<h2 id="h2-Segnali20rialzisti20per20lindustria20dei20giochi20blockchain590425"><a name="Segnali rialzisti per l’industria dei giochi blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Segnali rialzisti per l’industria dei giochi blockchain</h2><p>L’aumento dei portafogli attivi unici (dUAW) durante il primo trimestre del 2023 è un segnale rialzista per i giochi blockchain. C’è stata una crescita del numero di blockchain che offrono servizi di gioco nel 2022.</p>
<p>Già adesso, ci sono molti giochi nelle loro fasi Alpha e Beta. Imposters, Among Us, Deadrop e Parallel sono esempi di giochi che sono in fasi avanzate di sviluppo e probabilmente lanceranno i loro giochi nel 2023. Inoltre, i giochi blockchain sono ora popolari sui dispositivi mobili che aumentano la loro portata e domanda.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/polygon-matic" target="_blank">Previsione del prezzo di Polygon (MATIC) 2023-2030</a></p>
<h2 id="h2-come20acquistare20matic2020su20Gateio720102"><a name="come acquistare matic  su Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/how-to-buy/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">come acquistare matic</a> su Gate.io</h2><p>Abbiamo discusso di come <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygona</a> La blockchain ospita molte piattaforme di gioco blockchain che stanno andando bene. Questo aumenta anche la domanda per la sua criptovaluta nativa chiamata Matic. Discutiamo brevemente <a href="https://www.gate.io/how-to-buy/polygon-matic" target="_blank">come puoi acquistare Matic su Gate.io</a></p>
<p>Il primo passo è creare e verificare il tuo account Gate.io. Il passo successivo è finanziare il tuo account utilizzando una delle principali criptovalute come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, USDT o ETH.</p>
<p>Puoi acquistare queste principali criptovalute utilizzando un bonifico bancario o una carta di credito. Una volta che hai una di queste criptovalute nel tuo account, vai al <a href="https://www.gate.io/trade/MATIC_USDT" target="_blank">Sezione di scambio immediato</a> e selezionare la coppia adatta come USDT/Matic come indicato di seguito.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1682586603Polygon 3.png" alt=""></p>
<p>Una volta cliccato su quella coppia, USDT/Matic, si aprirà una nuova finestra che ti permette di inserire l’importo di <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> vuoi comprare.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1682586649Polygon 4.png" alt=""></p>
<p>Una volta che hai inserito l’importo di Matic che desideri acquistare, clicca su “ <a href="/how-to-buy/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">acquista matic</a>.” Dopo di che dovrai confermare la transazione.</p>
<h2 id="h2-Conclusione744298"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il settore dei giochi blockchain si è espanso rapidamente dal 2022. Analogamente, ha mantenuto quel momentum nel 2023, con Splinterlands, Benji Bananas, Iskala, Uliverse, Hunters On-chain, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> e Yuga Labs sono i giochi web3 con le migliori prestazioni nel primo trimestre del 2023. <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> è seconda solo a WAX come blockchain che ospita e supporta molte piattaforme di gioco blockchain.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni 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à consentita la ripubblicazione dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>