R2F0ZS5pbyBBTUEgY29uIERPU0UtaWwgdG9rZW4gZGkgdXRpbGl0w6AgZGVsbCdlY29zaXN0ZW1hIGZpdG5lc3MgZGkgT2xpdmVY

<p><img src="https://gimg2.gateimg.com/image/article/16885517431.jpg" alt=""><br><strong>Ora: 23 novembre 2021, 09:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione di AMA (Ask-Me-Anything) con Keith Rumjahn, CEO e co-fondatore di OliveX (BVI) 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://www.dosetoken.com/" rel="nofollow noopener noreferrer" target="_blank">https://www.dosetoken.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/DOSEToken" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/DOSEToken</a></strong><br><strong>Segui DOSE su <a href="https://twitter.com/DOSEToken" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/dose_community" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16885519012.png" alt=""><br><strong>Keith Rumjahn - CEO e co-fondatore di OliveX (BVI)</strong></p>
<h2 id="h2-QampA20da20Gateio85937"><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-Q120Puoi20per20favore20presentarti20alla20comunit72545"><a name="Q1: Puoi per favore presentarti alla comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi per favore presentarti alla comunità?</h3><p><strong>Keith</strong>: Il mio nome è Keith Rumjahn. Sono il CEO e co-fondatore di OliveX (BVI), un’azienda di stile di vita digitale focalizzata sull’industria della salute e del fitness che fornisce applicazioni, ‘tecnologia intelligente’ e un’esperienza utente basata sull’intelligenza artificiale, gamification e contenuti premium. Stiamo costruendo un metaverso fitness che consente al fitness del mondo reale di fondersi con l’universo digitale al fine di coinvolgere i consumatori con marchi, influencer e allenatori.</p>
<p>Siamo supportati da alcuni degli investitori più prestigiosi al mondo come Animoca Brands, che è un leader globale nel settore dei giochi blockchain.</p>
<h3 id="h3-Q220Grazie20Keith20Quindi20sotto20il20marchio20OliveX20c20lo20specchio20intelligente20per20il20fitness20KARA20Zombies20Run20e202220Pushups20Qual2020la20relazione20tra20DOSE20e20tutti20questi584402"><a name="Q2: Grazie, Keith! Quindi sotto il marchio OliveX c’è lo specchio intelligente per il fitness KARA, Zombies, Run! e 22 Pushups. Qual è la relazione tra DOSE e tutti questi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Grazie, Keith! Quindi sotto il marchio OliveX c’è lo specchio intelligente per il fitness KARA, Zombies, Run! e 22 Pushups. Qual è la relazione tra DOSE e tutti questi?</h3><p><strong>Keith</strong>: 22 Pushups, KARA Smart Fitness e Zombies, Run! (STS) fanno parte dell’azienda OliveX Holdings Enterprise. L’etica è che gli utenti delle piattaforme sono motivati ​​a essere più attivi. $DOSE è destinato a essere utilizzato come utility cross-title all’interno dell’ecosistema OliveX (BVI) ed è stato progettato per essere la forza trainante dietro il modello Run-for-Reward, Sweat-to-Win nell’universo dei prodotti OliveX (BVI), come KARA Smart Fitness, 22 PushUps e l’atteso Dustland Runner (basato sul successo di Zombies, Run!). Zombies, Run! è già un successo comprovato con migliaia di download e recensioni da parte di utenti attivi.</p>
<p>Dai un’occhiata alla nostra app qui: <a href="https://zombiesrungame.com" rel="nofollow noopener noreferrer" target="_blank">https://zombiesrungame.com</a></p>
<h3 id="h3-Q320Puoi20dirci20qual2020la20funzione20del20token20DOSE263557"><a name="Q3: Puoi dirci qual è la funzione del token DOSE?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Puoi dirci qual è la funzione del token DOSE?</h3><p><img src="https://gimg2.gateimg.com/image/article/16885519413.png" alt=""><br><strong>Keith</strong>: Ecco alcuni modi per utilizzare $DOSE:</p>
<ul>
<li>Vendite NFT: DOSE può essere utilizzato per acquistare NFT ufficiali di Dustland Runner direttamente dal gioco, o eventualmente tramite un Marketplace secondario, che sarà rivelato a tempo debito. Gli NFT saranno venduti singolarmente e tramite pacchetti e andranno dagli avatar ai cosmetici, ai veicoli e ai terreni virtuali. Nota: Non c’è sovrapposizione tra gli NFT ottenuti giocando e gli NFT disponibili per l’acquisto diretto dal gioco.</li><li>Quote d’ingresso e Eventi a Tempo Limitato: Mentre l’esperienza principale di Dustland Runner è gratuita, il DOSE viene utilizzato come quota d’ingresso per modalità di gioco speciali ed eventi a tempo limitato, inclusi corse virtuali e battaglie PvP. Una parte delle commissioni di gioco raccolte sarà concessa ai giocatori partecipanti come ricompensa per la loro partecipazione e prestazioni.</li><li>Aggiornamenti e Sbloccaggi: Man mano che i giocatori progrediscono nel gioco, possono spendere i token DOSE per sbloccare più opzioni e utilità nel gioco. Questo include l’espansione del numero di slot nei loro equipaggiamenti NFT così come l’evoluzione di alcuni NFT oltre il loro livello massimo (ad es. veicoli).</li><li>Abbonamento Stagionale al Battlepass: I giocatori possono opzionalmente acquistare l’accesso a un Battlepass stagionale, che permette loro di accedere a missioni narrative a tempo limitato così come a un sistema di ricompense a livelli per sbloccare NFT in edizione limitata.</li></ul>
<h3 id="h3-Q420In20cosa20si20differenzia20DOSE20da20qualsiasi20altro20metaverso963192"><a name="Q4: In cosa si differenzia DOSE da qualsiasi altro metaverso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: In cosa si differenzia DOSE da qualsiasi altro metaverso?</h3><p><strong>Keith</strong>: Come potreste sapere, non c’è ancora un metauniverso fitness là fuori. Quindi siamo i leader in questo metaverso. Il gameplay sotto il nostro impero del fitness è supportato anche da prodotti funzionanti come KARA Smart Fitness e Zombies, Run! e sono tutte app ben note di salute e fitness che offrono esperienza sull’argomento fitness dietro il nostro progetto. Inoltre, OliveX (BVI) è una società spin-off di Animoca Brands e abbiamo una lista di investitori da lì, quindi potremmo potenzialmente lavorare con i loro progetti blockchain.</p>
<h3 id="h3-Q520Rispetto20agli20altri20prodotti20fitness20quali20sono20i20vantaggi20e20i20punti20di20vendita20di20Dustland20Runner188452"><a name="Q5: Rispetto agli altri prodotti fitness, quali sono i vantaggi e i punti di vendita di Dustland Runner?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Rispetto agli altri prodotti fitness, quali sono i vantaggi e i punti di vendita di Dustland Runner?</h3><p><strong>Keith</strong> Siamo concentrati nel rendere i nostri giochi in esecuzione Dustland runner :woman-running: incredibili. È basato su Zombies, Run! che ha oltre 300.000 utenti attivi mensili e 50.000 abbonati paganti. Abbiamo un motore di gioco esistente che le persone amano giocare. Ma aggiungeremo molto più gioco profondo ad esso. Pensiamo che per l’economia avere successo, abbiamo bisogno di un gioco più profondo e anche di molteplici modi per giocare. Ecco perché il nostro designer di giochi Ubisoft che ha progettato rainbow six e far cry ha aiutato a progettare alcuni giochi incredibili all’interno del nostro gioco.</p>
<p>La prima caratteristica vincente è un nucleo di esperienza di gioco audio comprovato. Molte persone hanno provato a gamificare il fitness ma è molto difficile.</p>
<p>In secondo luogo, abbiamo capacità di storytelling di livello mondiale. Lo scrittore di Zombies, Run! è l’autrice premiata Naomi Alderman. La storia nei giochi conta.</p>
<p>In terzo luogo, ci troviamo all’incrocio tra blockchain, fitness e gaming. È davvero difficile trovare un’azienda che faccia bene tutte e 3 le cose!</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 alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo purché 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>