R2F0ZS5pbyBBTUEgY29uIEV0aGVybW9uLSBBdnZlbnR1cmEgY29uIGkgdHVvaSBNb25zIGluIERlY2VudHJhbGFuZCwgY29tYmF0dGkgY29uIGFsdHJlIGxlZ2dlbmRlIGUgZ3VhZGFnbmEgbWVudHJlIGdpb2NoaQ==

<p><img src="https://gimg2.gateimg.com/image/article/16859475231.jpeg" alt=""><br><strong>Orario: 31 gennaio 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 Ryan MacDowell, CMO di Ethermon in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Community dell’Exchange Gate.io</a>.</strong><br><strong>Sito web ufficiale: <a href="http://ethermon.io/" rel="nofollow noopener noreferrer" target="_blank">http://ethermon.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Ethermon_NFT" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Ethermon_NFT</a></strong><br><strong>Segui Ethermon su <a href="https://t.me/ethermon" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://discord.com/invite/p7wBXc9" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16859477962.png" alt=""><br><strong>Ryan MacDowell - CMO di Ethermon</strong></p>
<h2 id="h2-QampA20da20Gateio695728"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Cos20Ethermon20e20cosa20lo20rende20unico20nel20gioco20NFT720428"><a name="Q1: Cos’è Ethermon e cosa lo rende unico nel gioco NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Cos’è Ethermon e cosa lo rende unico nel gioco NFT?</h3><p><strong>Ryan</strong>: Certo! Ethermon è in realtà uno dei primi giochi NFT, con la creazione dei suoi primi Mostri digitali (chiamati Mons) nel 2017. Puoi giocare e guadagnare $EMON mentre combatti altri giocatori sul nostro sito ethermon.io o in Decentraland, dove possediamo un distretto LAND di 668 (l’ottavo più grande in DCL). Oltre ad essere uno dei pochi progetti a costruire in questo spazio da oltre 4 anni, l’MMO che stiamo sviluppando in DCL è ciò che ci rende davvero unici. Puoi vedere i tuoi Mons in 3D e combattere PvE per una vasta gamma di ricompense, inclusi NFT rari.</p>
<h3 id="h3-Q220Ok20e20come20puoi20raccogliere20e20giocare20con20Ethermon783280"><a name="Q2: Ok e come puoi raccogliere e giocare con Ethermon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ok e come puoi raccogliere e giocare con Ethermon?</h3><p><strong>Ryan</strong>: Puoi iniziare a giocare gratuitamente su ethermon.io creando un account, che ti darà 3 Mons “offchain” gratuiti per iniziare. Vogliamo che tutti possano giocare, anche se inizi con 0 investimenti in Ethermon. Poi puoi partecipare a un torneo di scalata di battaglie PvP o naturalmente immergerti direttamente in Decentraland.<br><img src="https://gimg2.gateimg.com/image/article/16859478333.png" alt=""><br>Per le scale di battaglia PvP su Ethermon . io , distribuiamo ora oltre 80k EMON ogni settimana ai primi 100 giocatori delle 6 scale, oltre a 2 scale che premiano EMON ogni volta che vinci una battaglia. Puoi anche guadagnare Mons e altre ricompense/premi completando quest.</p>
<p>Stiamo sviluppando attivamente nuovi modi per farmare il nostro gioco sia nelle modalità PvP ethermon.io che in DCL.</p>
<h3 id="h3-Q320Qual2020la20differenza20tra20Ethermon20Classic20e20Metaverse650485"><a name="Q3: Qual è la differenza tra Ethermon Classic e Metaverse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Qual è la differenza tra Ethermon Classic e Metaverse?</h3><p><strong>Ryan</strong>: Giusto! Quindi l’obiettivo più grande nel gioco NFT è consentire l’utilizzo dei tuoi NFT in quante più modalità di gioco e impostazioni possibili, tra metaversi, ecc. Siamo appena all’inizio con queste 2 modalità di gioco che hai menzionato: Classico (ethermon . io) e Metaverso (solo in Decentraland, per ora).</p>
<p>Quindi, entrambi fanno parte dell’ambiente Ethermon. Il gioco classico è una versione 2D del browser in cui l’aspetto più importante è la raccolta di mostri, la creazione di squadre strategiche e la battaglia PvP.</p>
<p>E ancora una volta, la versione Metaverse è ospitata in Decentraland, dove c’è un enorme mondo aperto da esplorare attraverso diversi ‘biomi’, che sono come labirinti in cui combatti contro diversi nemici e boss PvE da sconfiggere, sbloccando il successivo dei 6 biomi. Oltre al nostro distretto, permettiamo anche a ogni proprietario di LAND di mettere in campo i ‘Metas’, dove possono trarre profitto dai visitatori che giocano a Ethermon sulla loro terra.</p>
<p>Siamo molto entusiasti per ciò che sta per essere rilasciato per DCL.</p>
<h3 id="h3-Q420Questo2020incredibile20Sicuramente20non20molti20progetti20stanno20facendo20questo2020bello20averlo20ma20linnovazione20viene20dallavere20la20voglia20di20provare20qualcosa20di20nuovo20Sembra20che20tu20sia20stato20molto20occupato20c20altro20in20arrivo20Hai20qualche20sviluppo20interessante20in20arrivo20presto574724"><a name="Q4: Questo è incredibile! Sicuramente non molti progetti stanno facendo questo. È bello averlo, ma l’innovazione viene dall’avere la voglia di provare qualcosa di nuovo! Sembra che tu sia stato molto occupato… c’è altro in arrivo? Hai qualche sviluppo interessante in arrivo presto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Questo è incredibile! Sicuramente non molti progetti stanno facendo questo. È bello averlo, ma l’innovazione viene dall’avere la voglia di provare qualcosa di nuovo! Sembra che tu sia stato molto occupato… c’è altro in arrivo? Hai qualche sviluppo interessante in arrivo presto?</h3><p><strong>Ryan</strong>: Stiamo sicuramente spingendo i limiti di ciò che è possibile con DCL, ma la fondazione è stata molto solidale mentre proviamo cose che non sono mai state fatte prima.</p>
<p>Dopo 4 anni di costruzione, sembra che siamo ancora all’inizio. Questo spazio è così fresco che a volte dimentichiamo quanto sia presto.</p>
<p>Per il nostro gioco Metaverse in DCL, presto potrai combattere nemici e boss utilizzando una gamma completamente nuova di 150 mosse di battaglia sbloccabili per ottenere ricompense preziose e NFT. Fino ad ora eravamo in fase di test alpha con solo 8 mosse casuali assegnate ai tuoi Mons in modo che potessi avere un’idea di ciò che è possibile.</p>
<p>Abbiamo già quasi 50 Mons modellati per il gameplay 3D e continuiamo ad aggiungere più versioni 3D dalla nostra crescente collezione di oltre 300 Mons ‘2D’.</p>
<p>Oltre a questo, stiamo introducendo un nuovo sistema di loot drop e creazione di oggetti, case speciali per i giocatori (che potrai potenziare nel tempo e ottenere vantaggi passivi), e gilde di giocatori in modo da poter fare squadra con i tuoi amici per affrontare boss più grandi e sfide che richiedono di lavorare insieme.</p>
<p>Nel suo nucleo, DCL è destinato ad essere sociale e collaborativo, quindi è questa la direzione verso cui ci stiamo dirigendo man mano che lo sviluppo lo rende sempre più possibile.</p>
<p><a href="https://play" rel="nofollow noopener noreferrer" target="_blank">https://play</a>. <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a>.org/?position=78%2C53</p>
<p>Ecco un punto di ingresso nel nostro quartiere in modo da poter vedere il lavoro incredibile dei nostri sviluppatori e dello studio partner Polygonal Mind.</p>
<p>Sono sempre stupito da ciò che questi artisti e sviluppatori inventano.</p>
<p>Prima di andare avanti, ancora un paio di cose:<br>$EMON è la valuta che alimenta il nostro gioco, e cerchiamo costantemente nuovi modi per aumentarne il valore per i nostri investitori e i giocatori che coltivano il token.</p>
<p>In primo luogo, avrai ancora bisogno della valuta Ethermon $EMON per acquistare tutti i nuovi Mons, che rilasceremo in modo coerente in futuro <a href="https://ethermon.io/store" rel="nofollow noopener noreferrer" target="_blank">https://ethermon.io/store</a> Tutti i Mon NFT stanno per ricevere un aggiornamento visivo con nuovi design delle carte.</p>
<p>Le grandi novità includeranno: lo staking di singoli asset EMON, grandi bruciature di EMON come il requisito per avviare una gilda e una serie di nuovi asset in-game come mosse, personalizzazioni come skin e sfondi, e stiamo lavorando su un’intera nuova tokenomica che dà ai detentori di EMON più potere per influenzare la direzione del gioco.</p>
<p>Per l’ultimo punto, stiamo esplorando come sarebbe un Ethermon DAO e come essere ancora più guidati dalla comunità.</p>
<p>Ho dimenticato di menzionare, ma questo progetto è stato effettivamente preso in carico dai migliori giocatori e membri della comunità nel 2019. In origine ero un giocatore all’inizio del 2018 e ho lasciato il mio lavoro al MIT per unirmi al team a tempo pieno lo scorso dicembre. Potresti dire che siamo dei veri credenti e il potere di questo spazio è che non richiede una leadership centralizzata dall’alto per gestire un progetto che fa tremare la terra. Siamo di successo perché attingiamo dalla conoscenza di molte persone appassionate nelle nostre comunità.</p>
<h3 id="h3-Q520Puoi20dirci20di20pi20sul20tuo20prossimo20rilascio20PFP552182"><a name="Q5: Puoi dirci di più sul tuo prossimo rilascio PFP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Puoi dirci di più sul tuo prossimo rilascio PFP?</h3><p><strong>Ryan</strong>: Sì! Grazie, quasi dimenticavo del nostro prossimo rilascio più entusiasmante.</p>
<p>Quindi per chiunque non lo sappia, PFP significa immagine del profilo o a volte foto a scopo dimostrativo. Probabilmente hai sentito parlare di Cryptopunks o Bored Ape Yacht Club - o di uno qualsiasi dei tanti nuovi progetti PFP che vengono pubblicizzati nei tuoi messaggi diretti.</p>
<p>La maggior parte di questi sono solo una serie di 10k pezzi di arte digitale collezionabili simili e non hanno alcuna utilità. Alcuni potrebbero promettere giochi, ma pochi realmente realizzano ciò che è scritto nelle loro road map.</p>
<p>Per portare il nostro gioco al livello successivo, stiamo rilasciando 10.000 Ethermon trainer PFP che saranno anche immediatamente giocabili nel gioco (sia nella modalità PvP che PvE)</p>
<p>Saremo il primo progetto a lanciare PFP con un gioco GIÀ presente da diversi anni.</p>
<h3 id="h3-Q620Sembra20davvero20emozionante20E20dove20possono20ottenerli20le20persone25630"><a name="Q6: Sembra davvero emozionante! E dove possono ottenerli le persone?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Sembra davvero emozionante! E dove possono ottenerli le persone?</h3><p><strong>Ryan</strong>: Stiamo per lanciare un sito per promuovere la serie, ma posso darvi un primo sguardo a 3 dei 10k trainers qui. Abbiamo alcuni artisti straordinari a bordo.</p>
<p>Nel frattempo, puoi unirti a noi su Twitter e Discord per rimanere aggiornato su come ottenere la lista bianca.<br><img src="https://gimg2.gateimg.com/image/article/16859478494.jpg" alt=""><br>Siamo entusiasti di lanciarli e offrire una nuova dimensione ai Mons. La nostra tradizione ruota intorno a qualcosa di molto reale: che ognuno di noi ha un Mon o un Mostro o un lato oscuro, ma che possiamo lasciarci sopraffare o trarre energia dalle nostre comunità e dallo spirito collettivo per trovare una via d’uscita. Questo gioco riguarda l’unione e la risoluzione di problemi collettivi, che a volte sono semplici come una battaglia con il boss.</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à consentito ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>