R2F0ZS5pbyBBTUEgbWV0IE1pbWlyLVdlIGJyZW5nZW4gYmxvY2tjaGFpbiBnYW1lcyBuYWFyIGRlIG1hc3NhLW1hcmt0

<p><img src="https://gimg2.gateimg.com/image/article/16879337001.jpeg" alt=""><br><strong>Tijd: 29 november 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Viktor Sodermark, CEO &amp; Allfather van Mimir 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://www.mimirquiz.com/" rel="nofollow noopener noreferrer" target="_blank">https://www.mimirquiz.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/MimirToken" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/MimirToken</a></strong><br><strong>Volg Mimir op <a href="https://twitter.com/MimirToken" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/mimirannouncements" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16879338782.jpg" alt=""><br><strong>Viktor Sodermark — CEO &amp; Allfather van Mimir</strong></p>
<h2 id="h2-QampA20van20Gateio482507"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-Q120Waar20gaat20het20Mimirproject20over907754"><a name="Q1: Waar gaat het Mimir-project over?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Waar gaat het Mimir-project over?</h3><p><strong>Viktor</strong>: Geweldige vraag!</p>
<p>De Mimir World of Blockchain Games is een Zweedse spelstudio met een zeer duidelijke missie:<br>We brengen blockchain games naar de massa-markt!</p>
<p>Onze blockchainspellen draaien om bewezen en universele spelconcepten, maar met de unieke twist dat we alle revolutionaire ideeën van GameFi en blockchain in de mix toevoegen. We bouwen deze spellen met de intentie om ze vriendelijk te maken voor de massamarkt.</p>
<p>Ons eerste spel op de markt is de Mimir Quiz - ‘s Werelds eerste quiz-app aangedreven door blockchain. Met de Mimir Quiz ontgrendelen we de ware kracht van blockchaintechnologie, play-to-earn, NFT’s en alle voordelen van GameFi.</p>
<h3 id="h3-Q220Welke20problemen20los20je20op997365"><a name="Q2: Welke problemen los je op?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Welke problemen los je op?</h3><p><strong>Viktor</strong>: Het korte antwoord is dat we een van de belangrijkste problemen van vandaag op de cryptomarkt zullen oplossen, namelijk het betrekken van de massa op de wereld van crypto.</p>
<p>Op dit moment zijn er meer dan 2,5 miljard mensen op deze planeet die mobiele games spelen. Het is een enorme markt die wordt gecontroleerd door gecentraliseerde gaming giganten die een fortuin verdienen aan hun spelers, maar zeer weinig teruggeven aan hun gemeenschap.</p>
<p>We verstoren de mobiele gamingmarkt door blockchain en GameFi te introduceren bij miljarden gamers over de hele wereld, zodat onze games gratis kunnen worden gespeeld, zonder vervelende advertenties en waar je betaald krijgt in MIMIR-tokens voor het spelen van onze leuke mobiele games.</p>
<p>Mimir Quiz is het eerste blockchain-spel met massamarktpotentieel, omdat het draait om quiz &amp; trivia, wat de meest bewezen en universele spelmodus aller tijden is.</p>
<h3 id="h3-Q320Vertel20ons20over20het20gebruik20en20de20nut20van20MIMIRtoken63086"><a name="Q3: Vertel ons over het gebruik en de nut van MIMIR-token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Vertel ons over het gebruik en de nut van MIMIR-token?</h3><p><strong>Viktor</strong>: $MIMIR is de ENE en ENIGE token die ooit zal worden gebruikt in de Mimir Wereld van Blockchain Games.</p>
<p>Gebruik en nut:</p>
<ul>
<li>Spelers verdienen $MIMIR door simpelweg te spelen en te winnen in onze mobiele games via ons play-to-earn-model. Spelers kunnen ook hun Mimir-tokens gebruiken.</li><li>In-game aankopen zoals inschrijfgeld voor onze grote LIVE quizshows, in-game items (NFT’s) en voordelen om je game-ervaring te verbeteren.</li><li>Staken voordat je een spel binnengaat om een prijzenpot op te bouwen om voor te strijden.</li><li>Gedecentraliseerd bestuur met stemrechten.</li></ul>
<h3 id="h3-Vraag20420Wat20is20Mimir20Quiz890383"><a name="Vraag 4: Wat is Mimir Quiz?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 4: Wat is Mimir Quiz?</h3><p><strong>Viktor</strong>: Mimir Quiz is ‘s werelds eerste game show-app die wordt aangedreven door blockchaintechnologie!</p>
<p>Het is al goedgekeurd door Google Play &amp; App Store, wat ENORM voor ons is. We zijn momenteel bezig met de laatste onderdelen van het testen voordat we het publiceren voor het grote publiek en we verwachten dat ons marketingplan en het leuke spel dat we op de markt brengen meer dan 100.000 actieve gebruikers zal hebben tijdens december.</p>
<p>Mimir Quiz is een spel om geld te verdienen waar spelers zich kunnen aansluiten bij leuke 1vs1 quizspellen en kunnen meedoen aan onze live video streaming toernooien waar we je kennis testen over verschillende onderwerpen.<br><img src="https://gimg2.gateimg.com/image/article/16879338963.jpg" alt=""><br>Spelers strijden om glorie en ENORME prijzen in MIMIR-tokens. Je kunt nu al naar onze website gaan om het uit te proberen in de vroege toegang en misschien heeft de Mimir Quiz het definitieve antwoord op de vraag wie miljonair wil worden?</p>
<h3 id="h3-Q520En20tot20slot20voordat20we20overgaan20op20vragen20van20ons20publiek20Wat20zijn20de20volgende20grote20dingen20die20gebeuren20voor20MIMIR87223"><a name="Q5: En tot slot voordat we overgaan op vragen van ons publiek. Wat zijn de volgende grote dingen die gebeuren voor MIMIR?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: En tot slot voordat we overgaan op vragen van ons publiek. Wat zijn de volgende grote dingen die gebeuren voor MIMIR?</h3><p><img src="https://gimg2.gateimg.com/image/article/16879339104.jpg" alt=""><br><strong>Viktor</strong>: Aankomende hoogtepunten voor Mimir:</p>
<ul>
<li>Openbare release van Mimir Quiz op Google Play, App Store en webbrowser die wereldwijd wordt gelanceerd</li><li>Mimir Quiz heeft al 30K aanmeldingen, maar streeft ernaar om tijdens december +100K spelers te hebben zodra we live gaan</li><li>Beroemde gasten zullen verschijnen als spelhosts in Mimir Quiz</li><li>BitBoy, CryptosRus &amp; veel influencers promoten Mimir Quiz</li><li>Het 2e Mimir Wereldspel zal gelanceerd worden in het midden van Q1 naar Google Play &amp; App Store</li><li>Het ecosysteem van Blockchain Games dat we bouwen zal tegen Midzomer 2022 de meest actieve maandelijkse gebruikers op de cryptomarkt hebben.</li></ul>
<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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>