R2F0ZS5pbyBBTUEgbWV0IFBsYW5ldCBTYW5kYm94IC0gRWVuIG9wIG5hdHV1cmt1bmRlIGdlYmFzZWVyZCBORlQtemFuZGJhayBzY2hpZXRzcGVs

<p><img src="https://gimg2.gateimg.com/image/article/16824918171.jpeg" alt=""><br><strong>Tijd: 3 maart 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Minh Nguyen, CEO/Founder van het PlanetSandbox project in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Community</a>.</strong><br><strong>Officiële website: <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>Volg PlanetSandbox op <a href="https://discord.com/invite/zwpC6EAatV" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://t.me/planetsandbox" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16824919652.png" alt=""><br><strong>Minh Nguyen — CEO/Founder van het PlanetSandbox-project</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio598304"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120MrMinh20kunt20u20een20korte20introductie20geven20over20PlanetSandbox20en20waarom20het20verschilt20van20andere20projecten830107"><a name="Q1: Mr.Minh, kunt u een korte introductie geven over PlanetSandbox en waarom het verschilt van andere projecten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Mr.Minh, kunt u een korte introductie geven over PlanetSandbox en waarom het verschilt van andere projecten?</h3><p><strong>Minh</strong>: Planet Sandbox is een op natuurkunde gebaseerd NFT-zandbak schietspel vanuit een third-person perspectief. Spelers kunnen hun eigen werelden bouwen of deelnemen aan de intense gevechtsmodus met behulp van NFT-wapens en accessoires. Sinds onze IDO in oktober 2021 hebben we deze mijlpalen bereikt:</p>
<ul>
<li>Onze eerste INO - NFT-verkoop van exclusieve wapens met een totale omzet van 350 <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a></li><li>Stakingprogramma gelanceerd met in totaal 264.069 $PSB vergrendeld</li><li>Onze op het web gebaseerde alphatest lancering met kerstcampagne</li><li>Onlangs is ons Lucky Ticket-evenement met een totale prijs van 12.480 $PSB samen met de PC-testversie gekomen.<br>In dit Q1/2022 zullen we onze testnet lanceren en vervolgens de officiële Play2Earn-mainnet.</li></ul>
<h3 id="h3-Q220Hoe20zit20het20met20de20tokenomie20Kunt20u20meer20uitleg20geven20over20de20rol20van20twee20tokens20in20uw20gameecosysteem486892"><a name="Q2: Hoe zit het met de tokenomie? Kunt u meer uitleg geven over de rol van twee tokens in uw game-ecosysteem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Hoe zit het met de tokenomie? Kunt u meer uitleg geven over de rol van twee tokens in uw game-ecosysteem?</h3><p><strong>Minh</strong>: PlanetSandbox wordt aangedreven door 2 tokens: $PSB en $PULV. $PSB is het governance-token, dat wordt gebruikt voor staking om aantrekkelijke APR te verdienen, het kopen van exclusieve NFT’s en in de toekomst om deel te nemen aan ons DAO-stemmingssysteem. Ondertussen is $PULV een game-facilitator-token, gebruikers kunnen $PULV gebruiken om normale NFT’s te kopen, hun wapens/skins te upgraden voor betere in-game statistieken en daardoor een betere kans op verdienen, en de beloningen van play-to-earn zijn in $PULV.<br><img src="https://gimg2.gateimg.com/image/article/16824920053.jpg" alt=""><br>$PSB wordt nu actief verhandeld op Gate.io en <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>, en we hebben plannen om $PULV deze kwartaal te vermelden ter voorbereiding op de mainnet-lancering.</p>
<h3 id="h3-Q320Ik20zag20dat20je20het20staking20programma20hebt20genoemd20kun20je20ons20meer20details20geven998045"><a name="Q3: Ik zag dat je het staking programma hebt genoemd, kun je ons meer details geven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ik zag dat je het staking programma hebt genoemd, kun je ons meer details geven?</h3><p><strong>Minh</strong>: Ons ‘staking’ programma wordt gecontroleerd door CertiK - een toonaangevend bedrijf op het gebied van blockchain beveiliging. Er zijn 4 ‘staking pools’, elk met een verschillende toegewijde ‘staking duration’: 15 dagen, 90 dagen, 180 dagen en 365 dagen. Het APR, minimum en maximum ‘staking limit’ per gebruiker, en de ‘pool cap’ van elke pool is ook verschillend. Raadpleeg deze tabel voor details:<br><img src="https://gimg2.gateimg.com/image/article/16824919874.jpg" alt=""><br>Stakingsportaal: <a href="https://staking.planetsandbox.io/staking" rel="nofollow noopener noreferrer" target="_blank">https://staking.planetsandbox.io/staking</a><br>Hier is de handleiding om bij ons te staken: <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/een-gids-om-te-staken-met-het-planet-sandbox-staking-programma-e80d01cd574e</a></p>
<h3 id="h3-Q420Ik20ben20zo20enthousiast20over20de20aanstaande20lancering20van20het20mainnet20Kun20je20een20paar20details20delen20en20de20stand20van20zaken20tot20nu20toe877197"><a name="Q4: Ik ben zo enthousiast over de aanstaande lancering van het mainnet! Kun je een paar details delen en de stand van zaken tot nu toe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ik ben zo enthousiast over de aanstaande lancering van het mainnet! Kun je een paar details delen en de stand van zaken tot nu toe?</h3><p><strong>Minh</strong>: Het mainnet-spel wordt geleverd in PvP Battle Royale-modus en PvE Zombie-modus, zodat schutters tegelijkertijd kunnen genieten en verdienen. Daarvoor zullen we onze eigen marktplaats lanceren waar spelers de NFT’s kunnen verhandelen met onze eigen tokens en de uitrusting kunnen verkrijgen die klaar is voor het spel. <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>We zullen doorgaan met het updaten en vrijgeven van lekken over de voortgang van het spel, blijf op de hoogte!</p>
<h3 id="h3-Q520Ok20laatste20vraag20van20onze20kant20wat20maakt20PlanetSandbox20volgens20jou20opvallen20ten20opzichte20van20andere20projecten20in20de20cryptoruimte183108"><a name="Q5: Oké, laatste vraag van onze kant, wat maakt PlanetSandbox volgens jou opvallen ten opzichte van andere projecten in de cryptoruimte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Oké, laatste vraag van onze kant, wat maakt PlanetSandbox volgens jou opvallen ten opzichte van andere projecten in de cryptoruimte?</h3><p><strong>Minh</strong>: Allereerst zijn de PlanetSandbox-spellen boeiend en interactief met verfijnde graphics. In tegenstelling tot andere eenvoudige maar saaie play2earn-spellen, kunnen onze gebruikers genieten, ontspannen met het spelen van het spel en tegelijkertijd inkomen genereren.<br>Ten tweede heeft ons team ruime ervaring in gameontwikkeling en blockchaintechnologie om het beste project aan onze gebruikers te bieden. We zijn een studio in Vietnam met bijna 40 medewerkers. Je kunt ook mijn portfolio hier bekijken:<br>Ten derde controleren we elke belangrijke ontwikkelingsfase met CertiK om de veiligheid van onze gebruikers te waarborgen.<br>Last but not least, dit is pas het begin voor PlanetSandbox. Onze testnet zal eind deze maand worden gelanceerd en het officiële mainnet-spel zal volgende maand worden uitgebracht!</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>