R2F0ZS5pbyBBTUEgbWV0IEV0aGVybW9uLUF2b250dXVyIG1ldCBqZSBNb25zIGluIERlY2VudHJhbGFuZCwgdmVjaHQgdGVnZW4gYW5kZXJlIGxlZ2VuZGVzIGVuIHZlcmRpZW4gdGVyd2lqbCBqZSBzcGVlbHQ=

<p><img src="https://gimg2.gateimg.com/image/article/16859475231.jpeg" alt=""><br><strong>Tijd: 31 januari 2022, 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 Ryan MacDowell, CMO van Ethermon 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="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>Volg Ethermon op <a href="https://t.me/ethermon" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/p7wBXc9" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16859477962.png" alt=""><br><strong>Ryan MacDowell — CMO van Ethermon</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio479092"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-Vraag20120Wat20is20Ethermon20en20wat20maakt20het20uniek20in20NFTgaming152222"><a name="Vraag 1: Wat is Ethermon en wat maakt het uniek in NFT-gaming?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 1: Wat is Ethermon en wat maakt het uniek in NFT-gaming?</h3><p><strong>Ryan</strong>: Zeker! Ethermon is eigenlijk een van de eerste NFT-games en heeft zijn eerste digitale Monsters (we noemen ze Mons) gemint in 2017. Je kunt spelen en $EMON verdienen terwijl je andere spelers bestrijdt op onze site ethermon.io of in Decentraland, waar we een district van 668 LAND bezitten (de op acht na grootste in DCL). Naast dat we een van de weinige projecten zijn die al meer dan 4 jaar actief zijn in deze ruimte, is het MMO dat we in DCL bouwen wat ons echt uniek maakt. Je kunt je Mons in 3D zien en PvE-gevechten aangaan voor een breed scala aan buit, waaronder zeldzame NFT’s.</p>
<h3 id="h3-V220Ok20en20hoe20kun20je20Ethermon20verzamelen20en20spelen158002"><a name="V2: Ok en hoe kun je Ethermon verzamelen en spelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Ok en hoe kun je Ethermon verzamelen en spelen?</h3><p><strong>Ryan</strong>: U kunt beginnen met spelen om gratis te verdienen op ethermon.io door een account aan te maken, waarmee u 3 gratis “offchain” Mons krijgt om te beginnen. We willen dat iedereen kan spelen, zelfs als u begint met 0 investering in Ethermon. Vervolgens kunt u deelnemen aan een PvP-gevechtsladdertoernooi of natuurlijk meteen in <a href="/price/decentraland-mana" target="_blank" class="blog_inner_link">Decentraland</a> duiken.<br><img src="https://gimg2.gateimg.com/image/article/16859478333.png" alt=""><br>Voor de PvP-gevechtsladders op Ethermon.io verdelen we nu meer dan 80k EMON per week onder de top 100 spelers van 6 ladders, evenals 2 ladders die EMON belonen elke keer dat je een gevecht wint. Je kunt ook Mons en andere beloningen/prijzen verdienen door daar quests te voltooien.</p>
<p>We ontwikkelen actief nieuwe manieren voor jou om ons spel te farmen, zowel in de ethermon.io PvP-modi als in DCL.</p>
<h3 id="h3-V320Wat20is20het20verschil20tussen20Ethermon20Classic20en20Metaverse43716"><a name="V3: Wat is het verschil tussen Ethermon Classic en Metaverse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3: Wat is het verschil tussen Ethermon Classic en Metaverse?</h3><p><strong>Ryan</strong>: Klopt! Het grootste doel in NFT-gaming is om je NFT’s te laten gebruiken in zoveel mogelijk gamemodi en instellingen in metaversen, enzovoort. We zijn net begonnen met deze 2 gamemodi die je noemt: Classic (ethermon. io) en Metaverse (alleen in Decentraland, voor nu).</p>
<p>Dus, beide maken deel uit van de Ethermon-omgeving. Het klassieke spel is een 2D-browser versie waarbij het verzamelen van mons, het vormen van strategische teams en het strijden in PvP de belangrijkste aspecten zijn.</p>
<p>En opnieuw wordt de Metaverse-versie gehost in Decentraland, waar een enorme open wereld is om te verkennen via verschillende ‘biomen’ die lijken op doolhoven waar je vecht tegen verschillende PvE-vijanden en bazen om te verslaan, en zo de volgende van de 6 biomen vrij te spelen. Naast onze eigen wijk staan we ook toe dat elke LANDeigenaar ‘Metas’ implementeert waar ze kunnen profiteren van bezoekers die Ethermon spelen op hun eigen land.</p>
<p>We zijn erg enthousiast over wat er binnenkort voor DCL zal worden uitgebracht.</p>
<h3 id="h3-Q420Dit20is20geweldig20Zeker20niet20veel20projecten20doen20dit20Het20is20goed20om20te20hebben20maar20innovatie20komt20met20de20wens20om20iets20nieuws20te20proberen20Dus20het20lijkt20erop20dat20je20heel20druk20bent20geweest20komt20er20meer20aan20Heb20je20binnenkort20spannende20ontwikkelingen79287"><a name="Q4: Dit is geweldig! Zeker niet veel projecten doen dit. Het is goed om te hebben, maar innovatie komt met de wens om iets nieuws te proberen! Dus het lijkt erop dat je heel druk bent geweest… komt er meer aan? Heb je binnenkort spannende ontwikkelingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Dit is geweldig! Zeker niet veel projecten doen dit. Het is goed om te hebben, maar innovatie komt met de wens om iets nieuws te proberen! Dus het lijkt erop dat je heel druk bent geweest… komt er meer aan? Heb je binnenkort spannende ontwikkelingen?</h3><p><strong>Ryan</strong>: We verleggen zeker grenzen met wat mogelijk is met DCL, maar de stichting is super ondersteunend geweest bij het proberen van dingen die nog nooit eerder zijn gedaan.</p>
<p>Na 4 jaar bouwen voelt het eigenlijk alsof we nog maar net zijn begonnen. Soms is deze ruimte zo nieuw dat we vergeten hoe vroeg het is.</p>
<p>Voor ons Metaverse-spel in DCL zul je binnenkort in staat zijn om vijanden en bazen te bestrijden met een hele reeks van 150 ontgrendelbare gevechtsbewegingen om waardevolle buit en NFT’s te winnen. Tot nu toe waren we in alfa-testen met slechts 8 willekeurige bewegingen toegewezen aan je Mons, zodat je een idee kon krijgen van wat er mogelijk is.</p>
<p>We hebben al bijna 50 Mons gemodelleerd voor 3D-gameplay en voegen voortdurend meer 3D-versies toe van onze groeiende verzameling van meer dan 300 ‘2D’ Mons.</p>
<p>Afgezien daarvan introduceren we een nieuw loot-drop en voorwerpenmaaksysteem, speciale spelerhuizen (die je in de loop van de tijd kunt upgraden en passieve voordelen van kunt krijgen), en spelersgilden zodat je met je vrienden kunt samenwerken om grotere bazen en uitdagingen aan te gaan waarvoor je samen moet werken.</p>
<p>In de kern is DCL bedoeld om sociaal en samenwerkend te zijn, dus daar gaan we heen naarmate de ontwikkeling het steeds meer mogelijk maakt.</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>Hier is een toegangspunt tot onze wijk zodat je het geweldige werk van onze ontwikkelaars en partnerstudio Polygonal Mind kunt zien.</p>
<p>Ik ben altijd onder de indruk van wat deze artiesten en ontwikkelaars bedenken.</p>
<p>Voordat we verder gaan, nog een paar dingen:<br>$EMON is de valuta die ons spel voedt, en we zijn constant op zoek naar meer manieren om de waarde ervan te verhogen voor onze investeerders en spelers die het token bewerken.</p>
<p>Ten eerste zul je de Ethermon-valuta $EMON nog steeds nodig hebben om alle nieuwe Mons te kopen, die we consequent zullen blijven uitbrengen in <a href="https://ethermon.io/store" rel="nofollow noopener noreferrer" target="_blank">https://ethermon.io/store</a>. Alle Mon NFT’s krijgen binnenkort een visuele upgrade met nieuwe kaartontwerpen.</p>
<p>Grote nieuwe dingen zullen omvatten: EMON enkele asset staking, massale EMON verbrandingen zoals vereiste om een guild te starten, en een reeks nieuwe in-game assets zoals moves, aanpassingen zoals skins en achtergronden, en we werken aan een geheel nieuwe tokenomics die EMON houders meer macht geeft om de richting van het spel te beïnvloeden.</p>
<p>Naar het laatste punt kijken we naar hoe een Ethermon DAO eruit zou kunnen zien en hoe we nog meer door de community geleid kunnen worden.</p>
<p>Ik vergat te vermelden, maar dit project werd eigenlijk overgenomen door de top spelers en gemeenschapsleden in 2019. Ik was oorspronkelijk een speler in het begin van 2018 en verliet mijn werk bij MIT om in december fulltime bij het team te komen. Je zou kunnen zeggen dat we ware gelovigen zijn en de kracht van deze ruimte is dat het geen top-down gecentraliseerd leiderschap vereist om een baanbrekend project te leiden. We zijn succesvol omdat we putten uit de kennis van vele gepassioneerde mensen in onze gemeenschappen.</p>
<h3 id="h3-Q520Kun20je20ons20meer20vertellen20over20je20aankomende20PFPrelease454213"><a name="Q5: Kun je ons meer vertellen over je aankomende PFP-release?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kun je ons meer vertellen over je aankomende PFP-release?</h3><p><strong>Ryan</strong>: Ja! Bedankt, ik was bijna vergeten over onze meest spannende aankomende release.</p>
<p>Dus voor wie het niet weet, PFP betekent profielfoto of soms foto als bewijs. Je hebt waarschijnlijk gehoord van Cryptopunks of Bored Ape Yacht Club - of een van de vele nieuwe PFP-projecten die gepromoot worden in je DM’s.</p>
<p>De meeste hiervan zijn slechts een reeks van 10k vergelijkbare verzamelbare digitale kunstwerken en hebben geen enkele functionaliteit. Sommige beloven misschien spelletjes, maar weinigen leveren echt wat er in hun routekaarten staat geschreven.</p>
<p>Om ons spel naar het volgende niveau te tillen, brengen we 10.000 Ethermon-trainer PFP’s uit die ook direct speelbaar zullen zijn in het spel (zowel in PvP- als PvE-spelmodi).</p>
<p>We gaan het eerste project worden dat PFP’s lanceert met een spel DAT al meerdere jaren bestaat.</p>
<h3 id="h3-Q620Klinkt20super20spannend20En20waar20kunnen20mensen20ze20krijgen210797"><a name="Q6: Klinkt super spannend! En waar kunnen mensen ze krijgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Klinkt super spannend! En waar kunnen mensen ze krijgen?</h3><p><strong>Ryan</strong>: We staan op het punt om een website te lanceren om de serie te promoten, maar ik kan alvast een eerste blik werpen op 3 van de 10k trainers hier. We hebben een aantal geweldige artiesten aan boord.</p>
<p>Intussen kunt u ons ook volgen op Twitter en Discord om op de hoogte te blijven van hoe u op de whitelist kunt komen.<br><img src="https://gimg2.gateimg.com/image/article/16859478494.jpg" alt=""><br>We zijn super enthousiast om deze gelanceerd te krijgen en een hele nieuwe dimensie aan de Mons te geven. Onze lore draait om iets zeer reëels - dat we allemaal een Mon of Monster of donkere kant hebben, maar dat we hetzij kunnen laten overheersen, hetzij kracht kunnen putten uit onze gemeenschappen en collectieve geest om een weg vooruit te vinden. Dit spel gaat over samenwerken en gezamenlijke problemen oplossen, die soms zo simpel zijn als een eindbaasgevecht.</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 investeringssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het herposten van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>