R2F0ZS5pbyBBTUEgY29uIFlPT1NISS1HYW1lICsgTkZUICsgREVGSSArIERBTw==

<p><img src="https://gimg2.gateimg.com/image/article/16889717321.jpg" alt=""><br><strong>Ora: 5 novembre 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Vincent, Volontario della Comunità di YOOSHI nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito ufficiale: <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>Segui YOOSHI su <a href="https://twitter.com/yooshi_official" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/yooshi_official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16889720032.jpg" alt=""><br><strong>Vincent — Volontario della comunità di YOOSHI</strong></p>
<h2 id="h2-QampA20da20Gateio114779"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120YooShi2020molto20popolare20sul20mercato20recentemente20e20molte20persone20stanno20cominciando20a20prestare20attenzione20ad20esso20Potresti20parlare20di20YooShi347210"><a name="Q1: YooShi è molto popolare sul mercato recentemente e molte persone stanno cominciando a prestare attenzione ad esso. Potresti parlare di YooShi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: YooShi è molto popolare sul mercato recentemente e molte persone stanno cominciando a prestare attenzione ad esso. Potresti parlare di YooShi?</h3><p><strong>Vincent</strong>: YOOSHI = Gioco + NFT + DEFI + DAO<br>YooShi ha tre sezioni principali:<br>1)YooShi GamePad<br>YooShi GamePad è la prima piattaforma IDO di gioco basata su NFT. YooShi GamePad consentirà agli sviluppatori di giochi di raccogliere fondi prevendendo asset di gioco unici sotto forma di NFT.<br>2)Laboratori YooShi<br>YooShi GameFi Labs è un incubatore di giochi indipendente nell’era del WEB3.0. Fornisce agli sviluppatori di giochi il sistema completo di progettazione del gioco GameFi e il supporto tecnico per aiutare gli sviluppatori di giochi a completare più facilmente lo sviluppo del gioco blockchain.<br>3)Gioca per guadagnare l’alleanza della gilda<br>P2EGA è un’alleanza di gilde di gioco Play-to-Earn. Speriamo di aiutare milioni di persone a basso reddito a ottenere maggiori profitti attraverso i giochi “Play-to-Earn” e portare più utenti nel gioco!</p>
<p>L’attuale ecosistema di YooShi può essere compreso come due parti principali<br>1) L’espansione di YooShi di NFT, Farm, ecc.<br>NFT: Con i propri NFT di YooShi, i titolari possono scommettere per partecipare a Farm. Inoltre, nell’ultimo progetto StarMon, coloro che detengono NFT di YooShi e soddisfano i requisiti corrispondenti hanno goduto del privilegio dell’acquisto di una scatola cieca.<br>$YOOSHI: $YOOSHI può essere scommesso in Farms. Usato per scopi multipli come migliorare la potenza di mining, acquistare NFT, ecc.</p>
<p>2) Progetti Incubati da YooShi<br>IDO: Il GamePad consente agli sviluppatori di giochi di raccogliere fondi tramite la pre-vendita di asset di gioco sotto forma di NFT.<br>Lancio del gioco: gli utenti possono accedere al gioco tramite l’interfaccia YooShi e goderne.</p>
<p>YooShi Game Guild: YooShi formerà la propria gilda, portando i membri della gilda a godere di progetti di qualità guadagnando entrate effettive.</p>
<p>NFT: Commercio e aste nel mercato NFT.</p>
<p>Marketplace: Trading di asset in-game</p>
<h3 id="h3-Q220Gli20attuali20risultati20di20YooShi20sono20strettamente20legati20al20suo20modello20economico20che2020alla20base20dello20sviluppo20del20progetto20Puoi20parlarci20del20modello20economico20di20YooShi836888"><a name="Q2: Gli attuali risultati di YooShi sono strettamente legati al suo modello economico, che è alla base dello sviluppo del progetto. Puoi parlarci del modello economico di YooShi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Gli attuali risultati di YooShi sono strettamente legati al suo modello economico, che è alla base dello sviluppo del progetto. Puoi parlarci del modello economico di YooShi?</h3><p><strong>Vincent</strong>: Tokenomica di YooShi - La logica interna di $YOOSHI</p>
<p>Il modello economico di YooShi può essere diviso in tre dimensioni: sistema economico di base, livello del prodotto e livello ecologico.</p>
<p>$YOOSHI– Il sistema economico di fondo<br><img src="https://gimg2.gateimg.com/image/article/16889728103.jpg" alt=""><br>Combustione della transazione: In ogni operazione, viene applicata una commissione del 10% sulla transazione, di cui il 4% viene ridistribuito a tutti i detentori esistenti, il 3% viene reinvestito in NFT Farming e il 3% viene diviso50⁄50, metà delle quali viene venduta dal contratto in <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, mentre l’altra metà dei token YooShi viene accoppiata automaticamente con i <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> precedentemente menzionati e aggiunta come una coppia di liquidità su <a href="/price/pancakeswap-cake" rel="nofollow noopener noreferrer" target="_blank">PancakeSwap</a>.</p>
<p>Quando gli indirizzi di YooShi raggiungono un numero fisso, verrà attivata la combustione.</p>
<p>$YOOSHI - Livello del prodotto di YooShi</p>
<p>Asta pubblica YooShi NFT<br>Quando il numero di BNB nell’indirizzo del contratto raggiunge 10, i BNB ottenuti dall’asta verranno automaticamente SWAP a $YOOSHI, il 40% dei quali verrà iniettato nel pool NFT e il 50% verrà bruciato.</p>
<p>Asta:<br>La piattaforma addebiterà il 20% di commissione di offerta come tariffa di servizio, di cui il 40% andrà al pool di mining NFT, il 50% sarà convertito in $YOOSHI e bruciato.</p>
<p>Dopo il successo dell’asta, la piattaforma addebiterà il 3% dei profitti dell’editore come tariffa di servizio. Tra questi, il 40% entra nel pool di coltivazione di YooShi NFT, il 50% sarà scambiato per $YOOSHI e bruciato.</p>
<p>Marketplace - Progetti Incubati da YooShi<br>Esempio: Il Marketplace DNAxCAT supporta solo il pagamento in $BNB e il 4,5% di ogni transazione verrà addebitato come tariffa di servizio, di cui l’1,5% va alla tariffa di manutenzione dell’accordo di YooShi (il 40% va nel tesoro di YooShi, il 50% viene scambiato in $YOOSHIi e distrutto)</p>
<p>Il livello inferiore si basa sul meccanismo di combustione del trasferimento $YOOSHI, e YooShi ha i propri prodotti su questa base. Il livello superiore è l’ecologia che contiene tutti i progetti incubati da YooShi.</p>
<p>$YOOSHI coprirà tutti gli aspetti dell’ecologia. Dopo una precedente esplorazione accurata, YooShi è entrato nella fase di sviluppo rapido e sono entrati nell’ecosistema progetti di alta qualità. Senza il supporto dell’ecosistema, YooShi può svilupparsi in modo stabile da solo, mentre con l’ecosistema, YooShi si svilupperà significativamente più velocemente e attirerà più progetti di alta qualità, significando l’espansione del territorio ecologico di YooShi. In futuro, sempre più persone conosceranno YooShi, attraverso i suoi progetti di incubazione, indicando un circolo virtuoso dello sviluppo di YooShi.</p>
<h3 id="h3-Q320Lecosistema20YooShi2020ancora20nelle20prime20fasi20e20devo20dire20che2020pieno20di20opportunit20Quindi20come20possono20i20giocatori20e20gli20investitori20partecipare20allecosistema20di20YooShi798039"><a name="Q3: L’ecosistema YooShi è ancora nelle prime fasi e devo dire che è pieno di opportunità. Quindi come possono i giocatori e gli investitori partecipare all’ecosistema di YooShi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: L’ecosistema YooShi è ancora nelle prime fasi e devo dire che è pieno di opportunità. Quindi come possono i giocatori e gli investitori partecipare all’ecosistema di YooShi?</h3><p><strong>Vincent</strong>: Al momento, i giocatori e gli investitori possono partecipare a YooShi nei seguenti modi:<br>$YOOSHI<br>YooShi è una piattaforma di lancio di giochi e IDO basata su NFT a cui YooShi sarà legato a $YOOSHI. Progetti di incubazione e cambiamenti nella posizione sono tutti finalizzati a dare a $YOOSHI più energia. Attraverso un’osservazione attenta, è possibile notare che le vendite di blind box, le vendite di mercato e le aste nel mercato e nel marketplace di NFT sono tutte associate a $YOOSHI.</p>
<p>YooShi NFT<br>Anche il NFT di YooShi è stato menzionato in precedenza: YooShi ha il suo NFT che può essere staked ed ha anche un gameplay di creazione. Inoltre, una fase è stata aggiunta all’acquisto della scatola cieca di StarMon, il secondo progetto incubato da YooShi. È appositamente preparata per gli utenti che soddisfano i requisiti di potenza di mining di YooShi NFT. Questo è anche un vantaggio per i membri della community di YooShi proposto dal team di YooShi e dal progetto StarMon.</p>
<p>Progetti incubati da YooShi<br>I progetti incubati da YooShi sono anche correlati a YooShi e molti nuovi utenti conoscono YooShi attraverso i progetti incubati da essa. Sebbene YooShi mantenga una relazione indipendente con i suoi progetti di incubazione, il team di YooShi darà anche alcuni suggerimenti e aiuterà a risolvere alcuni problemi durante il processo di sviluppo del gioco. Pertanto, alcuni attributi di YooShi saranno impliciti nel progetto incubato e la partecipazione degli utenti al progetto incubato di YooShi contribuirà anche alla deflazione del token YOOSHI e all’espansione dell’ecosistema.</p>
<h3 id="h3-Q420YooShi20si20sta20sviluppando20cos20rapidamente20che20non20possiamo20fare20a20meno20di20chiederci20qual2020il20piano20di20sviluppo20futuro20di20YooShi20e20come20YooShi20manterr20lattuale20tendenza20al20rialzo20Puoi20dirci20qualcosa20a20riguardo66849"><a name="Q4: YooShi si sta sviluppando così rapidamente che non possiamo fare a meno di chiederci qual è il piano di sviluppo futuro di YooShi e come YooShi manterrà l’attuale tendenza al rialzo. Puoi dirci qualcosa a riguardo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: YooShi si sta sviluppando così rapidamente che non possiamo fare a meno di chiederci qual è il piano di sviluppo futuro di YooShi e come YooShi manterrà l’attuale tendenza al rialzo. Puoi dirci qualcosa a riguardo?</h3><p><strong>Vincent</strong>: 1) Abbiamo menzionato il lancio di YooShi 3.0 in precedenza in yooshi 2.5 che è considerato una fase relativamente di transizione. Con l’apertura del test DNAxCAT e il primo test di StarMon, la piattaforma di gioco di YooShi è ufficialmente lanciata. Ulteriori funzioni saranno aggiunte a YooShi 3.0, come YooShi ID, tramite il quale i giocatori possono accedere a tutti i giochi incubati da YooShi per migliorare l’esperienza dell’utente, che è più favorevole per i giocatori a gestire i loro account e asset. Anche il mining pool sarà riconfigurato in YooShi 3.0, i dati specifici saranno soggetti alla situazione effettiva, e l’orario specifico di apertura di YooShi 3.0 sarà soggetto all’ufficiale.<br>2) Abbiamo pubblicizzato i progetti di incubazione Yooshi su twitter e abbiamo dato un’idea generale delle due ombre nella parte finale. L’orario specifico è soggetto all’ufficiale.<br>3) Promozione e cooperazione di YooShi. Al momento, YooShi ha costruito un certo effetto di marca, istituito YooShi IP e collaborato con sempre più partner competitivi.<br>4) YooShi organizzerà un’attività di beneficenza - l’intenzione originale della creazione di YooShi</p>
<p>Si dice che ogni bambino sia un dono di Dio all’umanità e un angelo al mondo. Tuttavia, nel mondo reale, ci sono tali “angeli” che sembrano uguali agli altri, ma hanno sempre un sorriso luminoso sui loro volti. Dio si è preso gioco di loro e li ha fatti venire al mondo con alcune deformità. Soffrono della Sindrome di Angelman (AS).</p>
<p>La sindrome dell’angelo è anche conosciuta come sindrome del burattino felice, perché i bambini spesso ridono, alzano e agitano le mani, camminano in modo instabile, hanno difficoltà di linguaggio e intellettuali. Sembrano dei burattini. Quindi le persone hanno chiamato questa malattia sindrome del burattino felice.</p>
<p>Il design dell’immagine di YooShi deriva da questo, e anche l’NFT di YooShi Angel deriva da questo. Non abbiamo dimenticato la nostra intenzione originale - aiutare tutti e rendere il mondo un posto migliore. L’attività di beneficenza di YooShi sta per iniziare. Si può rivelare che attualmente il fondo del fondo di beneficenza di YooShi ha raggiunto 1,5 milioni di dollari, che saranno interamente utilizzati per la beneficenza, e i dettagli specifici… <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> L’annuncio dei fondi sarà pubblicato sul sito ufficiale per garantire che i fondi vengano utilizzati per i piccoli angeli adorabili. Supervisione di tutti è benvenuta! Spero anche che tu possa partecipare attivamente alla nostra prossima attività di beneficenza per diffondere l’amore di YooShi in tutto il mondo!</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rio Fu.</strong>, Comunità Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>