R2F0ZS5pbyBBTUEgY29uIE9wZW5CbG94IC0gUmFjY29nbGksIEFsbGV2YSwgQ29tYmF0dGkgZWQgRXNwbG9yYQ==

<p><img src="https://gimg2.gateimg.com/image/article/16771415501.png" alt=""><br><strong>Ora: 9 settembre 2022, 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 il Co-Fondatore e Product Manager di OpenBlox, Nik 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://openblox.io/" rel="nofollow noopener noreferrer" target="_blank">https://openblox.io/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/OpenBlox_io" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/OpenBlox_io</a></strong></p>
<p><strong>Segui OpenBlox su <a href="https://twitter.com/OpenBlox_io" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/openblox_eng" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16771418052.png" alt=""><br><strong>Nik - Co-Fondatore e Product Manager</strong></p>
<h2 id="h2-QampA20da20Gateio321344"><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-Q120Potresti20parlare20di20come20sei20entrato20nello20spazio20delle20criptovalute20e20di20come20il20tuo20background20ha20contribuito20ai20tuoi20successi20iniziali728958"><a name="Q1: Potresti parlare di come sei entrato nello spazio delle criptovalute e di come il tuo background ha contribuito ai tuoi successi iniziali?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti parlare di come sei entrato nello spazio delle criptovalute e di come il tuo background ha contribuito ai tuoi successi iniziali?</h3><p><strong>Nik</strong>: La mia laurea è in Informatica Aziendale, il che mi ha permesso di comprendere entrambi gli sfondi.<br>La mia carriera iniziò nella banca, concentrando principalmente gli sforzi nell’improvvisazione dei prodotti bancari.<br>Nel frattempo, lavorando in banca, ho notato molti problemi nel sistema bancario centralizzato.<br>Fu in quel momento che la tecnologia blockchain stava diventando molto popolare. In quel momento, ho visto davvero un’enorme opportunità tecnologica che avrebbe cambiato il modo in cui interagiamo con le finanze, fornendo nel frattempo la migliore trasparenza al pubblico.<br>Le mie esperienze precedenti nell’improvvisazione dei prodotti mi hanno aiutato molto a dare il miglior contributo al nostro progetto, in modo da poter fornire il miglior prodotto possibile per la nostra comunità.</p>
<h3 id="h3-Q220Qual2020esattamente20il20tuo20progetto20e20puoi20dirci20di20pi20sulla20tua20visione959646"><a name="Q2: Qual è esattamente il tuo progetto e puoi dirci di più sulla tua visione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Qual è esattamente il tuo progetto e puoi dirci di più sulla tua visione?</h3><p><strong>Nik</strong>: OpenBlox è una piattaforma di giochi Blockchain e <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Apps.<br>Sfruttando il potente team di tecnologia blockchain, ci concentriamo sulla creazione di un ponte tra web2 e web3 e offriamo a tutti i progetti tradizionali di web2 la possibilità di integrare l’infrastruttura blockchain nella loro attività.<br>Quando abbiamo avviato OpenBlox, l’obiettivo era creare una grande piattaforma di giochi NFT, che avrebbe collegato i giochi e la blockchain.<br>RougeBlox è un gioco di carte strategico a turni PvE di tipo roguelike.<br>È necessario un NFT Blox per giocare al gioco.<br>Mentre stavamo sviluppando il gioco, abbiamo notato che gli esseri umani stanno diventando sempre più connessi con la tecnologia, non solo a causa dei suoi bisogni essenziali di cui tutti beneficiano, ma anche a causa dell’esperienza affascinante che la tecnologia crea nelle nostre vite. Da un lato, la tecnologia beneficia gli esseri umani, ma dall’altro sta creando un’enorme distanza tra loro e il mondo reale.<br>Con questa quantità di tecnologia nella nostra vita, è molto facile disconnettersi dal mondo reale, quindi è per questo che dobbiamo cambiarlo ed è per questo che abbiamo sviluppato RunBlox.<br><img src="https://gimg2.gateimg.com/image/article/16771418473.png" alt=""><br>RunBlox è un’app per lo stile di vita Web3 costruita sul <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> L’ecosistema.<br>Il suo scopo è quello di unire il mondo fisico con quello virtuale, creando una buona combinazione tra mantenersi sani e attivi ma anche godersi le ricompense di Move&amp;Earn.</p>
<h3 id="h3-Q320Cos20il20Bear20Market20Marathon20e20come20posso20richiedere20la20mia20scarpa20Marathon20gratuita547312"><a name="Q3: Cos’è il Bear Market Marathon e come posso richiedere la mia scarpa Marathon gratuita?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Cos’è il Bear Market Marathon e come posso richiedere la mia scarpa Marathon gratuita?</h3><p><strong>Nik</strong>: RunBlox organizzerà il prossimo mese un evento di maratona virtuale. Si tratta della prima maratona dell’orso mai vista e durante la competizione di 30 giorni della maratona, è necessario guadagnare il maggior numero possibile di $RUX. I primi tre utenti con il maggior numero di $RUX diventeranno detentori di NFT blue-chip.<br>Per richiedere la tua scarpa da maratona gratuita, innanzitutto, è necessario avere un nuovo indirizzo del portafoglio Runblox e mantenere un po’ di $SEWAT nel tuo portafoglio/CEXs (nessuna quantità minima richiesta), quindi puoi compilare questo modulo per richiedere la tua scarpa NFT gratuita: <a href="https://forms.gle/Ah8ujK6QMJnGS8ur7" rel="nofollow noopener noreferrer" target="_blank">https://forms.gle/Ah8ujK6QMJnGS8ur7</a><br>Innanzitutto, è necessario avere un nuovo indirizzo del portafoglio Runblox e possedere un po’ di $SEWAT nel tuo portafoglio/CEXs (non è richiesta una quantità minima), quindi puoi compilare questo modulo per richiedere la tua scarpa NFT gratuita: <a href="https://forms.gle/Ah8ujK6QMJnGS8ur7" rel="nofollow noopener noreferrer" target="_blank">https://forms.gle/Ah8ujK6QMJnGS8ur7</a></p>
<h3 id="h3-Q420Quante20scarpe20da20maratona20posso20ottenere396673"><a name="Q4: Quante scarpe da maratona posso ottenere?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Quante scarpe da maratona posso ottenere?</h3><p><strong>Nik</strong>: Puoi ottenere una scarpa dalla registrazione. Questa scarpa servirà come biglietto per i nuovi utenti che vogliono partecipare all’evento maratona. Puoi anche fornire il tuo indirizzo del portafoglio RunBlox come codice di invito. Più utenti inviti, più scarpe gratuite puoi ottenere. Ci saranno al massimo altre tre scarpe da maratona gratuite che puoi ottenere. Una scarpa da maratona ti darà due energie per iniziare. Più scarpe hai nella tua app RunBlox, più energia potrai ottenere, il che ti aiuterà a massimizzare la capacità di $RUX.</p>
<h3 id="h3-Q520Quali20sono20le20recenti20partnership20di20OpenBlox740838"><a name="Q5: Quali sono le recenti partnership di OpenBlox?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quali sono le recenti partnership di OpenBlox?</h3><p><strong>Nik</strong>: Oltre ad alcune buone partnership che abbiamo fatto, la più entusiasmante è con un viaggiatore spaziale e investitore giapponese chiamato Yusaku Maezawa, anche conosciuto come il “Elon Musk giapponese”.<br><img src="https://gimg2.gateimg.com/image/article/16771418914.jpg" alt=""><br>Siamo molto felici di essere il primo progetto Web3 nel suo portafoglio.</p>
<h3 id="h3-Q620Raccontaci20di20pi20sulla20tokenomica20del20progetto176406"><a name="Q6: Raccontaci di più sulla tokenomica del progetto." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Raccontaci di più sulla tokenomica del progetto.</h3><p><strong>Nik</strong>: Poiché prevediamo di lanciare diversi giochi e diverse app, l’economia dei token svolgerà un ruolo molto importante nell’ecosistema della piattaforma.<br>La chiave è dare ai nostri utenti la flessibilità di scambiare i token all’interno della nostra piattaforma in modo che possano godere di spendere le ricompense di un gioco sull’altro gioco o app.<br>Al momento, abbiamo già sviluppato una funzione di scambio nell’app in cui gli utenti possono scambiare più token.<br>Nel frattempo, di recente lo staking e il farming sono disponibili su TraderJoe.</p>
<h3 id="h3-Q720Dove20ti20stai20dirigendo20nei20prossimi20anni20e20quali20sono20i20prossimi20aggiornamenti20principali20per20te862177"><a name="Q7: Dove ti stai dirigendo nei prossimi anni e quali sono i prossimi aggiornamenti principali per te?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Dove ti stai dirigendo nei prossimi anni e quali sono i prossimi aggiornamenti principali per te?</h3><p><strong>Nik</strong>: In termini di sviluppo, un piano a breve termine entusiasmante è il lancio dell’app RunBlox sullo Smart Watch, che porterà l’esperienza M2E al livello successivo.<br>Ma il futuro è entusiasmante.<br>Porteremo l’interazione fisica al livello successivo, creando molte attività nel mondo reale, in cui gli utenti si uniranno per competere tra loro o condividere eventi tra loro.<br>Forse persino raccogliere ricompense in luoghi specifici, dove incontreranno altri utenti di RunBlox.<br>Dato che siamo nella settimana di LootBox, volevo condividere con voi che potremmo persino avere alcune fantastiche ricompense legate al nostro stile di vita quotidiano, come sconti su diverse marche sportive.<br><img src="https://gimg2.gateimg.com/image/article/16771416635.png" alt=""><br>Queste sono alcune idee che stiamo pianificando, ma voglio assicurarti che il futuro è molto emozionante e i primi sostenitori saranno sicuramente quelli che trarranno maggiori vantaggi.</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 riutilizzo 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>