R2F0ZS5pbyBBTUEgbWV0IEdhbGF4eSBCbGl0eiAtIE9tIGRlIGFmc3RhbW1lbGluZ2VuIHZhbiBkZSBtZW5zaGVpZCB0ZSBsZWlkZW4gZW4gZWVuIG5pZXV3IHJpamsgdGUgc21lZGVu

<p><img src="https://gimg2.gateimg.com/image/article/16805043471.jpg" alt=""><br><strong>Tijd: 4 mei 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 Cherry, Marketing Manager van Galaxy Blitz in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://www.Galaxyblitz.world/" rel="nofollow noopener noreferrer" target="_blank">https://www.Galaxyblitz.world/</a></strong><br><strong>Twitter: <a href="https://twitter.com/GalaxyBlitzGame" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/GalaxyBlitzGame</a></strong><br><strong>Volg Galaxy Blitz op <a href="https://discord.com/invite/cfkcVjBDW8" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://t.me/galaxyblitz" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16805046222.png" alt=""><br><strong>Cherry - Marketing Manager van Galaxy Blitz</strong></p>
<h2 id="h2-QampA20van20Gateio84680"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-Q120Kunt20u20alstublieft20uw20project20en20de20problemen20die20u20wilt20oplossen2020oplossingen20die20u20voorstelt20introduceren29464"><a name="Q1: Kunt u alstublieft uw project en de problemen die u wilt oplossen / oplossingen die u voorstelt, introduceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u alstublieft uw project en de problemen die u wilt oplossen / oplossingen die u voorstelt, introduceren?</h3><p><strong>Kers</strong>: GalaxyBlitz is een massief multiplayer Play-To-Earn gevechtsstrategie blockchainspel dat waarde hecht aan speelervaring, samen met de Play2Earn-functie; het combineert het gebruik van tokens die in de echte wereld bruikbaar zijn met high-octane gameplay en uitgebreide geschiedenis en lore voor een unieke spelerervaring.</p>
<p>We erkennen het huidige pijnpunt voor blockchainspellen: ze bieden niet de kerngameplay-ervaring die spelers verwachten en verdienen in vergelijking met traditionele spellen, waardoor ze een ongelukkige compromis zijn tussen een volledig meeslepende eersteklas ervaring en de voordelen van on-chain zijn. Galaxy Blitz wordt het blockchainspel dat de nadruk legt op de spelerservaring, samen met de Play-To-Earn-functionaliteit om onze missie te vervullen om de ultieme Metaverse-gamingervaring naar de speler te brengen.</p>
<h3 id="h3-Q220En20kunt20u20de20ontwikkelingsstatus20en20voortgang20van20het20project20tot20nu20toe20delen501427"><a name="Q2: En kunt u de ontwikkelingsstatus en voortgang van het project tot nu toe delen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: En kunt u de ontwikkelingsstatus en voortgang van het project tot nu toe delen?</h3><p><img src="https://gimg2.gateimg.com/image/article/16805046523.jpg" alt=""><br><strong>Kers</strong> Gelieve onze routekaart te controleren.</p>
<p>Onze demo wordt volgende week uitgebracht. Je kunt alle NFT’s al zien in onze demo. Meld je aan om zo snel mogelijk de demotestplaatsen te bemachtigen. We zouden graag wat feedback van onze gebruikers ontvangen over onze demo.</p>
<p>We hebben een bètaversie die in april aan het publiek zal worden vrijgegeven. NFT-houders kunnen deelnemen aan onze bètatest. Ons spel wordt officieel gelanceerd in het tweede kwartaal van 2022.</p>
<h3 id="h3-Q320Heeft20het20spel20nietNFTactiva20Zo20ja20hoe20is20de20combinatie20van20NFT20en20nietNFTactiva20in20het20spel938188"><a name="Q3: Heeft het spel niet-NFT-activa? Zo ja, hoe is de combinatie van NFT- en niet-NFT-activa in het spel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Heeft het spel niet-NFT-activa? Zo ja, hoe is de combinatie van NFT- en niet-NFT-activa in het spel?</h3><p><strong>Kers</strong>: Galaxy Blitz brengt een traditioneel SLG-spel op blockchain. We hechten veel waarde aan game-ervaring en zijn van mening dat degenen die momenteel op de markt verkrijgbaar zijn, gamers niet dezelfde ervaring bieden die ze vroeger hadden. Galaxy Blitz combineert hun traditionele gaming-expertise met blockchain-functies zoals de NFT’s, Play to Earn en Loan to Earn, functies die alleen beschikbaar zijn op blockchain. Alleen belangrijke activa in het spel zullen verhandelbaar zijn als een NFT. Voornamelijk 3 categorieën: Ruimteschepen, Wapens en Helden.</p>
<p>Niet-NFT-activa zijn essentieel en noodzakelijk voor het spel, maar zullen worden onderscheiden als basisactiva die gamers consumeren. Niet-NFT-activa zijn voornamelijk ontworpen voor de game-ervaring, terwijl de NFT’s de nadruk zullen leggen op het Play-to-Earn-gedeelte en meer beloningen zullen bieden aan spelers.</p>
<h3 id="h3-Q420Wat20zou20je20zeggen20zijn20de20voordelen20van20ingame20NFTs917053"><a name="Q4: Wat zou je zeggen zijn de voordelen van in-game NFT’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Wat zou je zeggen zijn de voordelen van in-game NFT’s?</h3><p><strong>Kers</strong> Onze NFT’s hebben 5 verschillende niveaus binnen het spel. Gamers kunnen hun NFT’s upgraden via verschillende manieren, zoals het gebruik van middelen of tokens. Onze NFT’s hebben meerdere toepassingen:</p>
<ol>
<li>Onze hoogste niveau NFT’s, niveau 4 en 5, profiteren van de AR- en stakingfuncties tot 600% APY. Dit maakt ze echt waardevol, zowel in het spel als als NFT.</li><li>Verzamelde NFT’s kunnen worden gebruikt om te ruilen voor fysieke activa en kunnen in het spel worden gebruikt.</li><li>NFT-houders kunnen deelnemen aan de bètatest van het spel.</li><li>Verzamelaars ontvangen tot 1000 MIT voor het verzamelen van 3 NFT’s van één factie met niveaus gelijk aan of hoger dan SR.</li><li>Pledge NFT om deel te nemen aan MIT seizoensgebonden beloningspool (Farm)</li><li>NFT samenvoegen (N+N=R, R+R=SR)</li><li>Loterij: stake bepaald niveau van NFT om kans te maken op de prijs.</li></ol>
<h3 id="h3-Q520Kun20je20ons20nu20vertellen20hoe20het20token20binnen20het20spel20wordt20gebruikt943310"><a name="Q5: Kun je ons nu vertellen hoe het token binnen het spel wordt gebruikt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kun je ons nu vertellen hoe het token binnen het spel wordt gebruikt?</h3><p><strong>Kers</strong>: Onze utility-token, MIT-token, zal degene zijn die in ons spel wordt gebruikt.<br>De belangrijkste gebruiken van onze token zijn:<br>-Staking in het spel om de productietijd te versnellen<br>-Token consumeren om de afkoeltijd te verminderen<br>-In app-aankopen doen, zoals het kopen van nieuwe items of nieuwe skins van een ruimteschip of wapen<br>-Token kan ook worden gebruikt om de NFTs te repareren die tijdens gevechten beschadigd zijn geraakt</p>
<h3 id="h3-Q620Wat20zou20je20nog20meer20zeggen20is20het20nut20van20MIT20token793023"><a name="Q6: Wat zou je nog meer zeggen is het nut van MIT token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Wat zou je nog meer zeggen is het nut van MIT token?</h3><p><strong>Kers</strong>: Met MIT staking krijgen spelers meer Star Coins (tot 20%)<br>Met MIT staking krijgen spelers zeldzame middelen die nodig zijn bij het slaan, upgraden (smeden) en repareren/genezen van NFT’s<br>MIT kan worden gebruikt om meer bouwers te activeren (standaard is slechts één bouwer geactiveerd en gratis)<br>MIT kan worden gebruikt om de immuunperiode van spelers tegen aanvallen te verlengen (tot 24 uur)<br>MIT kan worden gebruikt om Star Coins in het spel te kopen<br>MIT kan worden gebruikt om Cool Down Time te verminderen, bijvoorbeeld voor troepenfokken, structuurbouw en onderzoeksupgrades.</p>
<p>MIT kan worden gebruikt in DApps om originele NFT’s te maken en andere NFT’s te kopen<br>MIT kan worden gebruikt om de vluchttijd van ruimteschepen te verkorten<br>MIT kan worden gebruikt om NFT’s te repareren/genezen of de duurzaamheid van NFT’s te verhogen (in combinatie met Hydroxyls)<br>Bij het overdragen van Star Coins wordt zowel Star Coins als MIT in rekening gebracht voor de gasvergoeding.<br>MIT kan worden gebruikt om de succeskans van NFT-minting en forges aanzienlijk te verbeteren<br>Bij het handelen in in-game NFT’s betalen spelers een transactiebelasting van 2%, die zal worden gebruikt voor het terugkopen en verbranden van MIT.</p>
<p>Als een blockchainspel dat vriendelijk is voor spelers van traditionele spellen, gebruikt Galaxy Blitz inkomsten van de Apple Store en Google Play voor het terugkopen en verbranden van MIT en Star Coin.<br>Voor MIT gegenereerd uit in-game consumptie en storting (van fiatvaluta’s) wordt 100% ervan het eerste jaar verbrand; 70% wordt het tweede jaar verbrand, terwijl de resterende 30% wordt gebruikt om een deel van de operationele kosten, zoals servers, te dekken; vanaf het derde jaar wordt 60% verbrand en wordt de andere 40% gebruikt om een deel van de operationele kosten te dekken.</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 zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>