R2F0ZS5pbyBBTUEgbWV0IFlPT1NISS1HYW1lICsgTkZUICsgREVGSSArIERBTw==

<p><img src="https://gimg2.gateimg.com/image/article/16889717321.jpg" alt=""><br><strong>Tijd: 5 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 Vincent, Community Vrijwilliger van YOOSHI 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://yooshi.io/" rel="nofollow noopener noreferrer" target="_blank">https://yooshi.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/yooshi_official" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/yooshi_official</a></strong><br><strong>Volg YOOSHI op <a href="https://twitter.com/yooshi_official" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/yooshi_official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16889720032.jpg" alt=""><br><strong>Vincent — Gemeenschapsvrijwilliger van YOOSHI</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio587613"><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-Q120YooShi20is20de20laatste20tijd20erg20populair20op20de20markt20en20veel20mensen20beginnen20er20aandacht20aan20te20besteden20Kun20je20ons20iets20vertellen20over20YooShi727138"><a name="Q1: YooShi is de laatste tijd erg populair op de markt, en veel mensen beginnen er aandacht aan te besteden. Kun je ons iets vertellen over YooShi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: YooShi is de laatste tijd erg populair op de markt, en veel mensen beginnen er aandacht aan te besteden. Kun je ons iets vertellen over YooShi?</h3><p><strong>Vincent</strong>: YOOSHI = Spel + NFT + DEFI + DAO<br>YooShi heeft drie grote secties:<br>1) YooShi GamePad<br>YooShi GamePad is het eerste op NFT gebaseerde gaming IDO platform. YooShi GamePad stelt game-ontwikkelaars in staat om geld in te zamelen door unieke in-game activa in de vorm van NFT vooraf te verkopen.<br>2) YooShi-laboratoria<br>YooShi GameFi Labs is een onafhankelijke game-incubator in het WEB3.0-tijdperk. Het biedt game-ontwikkelaars het complete GameFi-game-ontwerpsysteem en technische ondersteuning om de game-ontwikkelaars te helpen de ontwikkeling van blockchain-games gemakkelijker af te ronden.<br>3) Speel om Guild Alliance te verdienen<br>P2EGA is een Play-to-Earn gaming guild alliantie. We hopen miljoenen mensen met een laag inkomen te helpen meer winst te maken door middel van “Play-to-Earn”-spellen en meer gebruikers in het spel te krijgen!</p>
<p>De huidige ecologie van YooShi kan worden begrepen als twee belangrijke onderdelen<br>1) De uitbreiding van NFT, Farm, etc. door YooShi.<br>NFT: Met YooShi’s eigen NFT kunnen houders staken om deel te nemen aan de Farm. Bovendien hebben degenen die YooShi NFT vasthouden en aan de overeenkomstige vereisten voldoen, genoten van het voorrecht van blind box-aankoop in het laatste project StarMon.<br>$YOOSHI: $YOOSHI kan worden gestaked in Farms. Gebruikt voor meerdere doeleinden zoals het upgraden van mining kracht, het kopen van NFT, enzovoort.</p>
<p>2) Projecten geïncubeerd door YooShi<br>IDO: De GamePad stelt game-ontwikkelaars in staat om geld in te zamelen door in-game assets in de vorm van NFT voor te verkopen.<br>Game lancering: Gebruikers kunnen het spel betreden via de YooShi interface en ervan genieten.</p>
<p>YooShi Game Guild: YooShi zal zijn eigen gilde vormen en gildeleden leiden om te genieten van kwaliteitsprojecten en tegelijkertijd daadwerkelijke inkomsten te verdienen.</p>
<p>NFT: Handel en veilingen in de NFT-markt.</p>
<p>Marktplaats: In-game asset trading</p>
<h3 id="h3-Q220De20huidige20prestaties20van20YooShi20zijn20nauw20verbonden20met20het20economische20model20dat20de20basis20vormt20voor20de20ontwikkeling20van20het20project20Kunt20u20ons20vertellen20over20het20economische20model20van20YooShi784772"><a name="Q2: De huidige prestaties van YooShi zijn nauw verbonden met het economische model, dat de basis vormt voor de ontwikkeling van het project. Kunt u ons vertellen over het economische model van YooShi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: De huidige prestaties van YooShi zijn nauw verbonden met het economische model, dat de basis vormt voor de ontwikkeling van het project. Kunt u ons vertellen over het economische model van YooShi?</h3><p><strong>Vincent</strong>: YooShi Tokenomics – De interne logica van $YOOSHI</p>
<p>Het economische model van YooShi kan worden onderverdeeld in drie dimensies: het economische systeem op de bodem, het productniveau en het ecologische niveau.</p>
<p>$YOOSHI - Het onderste economische systeem<br><img src="https://gimg2.gateimg.com/image/article/16889728103.jpg" alt=""><br>Transactie verbranding: Bij elke transactie wordt er een belasting van 10% in rekening gebracht, waarvan 4% wordt herverdeeld onder alle bestaande houders, 3% wordt geïnjecteerd in NFT Farming en 3% wordt verdeeld.50⁄50, waarvan de helft wordt verkocht door het contract in <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, terwijl de andere helft van YooShi-tokens automatisch wordt gekoppeld aan de eerder genoemde <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> en wordt toegevoegd als een liquiditeitspaar op <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>.</p>
<p>Wanneer het aantal YooShi-houdadressen een vast aantal bereikt, wordt er verbranding geactiveerd.</p>
<p>$YOOSHI - YooShi’s Product Level</p>
<p>YooShi NFT Openbare Veiling<br>Wanneer het aantal BNB in het contractadres 10 bereikt, zal de BNB die via de veiling is verkregen automatisch worden omgewisseld naar $YOOSHI, waarvan 40% zal worden geïnjecteerd in de NFT-pool en 50% zal worden verbrand.</p>
<p>Veiling:<br>Het platform zal 20% van de biedingscommissie als servicekosten in rekening brengen, waarvan 40% naar de NFT-miningpool zal gaan, 50% zal worden omgewisseld in $YOOSHI en verbrand.</p>
<p>Na een succesvolle veiling brengt het platform 3% van de winst van de uitgever in rekening als servicekosten. Hiervan gaat 40% naar de YooShi NFT farming pool, 50% wordt omgewisseld voor $YOOSHI en verbrand.</p>
<p>Marktplaats – Projecten die zijn geïncubeerd door YooShi<br>bijv: DNAxCAT Marketplace ondersteunt alleen betalingen in $BNB en er wordt 4,5% van elke transactie in rekening gebracht als servicekosten, waarvan 1,5% naar de onderhoudskosten van het YooShi-overeenkomst gaat (40% gaat naar de YooShi-schatkist, 50% wordt omgewisseld in $YOOSHIi en verbrand)</p>
<p>Het onderste niveau is gebaseerd op het $YOOSHI-overdrachtsverbrandingsmechanisme, en YooShi heeft op basis hiervan zijn eigen producten. Het bovenste niveau is de ecologie die alle door YooShi geïncubeerde projecten bevat.</p>
<p>$YOOSHI zal alle aspecten van de ecologie behandelen. Na eerdere zorgvuldige verkenning is YooShi de fase van snelle ontwikkeling ingegaan en zijn er meer hoogwaardige projecten in de ecologie gekomen. Zonder de ondersteuning van ecologie kan YooShi zelfstandig stabiel ontwikkelen, maar met ecologie zal YooShi aanzienlijk sneller ontwikkelen en meer hoogwaardige projecten aantrekken, wat betekent dat het ecologische grondgebied van YooShi wordt uitgebreid. In de toekomst zullen meer mensen op hun beurt YooShi kennen, via de incubatieprojecten, wat wijst op een deugdzame cirkel van de ontwikkeling van YooShi.</p>
<h3 id="h3-V320Het20YooShiecosysteem20bevindt20zich20nog20in20de20beginfase20en20ik20moet20zeggen20dat20het20vol20kansen20zit20Dus20hoe20kunnen20spelers20en20investeerders20deelnemen20aan20het20ecosysteem20van20YooShi146697"><a name="V3: Het YooShi-ecosysteem bevindt zich nog in de beginfase en ik moet zeggen dat het vol kansen zit. Dus hoe kunnen spelers en investeerders deelnemen aan het ecosysteem van YooShi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3: Het YooShi-ecosysteem bevindt zich nog in de beginfase en ik moet zeggen dat het vol kansen zit. Dus hoe kunnen spelers en investeerders deelnemen aan het ecosysteem van YooShi?</h3><p><strong>Vincent</strong>: Op dit moment kunnen spelers en investeerders op de volgende manieren deelnemen aan YooShi:<br>$YOOSHI<br>YooShi is een IDO en games-lanceerplatform op basis van NFT wat YooShi doet, zal gerelateerd zijn aan $YOOSHI. Incuberende projecten en de verandering in positionering zijn allemaal bedoeld om $YOOSHI meer energie te geven. Door nauwlettend te observeren, kunt u vinden dat de verkoop van blinddozen, marktverkopen en veilingen op de NFT-markt en marktplaats allemaal verband houden met $YOOSHI.</p>
<p>YooShi NFT<br>De YooShi NFT werd eerder ook genoemd: YooShi heeft zijn eigen NFT die gestaked kan worden en heeft ook een minting gameplay. Daarnaast wordt er een ronde toegevoegd aan de aankoop van een blind box van StarMon, het tweede project dat door YooShi wordt geïncubeerd. Het is speciaal bedoeld voor gebruikers die voldoen aan de mining power vereisten van YooShi NFT. Dit is ook een voordeel voor de YooShi gemeenschapsleden voorgesteld door het YooShi team en het StarMon project.</p>
<p>Projecten geïncubeerd door YooShi<br>De projecten geïncubeerd door YooShi zijn ook gerelateerd aan YooShi, en veel nieuwe gebruikers leren YooShi kennen via de projecten die geïncubeerd zijn door YooShi. Hoewel YooShi een onafhankelijke relatie onderhoudt met zijn incubatieprojecten, zal het YooShi-team ook enkele suggesties geven en helpen bij het oplossen van enkele problemen tijdens het spelontwikkelingsproces. Daarom zullen enkele van de eigenschappen van YooShi worden geïmpliceerd in het geïncubeerde project, en de deelname van gebruikers aan het YooShi-geïncubeerde project zal ook een zekere bijdrage leveren aan de deflatie van de YOOSHI-token en de uitbreiding van de ecologie.</p>
<h3 id="h3-Vraag20420YooShi20ontwikkelt20zich20zo20snel20dat20we20ons20afvragen20wat20YooShis20toekomstige20ontwikkelingsplan20is20en20hoe20YooShi20de20huidige20opwaartse20trend20zal20vasthouden20Kun20je20daar20iets20over20vertellen677903"><a name="Vraag 4: YooShi ontwikkelt zich zo snel dat we ons afvragen wat YooShi’s toekomstige ontwikkelingsplan is en hoe YooShi de huidige opwaartse trend zal vasthouden. Kun je daar iets over vertellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 4: YooShi ontwikkelt zich zo snel dat we ons afvragen wat YooShi’s toekomstige ontwikkelingsplan is en hoe YooShi de huidige opwaartse trend zal vasthouden. Kun je daar iets over vertellen?</h3><p><strong>Vincent</strong>: 1) We hebben de lancering van YooShi 3.0 eerder genoemd in Yooshi 2.5, wat wordt beschouwd als een relatief overgangsperiode. Met de opening van de DNAxCAT-test en de eerste test van StarMon, wordt het gameplatform van YooShi officieel gelanceerd. Meer functies zullen aan YooShi 3.0 worden toegevoegd, zoals YooShi ID, waarmee spelers kunnen inloggen bij alle door YooShi geïncubeerde spellen om de gebruikerservaring te verbeteren, wat meer bevorderlijk is voor spelers om hun accounts en activa te beheren. De mining pool zal ook worden aangepast in YooShi 3.0, de specifieke gegevens zullen afhankelijk zijn van de feitelijke situatie, en de specifieke openingstijd van YooShi 3.0 zal ook afhankelijk zijn van de officiële aankondiging.<br>2) We hebben Yooshi-incubatieprojecten op Twitter bekendgemaakt en de algemene opzet van de twee schaduwen in het laatste deel gegeven. De specifieke tijd is afhankelijk van de officiële aankondiging.<br>3) Promotie en samenwerking van YooShi. Op dit moment heeft YooShi een zeker merkeffect opgebouwd, YooShi IP opgericht en samengewerkt met steeds meer competitieve partners.<br>4) YooShi zal een liefdadigheidsactiviteit houden - de oorspronkelijke bedoeling van de oprichting van YooShi</p>
<p>Er wordt gezegd dat elk kind een geschenk van God aan de mensheid is en een engel voor de wereld. Maar in de echte wereld zijn er zulke ‘engelen’ die er hetzelfde uitzien als anderen, maar altijd een stralende glimlach op hun gezicht hebben. God maakte grapjes met hen en liet hen met enkele misvormingen ter wereld komen. Ze lijden aan het Angelman-syndroom (AS).</p>
<p>“Angel Syndrome” staat ook bekend als “happy puppet syndrome”, omdat kinderen vaak lachen, hun handen opsteken en zwaaien, onstabiel lopen en taal- en intellectuele barrières hebben. Ze lijken op een pop. Daarom hebben mensen deze ziekte “happy puppet syndrome” genoemd.</p>
<p>Het ontwerp van YooShi’s imago komt hiervandaan, en YooShi Angel NFT komt hier ook vandaan. We zijn onze oorspronkelijke bedoeling niet vergeten - iedereen helpen en de wereld een betere plek maken. YooShi’s liefdadigheidsactiviteit staat op het punt te beginnen. Het kan worden onthuld dat het fonds van het YooShi liefdadigheidsfonds op dit moment $1,5 miljoen heeft bereikt, dat volledig zal worden gebruikt voor liefdadigheid, en de specifieke <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> De toewijzing van de fondsen zal worden aangekondigd op de officiële website om ervoor te zorgen dat de fondsen worden gebruikt voor de schattige kleine engelen. Ieders toezicht is welkom! Ik hoop ook dat je actief deelneemt aan onze aankomende liefdadigheidsactiviteit om de liefde van YooShi over de hele wereld te verspreiden!</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 opvattingen 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>