R2F0ZS5pbyBBTUEgbWV0IE9wZW5CbG94IC0gVmVyemFtZWwsIEt3ZWVrLCBTdHJpamQgZW4gVmVya2Vu

<p><img src="https://gimg2.gateimg.com/image/article/16771415501.png" alt=""><br><strong>Tijd: 9 september 2022, 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 mede-oprichter &amp; productmanager van OpenBlox, Nik 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://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>Volg OpenBlox op <a href="https://twitter.com/OpenBlox_io" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/openblox_eng" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16771418052.png" alt=""><br><strong>Nik - medeoprichter &amp; productmanager</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio939792"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Kunt20u20ons20vertellen20hoe20u20in20de20cryptoruimte20bent20gekomen20en20hoe20uw20achtergrond20heeft20bijgedragen20aan20uw20vroege20successen964877"><a name="Q1: Kunt u ons vertellen hoe u in de crypto-ruimte bent gekomen en hoe uw achtergrond heeft bijgedragen aan uw vroege successen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u ons vertellen hoe u in de crypto-ruimte bent gekomen en hoe uw achtergrond heeft bijgedragen aan uw vroege successen?</h3><p><strong>Nik</strong> Mijn opleiding is Bedrijfsinformatie, wat me in staat stelde om beide achtergronden te begrijpen.<br>Mijn vroege carrière begon in de banksector, waarbij ik me voornamelijk richtte op het verbeteren van bankproducten.<br>Ondertussen werkte ik in de banksector en zag ik veel problemen in het gecentraliseerde banksysteem.<br>Het was het moment waarop blockchain erg populair begon te worden. Op dat moment zag ik echt een enorme technologische kans die de manier waarop we met financiën omgaan zou veranderen, terwijl tegelijkertijd de beste transparantie aan het publiek wordt geboden.<br>Mijn eerdere ervaringen met productverbetering hebben me enorm geholpen om de beste bijdrage te leveren aan ons project, zodat we het best mogelijke product voor onze gemeenschap konden leveren.</p>
<h3 id="h3-Q220Wat20is20precies20uw20project20en20kunt20u20ons20meer20vertellen20over20uw20visie777956"><a name="Q2: Wat is precies uw project en kunt u ons meer vertellen over uw visie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat is precies uw project en kunt u ons meer vertellen over uw visie?</h3><p><strong>Nik</strong> OpenBlox is een Blockchain Gaming &amp; <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Apps Platform. Dankzij ons krachtige blockchain Tech team richten we ons op het creëren van een brug tussen web2 en web3 en het bieden van de kans aan alle web2 traditionele projecten om de blockchain-infrastructuur in hun activiteiten te integreren. Toen we OpenBlox startten, was het de bedoeling om een grote NFT Gaming Platform te creëren, dat gaming en blockchain met elkaar zou verbinden. RougeBlox is een roguelike strategisch PvE, turn-based kaartspel. Een NFT Blox is nodig om het spel te spelen. Terwijl we het spel aan het ontwikkelen waren, merkten we op dat mensen steeds meer verbonden raken met technologie, niet alleen vanwege de essentiële behoeften waar iedereen van profiteert, maar ook vanwege de fascinerende ervaring die technologie in al onze levens creëert. Aan de ene kant is technologie gunstig voor mensen, maar aan de andere kant creëert het een grote kloof tussen hen en de echte wereld. Met zoveel technologie in ons leven is het heel gemakkelijk om losgekoppeld te raken van de echte wereld, daarom is het noodzakelijk om hier verandering in te brengen en daarom hebben we RunBlox ontwikkeld.<br><img src="https://gimg2.gateimg.com/image/article/16771418473.png" alt=""><br>RunBlox is een Web3 lifestyle app gebouwd op de <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> Het doel van de ecosystem.<br>Het doel is om de fysieke wereld te combineren met de virtuele wereld, een goede combinatie te bieden tussen gezond en actief blijven en tegelijkertijd te genieten van de beloningen van Move&amp;Earn.</p>
<h3 id="h3-Q320Wat20is20Bear20Market20Marathon20en20hoe20claim20ik20mijn20gratis20Marathonschoen361220"><a name="Q3: Wat is Bear Market Marathon en hoe claim ik mijn gratis Marathon-schoen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wat is Bear Market Marathon en hoe claim ik mijn gratis Marathon-schoen?</h3><p><strong>Nik</strong>: RunBlox organiseert volgende maand een virtueel marathon evenement. Het is de allereerste Bear Market Marathon en tijdens de 30-daagse marathonwedstrijd moet je zoveel mogelijk $RUX verdienen tijdens het rennen. De top drie gebruikers met de meeste $RUX worden blue-chip NFT-houders. Om je gratis marathonschoen te claimen, heb je allereerst een gloednieuw Runblox-portemonnee-adres nodig en houd je wat $SEWAT in je portemonnee/CEXs (geen minimumbedrag vereist), daarna kun je dit formulier invullen om je gratis NFT-schoen te claimen: <a href="https://forms.gle/Ah8ujK6QMJnGS8ur7" rel="nofollow noopener noreferrer" target="_blank">https://forms.gle/Ah8ujK6QMJnGS8ur7</a><br>Ten eerste heb je een gloednieuw Runblox wallet-adres nodig en moet je wat $SEWAT in je wallet/CEXs hebben (geen minimumbedrag vereist), daarna kun je dit formulier invullen om je gratis NFT-schoen te claimen: <a href="https://forms.gle/Ah8ujK6QMJnGS8ur7" rel="nofollow noopener noreferrer" target="_blank">https://forms.gle/Ah8ujK6QMJnGS8ur7</a></p>
<h3 id="h3-V420Hoeveel20marathon20schoenen20kan20ik20krijgen207953"><a name="V4: Hoeveel marathon schoenen kan ik krijgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4: Hoeveel marathon schoenen kan ik krijgen?</h3><p><strong>Nik</strong>: U kunt één schoen krijgen bij registratie. Deze schoen zal dienen als een ticket voor nieuwe gebruikers om deel te nemen aan het marathon evenement. U kunt ook uw RunBlox wallet adres verstrekken als een uitnodigingscode. Hoe meer gebruikers u uitnodigt, hoe meer gratis schoenen u kunt krijgen. U kunt maximaal nog drie gratis marathon schoenen krijgen. Eén marathon schoen geeft u twee energieën om te starten. Hoe meer schoenen u heeft in uw RunBlox APP, hoe meer energie u kunt krijgen, wat u zal helpen om uw $RUX capaciteit te maximaliseren.</p>
<h3 id="h3-Vraag20520Wat20zijn20de20recente20partnerschappen20van20OpenBlox934652"><a name="Vraag 5: Wat zijn de recente partnerschappen van OpenBlox?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 5: Wat zijn de recente partnerschappen van OpenBlox?</h3><p><strong>Nik</strong>: Afgezien van een aantal goede partnerschappen die we hebben gedaan, is de meest opwindende met een ruimtereiziger en Japanse investeerder genaamd Yusaku Maezawa, ook wel bekend als “Japonese Elon Musk”.<br><img src="https://gimg2.gateimg.com/image/article/16771418914.jpg" alt=""><br>We zijn erg blij dat we het eerste Web3-project in zijn portfolio zijn.</p>
<h3 id="h3-Q620Vertel20ons20meer20over20de20tokenomics20achter20het20project471872"><a name="Q6: Vertel ons meer over de tokenomics achter het project." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Vertel ons meer over de tokenomics achter het project.</h3><p><strong>Nik</strong>: Aangezien we van plan zijn om meerdere spellen en meerdere apps te lanceren, zal de tokenomie een zeer belangrijke rol spelen in het platformecosysteem.<br>Het belangrijkste is om onze gebruikers de flexibiliteit te geven om de tokens binnen ons platform uit te wisselen, zodat ze kunnen genieten van het uitgeven van de beloningen van het ene spel in het andere spel of de andere app.<br>Op dit moment hebben we al een Swap-functie ontwikkeld in de app waar gebruikers meerdere tokens kunnen uitwisselen.<br>Ondertussen is er recentelijk staking en farming beschikbaar op TraderJoe.</p>
<h3 id="h3-Q720Waar20ga20je20de20komende20jaren20naartoe20en20wat20zijn20de20volgende20belangrijke20updates20voor20jou263007"><a name="Q7: Waar ga je de komende jaren naartoe en wat zijn de volgende belangrijke updates voor jou?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Waar ga je de komende jaren naartoe en wat zijn de volgende belangrijke updates voor jou?</h3><p><strong>Nik</strong> Wat betreft de ontwikkeling is een opwindend kortetermijnplan de lancering van de RunBlox-app op de Smart Watch, waarmee de M2E-ervaring naar een hoger niveau wordt getild.<br>Maar de toekomst is opwindend.<br>We zullen de fysieke interactie naar een hoger niveau tillen door veel activiteiten in de echte wereld te creëren, waar de gebruikers zich bij elkaar kunnen voegen om met elkaar te concurreren of evenementen met elkaar te delen.<br>Misschien zelfs beloningen verzamelen op specifieke locaties, waar ze zelfs andere RunBlox-gebruikers zullen ontmoeten.<br>Omdat we deze week over LootBox praten, wilde ik met jullie delen dat we zelfs een aantal coole beloningen kunnen hebben die verbonden zijn met ons dagelijks leven, zoals kortingen op verschillende sportmerken.<br><img src="https://gimg2.gateimg.com/image/article/16771416635.png" alt=""><br>Dit zijn enkele ideeën die we plannen, maar ik wil u verzekeren dat de toekomst erg spannend is en dat de vroege supporters zeker degenen zullen zijn die het meeste profiteren.</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 standpunten 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 gevallen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>