R2F0ZS5pbyBBTUEgbWV0IE1ldGFTb2NjZXItSk9VVyBWT0xHRU5ERe+5o0dFTiBWT0VUQkFMQ0xVQg==

<p><img src="https://gimg2.gateimg.com/image/article/16856911161.jpg" alt=""><br><strong>Tijd: 12 januari 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hostte een AMA (Ask-Me-Anything) sessie met Patxi Barrios, COO van MetaSoccer 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://metasoccer.com/" rel="nofollow noopener noreferrer" target="_blank">https://metasoccer.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/MetaSoccer_EN" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/MetaSoccer_NL</a></strong><br><strong>Volg MetaSoccer op <a href="https://t.me/MetaSoccerOfficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/metasoccer" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16856912782.png" alt=""><br><strong>Patxi Barrios — COO van MetaSoccer</strong></p>
<h2 id="h2-QampA20van20Gateio628346"><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-Q120Kun20je20ons20een20korte20introductie20van20jezelf20geven20alsjeblieft20Patxi846835"><a name="Q1: Kun je ons een korte introductie van jezelf geven alsjeblieft Patxi!" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je ons een korte introductie van jezelf geven alsjeblieft Patxi!</h3><p><strong>Patxi</strong>: Zeker! Ik ben de COO bij Champion Games, een 6 jaar oude videogame achter MetaSoccer.</p>
<h3 id="h3-V220Dus20wat20betreft20Metasoccer20zou20je20ons20er20meer20over20kunnen20vertellen20Beschrijf20beknopt20je20project20en20zijn20ambities537910"><a name="V2: Dus, wat betreft Metasoccer, zou je ons er meer over kunnen vertellen? Beschrijf beknopt je project en zijn ambities." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Dus, wat betreft Metasoccer, zou je ons er meer over kunnen vertellen? Beschrijf beknopt je project en zijn ambities.</h3><p><strong>Patxi</strong>: MetaSoccer is een hele voetbal metaverse waarin je je eigen club kunt beheren en inkomsten kunt genereren terwijl je speelt. Dit is het startpunt van een nieuw paradigma in het sportecosysteem, gedecentraliseerd en waarin je op meerdere manieren actief kunt deelnemen.<br><img src="https://gimg2.gateimg.com/image/article/16856912973.png" alt=""><br>Onze ambitie is om een nieuwe voetbalcategorie te creëren, metaverse voetbal. De nieuwe Messi en CR7 zullen ontdekt worden in ons ecosysteem, en de Metasoccer Clubs zullen in staat zijn om inkomen te genereren op hetzelfde niveau als een professioneel team in de echte wereld via sponsoring, streaming, weddenschapsevenementen en studiebeurzen.</p>
<h3 id="h3-Q320Erg20interessant20En20hoe20ben20je20erop20gekomen20wat20is20de20geschiedenis20achter20Metasoccer427106"><a name="Q3: Erg interessant! En hoe ben je erop gekomen; wat is de geschiedenis achter Metasoccer?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Erg interessant! En hoe ben je erop gekomen; wat is de geschiedenis achter Metasoccer?</h3><p><strong>Patxi</strong> Wij zijn een zes jaar oude videogame studio, dus we hebben een sterke expertise in het maken van voetbalgames en vanwege deze expertise en interesse in crypto heeft het team besloten om MetaSoccer te creëren met enkele belangrijke concepten die we kunnen vinden in <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> bijvoorbeeld.</p>
<p>Zoals ik al eerder heb vermeld, weten we veel over voetbal en hoe we een succesvol bedrijf kunnen opzetten, en onze partners kunnen dat ook zien. We worden ondersteund door eersteklas durfkapitaalfondsen zoals PlayVentures, DeFiance, ParaFi, DAO Maker en enkele topspelers van niveau 1.</p>
<h3 id="h3-Q420Ok20heel20goed20om20te20weten20dat20je20een20goede20backup20hebt20dat20spreekt20altijd20goed20over20de20toekomst20van20de20projecten20Hoe20zit20het20met20het20team20Laat20ons20meer20weten20over20jezelf20en20de20rest20van20de20teamleden382429"><a name="Q4: Ok heel goed om te weten dat je een goede back-up hebt, dat spreekt altijd goed over de toekomst van de projecten. Hoe zit het met het team? Laat ons meer weten over jezelf en de rest van de teamleden." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ok heel goed om te weten dat je een goede back-up hebt, dat spreekt altijd goed over de toekomst van de projecten. Hoe zit het met het team? Laat ons meer weten over jezelf en de rest van de teamleden.</h3><p><strong>Patxi</strong>: We werken sinds 2015 als team samen en we zijn nu met 21 mensen in de studio gericht op de uitvoering en groei van het MetaSoccer-product. Marc Cercós, CEO, leidt de gamificatie en Alex Fiestas, CTO, beheert de technische kant van het project.</p>
<p>Dus we weten veel over voetbal en hoe we een succesvol bedrijf kunnen oprichten, en onze partners kunnen dat ook zien, en dat is de reden waarom we in staat waren om +2M euro aan financiering op te halen en ook grote partnerschappen te sluiten met de grootste lanceerplatform in de markt en ook met de grootste Gilden.</p>
<h3 id="h3-Q520Gefeliciteerd20met20de20verhoging20Best20indrukwekkend20Dus20hoe20kunnen20mensen20zich20aansluiten20bij20Metasoccer20en20het20MSUecosysteem20Waarom20zouden20gebruikers20het20op20lange20termijn20moeten20vasthouden486505"><a name="Q5: Gefeliciteerd met de verhoging! Best indrukwekkend. Dus hoe kunnen mensen zich aansluiten bij Metasoccer en het $MSU-ecosysteem? Waarom zouden gebruikers het op lange termijn moeten vasthouden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Gefeliciteerd met de verhoging! Best indrukwekkend. Dus hoe kunnen mensen zich aansluiten bij Metasoccer en het $MSU-ecosysteem? Waarom zouden gebruikers het op lange termijn moeten vasthouden?</h3><p><strong>Patxi</strong>: In ons spel zul je het PVE- en PVP-systeem hebben, vergelijkbaar met Axie. Dus je zult op dagelijkse basis $MSU-tokens kunnen krijgen met het PVE, en bij PVP zal het afhangen van je resultaten in het spel en je divisie. Als je in de topdivisies zit, zul je meer $MSU ontvangen.</p>
<p>Het spel zal vele functies hebben zoals streaming en wedden, en de waardering van onze token en zijn bruikbaarheid zal in de loop van de tijd toenemen.</p>
<h3 id="h3-Q620Ok20het20lijkt20dus20vrij20eenvoudig20om20mee20te20beginnen20En20hoe20ontwikkelt20het20product20zich20Zou20je20ons20meer20kunnen20vertellen20over20jullie20routekaart101177"><a name="Q6: Oké, het lijkt dus vrij eenvoudig om mee te beginnen! En hoe ontwikkelt het product zich? Zou je ons meer kunnen vertellen over jullie routekaart?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Oké, het lijkt dus vrij eenvoudig om mee te beginnen! En hoe ontwikkelt het product zich? Zou je ons meer kunnen vertellen over jullie routekaart?</h3><p><strong>Patxi</strong>: We liggen op schema met onze routekaart en we hebben onze eerste gelicentieerde speelbare NFT aangekondigd, Thomas Partey van Arsenal Club, en we gaan de komende weken een Ballon d’Or-voetballer aankondigen.</p>
<p>We hebben onze token gelanceerd en 4 verschillende NFT-drops (allemaal uitverkocht). We richten ons nu op de release van de staking en marktplaats in de komende weken. De gebruiker zal op die datum inkomsten kunnen genereren.<br>PVE wordt uitgebracht in Q1 2022 en PVP in Q2 2022.<br>U kunt hier alle mijlpalen bekijken: <a href="https://whitepaper.metasoccer.com/metasoccer/more/roadmap" rel="nofollow noopener noreferrer" target="_blank">https://whitepaper.metasoccer.com/metasoccer/more/roadmap</a></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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>