R2F0ZS5pbyBBTUEgY29uIEdhbGF4eSBCbGl0eiAtIFBlciBndWlkYXJlIGkgZGlzY2VuZGVudGkgZGVsbCd1bWFuaXTDoCBlIGZvcmdpYXJlIHVuIG51b3ZvIGltcGVybw==

<p><img src="https://gimg2.gateimg.com/image/article/16805043471.jpg" alt=""><br><strong>Tempo: 4 maggio 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 Cherry, Responsabile Marketing di Galaxy Blitz nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito ufficiale: <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>Segui Galaxy Blitz su <a href="https://discord.com/invite/cfkcVjBDW8" rel="nofollow noopener noreferrer" target="_blank">Discord</a> e <a href="https://t.me/galaxyblitz" rel="nofollow noopener noreferrer" target="_blank">Telegramma</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16805046222.png" alt=""><br><strong>Cherry - Responsabile Marketing di Galaxy Blitz</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio967364"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Puoi20presentare20il20tuo20progetto20e20i20problemi20che20vuoi20risolvere2020Soluzioni20che20stai20proponendo195519"><a name="Q1: Puoi presentare il tuo progetto e i problemi che vuoi risolvere / Soluzioni che stai proponendo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi presentare il tuo progetto e i problemi che vuoi risolvere / Soluzioni che stai proponendo?</h3><p><strong>Ciliegia</strong>: GalaxyBlitz è un enorme gioco di strategia di combattimento multiplayer Play-To-Earn basato su blockchain che valorizza l’esperienza di gioco, insieme alla funzione Play2Earn; combina l’uso di token utilizzabili nel mondo reale con un gameplay ad alta intensità e una vasta storia e lore per un’esperienza di gioco unica.</p>
<p>Riconosciamo che il punto critico attuale dei giochi blockchain è che non offrono l’esperienza di gioco principale che i giocatori si aspettano e meritano rispetto ai giochi tradizionali, rendendoli un compromesso sfortunato tra un’esperienza di primo livello completamente immersiva e i vantaggi di essere su una catena. Galaxy Blitz sarà il gioco blockchain che pone la priorità sull’esperienza del giocatore, insieme alla funzionalità Play-To-Earn per realizzare la nostra missione di portare all’utente l’esperienza di gioco definitiva del Metaverse.</p>
<h3 id="h3-Q220E20potresti20condividere20lo20stato20di20sviluppo20e20i20progressi20del20progetto20finora308060"><a name="Q2: E potresti condividere lo stato di sviluppo e i progressi del progetto finora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: E potresti condividere lo stato di sviluppo e i progressi del progetto finora?</h3><p><img src="https://gimg2.gateimg.com/image/article/16805046523.jpg" alt=""><br><strong>Ciliegia</strong>: Si prega di controllare la nostra roadmap.</p>
<p>La nostra dimostrazione verrà rilasciata la prossima settimana. Puoi già vedere tutti gli NFT nella nostra dimostrazione. Iscriviti per ottenere al più presto i posti di prova della demo. Ci piacerebbe ricevere alcuni feedback dai nostri utenti riguardo alla nostra dimostrazione.</p>
<p>Abbiamo una versione beta che verrà rilasciata al pubblico ad aprile. I possessori di NFT potranno partecipare alla nostra fase di beta testing. Il nostro gioco verrà ufficialmente lanciato nel Q2 2022.</p>
<h3 id="h3-Q320Il20gioco20ha20asset20non20NFT20In20tal20caso20come20avviene20la20combinazione20di20asset20NFT20e20non20NFT20allinterno20del20gioco772806"><a name="Q3: Il gioco ha asset non NFT? In tal caso, come avviene la combinazione di asset NFT e non NFT all’interno del gioco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Il gioco ha asset non NFT? In tal caso, come avviene la combinazione di asset NFT e non NFT all’interno del gioco?</h3><p><strong>Ciliegia</strong>: Galaxy Blitz sta portando un tradizionale gioco SLG sulla blockchain. Valorizziamo veramente l’esperienza di gioco e crediamo che quelli attualmente disponibili sul mercato non offrano ai giocatori la stessa esperienza che avevano in passato. Galaxy Blitz sta combinando la loro competenza tradizionale nel gioco con le caratteristiche della blockchain come gli NFT, il gioco per guadagnare e il prestito per guadagnare, caratteristiche disponibili solo sulla blockchain. Solo gli asset principali all’interno del gioco saranno scambiabili come NFT. Principalmente 3 categorie: astronavi, armi e eroi.</p>
<p>Gli asset non NFT sono vitali ed essenziali per il gioco, ma saranno differenziati come asset di base che i giocatori stanno consumando. Gli asset non NFT sono progettati principalmente per l’esperienza di gioco, mentre gli NFT enfatizzeranno la parte Play to Earn e offriranno più ricompense ai giocatori.</p>
<h3 id="h3-Q420Quali20sarebbero20a20tuo20parere20i20vantaggi20degli20NFT20ingame233704"><a name="Q4: Quali sarebbero, a tuo parere, i vantaggi degli NFT in-game?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Quali sarebbero, a tuo parere, i vantaggi degli NFT in-game?</h3><p><strong>Ciliegia</strong>: I nostri NFT hanno 5 diversi livelli all’interno del gioco. I giocatori potrebbero aggiornare i loro NFT in modi diversi, ad esempio utilizzando risorse o token. I nostri NFT hanno utilizzi multipli:</p>
<ol>
<li>I nostri NFT di livello più alto, livello 4 e 5, beneficiano delle funzioni di AR e staking fino al 600% APY. Ciò li rende davvero preziosi sia nel gioco che come NFT.</li><li>I NFT raccolti possono essere utilizzati per scambiare beni fisici e utilizzati nel gioco.</li><li>I detentori di NFT potranno partecipare alla fase di beta testing del gioco.</li><li>I collezionisti ricevono fino a 1000 MIT per la raccolta di 3 NFT di una fazione con livelli superiori o uguali a SR.</li><li>Pledge NFT per condividere il pool di premi stagionali MIT (Farm)</li><li>Fusione NFT (N+N=R, R+R=SR)</li><li>Lotteria: scommetti un livello determinato di NFT per avere la possibilità di vincere il premio.</li></ol>
<h3 id="h3-Q520Ora20puoi20spiegarci20luso20del20token20allinterno20del20gioco640014"><a name="Q5: Ora puoi spiegarci l’uso del token all’interno del gioco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ora puoi spiegarci l’uso del token all’interno del gioco?</h3><p><strong>Ciliegia</strong>: Il nostro token di utilità, il token MIT, sarà quello utilizzato all’interno del nostro gioco.<br>I principali utilizzi del nostro token sono:<br>-Staking all’interno del gioco per accelerare il tempo di produzione<br>-Consumare i token per ridurre il tempo di riposo<br>-Fare acquisti in-app, come l’acquisto di nuovi oggetti o nuove skin di un’astronave o di un’arma<br>-Il token può anche essere utilizzato per riparare gli NFT danneggiati durante le battaglie</p>
<h3 id="h3-Q620Cosaltro20diresti20che2020lutilit20del20token20MIT24329"><a name="Q6: Cos’altro diresti che è l’utilità del token MIT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Cos’altro diresti che è l’utilità del token MIT?</h3><p><strong>Ciliegia</strong>: Con lo staking MIT, i giocatori ottengono più Star Coins (fino al 20%)<br>Con lo staking MIT, i giocatori ottengono risorse rare necessarie per coniare, aggiornare (forgiare) e riparare/guarire NFT<br>MIT può essere utilizzato per attivare più costruttori (solo un costruttore è attivato per impostazione predefinita e gratuitamente)<br>MIT può essere utilizzato per aumentare la durata del periodo durante il quale i giocatori sono immuni agli attacchi (fino a 24 ore)<br>MIT può essere utilizzato per acquistare Star Coins nel gioco<br>MIT può essere utilizzato per ridurre il tempo di attesa, ad esempio, per la riproduzione delle truppe, la costruzione delle strutture, l’aggiornamento della ricerca.</p>
<p>MIT può essere utilizzato in DApps per creare NFT originali e acquistare altri NFT<br>MIT può essere utilizzato per accorciare il tempo di volo delle astronavi<br>MIT può essere utilizzato per riparare/guarire NFT o aumentare la durata dei NFT (in combinazione con idrossili)<br>Nel trasferimento di Star Coins, sia Star Coins che MIT verranno addebitati come tassa di gas.<br>MIT può essere utilizzato per migliorare significativamente la probabilità di successo nella creazione e forgia di NFT<br>Nel trading di NFT in-game, i giocatori pagano una tassa di transazione del 2%, che verrà utilizzata per il buy-back e la distruzione di MIT</p>
<p>Come un gioco blockchain che è amichevole per i giocatori di giochi tradizionali, Galaxy Blitz spende ricavi da Apple Store e Google Play per il buy-back e il burning di MIT e Star Coin. Per MIT generato dal consumo in-game e dal deposito (di valute fiat), il 100% di essi sarà bruciato nel primo anno; il 70% sarà bruciato nel secondo anno, mentre il restante 30% sarà utilizzato per coprire parte delle spese operative come i server; a partire dal terzo anno, il 60% sarà bruciato e il restante 40% sarà utilizzato per coprire parte delle spese operative.</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à consentita la ripubblicazione dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>