VGhlIFNhbmRib3g6IENhdmFsY2FuZG8gbCdvbmRhIHZlcnNvIHVuYSB2YWx1dGF6aW9uZSBkaSAxIG1pbGlhcmRvIGRpIGRvbGxhcmkgbmVsbCdFdGhlcmV1bSBNZXRhdmVyc2U=

2024-06-19, 08:21

<p><img src="https://gimg2.gateimg.com/image/article/17187847721690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR590935"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Animoca Brands e Kingsway Capital hanno aiutato il Sandbox a raccogliere $1 milione per il miglioramento di varie caratteristiche e funzionalità.</p>
<p><a href="/price/the-sandbox-sand" rel="nofollow noopener noreferrer" target="_blank">The Sandbox</a> ha una valutazione di $1 miliardo che indica la sua costante crescita negli anni.</p>
<p>The Sandbox mira a migliorare gli strumenti per i creatori e le funzionalità di gioco.</p>
<h2 id="h2-Introduzione457369"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’introduzione del metaverso ha cambiato il modo in cui le persone interagiscono tra di loro. Ciò ha anche aperto la strada a un nuovo modo di guadagnarsi da vivere, poiché le persone possono partecipare facilmente all’economia del metaverso. Esempi di economie leader del metaverso sono <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a> e Sandbox. In questo articolo copriamo l’attività di raccolta fondi di Sandbox e l’obiettivo di espansione.</p>
<p>Fondamentalmente, <a href="https://www.gate.io/learn/articles/what-is-the-sandbox/88" target="_blank">Sandbox è una piattaforma di gioco decentralizzata</a> costruito sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La blockchain. Ha pezzi di <a href="/price/terra-luna" target="_blank" class="blog_inner_link">terra</a> digitali, rappresentati da token non fungibili, che le persone possono acquistare e stabilire beni virtuali come immobili reali.</p>
<h2 id="h2-The20Sandbox20ha20raccolto202020milioni20in20una20recente20tornata20di20finanziamenti130411"><a name="The Sandbox ha raccolto 20 milioni in una recente tornata di finanziamenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>The Sandbox ha raccolto 20 milioni in una recente tornata di finanziamenti</h2><p>Sandbox, la piattaforma metaversale, è <a href="https://www.gate.io/blog_detail/409/the-sandbox-everything-you-need-to-know" target="_blank">uno degli ultimi unicorni della criptovaluta</a> che fornisce un servizio digitale decentralizzato sotto forma di asset virtuali. Animoca Brands, la società madre di Sandbox, e Kingsway Capital hanno svolto un grande ruolo nel raccogliere i 20 milioni di dollari per Sandbox. Dopo aver raccolto 20 milioni di dollari in cambiali, il nuovo cripto unicorno ha raggiunto una valutazione di 1 miliardo di dollari. Le altre società che hanno partecipato all’attività di raccolta fondi includono Bacasable Global Limited, LG Tech Ventures e True Global Ventures.</p>
<p>Il recente finanziamento di Sandbox è avvenuto due anni dopo il suo piano iniziale di raccogliere $400 milioni con una valutazione di $4 miliardi. I detentori dei titoli di credito possono facilmente convertire gli strumenti di investimento in azioni di Bacasable Global.</p>
<h2 id="h2-La20visione20di20Yat20Siu20sul20futuro20della20piattaforma20Sandbox267614"><a name="La visione di Yat Siu sul futuro della piattaforma Sandbox" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La visione di Yat Siu sul futuro della piattaforma Sandbox</h2><p>Di recente, Yat Siu, co-fondatore di Animoca Brands, ha affermato che Sandbox si concentra su “l’evoluzione dei giochi UGC per l’era della proprietà digitale”. In un comunicato stampa, <a href="https://www.animocabrands.com/the-sandbox-announces-usd20m-funding-at-usd1b-valuation-cap" rel="nofollow noopener noreferrer" target="_blank">Arthur Madrid, co-fondatore e CEO di Sandbox, ha dichiarato</a>, “La nostra missione a <a href="/price/the-sandbox-sand" target="_blank" class="blog_inner_link">The Sandbox</a> è sviluppare strumenti e tecnologie creative che portano equità e nuove opportunità per tutti i tipi di creatori nell’open metaverse.”</p>
<p><a href="https://www.animocabrands.com/the-sandbox-announces-usd20m-funding-at-usd1b-valuation-cap" rel="nofollow noopener noreferrer" target="_blank">In una dichiarazione simile, Siu ha detto</a> Siamo profondamente onorati dall’impegno continuo verso la visione di The Sandbox e siamo incredibilmente entusiasti del futuro dei giochi componibili generati dagli utenti.</p>
<p>Madrid ha aggiunto: “Con i nostri investitori, condividiamo una visione del metaverso. Vedono anche che Roblox sta anche trovando il modo di raggiungere un nuovo tipo di esperienza immersiva. Ci concentriamo sull’Asia e c’è una visione completamente diversa del mercato. L’Asia è un mercato completamente diverso quando si tratta di Web3”.</p>
<h2 id="h2-Le20priorit20di20sviluppo20di20The20Sandbox109288"><a name="Le priorità di sviluppo di The Sandbox" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le priorità di sviluppo di The Sandbox</h2><p>Dopo aver raccolto 20 milioni di dollari, il team di Sandbox si è posto diversi obiettivi da raggiungere nel 2024. Gli obiettivi principali del team includono lo sviluppo di una versione mobile da lanciare nel 2025, il miglioramento degli strumenti per i creatori e nuove funzionalità di gioco. Oltre allo sviluppo di un metaverso decentralizzato per dispositivi mobili, Sandbox utilizzerà i fondi per aggiornare i suoi strumenti di editing 3D e Game Maker.</p>
<p>Siu vuole che Sandbox offra ai suoi utenti vantaggi unici, incomparabili ad altre piattaforme di gioco. Ha chiarito <a href="https://www.animocabrands.com/the-sandbox-announces-usd20m-funding-at-usd1b-valuation-cap" rel="nofollow noopener noreferrer" target="_blank">la sua visione quando ha detto</a>, “Oggi, giochi come Minecraft e Roblox sono tra i titoli più popolari al mondo, ma non forniscono ai loro utenti i diritti di proprietà digitale. The Sandbox rappresenta l’evoluzione dei giochi UGC per l’era della proprietà digitale.”</p>
<p>Madrid ha ampliato le future aspirazioni di Sandbox. Ha detto: “Il metaverso aperto dà potere a chiunque di esprimersi mentre scopre e interagisce con la cultura di milioni di altri utenti. La nostra missione a The Sandbox è sviluppare strumenti creativi e tecnologie che portino equità e nuove opportunità per tutti i tipi di creatori nel metaverso aperto in tutti gli aspetti della cultura, in particolare giochi, musica, moda, arte, sport e intrattenimento.”</p>
<p>Nel suo percorso verso i suoi obiettivi chiave, Sandbox ha raggiunto diversi obiettivi, tra cui consentire ai proprietari di terreni virtuali di pubblicare le loro esperienze uniche di LAND al pubblico. Ha inoltre stabilito un mercato <a href="https://www.gate.io/learn/articles/what-is-polygon-2/899" target="_blank">su L2 di Polygon</a> che consente ai creatori di sviluppare e vendere i loro asset virtuali che trasformano la piattaforma in un’economia fiorente.</p>
<p>Leggi anche su <a href="https://www.gate.io/price-prediction/the-sandbox-sand &quot;The Sandbox (SAND" rel="nofollow noopener noreferrer" target="_blank">Previsione del prezzo di The Sandbox (SAND) 2024-2030</a> Previsione dei prezzi 2024-2030”)</p>
<h2 id="h2-The20Sandbox20nellEcosistema20Metaverse342909"><a name="The Sandbox nell’Ecosistema Metaverse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>The Sandbox nell’Ecosistema Metaverse</h2><p>The sandbox è una delle economie metaverse leader con oltre 125.000 creator e milioni di utenti. Recentemente, le piattaforme virtuali decentralizzate hanno aggiunto più di 330.000 creator unici che hanno già scaricato il Game Maker senza codice di The Sandbox. D’altra parte, <a href="https://www.gate.io/how-to-buy/the-sandbox-sand" target="_blank">SAND, la criptovaluta nativa di Sandbox</a> è tra le prime 100 cripto valute, basate sulla capitalizzazione di mercato. Sta competendo con altri token leader basati su metaverse come MANA per Decentraland.</p>
<p>Ci sono diverse ragioni per cui Sandbox è in tendenza. Prima di tutto, la piattaforma metaverse premia i creatori per la loro creatività. Ad esempio, quando i giocatori vendono i loro asset virtuali nel suo marketplace guadagnano token cripto. Allo stesso modo, guadagnano anche i token quando monetizzano i loro giochi o affittano i loro terreni NFT ad altri giocatori.</p>
<p>In altre notizie, The Sandbox ha lanciato un’organizzazione autonoma decentralizzata (DAO) che consentirà ai detentori di token di partecipare alle decisioni riguardanti questioni di sviluppo, come l’introduzione di nuove funzionalità. Gli utenti di The Sandbox che possiedono il <a href="https://www.gate.io/trade/SAND_USDT" target="_blank">token SAND</a> o le trame LAND basate su NFT avranno la possibilità di proporre o votare su vari aspetti del gioco come nuove funzionalità di gioco, aggiornamenti, ricompense o eventi futuri.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/top-10-best-metaverse-virtual-worlds-with-land-nfts/1602" target="_blank">Top 10 migliori mondi virtuali Metaverse con NFT di terreni</a></p>
<h2 id="h2-Limpatto20delle20partnership20tra20celebrit20e20marchi24840"><a name="L’impatto delle partnership tra celebrità e marchi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’impatto delle partnership tra celebrità e marchi</h2><p>Sandbox <a href="https://www.gate.io/learn/articles/what-is-the-sandbox-how-to-join-the-metaverse/1599" target="_blank">impulso di molte partnership nel metaverso</a> che includono oltre 250 Trusted Partners come agenzie e individui formati e certificati da The Sandbox per aiutare i detentori di IP a creare esperienze metaverse per i loro follower. I partner assistono anche nella promozione del marchio Sandbox.</p>
<p>Attualmente, Sandbox sta accogliendo partner da diverse regioni tra cui Africa, Vietnam e Arabia Saudita. Esempi di marchi globali che hanno collaborato con Sandbox sono Lionsgate, Hellboy, Ubisoft, Magnificent Century, Habbo, Warner Music e Space Invaders a Shibuya109. Oltre a questi marchi, l’ecosistema di Sandbox ha il sostegno di molte celebrità tra cui Snoop Dogg, Gucci, Notorious BIG e Paris Hilton.</p>
<p>Riguardo a questo <a href="https://www.animocabrands.com/the-sandbox-announces-usd20m-funding-at-usd1b-valuation-cap" rel="nofollow noopener noreferrer" target="_blank">Borget ha detto</a> Siamo entusiasti di dare il benvenuto a nuovi partner strategici che sostengono la nostra visione di sviluppare la piattaforma più accessibile e inclusiva che mette a disposizione le opportunità di <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> a un pubblico globale, e in cui marchi e comunità si uniscono per co-creare il futuro dei giochi e dell’intrattenimento. The Sandbox è un fiero sostenitore del potere del metaverso nel plasmare il nostro domani digitale in modo collaborativo, equo e aperto.</p>
<p>Dato che queste celebrità hanno numerosi seguaci, attirano giocatori nel gioco Sandbox. Alcuni di questi utenti investono in diversi asset digitali, come ad esempio l’immobiliare virtuale. Ad esempio, nel 2021 un investitore ha pagato $450.000 per acquisire un terreno virtuale adiacente alla villa metauniversale di Snoop Dogg. Per la cronaca, Snoop Dogg ha ricreato la sua villa in California sulla piattaforma di gioco metauniversale Ethereum. Fondamentalmente, il terreno su Sandbox viene venduto sotto forma di token non fungibili (NFT).</p>
<h2 id="h2-Conclusione660225"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Recentemente, il Sandbox ha raccolto $20 milioni da utilizzare per migliorare la propria infrastruttura. Animoca Brands e Kingsway Capital hanno giocato un ruolo centrale nella raccolta di capitali. Ora, il Sandbox ha una valutazione di $1 miliardo, a significare la sua costante crescita nel corso degli anni. Nel suo tentativo di promuovere il suo marchio, il Sandbox ha stretto partnership con varie organizzazioni e individui.</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 il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>