Z2F0ZUxpdmUgQU1BIFNhbWVudmF0dGluZy1GcnV0dGkgRGlubw==

2023-04-19, 03:21

<p><img src="https://gimg2.gateimg.com/image/article/1681874463Blog.jpg" alt=""></p>
<h2 id="h2-Hi20Welkom20bij20Gateio20AMA20Voordat20we20beginnen20kunt20u20zichzelf20uw20bedrijf20en20uw20rol20in20Monoverse20alstublieft20voorstellen100669"><a name="Hi, Welkom bij Gate.io AMA! Voordat we beginnen, kunt u zichzelf, uw bedrijf en uw rol in Monoverse alstublieft voorstellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hi, Welkom bij Gate.io AMA! Voordat we beginnen, kunt u zichzelf, uw bedrijf en uw rol in Monoverse alstublieft voorstellen?</h2><p><strong>Dilys H. (Growth Lead):</strong><br>Hallo, ik ben Dilys, Growth Lead van het Marketing Team van Monoverse. Het is een hele eer om hier te zijn. En ik ben nu verantwoordelijk voor het maken van inhoud op sociale mediakanalen en het ontwikkelen van marketingstrategieën.</p>
<p>Monoverse is een blockchain game ontwikkelaar met kantoren in de VS en Zuid-Korea.<br>Ons team heeft een groep ervaren experts samengesteld die eerder hebben gewerkt bij grote Koreaanse game ontwikkelingsbedrijven zoals NEXON, Netmarble, NCSoft. Ons bedrijf ontwikkelt 3 gerelateerde gaming projecten met schattige dinosaurus karakters genaamd Frutti Dino. Een van onze spellen, Frutti Dino Stories, een Web2 mobiel spel, is vorige week wereldwijd gelanceerd in de bèta versie! Andere NFT spellen zullen naar verwachting worden uitgebracht in het tweede en derde kwartaal van dit jaar.</p>
<h2 id="h2-Gefeliciteerd20Dat20is20enorm20Dus20kun20je20ons20meer20vertellen20over20Frutti20Dino20Stories20Dus20nu20kunnen20we20downloaden20en20spelen20toch453917"><a name="Gefeliciteerd! Dat is enorm! Dus kun je ons meer vertellen over Frutti Dino Stories? Dus nu kunnen we downloaden en spelen, toch?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gefeliciteerd! Dat is enorm! Dus kun je ons meer vertellen over Frutti Dino Stories? Dus nu kunnen we downloaden en spelen, toch?</h2><p><strong>Dilys H.(Growth Lead):</strong><br>-Basisgameplayvideo: <a href="https://youtu.be/jo9oJFfh9qs" rel="nofollow noopener noreferrer" target="_blank">https://youtu.be/jo9oJFfh9qs</a></p>
<p>Ja! Frutti Dino Stories is nu wereldwijd beschikbaar op Google Play (maar vanwege enkele regelgevingen van de lokale overheden zijn ze niet beschikbaar in Korea, China en Vietnam).</p>
<p>Laat me je de gameplay zien!</p>
<p>Eigenlijk heten onze personages Frutti Dino, dit zijn dinosaurussen gecombineerd met verschillende soorten fruit. Dus in dit spel ontmoet je de schattige babydinosaurussen op het eiland en voed je ze op. En je moet ze goed gevoed houden met fruit, schoon door ze te wassen en gelukkig zijn door een aantal speurtochten. De Dino zullen hun onderdelen ontwikkelen op basis van het voedsel dat je hem hebt gegeven of de themamaterialen die je hebt verzameld. Je kunt er ook voor kiezen om het te evolueren om fruitdelen of beperkte themadelen te verkrijgen die exclusief zijn voor dit spel. Het betekent dat je je eigen unieke Frutti Dino’s kunt maken! Dus hoe je het opvoedt, heeft een sterke invloed op hoe ze eruit zien. Maar het is niet eenvoudig om alle onderdelen te krijgen die je wilt! Het draait allemaal om waarschijnlijkheid!</p>
<h2 id="h2-Wow20De20personages20zien20er20zo20schattig20uit20Maar20zoals20je20zei20is20het20niet20gemakkelijk20om20de20onderdelen20te20krijgen20die20ik20wil20Zijn20er20nog20andere20manieren20om20de20onderdelen20te20verkrijgen697436"><a name="Wow! De personages zien er zo schattig uit. Maar zoals je zei, is het niet gemakkelijk om de onderdelen te krijgen die ik wil. Zijn er nog andere manieren om de onderdelen te verkrijgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wow! De personages zien er zo schattig uit. Maar zoals je zei, is het niet gemakkelijk om de onderdelen te krijgen die ik wil. Zijn er nog andere manieren om de onderdelen te verkrijgen?</h2><p><strong>Dilys H. (Growth Lead):</strong><br>-Fusie video: <a href="https://youtu.be/Y2nvt9GFcbI" rel="nofollow noopener noreferrer" target="_blank">https://youtu.be/Y2nvt9GFcbI</a></p>
<p>Om gebruikers in staat te stellen de Dino’s te verzamelen die ze willen, hebben we de fusiefunctie aan het spel toegevoegd. Je kunt nu proberen de Dino’s samen te voegen die je wilt!</p>
<p>In het begin moet je minstens 2 Level 30 Dino’s hebben. Dus hier heeft de Dino 2 bosbessenonderdelen, maar je wilt een volledige bosbessen Dino. Dan moet je de Dino’s kiezen met meer bosbessenonderdelen. Voor de fusie kun je controleren of de kansen om de pure onderdelen te krijgen meer dan 50% zijn. Maar dat betekent ook dat er 40% kans is dat je de pure onderdelen niet kunt krijgen en je Dino mogelijk het oorspronkelijke onderdeel verliest dat het had. Zoals je ziet in dit voorbeeld, heeft je bosbessen Dino na de fusie nog steeds slechts 2 zuivere onderdelen.</p>
<p>Een ander voorbeeld zou thema-fusie zijn. De dinosaurussen kunnen het exclusief beperkte onderdeel van het spel krijgen. Dus de stappen zullen hetzelfde zijn. Kies de doeldino, je ziet dat deze dino geen beperkte onderdelen heeft. En de materiaaldinosaurussen hebben ook geen beperkte onderdelen. Maar na het controleren van de waarschijnlijkheid ontdek je dat de kans op het krijgen van de thema-onderdelen hoger is. Dus je kunt doorgaan met de themafusie en dan heeft je dino 3 beperkte onderdelen na de fusie!</p>
<p>Nog een punt is dat het niet uitmaakt hoeveel Dino’s je gebruikt in de fusie, je zult na de fusie slechts 1 Dino krijgen.</p>
<h2 id="h2-Klinkt20interessant20maar20het20hangt20ook20af20van20je20geluk20Haha20als20ik20de20Dinos20sneller20wil20opvoeden20heb20je20dan20tips955461"><a name="Klinkt interessant, maar het hangt ook af van je geluk. Haha, als ik de Dino’s sneller wil opvoeden, heb je dan tips?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Klinkt interessant, maar het hangt ook af van je geluk. Haha, als ik de Dino’s sneller wil opvoeden, heb je dan tips?</h2><p><strong>Dilys H.(Growth Lead):</strong><br>In-app aankoop: <a href="https://www.youtube.com/shorts/8mBUuIEu0uU" rel="nofollow noopener noreferrer" target="_blank">https://www.youtube.com/shorts/8mBUuIEu0uU</a></p>
<p>Dus in deze bètaversie kun je de amberfragmenten in het spel kopen. Amberfragmenten zijn belangrijk omdat ze de voortgang van een speler in het spel kunnen versnellen, verschillende spelverbeteringen kunnen activeren om de prestaties te verbeteren en je helpen om sneller doelen te bereiken.</p>
<p>Bovendien kunt u de ontwakingspas kopen die kan worden ingewisseld voor een muntservice op onze website.</p>
<h2 id="h2-Dus20je20noemt20de20gate20pass20en20het20minten20ook20Kun20je20ons20er20meer20over20vertellen564095"><a name="Dus je noemt de gate pass en het minten ook. Kun je ons er meer over vertellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dus je noemt de gate pass en het minten ook. Kun je ons er meer over vertellen?</h2><p><strong>Dilys H.(Growth Lead):</strong><br>-Mintproces: <a href="https://youtu.be/nMd6T1bNBN0" rel="nofollow noopener noreferrer" target="_blank">https://youtu.be/nMd6T1bNBN0</a></p>
<p>Ja, een van onze onderscheidende punten is dat MAP - Minting na het spelen. Wanneer Dinos niveau 30 bereiken, kunt u hun Dinos op de website ‘ontwaken’, wat betekent dat u ze in NFT’s kunt uitgeven. We proberen de moeilijke woordenschat die wordt gebruikt in de web3-industrie te vereenvoudigen om iedereen in staat te stellen de Web3-wereld binnen te gaan.</p>
<p>Na het verbinden van je spelaccount met onze website, wordt je Dino-personage op de website weergegeven. Er zijn 2 NFT-zeldzaamheden waaruit je kunt kiezen. Normale NFT heeft een aantal verbeterde spelbuffs, terwijl Rookie NFT goedkoper is.</p>
<p>We zullen de Rookie NFT-muntuitgifte proberen. Je kunt ervoor kiezen om te munt door te betalen <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, Ontwakingspas. Ik zal de ontwakingspas gebruiken die ik eerder in het spel heb gekocht. Controleer alle belangrijke aantekeningen en klik vervolgens op bevestigen! Zo kunt u uw Dino NFT in de inventaris controleren binnen 10 minuten, afhankelijk van de transactieverkeer. Vervolgens zal het enige en unieke personage nu als NFT worden geslagen! U krijgt volledig eigendom en kunt uw NFT’s gebruiken voor aankomende spellen.</p>
<h2 id="h2-Wow20dat20is20zo20cool20Terwijl20we20wachten20op20de20Frutti20Dino20NFTspellen20heb20je20nog20andere20spellen20die20we20eerst20kunnen20spelen701872"><a name="Wow, dat is zo cool! Terwijl we wachten op de Frutti Dino NFT-spellen, heb je nog andere spellen die we eerst kunnen spelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wow, dat is zo cool! Terwijl we wachten op de Frutti Dino NFT-spellen, heb je nog andere spellen die we eerst kunnen spelen?</h2><p><strong>Dilys H.(Growth Lead):</strong><br>-Website: <a href="https://www.fruttidino.com/arcade/dinoderby" rel="nofollow noopener noreferrer" target="_blank">https://www.fruttidino.com/arcade/dinoderby</a></p>
<p>Ja! Wat dacht je van een gratis te spelen website spel? Het Frutti Dino Derby seizoen 3 is nu LIVE! Haha Je kunt het spelen op onze website door je Google- of Facebook-account te verbinden.<br>Het is een eenvoudig spel waarbij je alleen maar hoeft te raden welke Dino de winnaar zal zijn. Dagelijks punten ontvangen voor het inloggen elke dag. Je kunt tot 3 Dino’s kiezen. Maar hoe meer Dino’s je kiest, hoe lager de winstbonus die je gaat krijgen.</p>
<p>Er zullen verschillende ranglijsten zijn. Je kunt winnen door het meeste in te zetten, of zoveel mogelijk reeksen te winnen. Maar ik heb nog nooit meer dan 3 keer gewonnen.</p>
<h2 id="h2-Zijn20er20nu20evenementen20waar20ik20aan20kan20deelnemen255209"><a name="Zijn er nu evenementen waar ik aan kan deelnemen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn er nu evenementen waar ik aan kan deelnemen?</h2><p><strong>Dilys H.(Groei Lead):</strong><br>-Twitter: <a href="https://twitter.com/FruttiDino" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/FruttiDino</a></p>
<p>Ja! We organiseren nu het wereldwijde bètalanceringsevenement. Speel de Frutti Dino-verhalen en verhoog de Dino tot niveau 10, upload de schermafbeeldingen naar Twitter met hashtags! Je maakt kans om een Awakening-pas en amber scherven te winnen!<br>Of je kunt je vrienden uitnodigen om deel te nemen aan het Derby-evenement en je maakt kans om tot 2,1 te winnen. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> ook!<br>Volg alstublieft onze Twitter of voeg u toe aan onze andere sociale mediakanalen voor meer updates!</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt zich alle rechten voor op dit artikel. Het herdrukken van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>