R2F0ZS5pbyBBTUEgbWV0IEFudG1vbnMtQSBNZXRhTkZULCBCYXR0bGUtdG8tRWFybiBHYW1lRmktcGxhdGZvcm0gY29tcGF0aWJlbCBtZXQgV2ViMiBlbiBXZWIzLWdlYnJ1aWtlcnM=

<p><img src="https://gimg2.gateimg.com/image/article/16957937791.jpg" alt=""><br><strong>Tijd: 26 september 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> heeft een AMA (Ask-Me-Anything) sessie gehouden met Jeff, COO van Antmons 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://antmons.com/" rel="nofollow noopener noreferrer" target="_blank">https://antmons.com/</a></strong><br><strong>Telegram: <a href="https://t.me/Antmons" rel="nofollow noopener noreferrer" target="_blank">https://t.me/Antmons</a></strong><br><strong>Volg Antmons op <a href="https://t.me/Antmons" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/AntmonsOfficial" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16957940072.jpg" alt=""><br><strong>Jeff - COO van Antmons</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio758034"><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-V120Kunt20u20de20details20van20Antmons20Entertainment20introduceren20Om20u20te20helpen897252"><a name="V1: Kunt u de details van Antmons Entertainment introduceren? Om u te helpen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Kunt u de details van Antmons Entertainment introduceren? Om u te helpen</h3><p>meer weten over het potentieel van het project</p>
<p><strong>Jeff</strong>: Antmons Entertainment Is een MetaNFT, Battle-to-Earn GameFi platform dat compatibel is met web2- en web3-gebruikers.</p>
<p>Dit is geen enkel spel. Het is meer een set van normen, gewijd aan het bieden van gebruikers met een voortdurend rijk inhoudssysteem, en het verstrekken van ontwikkelaars met een eenvoudige, betrouwbare en duurzame ecologische platform.</p>
<p>Antmons heeft miljoenen dollars aan investeringen ontvangen van Kubi, BTS Ventures, CANDAQ, AFK en andere instellingen, en heeft strategische samenwerking bereikt met meerdere platforms. Antmons zal zorgeloze gebruikservaring en inkomstenmogelijkheden bieden aan de meerderheid van de gebruikers op basis van sterke ondersteuning!<br><img src="https://gimg2.gateimg.com/image/article/16957940443.jpg" alt=""><br>Eerder voltooide Antmons’s platformtoken $ AMS de IFO op de gate exchange, en namen 15.950 supporters deel aan ons evenement, met 49 miljoen usdt en een financieringspercentage van 61.733,10%. Hartelijk dank voor de steun van het gate-platform en zoveel investeerders! Ik hoop ook dat $ AMS in de toekomst enorme winsten voor u kan opleveren!</p>
<h3 id="h3-V220Dus20het20lijkt20erop20dat20er20veel20potentieel20is20voor20jou20en20Antmons20Waar20gaan20jullie20en20het20platform20naartoe374066"><a name="V2: Dus het lijkt erop dat er veel potentieel is voor jou en Antmons. Waar gaan jullie en het platform naartoe?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Dus het lijkt erop dat er veel potentieel is voor jou en Antmons. Waar gaan jullie en het platform naartoe?</h3><p><strong>Jeff</strong> We lanceren momenteel het eerste lichtgewicht MOBA-simulatiespel, Antmons.</p>
<p>Het is een op blockchain gebaseerd spel waarbij je kunt verdienen door real-time gevechten te voeren en gratis avonturen te beleven. Gebruikers kunnen inkomsten genereren door dagelijks deel te nemen aan gevechten of risico’s te nemen in Token Pool Bettles.</p>
<p>Het bevindt zich momenteel in de laatste testfase en staat gepland om officieel in oktober gelanceerd te worden!</p>
<p>In de toekomst zal het tweede Duitse pu-strategiekaartspel gelanceerd worden, waardoor spelers een nog spannendere ervaring krijgen en ook veel inkomstenbeloningen kunnen krijgen via de gelukkige spelmodus!</p>
<h3 id="h3-Q320Wie20zijn20de20teamleden20van20Antmons399100"><a name="Q3: Wie zijn de teamleden van Antmons?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wie zijn de teamleden van Antmons?</h3><p><strong>Jeff</strong> Het oprichtingsteam van Antmons bestaat uit de kernleden van Supercell, het Roblox-ontwikkelingsteam, Brawl Stars, Clash of Clans (Clash) en het blockchain-ontwikkelingsteam van enkele prominente cryptokapitaal- en analytische bedrijven.</p>
<p>Het team, opgericht in 2021, bestaat uit 20 leden en bestaat uit gamedevelopment (12 personen), blockchaintechnologie (4 personen) en marketing en business development (4 personen).</p>
<h3 id="h3-Q420Wat20zijn20dus20de20hoogtepunten20van20Antmons20in20vergelijking20met20andere20platforms241822"><a name="Q4: Wat zijn dus de hoogtepunten van Antmons in vergelijking met andere platforms?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Wat zijn dus de hoogtepunten van Antmons in vergelijking met andere platforms?</h3><p><strong>Jeff</strong>: Antmons, Er zijn drie belangrijkste voordelen:</p>
<ol>
<li>Meta NFT<br>We willen dat het Antmons-universum inclusief en open is, dus hebben we Meta NFT niet beperkt tot een enkel personage of gameproduct.<br>Meta NFT is een set van NFT-beschrijvingsnormen die breed kunnen worden aangepast aan nieuwe gameplay, en het is de eerste poging om ContentFi te combineren met GameFi.<br>Meta NFT geeft spelers de mogelijkheid om allerlei soorten gameplay en artistieke inhoud te ervaren. Meta NFT-houders kunnen al onze spellen vooraf testen en inkomsten genereren.<br>En de waarde van Meta NFT zal blijven groeien met het aantal spellen in het ecosysteem, wat in de toekomst de basis zal leggen voor de secundaire markt.</li><li>Token Pool Bettle<br>Token Pool Bettle is een manier die is ontworpen om de overtollige winst van de winnaar te monetariseren. Op welke manier van gameplay dan ook kunnen spelers ervoor kiezen om voor de strijd te investeren in de token pool op basis van hun vertrouwen en het aantal tokens. Winnaars kunnen het prijzengeld ontvangen na aftrek van de kosten uit de token pool, dat evenredig zal worden bijgedragen door het overeenkomstige team.</li><li>Game-encyclopedie<br>Aangezien ons ontwerp erop gericht is een gedecentraliseerd contentecosysteem op te bouwen, zullen er voortdurend inhoud / spellen worden toegevoegd aan het metacom-universum van Antmons.<br><img src="https://gimg2.gateimg.com/image/article/16957940574.jpg" alt=""><br>Het algoritme introduceert en beveelt het spelproduct in realtime aan voor elke speler. We zullen de meest effectieve ontwikkelingsinterface creëren om ontwikkelaars te helpen hun eigen inhoud te creëren met geweldige ideeën en creativiteit via een dergelijk beoordelingssysteem.</li></ol>
<h3 id="h3-Q420Het20lijkt20erop20dat20Antmons20ook20voldoende20inspanningen20heeft20geleverd20om20een20uitstekende20keten20toerismeecologie20te20creren20Dus20hoe20komen20we20in20het20spel386315"><a name="Q4: Het lijkt erop dat Antmons ook voldoende inspanningen heeft geleverd om een uitstekende keten toerisme-ecologie te creëren! Dus hoe komen we in het spel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Het lijkt erop dat Antmons ook voldoende inspanningen heeft geleverd om een uitstekende keten toerisme-ecologie te creëren! Dus hoe komen we in het spel?</h3><p><strong>Jeff</strong>: Antmons test momenteel het spel systeem. Veel spelers nemen deel aan onze private beta.</p>
<p>Het zal binnenkort de officiële versie zijn om uit te brengen, dus je kunt het spel rechtstreeks downloaden van de officiële website. Bovendien bereiden we meer gameplay voor je voor, en ik geloof dat binnenkort meer mensen de Antmons spelwereld zullen betreden.</p>
<p>U kunt ook op elk moment aandacht besteden aan de officiële promotieactiviteiten, aandacht besteden aan de officiële versie van de online aankondiging en onregelmatig zal u de interne testquota en verschillende voordelen geven.</p>
<p><a href="https://twitter.com/AntmonsOfficial" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/AntmonsOfficial</a></p>
<h3 id="h3-Q520Ik20denk20dat20als20een20particuliere20belegger20ik20graag20meer20zou20willen20weten20en20leren20over20de20token20Kun20je20het20aan20ons20uitleggen305348"><a name="Q5: Ik denk dat als een particuliere belegger ik graag meer zou willen weten en leren over de token. Kun je het aan ons uitleggen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ik denk dat als een particuliere belegger ik graag meer zou willen weten en leren over de token. Kun je het aan ons uitleggen?</h3><p><strong>Jeff</strong>: Antmons Entertainment Het bestuurlijke token is $ AMS, in totaal 100 miljoen, nooit uitgegeven!</p>
<p>De circulatie is 1,7% van het totaal en het whitepaper heeft een gedetailleerd uitgavemechanisme （ <a href="https://docs.antmons.com/economy/ams-token" rel="nofollow noopener noreferrer" target="_blank">https://docs.antmons.com/economy/ams-token</a> ）</p>
<p>$ AMS heeft een verbrandingsdeflatiemechanisme, en het totale bedrag zal blijven afnemen! Na de lancering van het spel zal $ AMS de belangrijkste governance-token worden, gebruikt om deel te nemen aan het spel, tokenbelofte, aankoop van rekwisieten, spelupgrade, verbetering van goudinkomsten en andere noodzakelijke toepassingstokens, wat aanzienlijk zal leiden tot een vermindering van de marktcirculatie van tokens, om zo de prijs van tokens te verhogen!</p>
<h3 id="h3-Q620Kun20je20ons20meer20vertellen20over20de20toepassing20en20het20gebruik20van20deze20token83722"><a name="Q6: Kun je ons meer vertellen over de toepassing en het gebruik van deze token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Kun je ons meer vertellen over de toepassing en het gebruik van deze token?</h3><p><strong>Jeff</strong>: AMS-tokens hebben meerdere rollen in Antmons Entertainment, niet beperkt tot de volgende aspecten:</p>
<p><strong>Governance</strong>: AMS-tokens zijn governance-tokens, en houders kunnen deelnemen aan de governancebeslissingen van het platform. Ze hebben het recht om te stemmen en invloed uit te oefenen op de toewijzing van de kluis, gespecialiseerde gameplay-optimalisatie en de richting van het platform.</p>
<p><strong>Transactiekosten</strong>: Bij het kopen en handelen op de Antmons-markt worden transactiekosten in rekening gebracht, die zullen worden gebruikt om het garantiefonds en de spelbeloningen aan te vullen om de duurzame ontwikkeling van het P2E-ecosysteem te waarborgen.</p>
<p>Airdrop-activiteiten en verkoopactiviteiten: Antmons Entertainment kan luchtafzetactiviteiten uitvoeren via AMS-tokens om meer gebruikers aan te trekken om deel te nemen aan het platform. In de beginfase van de game-marketing kunnen er vervolgens project-release-whitelisting-campagnes zijn via AMS-tokens om gebruikersparticipatie aan te moedigen.</p>
<p>Beloningsbeloften: Gebruikers die AMS-tokens vasthouden, kunnen ervoor kiezen om tokens te beloven om in-game valutawinsten of NFT-prijzen te verkrijgen. Dit kan hen helpen om meer beloningen en beloningen te krijgen van verschillende spellen op het Antmons-entertainmentplatform.</p>
<p>Bovendien is AMS-token de enige valuta in Antmons Games Marketplace om de initiële Ferocious Eggs te kopen. Gebruikers van de AMS-tokens kunnen het gebruiken om deze specifieke game-items te kopen.</p>
<p>Samenvattend hebben AMS-tokens vele rollen in Antmons Entertainment, waaronder governance, transactiekosten, deelname aan activiteiten, beloningen voor inzet, en het kopen van specifieke game-items. Het is de kern token in het platform ecosysteem en heeft als doel de participatie en rendementen van houders te bevorderen en de duurzaamheid van het platform te stimuleren.</p>
<h3 id="h3-V720Op20dit20moment20is20AMS20gelanceerd20op20het20Gate20handelsplatform20Wat20zijn20uw20verwachtingen20voor20de20ontwikkeling20van20volgende20projecten999030"><a name="V7: Op dit moment is $AMS gelanceerd op het Gate handelsplatform. Wat zijn uw verwachtingen voor de ontwikkeling van volgende projecten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V7: Op dit moment is $AMS gelanceerd op het Gate handelsplatform. Wat zijn uw verwachtingen voor de ontwikkeling van volgende projecten?</h3><p><strong>Jeff</strong>: Het is verkocht omdat het spel niet officieel beschikbaar is, maar maak je geen zorgen, $ AMS zal niet teleurstellen!</p>
<p>We hebben de lancering van de IDO-fondsen aangekondigd om $ AMS gedurende drie maanden terug te kopen voor 600 ETH! Bovendien is het momenteel het stadium van onderwaardering van de waarde van $ AMS.</p>
<p>Online game offspring munten zullen een grote hoeveelheid belofte, brandende deflatiemechanisme en game-applicaties krijgen, wat de marktcirculatie aanzienlijk zal verminderen, om zo de prijsstijging te bevorderen en de werkelijke waarde van $ AMS terug te trekken! Laten we dus eens kijken naar de toekomst van $ AMS!</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 mening 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 zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>