Z2F0ZUxpdmUgQU1BLXNhbWVudmF0dGluZyBTdXBlcnBvd2VyIFNxdWFk

<p><img src="https://gimg2.gateimg.com/image/article/167628579920230213-170854.jpeg" alt=""></p>
<h2 id="h2-Kunt20u20ons20een20overzicht20geven20van20het20spel20en20wat20uw20visie20is20voor20het20project729419"><a name="Kunt u ons een overzicht geven van het spel en wat uw visie is voor het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kunt u ons een overzicht geven van het spel en wat uw visie is voor het project?</h2><p><strong>Anastasiia (Marketing Manager):</strong><br>Superpower Squad is een Web 3-gamingplatform met 2 jaar ontwikkeling gewijd aan een in-app-portemonnee en openbare Web 3-gameketen. De eerste Web 3 eSport-game Superpower Squad is live op alle mobiele platforms. Met een superheldenthema en verschillende PVE/PVP-modi is deze third-person shooter een leuk, casual en competitief spel dat duurzame tokenomics volgt en het creëren van spelers aanmoedigt met de User-Generated-Content (UGC)-modus (alle spelmodi zijn volledig ontwikkeld en zullen worden ingezet volgens het marketingplan). De game-ontwikkelaars maakten deel uit van een internationale AAA-studio en hadden talloze hittitels geproduceerd. Het team is mede ontwikkeld met onze cryptopartners en is uitgerust met 5 jaar ervaring in blockchain-ontwikkeling en het bouwen van start-ups in sil <a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON</a> vallei.</p>
<p>Superpower Squad is gratis te spelen en winstgevend, met de nadruk op hoge speelvaardigheden die hoge beloningen opleveren. Het spel is de eerste echt leuke (hoge speelbaarheid) en competitieve leider in de Web 3-industrie. We zullen blijven bouwen en meer spellen uitbrengen op ons platform. Het tweede spel heeft zijn eerste opzet voltooid, volg onze sociale media voor updates.</p>
<p>Wij geloven dat een goed spel free-to-play als kern moet hebben, waarbij het spel zelf leuk en plezierig is om te spelen. Immers, het spel komt voor Fi, en het Fi-element moet ook wrijvingsloos zijn.</p>
<p>En dat zijn de kernwaarden die we hebben vastgesteld voor het opbouwen van Superpower Squad. Het kostte tijd om een geweldig spel te bouwen en te leren hoe we kunnen innoveren op de beperkingen en tokenomische modellen die we kennen. Dus het heeft ons een paar jaar gekost om alle gedetailleerde personages en een goed functionerende in-game economie te ontwerpen. We namen de verantwoordelijkheid op ons om onze gebruikers een geweldig product te bieden en pas recentelijk voelden we dat het spel klaar was. Hoewel het even duurde voordat Superpower Squad de wereld ontmoette, zal ons 3 jaar harde werk zich uitbetalen in het langetermijnsucces van het spel.</p>
<h2 id="h2-220Wat20onderscheidt20Superpower20Squad20van20andere20speelomteverdienen20spellen20Wat20is20er20uniek20aan66624"><a name="2. Wat onderscheidt Superpower Squad van andere speel-om-te-verdienen spellen? Wat is er uniek aan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Wat onderscheidt Superpower Squad van andere speel-om-te-verdienen spellen? Wat is er uniek aan?</h2><p><strong>Anastasiia(Marketing Manager):​</strong></p>
<p>Het is jammer dat de meeste spellen op de huidige Game-Fi markt gebrek aan speelbaarheid hebben. Superpower Squad publiceert hoogwaardige spellen die echt de moeite waard zijn om te spelen, het zal de game veranderaar zijn en de GameFi-industrie revolutioneren.</p>
<p>Onze speelbaarheid wordt erkend door veel collega’s en spelers uit de industrie. We zijn toonaangevend in de branche met topcontent en complete spelmechanismen. Momenteel is al onze gamecontent klaar en volledig on-chain geïmplementeerd, en transacties zijn transparant en volledig traceerbaar.</p>
<p>We moedigen spelen om te verdienen en vooral vaardigheden om te verdienen aan. Spelers die echt van ons spel genieten, zullen tijd en moeite steken in het beheersen van hun vechtvaardigheden en zo de betrokkenheid van onze gebruikersbasis vergroten.</p>
<p>UGC-modus: Superpower Squad-spelers kunnen vrijelijk hun verbeeldingskracht verkennen via onze UGC-tool Metacube. Metacube biedt niet alleen een manier om hun eigen gamemodi en regels te creëren, maar ook om het spel te NFTize. Gebruikers kunnen de genetificeerde gamemodi uploaden en deze delen binnen de gamecommunity. Trendy gamemodi en regels stimuleren ook hun makers met goede verdiensten.</p>
<p>Superpower Squad biedt een volledige ervaring van Web 3 gaming en inspireert gebruikers om plezier te hebben tijdens het spelen. Wij zijn de spelprovider en -ontwikkelaar, en de spelers en de gemeenschap zijn de bestuurder en de besluitvormer. Doe met ons mee bij het bouwen van onze metaver en zie hoe we de volgende mijlpaal bereiken.</p>
<h2 id="h2-320Hoever20is20het20team20gevorderd20in20de20ontwikkeling20van20het20spel807568"><a name="3. Hoever is het team gevorderd in de ontwikkeling van het spel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Hoever is het team gevorderd in de ontwikkeling van het spel?</h2><p><strong>Anastasiia (Marketing Manager):</strong><br>De game heeft 3 rondes van bètatests doorlopen, cIFO op Pancake Swap op 15 december gelanceerd en voltooid. We hebben ons token onlangs op Gate.io vermeld en volg onze officiële kanalen voor updates.</p>
<p>Onze eerste ch <a href="/price/amp-amp" rel="nofollow noopener noreferrer" target="_blank">Amp</a> Ionship start en livestreamt in dit kwartaal ook. Met goede ondersteuning van topmedia en uitwisselingsplatforms kijken we ernaar uit om de winnaars te vieren met overvloedige prijzen.</p>
<p>Tot nu toe hebben we 5 gratis speelmodi, waarvan 1 waarin je met je team samenwerkt om een ander team te verslaan, 3 waarin je vecht om als laatste over te blijven en 1 waarin je vecht om die zombies te overleven. <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Golven</a>!</p>
<p>Daarnaast hebben we 1 (Play to Earn) P2E-modus of Win to Earn, ook bekend als de Battle Royale-modus. In Battle Royale kom je met 11 spelers op een kaart terecht en verdien je $ECG op basis van je prestaties. Het is vergelijkbaar met PubG en zal een van de beste GameFi-ervaringen zijn in 2023!</p>
<p>Daarnaast zullen we het komende jaar onze door gebruikers gegenereerde inhoud (UGC) modus genaamd Metacube lanceren. Denk aan DOTA of zelfs minecraft, hiermee kunnen spelers hun eigen spellen bouwen, delen en verhuren op basis van het SPS-platform!</p>
<p>Onze held NFT’s komen in 4 verschillende zeldzaamheid :</p>
<p>Klassiek Zeldzaam Legendarisch Mythisch</p>
<p>We hebben tot nu toe 25 helden ontwikkeld. Helden met een hogere zeldzaamheid hebben speciale functies, ze kunnen interageren met zeemilieus, landmilieus en luchtmilieus, regels breken en bonusbeloningen verdienen. Elke held heeft ook zijn unieke skins, wapens (verander gevechtsstijl en verhoog statistieken) en kan mooie achterornamenten uitrusten.</p>
<p>Je kunt je helden ook upgraden om je vechtstatistieken en beloonde gevechten te verhogen en meer $ECG per wedstrijd te verdienen!</p>
<p>Oh! We moedigen je ook aan om lid te worden van een guild of er een te creëren, waar je een s kunt bouwen <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> g team of goede vechters met degenen die goed zijn in vaardigheden en gelijkgestemd zijn.</p>
<p>En dit alles leeft in de Superpower Squad-app.</p>
<h2 id="h2-420Superpower20Squad20heeft20een20gedecentraliseerd20model20dat20op20de20lange20termijn20duurzaam20is20Laten20we20eens20kijken20hoe20dat20werkt20Komen20de20verdiensten20uit20een20schatkist20of20winnen20spelers20ze20van20de20verliezende20spelers227510"><a name="4. Superpower Squad heeft een gedecentraliseerd model dat op de lange termijn duurzaam is. Laten we eens kijken hoe dat werkt. Komen de verdiensten uit een schatkist of winnen spelers ze van de verliezende spelers?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4. Superpower Squad heeft een gedecentraliseerd model dat op de lange termijn duurzaam is. Laten we eens kijken hoe dat werkt. Komen de verdiensten uit een schatkist of winnen spelers ze van de verliezende spelers?</h2><p><strong>Anastasiia (Marketing Manager):</strong><br>Ja, we hebben SuperDao. Door lid te worden van onze SuperDao kunnen gebruikers ook hun $SQUAD-token inzetten in het pool om inkomsten te genereren en deel te nemen aan gemeenschapsbestuur. Ingezet $SQUAD kan worden omgezet in VSQUAD, en gebruikers kunnen een blokkeerperiode selecteren van één maand tot twee jaar. Optionele blokkeerperiodes zijn onder andere 1 maand, 6 maanden, 1 jaar en 2 jaar.</p>
<p>Als spelers zich aanmelden voor een lock-in periode van 1 maand, zal de tokenallocatie worden omgezet in een verhouding van 1:1. 1 $SQUAD-token wordt omgezet in 1 $VSQUAD-token. Als de lock-in periode 2 jaar is, zal de verhouding 1:24 zijn; 1 $SQUAD-token wordt omgezet in 24 $VSQUAD-tokens.</p>
<p>$VSQUAD-houders hebben recht op <a href="/price/dai-dai" rel="nofollow noopener noreferrer" target="_blank">Dai</a> ly profiteert van het platform. De inkomsten worden bepaald door het aantal $VSQUAD-tokens dat door gebruikers wordt aangehouden plus de inkomsten die het platform heeft gegenereerd in de voorgaande week. Als gebruiker X 10.000 $SQUAD-tokens heeft en besluit ze voor een periode van 2 jaar vast te zetten, zal de gebruiker in staat zijn om 240.000 $VSQUAD-tokens te ontvangen.</p>
<p>De inkomsten komen uit 3 verschillende bronnen:</p>
<p>50% van alle inkomsten van $ECG uit NFT-transacties zal <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroming</a> in de SuperDAO pool.</p>
<p>20% van al het $SQUAD dat door NFT-synthese wordt verbruikt, zal <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroming</a> in de SuperDAO pool.</p>
<p>20% van al het $SQUAD dat door NFT-upgrades wordt verbruikt, zal <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> in de SuperDAO-pool.</p>
<h2 id="h2-520Is20er20een20gecentraliseerde20server20die20het20spel20host705798"><a name="5. Is er een gecentraliseerde server die het spel host?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>5. Is er een gecentraliseerde server die het spel host?</h2><p><strong>Anastasiia (Marketing Manager):</strong><br>Ja, voor de gameserver wordt deze gehost door een gecentraliseerde server.</p>
<h2 id="h2-620Worden20items20in20het20spel20opgeslagen20op20de20blockchain20of20gedecentraliseerde20servers228472"><a name="6. Worden items in het spel opgeslagen op de blockchain of gedecentraliseerde servers?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>6. Worden items in het spel opgeslagen op de blockchain of gedecentraliseerde servers?</h2><p><strong>Anastasiia (Marketing Manager):</strong><br>Alle items kunnen worden opgeslagen op de blockchain. Spelers kunnen de items van het spel naar de blockchain en vice versa overbrengen. We hebben ook onze eigen gameketen, namelijk Superpower Squad Chain, dus de gasvergoeding voor alle interacties is veel lager dan op andere ketens.</p>
<h2 id="h2-720Vertel20ons20meer20over20mysteriedozen20en20hoe20de20ECGtoken20wordt20gebruikt864842"><a name="7. Vertel ons meer over mysteriedozen en hoe de ECG-token wordt gebruikt." class="reference-link"></a><span class="header-link octicon octicon-link"></span>7. Vertel ons meer over mysteriedozen en hoe de ECG-token wordt gebruikt.</h2><p><strong>Anastasiia (Marketing Manager):</strong><br>We gebruiken een dual-token systeem $SQUAD en $ECG, $ECG is ons in-game token, waarvan 90% zal worden gebruikt voor het gaming-ecosysteem. alle NFT’s worden beloond met $ECG. Beloningen worden gebaseerd op het classificatiesysteem en bonussen worden uitgedeeld op basis van de eigenschappen van helden en skinniveaus. De aankoop, upgrades en synthese van NFT’s vereisen een hoeveelheid $ECG, en de verbruikte $ECG wordt verbrand, inclusief tokens die worden gebruikt om NFT-heldenmysteriedozen van de officiële markt te kopen. En de gaskosten worden via $ECG verrekend.</p>
<p>Er zijn 2 soorten mysteriedozen in het spel, een daarvan is de Gouden doos, de andere is de Mythische doos, gebruikers kunnen 100% een NFT-held uit de dozen krijgen, de prijs hangt af van de drop rate van de verschillende zeldzaamheden van helden, voor de Gouden doos krijgen spelers ten minste één klassieke of zeldzame held, voor de Mythische doos kunnen spelers een legendarische of mythische held krijgen. Spelers kunnen kopen in onze officiële markt.</p>
<p>Klik hier om de lIve AMA&gt;&gt; te bekijken <a href="https://www.gate.io/live/video/a0f7a2e0ca58a91f1cb87fc23e6d92d7" target="_blank">AMA-Superpower Squad（GameFi）</a></p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Gate.io Team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<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>