Z2F0ZUxpdmUgQU1BIFJlY2FwLU11bHRpIFVuaXZlcnNlIENlbnRyYWw=

2024-04-19, 07:12

<p><img src="https://gimg2.gateimg.com/image/article/1713510613AMA_Blog.jpg" alt=""></p>
<h2 id="h2-V120Vertel20mij20alsjeblieft20over20joujullie20team571485"><a name="V1: Vertel mij alsjeblieft over jou/jullie team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Vertel mij alsjeblieft over jou/jullie team?</h2><p>Vincent is de CEO van de MUC. Hij zit al meer dan 25 jaar in de gaming- en entertainmentsector, wat betekent dat hij echt de ins en outs begrijpt over intellectuele eigendommen en gebruikerservaring. Mijn naam is Yooji en ik ben een Business Dev voor de MUC. Ik heb ongeveer 9 jaar doorgebracht in zakelijke en operationele activiteiten in Seoul en Londen. Ik ben nog vrij nieuw in <a href="/web3" target="_blank" class="blog_inner_link">web3</a> en weet er nog niet veel van, maar ik word er steeds beter in en doe elke dag nieuwe inzichten en vaardigheden op. En ik wil ook iets delen over Jacky. Hij is de zakelijk directeur en mijn directe baas. Hij werkt al meer dan 7 jaar in de web3-wereld en ik leer zoveel van hem op het werk. Er zijn nog veel andere leden in het MUC-team, en ik zou ze graag de volgende keer allemaal willen voorstellen. We hebben zo hard gewerkt aan de MUC en ik wil gewoon dank u zeggen tegen elk lid van het team.</p>
<h2 id="h2-Q220Wat20is20de20MUC8032"><a name="Q2: Wat is de MUC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat is de MUC?</h2><p>MUC token is onze utility-token waarmee gebruikers kunnen genieten van verschillende inhoud binnen ons ecosysteem. We zijn helemaal gericht op het ontwikkelen van coole inhoud die gebaseerd is op zeer solide en robuuste IPs, en ik moet zeggen dat we echt goed zijn in het ontwikkelen van IP-gebaseerde inhoud. Om je een beter idee te geven waarom we er echt goed in zijn, denk ik dat ik je eerst een korte introductie moet geven van ons moederbedrijf. Ons moederbedrijf is Commseed, een beursgenoteerd bedrijf in Japan, en zij hebben talloze games ontwikkeld en aangeboden op basis van superberoemde IPs in Japan, zoals Neon Genesis Evangelion, Attack on Titan, One Punch Man en Monster Hunter.</p>
<p>En op een dag heeft de CEO van ons moederbedrijf dit idee: ‘Laten we de business uitbreiden naar web3’ en twee dochterondernemingen opgericht: één in Korea om de zakelijke kant te regelen en de andere in Japan om zich te richten op ontwikkeling. Deze twee zijn de kern van de MUC. Ik zei eerder dat Vincent de CEO is van het MUC-project, maar technisch gezien is hij de CEO van beide dochterondernemingen. Terzijde, ik maak deel uit van de Koreaanse dochteronderneming.</p>
<p>Terugkomend op de introductie van de MUC, bereiden we ons voor om een breed scala aan inhoud te onthullen. Het eerste aanbod zal Universal Stallion zijn, een web3 paardenrace spel, liefkozend bekend als Unista. Daarnaast zijn we momenteel bezig met het maken van een webtoon met behulp van onze eigen IP. We gaan het lanceren op een Japans webtoon platform, en we zullen het lanceringschema te zijner tijd onthullen. Bovendien zijn we enthousiast over ons tweede web3 spel, dat een zeer bekende IP zal bevatten. We zullen in staat zijn om de details van het nieuwe spel met jullie te delen tegen het einde van dit jaar of begin volgend jaar.</p>
<p>We gaan steeds meer leuke dingen binnenhalen, zoals games en webtoons, met behulp van onze eigen unieke IP’s en enkele zeer erkende. En de MUC-token zal een zeer belangrijke rol spelen bij het genieten van zo’n verscheidenheid aan inhoud. MUC is een zeer langlopend project en we zullen decennialang blijven bouwen aan het project.</p>
<h2 id="h2-Q320Paardenracespellen20klinken20misschien20wat20onbekend20voor20sommige20mensen20Kun20je20ons20meer20vertellen20over20Universal20Stallion546846"><a name="Q3: Paardenracespellen klinken misschien wat onbekend voor sommige mensen. Kun je ons meer vertellen over Universal Stallion?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Paardenracespellen klinken misschien wat onbekend voor sommige mensen. Kun je ons meer vertellen over Universal Stallion?</h2><p>Unista is het ultieme simulatiespel dat je de echte paardenrace brengt. Het heeft de werkelijke namen en statistieken van de legendarische racepaarden van Japan die de banen volledig hebben gerockt. Spelers kunnen paarden koppelen met ons super coole en gedetailleerde fok, waarbij de pasgeboren veulens eigenschappen kunnen erven van hun ouders, hun grootouders of zelfs hun overgrootouders.</p>
<p>Unista biedt diverse trainingsmethoden waarmee spelers zich kunnen richten op specifieke kwaliteiten zoals snelheid, uithoudingsvermogen en stabiliteit, en hun paarden kunnen uitgroeien tot de ultieme racedieren. Wanneer het moment aanbreekt dat de renpaarden met pensioen gaan, eindigt de reis niet daar. Spelers kunnen ze na hun pensioen blijven fokken en verhandelen op de marktplaats. Een nieuwe generatie paarden komt op, elk met zijn eigen unieke kenmerken en persoonlijkheid. Overigens zal UNISTA eind april een gesloten bètatest hebben en daarna snel live gaan. Het zal beschikbaar zijn in zowel de iOS- als Android-appstores, en het mooie is dat je het kunt spelen zonder web3-wallets of NFT’s.</p>
<h2 id="h2-Q420Kun20je20me20meer20vertellen20over20MUCtoken20Wat20is20tokenomics482743"><a name="Q4: Kun je me meer vertellen over MUC-token? Wat is tokenomics?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je me meer vertellen over MUC-token? Wat is tokenomics?</h2><p>We zullen 1 miljard MUC verspreiden over 10 jaar. Ze worden veilig bewaard in multisig-portefeuilles, die meerdere privésleutels vereisen voor bepaalde taken. Dit betekent in feite dat MUC wordt bewaard in een superveilig fort. 98% van MUC is veilig vergrendeld en de totale waarde die is vergrendeld (TVL) is slechts 2%. Dat is veel meer dan wat je ziet bij de meeste web3-projecten, wat aangeeft dat MUC veel potentieel heeft om te groeien. 45% ervan is toegewezen voor NFT-stakingbeloningen en 26% voor het MUC-ecosysteem. Er is 5% voor de oprichter en het team, die over de komende 3 jaar worden verdeeld, te beginnen met dit jaar.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>GateLive</strong>, team van Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io als bron wordt vermeld. In alle glen zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>