Z2F0ZUxpdmUgQU1BIFJpYXNzdW50by1TdXBlcnBvd2VyIFNxdWFk

<p><img src="https://gimg2.gateimg.com/image/article/167628579920230213-170854.jpeg" alt=""></p>
<h2 id="h2-120Puoi20darci20una20panoramica20del20gioco20e20qual2020la20tua20visione20per20il20progetto694058"><a name="1. Puoi darci una panoramica del gioco e qual è la tua visione per il progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Puoi darci una panoramica del gioco e qual è la tua visione per il progetto?</h2><p><strong>Anastasiia (Responsabile Marketing):</strong><br>Superpower Squad è una piattaforma di gioco Web 3 con 2 anni di sviluppo dedicati a un portafoglio in-app e a una catena di gioco pubblica Web 3. Il suo primo gioco Web 3 eSport Superpower Squad è disponibile su tutte le piattaforme mobili. Con un tema supereroico e vari modi PVE / PVP, questo sparatutto in terza persona è un gioco divertente, informale e competitivo che segue una tokenomica sostenibile e incoraggia la creazione di giocatori con la modalità User-Generated-Content (UGC) (Tutte le modalità di gioco sono completamente sviluppate e saranno implementate secondo il piano di marketing). Gli sviluppatori del gioco facevano parte di uno studio AAA internazionale e avevano prodotto numerosi titoli di successo. Sviluppato in collaborazione con i nostri partner crypto, il team è dotato di 5 anni di esperienza nello sviluppo della blockchain e nella creazione di start-up in sil <a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON</a> valle.</p>
<p>Superpower Squad è free-to-play e play-to-earn, con un focus sulle abilità di gioco elevate che producono ricompense elevate. Il gioco è il primo leader del settore Web 3 veramente divertente (alta giocabilità) e competitivo. Continueremo a creare e pubblicare altri giochi sulla nostra piattaforma. Il secondo gioco ha terminato la sua messa in scena iniziale, segui i nostri social media per gli aggiornamenti.</p>
<p>Crediamo che un buon gioco dovrebbe essere basato sul free-to-play, dove il gioco stesso è divertente e piacevole da giocare. Dopotutto, il gioco viene prima di Fi, e l’elemento Fi dovrebbe essere senza attriti.</p>
<p>E questi sono i valori fondamentali che abbiamo stabilito per costruire Superpower Squad. Ci è voluto del tempo per costruire un grande gioco e imparare come innovare sui modelli di limitazioni e tokenomia che conosciamo. Ci sono voluti alcuni anni per progettare tutti i personaggi dettagliati e un’economia di gioco ben funzionante. Abbiamo assunto la responsabilità di fornire ai nostri utenti un ottimo prodotto e solo di recente abbiamo sentito che il gioco era pronto. Sebbene ci sia voluto un po’ di tempo affinché Superpower Squad incontrasse il mondo, i nostri 3 anni di duro lavoro daranno i loro frutti nel successo a lungo termine del gioco.</p>
<h2 id="h2-2Cosa20distingue20Superpower20Squad20dagli20altri20giochi20play20to20earn20Cosa20c20di20unico20in20questo388610"><a name="2.Cosa distingue Superpower Squad dagli altri giochi play to earn? Cosa c’è di unico in questo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2.Cosa distingue Superpower Squad dagli altri giochi play to earn? Cosa c’è di unico in questo?</h2><p><strong>Anastasiia (Responsabile Marketing):</strong></p>
<p>È un peccato che la maggior parte dei giochi nel mercato attuale di Game-Fi manchi di giocabilità. Superpower Squad pubblica giochi di alta qualità che vale veramente la pena giocare, sarà il cambiamento di gioco e rivoluziona l’industria del GameFi.</p>
<p>La nostra giocabilità è riconosciuta da molti colleghi del settore e giocatori. Siamo leader del settore con contenuti di alto livello e meccanismi di gioco completi. Attualmente, tutti i nostri contenuti di gioco sono finiti e completamente distribuiti in catena, e le transazioni sono trasparenti e completamente tracciabili.</p>
<p>Incentiviamo il gioco-per-guadagnare e, soprattutto, la competenza-per-guadagnare. I giocatori che veramente si godono il nostro gioco dedicheranno tempo ed impegno per padroneggiare le loro abilità di combattimento e renderanno il nostro utente fedele.</p>
<p>Modalità UGC: i giocatori di Superpower Squad possono esplorare liberamente la propria immaginazione attraverso il nostro strumento UGC Metacube. Metacube non solo fornisce un modo per creare le proprie modalità di gioco e regole, ma NFTizza anche il gioco. Gli utenti possono caricare le modalità di gioco NFTizzate e condividerle all’interno della comunità di gioco. Le modalità di gioco e le regole alla moda incentivano anche i loro creatori con buoni guadagni.</p>
<p>Superpower Squad offre un’esperienza completa di gioco Web 3 e ispira gli utenti a divertirsi mentre giocano. Siamo il fornitore e lo sviluppatore del gioco, mentre i giocatori e la comunità sono il motore e il decisore. Unisciti a noi nella costruzione del nostro metaverso e assisti al raggiungimento del prossimo obiettivo.</p>
<h2 id="h2-3A20che20punto2020lo20sviluppo20del20gioco261467"><a name="3.A che punto è lo sviluppo del gioco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3.A che punto è lo sviluppo del gioco?</h2><p><strong>Anastasiia (Marketing Manager):</strong><br>Il gioco ha superato 3 round di beta test, è stato lanciato e ha completato cIFO su Pancake Swap il 15 dicembre. Abbiamo recentemente elencato il nostro token su Gate.io, per favore segui i nostri canali ufficiali per gli aggiornamenti.</p>
<p>Il nostro primo ch <a href="/price/amp-amp" rel="nofollow noopener noreferrer" target="_blank">Amp</a> Anche la ionship sta iniziando e sta trasmettendo in live streaming in questo trimestre. Con un buon supporto da parte dei migliori media e piattaforme di scambio, non vediamo l’ora di celebrare i vincitori con abbondanti premi.</p>
<p>Finora, abbiamo 5 modalità free-to-play, 1 in cui lavori con la tua squadra per sconfiggere un’altra squadra, 3 in cui combatti per essere l’ultimo in piedi e 1 in cui combatti per sopravvivere a quegli zombie <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a>!</p>
<p>Poi, abbiamo 1 modalità P2E (Play to Earn) o Win to earn, nota anche come modalità Battle Royale. In Battle Royale, entrerai in una mappa con 11 giocatori e vincerai $ECG in base alle tue prestazioni. È simile a PubG e sarà una delle migliori esperienze GameFi nel 2023!</p>
<p>Inoltre, nel prossimo anno, lanceremo la nostra modalità di contenuti generati dagli utenti (UGC) chiamata Metacube. Pensa a DOTA o anche a Minecraft, permetterà ai giocatori di costruire, condividere e noleggiare i propri giochi dalla fondazione SPS!</p>
<p>I nostri eroi NFT sono disponibili in 4 diverse rarità :</p>
<p>Classico Raro Leggendario Mitico</p>
<p>Abbiamo sviluppato finora 25 eroi. Gli eroi con una rarità più alta presentano caratteristiche speciali, possono interagire con gli ambienti marini, terrestri e aerei, infrangere le regole e guadagnare ricompense bonus. Ogni eroe ha anche le proprie skin uniche, armi (cambia lo stile di combattimento e aumenta le statistiche) e può equipaggiare bellissimi ornamenti dorsali.</p>
<p>Puoi anche potenziare i tuoi eroi per aumentare le statistiche di combattimento, le battaglie ricompensate e guadagnare più $ECG per partita!</p>
<p>Oh! Ti incoraggiamo anche di unirti o creare una gilda, dove puoi costruire una s <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> squadra di buoni combattenti con coloro che sono esperti e con mentalità simili.</p>
<p>E tutto questo vive all’interno dell’app Superpower Squad.</p>
<h2 id="h2-420Superpower20Squad20ha20un20modello20decentralizzato20sostenibile20nel20lungo20termine20Approfondiamo20come20funziona20Gli20guadagni20provengono20da20un20tesoro20o20i20giocatori20li20vincono20dai20giocatori20perdenti381966"><a name="4. Superpower Squad ha un modello decentralizzato sostenibile nel lungo termine. Approfondiamo come funziona. Gli guadagni provengono da un tesoro o i giocatori li vincono dai giocatori perdenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4. Superpower Squad ha un modello decentralizzato sostenibile nel lungo termine. Approfondiamo come funziona. Gli guadagni provengono da un tesoro o i giocatori li vincono dai giocatori perdenti?</h2><p><strong>Anastasiia (Responsabile Marketing):</strong><br>Sì, abbiamo SuperDao. Unendoti a SuperDao, gli utenti possono anche scommettere il loro token $SQUAD nel pool per generare entrate e partecipare alla governance della comunità. I token $SQUAD scommessi possono essere convertiti in VSQUAD e gli utenti possono selezionare un periodo di blocco da uno a due anni. I periodi di blocco opzionali includono 1 mese, 6 mesi, 1 anno e 2 anni.</p>
<p>Se i giocatori optano per un periodo di blocco di 1 mese, l’allocazione di token verrà convertita nel rapporto di 1:1. 1 token $SQUAD sarà convertito in 1 token $VSQUAD. Se il periodo di blocco è di 2 anni, il rapporto sarà di 1:24; 1 token $SQUAD verrà convertito in 24 token $VSQUAD</p>
<p>$VSQUAD holders avranno diritto a <a href="/price/dai-dai" rel="nofollow noopener noreferrer" target="_blank">Dai</a> ly benefits from the platform. Revenue will be determined by the number of $VSQUAD held by users plus the revenue made by the platform during the previous week. If user X has 10,000 $SQUAD tokens and decides to lock them in for a 2 year period, the user will be able to receive 240,000 $VSQUAD tokens.</p>
<p>Il ricavo proviene da 3 modi:</p>
<p>50% di tutto il reddito di $ECG dalle transazioni NFT <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> nel pool SuperDAO.</p>
<p>Il 20% di tutti i $SQUAD consumati dalla sintesi NFT saranno <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> nel pool di SuperDAO.</p>
<p>il 20% di tutti i $SQUAD consumati dagli aggiornamenti NFT <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> nel pool SuperDAO.</p>
<h2 id="h2-520C20un20server20centralizzato20che20ospita20il20gioco114383"><a name="5. C’è un server centralizzato che ospita il gioco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>5. C’è un server centralizzato che ospita il gioco?</h2><p><strong>Anastasiia(Marketing Manager):</strong><br>Sì, per il server di gioco, è ospitato da un server centralizzato.</p>
<h2 id="h2-620Gli20oggetti20nel20gioco20sono20memorizzati20sulla20blockchain20o20su20server20decentralizzati312049"><a name="6. Gli oggetti nel gioco sono memorizzati sulla blockchain o su server decentralizzati?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>6. Gli oggetti nel gioco sono memorizzati sulla blockchain o su server decentralizzati?</h2><p><strong>Anastasiia(Marketing Manager):</strong><br>Tutti gli oggetti possono essere memorizzati sulla blockchain, i giocatori possono trasferire gli oggetti dal gioco alla blockchain e viceversa, a proposito, abbiamo la nostra catena di gioco, che è Superpower Squad Chain, quindi la commissione di gas di tutte le interazioni è molto più bassa rispetto ad altre catene.</p>
<h2 id="h2-720Per20favore20raccontaci20di20pi20sulle20scatole20misteriose20e20su20come20viene20utilizzato20il20token20ECG166751"><a name="7. Per favore, raccontaci di più sulle scatole misteriose e su come viene utilizzato il token ECG." class="reference-link"></a><span class="header-link octicon octicon-link"></span>7. Per favore, raccontaci di più sulle scatole misteriose e su come viene utilizzato il token ECG.</h2><p><strong>Anastasiia (Responsabile Marketing):</strong><br>utilizziamo un sistema a doppio token $SQUAD e $ECG, $ECG è il nostro token in-game, il 90% dei quali sarà utilizzato per l’ecosistema di gioco. Tutti gli NFT saranno ricompensati con $ECG. Le ricompense saranno basate sul sistema di classifica, e i bonus saranno distribuiti in base agli attributi e ai livelli della skin degli eroi. L’acquisto, l’aggiornamento e la sintesi degli NFT richiedono una quantità di $ECG, e gli $ECG consumati verranno bruciati, inclusi i token utilizzati per l’acquisto di casse misteriose degli eroi NFT dal mercato ufficiale. E le commissioni di Gas verranno regolate tramite $ECG.</p>
<p>Ci sono 2 tipi di scatole misteriose nel gioco, una è la scatola d’oro, l’altra è la scatola mitica, gli utenti possono ottenere al 100% l’eroe NFT dalle scatole, il prezzo dipende dal tasso di caduta della rarità diversa dell’eroe, per la scatola d’oro, i giocatori otterranno almeno un eroe classico o raro, per la scatola mitica, i giocatori potrebbero ottenere un eroe leggendario o mitico. I giocatori possono acquistare nel nostro mercato ufficiale.</p>
<p>Clicca qui per rivedere la AMA in diretta&gt;&gt; <a href="https://www.gate.io/live/video/a0f7a2e0ca58a91f1cb87fc23e6d92d7" target="_blank">AMA-Superpower Squad（GameFi）</a></p>
<div class="blog-details-info"><br><div>Autore: <strong>GateLive</strong>, Team di 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. La ripubblicazione dell'articolo sarà consentita a condizione che Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>