R2F0ZS5pbyBBTUEgY29uIEFudG1vbnMgLSB1bmEgcGlhdHRhZm9ybWEgTWV0YU5GVCwgQmF0dGxlLXRvLUVhcm4gR2FtZUZpIGNvbXBhdGliaWxlIGNvbiB1dGVudGkgV2ViMiAmIFdlYjM=

<p><img src="https://gimg2.gateimg.com/image/article/16957937791.jpg" alt=""><br><strong>Ora: 26 settembre 2023, 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 Jeff, COO di Antmons nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio di Gate.io</a>.</strong><br><strong>Sito ufficiale: <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>Segui Antmons su <a href="https://t.me/Antmons" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/AntmonsOfficial" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16957940072.jpg" alt=""><br><strong>Jeff - COO di Antmons</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio94995"><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-Q120Puoi20presentare20i20dettagli20di20Antmons20Entertainment20Per20aiutarti362549"><a name="Q1: Puoi presentare i dettagli di Antmons Entertainment? Per aiutarti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi presentare i dettagli di Antmons Entertainment? Per aiutarti</h3><p>conoscere meglio il potenziale del progetto</p>
<p><strong>Jeff</strong>: Antmons Entertainment è una piattaforma MetaNFT, Battle-to-Earn GameFi compatibile con utenti web2 e web3.</p>
<p>Questo non è un singolo gioco. È più simile a un insieme di standard, dedicato a fornire agli utenti un sistema di contenuti costantemente ricco e agli sviluppatori una piattaforma ecologica semplice, affidabile e sostenibile.</p>
<p>Antmons ha ottenuto milioni di dollari di investimenti da kubi, BTS Ventures, CANDAQ, AFK e altre istituzioni e ha raggiunto una collaborazione strategica con molte piattaforme. Antmons porterà un’esperienza d’uso senza pensieri e opportunità di guadagno alla maggioranza degli utenti sulla base di un forte supporto sul retro!<br><img src="https://gimg2.gateimg.com/image/article/16957940443.jpg" alt=""><br>In precedenza, il token della piattaforma Antmons $ AMS ha completato l’IFO sulla piattaforma Gate, e 15.950 sostenitori hanno partecipato al nostro evento, con 49 milioni di USDT e un tasso di raccolta fondi del 61.733,10%. Grazie mille per il supporto della piattaforma Gate e di così tanti investitori! Spero anche che $ AMS possa creare enormi profitti per voi in futuro!</p>
<h3 id="h3-Q220Quindi20sembra20che20ci20sia20molto20potenziale20per20te20e20Antmons20Dove20state20andando20voi20e20la20piattaforma832711"><a name="Q2: Quindi sembra che ci sia molto potenziale per te e Antmons. Dove state andando voi e la piattaforma?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Quindi sembra che ci sia molto potenziale per te e Antmons. Dove state andando voi e la piattaforma?</h3><p><strong>Jeff</strong>: Stiamo attualmente lanciando il primo gioco di simulazione MOBA leggero, Antmons.</p>
<p>È un gioco Play-to-Earn basato su blockchain con battaglie in tempo reale e funzionalità di avventura gratuite, che permette agli utenti di guadagnare ricavi partecipando a battaglie quotidiane o rischiando in Token Pool Bettles.</p>
<p>Attualmente è in fase di test finale ed è programmato per il lancio ufficiale in ottobre!</p>
<p>In futuro, il secondo gioco di carte strategico tedesco pu sarà lanciato, offrendo ai giocatori un’esperienza più eccitante e la possibilità di ottenere molte ricompense di reddito attraverso la modalità di gioco felice!</p>
<h3 id="h3-Q320Chi20sono20i20membri20del20team20di20Antmons440597"><a name="Q3: Chi sono i membri del team di Antmons?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Chi sono i membri del team di Antmons?</h3><p><strong>Jeff</strong>: Il team fondatore di Antmons include i membri principali di Supercell, il team di sviluppo di Roblox, Brawl Stars, Clash of Clans (Clash), e il team di sviluppo blockchain di alcune importanti aziende di capitale crittografico e analisi.</p>
<p>Il team, fondato nel 2021, conta 20 membri ed è composto da sviluppo di giochi (12 persone), sviluppo blockchain (4 persone) e marketing e sviluppo del business (4 persone).</p>
<h3 id="h3-Q420Quindi20quali20sono20i20punti20salienti20di20Antmons20rispetto20ad20altre20piattaforme621336"><a name="Q4: Quindi quali sono i punti salienti di Antmons rispetto ad altre piattaforme?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Quindi quali sono i punti salienti di Antmons rispetto ad altre piattaforme?</h3><p><strong>Jeff</strong>: Antmons, ci sono tre principali vantaggi:</p>
<p>1.Meta NFT<br>Vogliamo che l’universo di Antmons sia inclusivo e aperto, quindi abbiamo stabilito che Meta NFT non è limitato a un singolo personaggio o prodotto di gioco.<br>Meta NFT è un insieme di standard descrittivi NFT che possono essere ampiamente adattati a nuovi gameplay ed è il primo tentativo di combinare ContentFi con GameFi.<br>Meta NFT offre ai giocatori l’opportunità di sperimentare tutti i tipi di gameplay e contenuti artistici. I titolari di Meta NFT possono testare in anteprima tutti i nostri giochi e ottenere ricavi.<br>E il valore di Meta NFT continuerà a crescere con il numero di giochi nell’ecosistema, il che getterà le basi per il mercato secondario in futuro.<br>2.Token Pool Bettle<br>Token Pool Bettle è un modo progettato per monetizzare gli utili in eccesso del vincitore. In entrambi i modi di gioco, i giocatori possono scegliere di investire nel token pool prima della battaglia in base alla loro fiducia e al numero di token. I vincitori possono ricevere il denaro del premio dopo aver detratto le commissioni dal token pool, che verranno contribuite proporzionalmente dalla squadra corrispondente.</p>
<ol>
<li>Enciclopedia di gioco<br>Dal momento che il nostro obiettivo è costruire un ecosistema di contenuti decentralizzato, ci sarà un flusso costante di contenuti / giochi aggiunti all’universo di Antmons metacom.<br><img src="https://gimg2.gateimg.com/image/article/16957940574.jpg" alt=""><br>L’algoritmo introduce e raccomanda il prodotto di gioco per ogni giocatore in tempo reale. Creeremo l’interfaccia di sviluppo più efficace per aiutare gli sviluppatori a creare il proprio contenuto con grandi idee e creatività attraverso un sistema di valutazione del genere.</li></ol>
<h3 id="h3-Q420Sembra20che20Antmons20abbia20fatto20anche20abbastanza20sforzi20per20creare20un20eccellente20ecosistema20del20turismo20in20catena20Quindi20come20possiamo20entrare20nel20gioco364115"><a name="Q4: Sembra che Antmons abbia fatto anche abbastanza sforzi per creare un eccellente ecosistema del turismo in catena! Quindi come possiamo entrare nel gioco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Sembra che Antmons abbia fatto anche abbastanza sforzi per creare un eccellente ecosistema del turismo in catena! Quindi come possiamo entrare nel gioco?</h3><p><strong>Jeff</strong>: Antmons sta attualmente testando il sistema di gioco. Molti giocatori stanno partecipando al nostro beta privato.</p>
<p>Presto sarà disponibile la versione ufficiale da scaricare direttamente dal sito web ufficiale. Inoltre, stiamo preparando ulteriori modalità di gioco per voi e sono convinto che presto sempre più persone entreranno nel mondo di Antmons.</p>
<p>Puoi anche prestare attenzione alle attività promozionali ufficiali in qualsiasi momento, prestare attenzione all’annuncio online della versione ufficiale e in modo irregolare ti fornirà la quota di test interno e vari vantaggi.</p>
<p><a href="https://twitter.com/AntmonsOfficial" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/AntmonsOfficial</a></p>
<h3 id="h3-Q520Penso20che20come20investitore20al20dettaglio20mi20piacerebbe20conoscere20e20imparare20di20pi20sul20token20Puoi20spiegarcelo200953"><a name="Q5: Penso che come investitore al dettaglio mi piacerebbe conoscere e imparare di più sul token. Puoi spiegarcelo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Penso che come investitore al dettaglio mi piacerebbe conoscere e imparare di più sul token. Puoi spiegarcelo?</h3><p><strong>Jeff</strong>: Il token di governance di Antmons Entertainment è $AMS, per un totale di 100 milioni, mai emessi!</p>
<p>La circolazione è dell’1,7% del totale, e il white paper ha un meccanismo di rilascio dettagliato （ <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 ha un meccanismo di combustione-svalutazione, e l’importo totale continuerà a diminuire! Dopo il lancio del gioco, $ AMS diventerà il token di governance principale, utilizzato per partecipare al gioco, impegnare il token, acquistare accessori, aggiornare il gioco, migliorare il reddito in oro e altri token di applicazione necessari, ridurranno significativamente la circolazione di mercato dei token, al fine di aumentare il prezzo dei token!</p>
<h3 id="h3-Q620Come20vorresti20raccontarci20di20pi20sullapplicazione20e20sullutilizzo20di20questo20token300185"><a name="Q6: Come vorresti raccontarci di più sull’applicazione e sull’utilizzo di questo token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Come vorresti raccontarci di più sull’applicazione e sull’utilizzo di questo token?</h3><p><strong>Jeff</strong>: I token AMS hanno molteplici ruoli in Antmons Entertainment, non limitati ai seguenti aspetti:</p>
<p><strong>Governance</strong>: Gli AMS token sono token di governance e i detentori possono partecipare alle decisioni di governance della piattaforma. Hanno il diritto di voto e di influenzare l’allocazione della cassaforte, l’ottimizzazione del gameplay specializzato e la direzione della piattaforma.</p>
<p><strong>Commissioni di transazione</strong> Quando si acquista e si scambia nel mercato Antmons, viene addebitata una percentuale sulle commissioni di transazione, che verrà utilizzata per integrare il Tesoro di garanzia e le ricompense di gioco per mantenere lo sviluppo sostenibile dell’ecosistema P2E.</p>
<p>Attività di airdrop e attività di vendita: Antmons Entertainment potrebbe condurre attività di airdrop attraverso token AMS per attirare più utenti a partecipare alla piattaforma. Nei primi giorni di marketing del gioco, potrebbero esserci successive campagne di whitelist di rilascio del progetto attraverso token AMS per incoraggiare la partecipazione degli utenti.</p>
<p>Premi di impegno: Gli utenti che detengono token AMS possono scegliere di impegnare i token per ottenere guadagni in valuta di gioco o premi NFT. Ciò può aiutarli a ottenere più premi e ricompense da giochi diversi sulla piattaforma di intrattenimento Antmons.</p>
<p>Inoltre, il token AMS è l’unica valuta nel Marketplace dei Giochi di Antmons per l’acquisto delle Uova Feroci iniziali. Gli utenti dei token AMS possono utilizzarlo per l’acquisto di questi specifici oggetti di gioco.</p>
<p>In conclusione, i token AMS hanno molti ruoli in Antmons Entertainment, tra cui governance, commissioni di transazione, partecipazione alle attività, ricompense per la promessa e l’acquisto di specifici oggetti di gioco. È il token principale nell’ecosistema della piattaforma e mira a promuovere la partecipazione e i rendimenti dei detentori dai partecipanti e a sostenere la sostenibilità della piattaforma.</p>
<h3 id="h3-Q720Al20momento20AMS2020stato20lanciato20sulla20piattaforma20di20trading20di20Gate20Quali20sono20le20tue20aspettative20per20lo20sviluppo20dei20progetti20successivi19141"><a name="Q7: Al momento, $AMS è stato lanciato sulla piattaforma di trading di Gate. Quali sono le tue aspettative per lo sviluppo dei progetti successivi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Al momento, $AMS è stato lanciato sulla piattaforma di trading di Gate. Quali sono le tue aspettative per lo sviluppo dei progetti successivi?</h3><p><strong>Jeff</strong>: È stato venduto perché il gioco non è ufficialmente disponibile, ma non preoccuparti, $AMS non ti deluderà!</p>
<p>Abbiamo annunciato il lancio dei fondi IDO per il riacquisto di $AMS a 600 ETH per tre mesi! Inoltre, è attualmente la fase di svalutazione del valore di $AMS.</p>
<p>Le monete create dai giochi online otterranno una grande quantità di impegno, un meccanismo di deflazione del bruciamento e applicazioni di gioco, che ridurranno significativamente la circolazione di mercato, al fine di promuovere l’aumento dei prezzi e ritirare il valore reale di $AMS! Quindi vediamo per il futuro di $AMS!</p>
<div class="blog-details-info"><br><div>Autore: Rio Fu., Community di 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>