R2F0ZS5pbyBBTUEgY29uIFBsYW5ldCBTYW5kYm94IC0gVW4gZ2lvY28gZGkgdGlybyBzYW5kYm94IE5GVCBhbGltZW50YXRvIGRhbGxhIGZpc2ljYQ==

<p><img src="https://gimg2.gateimg.com/image/article/16824918171.jpeg" alt=""><br><strong>Ora: 3 marzo 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Minh Nguyen, CEO / Fondatore del progetto PlanetSandbox nella <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio di Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://planetsandbox.io/" rel="nofollow noopener noreferrer" target="_blank">https://planetsandbox.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/planetsandbox" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/planetsandbox</a></strong><br><strong>Segui PlanetSandbox su <a href="https://discord.com/invite/zwpC6EAatV" rel="nofollow noopener noreferrer" target="_blank">Discord</a> e <a href="https://t.me/planetsandbox" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16824919652.png" alt=""><br><strong>Minh Nguyen - CEO/Fondatore del progetto PlanetSandbox</strong></p>
<h2 id="h2-QampA20da20Gateio763703"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Signor20Minh20puoi20fornire20una20breve20introduzione20su20PlanetSandbox20e20perch2020diverso20dagli20altri20progetti701133"><a name="Q1: Signor Minh, puoi fornire una breve introduzione su PlanetSandbox e perché è diverso dagli altri progetti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Signor Minh, puoi fornire una breve introduzione su PlanetSandbox e perché è diverso dagli altri progetti?</h3><p><strong>Minh</strong>: Planet Sandbox è un gioco di sparatutto sandbox NFT con fisica dalla prospettiva di terza persona. I giocatori possono costruire i propri mondi o unirsi alla modalità di combattimento intenso utilizzando armi e accessori NFT. Dopo il nostro IDO nell’ottobre 2021, abbiamo raggiunto questi traguardi:</p>
<ul>
<li>La nostra prima INO - vendita di NFT di armi esclusive con un ricavo totale di 350 <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a></li><li>Programma di staking lanciato con un totale di 264.069 $PSB bloccati</li><li>Il nostro lancio alpha basato sul web con la campagna di Natale</li><li>Più recentemente, il nostro evento biglietto fortunato con un premio totale di 12.480 $PSB è arrivato insieme alla versione di prova per PC.<br>In questo Q1/2022, lanceremo la nostra testnet e poi la mainnet ufficiale Play2Earn.</li></ul>
<h3 id="h3-Q220Come20funziona20la20tokenomica20Puoi20spiegare20meglio20il20ruolo20dei20due20token20nel20tuo20ecosistema20di20gioco920699"><a name="Q2: Come funziona la tokenomica? Puoi spiegare meglio il ruolo dei due token nel tuo ecosistema di gioco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Come funziona la tokenomica? Puoi spiegare meglio il ruolo dei due token nel tuo ecosistema di gioco?</h3><p><strong>Minh</strong>: PlanetSandbox è alimentato da 2 token: $PSB e $PULV. $PSB è il token di governance, utilizzato per lo staking per guadagnare APR interessanti, l’acquisto di NFT esclusivi e in futuro è quello di partecipare al nostro sistema di voto DAO. Nel frattempo, $PULV è un token di facilitazione del gioco, gli utenti possono utilizzare $PULV per acquistare normali NFT, aggiornare le loro armi/skin per migliorare le statistiche di gioco e quindi una migliore possibilità di guadagno, e le ricompense del play-to-earn sono in $PULV.<br><img src="https://gimg2.gateimg.com/image/article/16824920053.jpg" alt=""><br>$PSB è ora attivamente negoziato su Gate.io e <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>, e abbiamo pianificato di elencare $PULV entro questo trimestre in preparazione per il lancio della mainnet.</p>
<h3 id="h3-Q320Ho20visto20che20hai20menzionato20il20programma20di20staking20puoi20darci20maggiori20dettagli897457"><a name="Q3: Ho visto che hai menzionato il programma di staking, puoi darci maggiori dettagli?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ho visto che hai menzionato il programma di staking, puoi darci maggiori dettagli?</h3><p><strong>Minh</strong>: Il nostro programma di staking è verificato da CertiK, un’azienda leader nella sicurezza blockchain. Ci sono 4 pool di staking, ognuno con una diversa durata dello staking impegnato: 15 giorni, 90 giorni, 180 giorni e 365 giorni. Anche l’APR, il limite minimo e massimo di staking per utente e il limite del pool di ciascun pool sono diversi. Si prega di fare riferimento a questa tabella per i dettagli:<br><img src="https://gimg2.gateimg.com/image/article/16824919874.jpg" alt=""><br>Portale di staking: <a href="https://staking.planetsandbox.io/staking" rel="nofollow noopener noreferrer" target="_blank">https://staking.planetsandbox.io/staking</a><br>Ecco la guida per fare staking con noi: <a href="https://planetsandbox.medium.com/a-guide-to-stake-with-planet-sandbox-staking-program-e80d01cd574e" rel="nofollow noopener noreferrer" target="_blank">https://planetsandbox.medium.com/a-guide-to-stake-with-planet-sandbox-staking-program-e80d01cd574e</a></p>
<h3 id="h3-Q420Sono20cos20eccitato20per20il20prossimo20lancio20del20mainnet20Puoi20condividere20alcuni20dettagli20e20lo20stato20di20preparazione20fino20ad20ora815380"><a name="Q4: Sono così eccitato per il prossimo lancio del mainnet! Puoi condividere alcuni dettagli e lo stato di preparazione fino ad ora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Sono così eccitato per il prossimo lancio del mainnet! Puoi condividere alcuni dettagli e lo stato di preparazione fino ad ora?</h3><p><strong>Minh</strong>: Il gioco della rete principale verrà proposto in modalità PvP battle royale e modalità PvE zombie per permettere ai giocatori di divertirsi e guadagnare contemporaneamente. Prima di ciò, lanceremo il nostro marketplace per permettere ai giocatori di scambiare gli NFT con i nostri token nativi e acquisire l’equipaggiamento necessario per il gioco. <a href="https://twitter.com/minh_psb/status/1482266273136328706" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/minh_psb/status/1482266273136328706</a></p>
<p>Continueremo ad aggiornare e rilasciare informazioni riservate sul progresso del gioco, rimanete sintonizzati!</p>
<h3 id="h3-Ultima20domanda20da20parte20nostra20cosa20pensi20che20renda20PlanetSandbox20unico20rispetto20ad20altri20progetti20nello20spazio20cripto271416"><a name="Ultima domanda da parte nostra, cosa pensi che renda PlanetSandbox unico rispetto ad altri progetti nello spazio cripto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultima domanda da parte nostra, cosa pensi che renda PlanetSandbox unico rispetto ad altri progetti nello spazio cripto?</h3><p><strong>Minh</strong>: Innanzitutto, i giochi di PlanetSandbox sono coinvolgenti e interattivi con grafica raffinata. A differenza di altri giochi semplici ma noiosi play2earn, i nostri utenti possono divertirsi, rilassarsi con il gioco e al tempo stesso guadagnare.<br>In secondo luogo, il nostro team ha una forte esperienza nello sviluppo di giochi e nella tecnologia blockchain per portare il miglior progetto ai nostri utenti. Siamo uno studio in Vietnam con quasi 40 dipendenti. Puoi anche controllare il mio portfolio qui:<br>In terzo luogo, verifichiamo ogni fase importante di sviluppo con CertiK per garantire la sicurezza dei nostri utenti.<br>Ultimo ma non meno importante, questo è solo l’inizio per PlanetSandbox. Il nostro testnet verrà lanciato alla fine di questo mese e il gioco ufficiale mainnet sarà rilasciato il prossimo mese!</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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à consentito il repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>