R2F0ZS5pbyBBTUEgY29uIEdBTUVFLUJsb2NrY2hhaW4gaW5jb250cmEgbCdpbnRyYXR0ZW5pbWVudG8gbW9iaWxl

<p><img src="https://gimg2.gateimg.com/image/article/16823164851.jpg" alt=""><br><strong>Tempo: 24 marzo 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 Bozena Rezab, CEO, Co-Fondatore di GAMEE in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a>.</strong><br><strong>Sito Web ufficiale: <a href="https://www.gamee.com/token" rel="nofollow noopener noreferrer" target="_blank">https://www.gamee.com/token</a></strong><br><strong>Twitter: <a href="https://twitter.com/GAMEEToken" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/GAMEEToken</a></strong><br><strong>Segui GAMEE su <a href="https://discord.com/invite/gamee" rel="nofollow noopener noreferrer" target="_blank">Discordia</a> e <a href="https://twitter.com/GAMEEToken" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16823166912.png" alt=""><br><strong>Bozena Rezab - CEO&amp;Co-Fondatrice di GAMEE</strong></p>
<p>Bozena Rezab è CEO e co-fondatrice di GAMEE, una piattaforma ad alta interazione che rappresenta la nuova frontiera dei giochi mobili nel metaverso, connettendo giocatori, marchi e comunità <a href="/web3" target="_blank" class="blog_inner_link">web3</a> nel gioco. Nel 2022, l’azienda ha attirato 2,5 milioni di giocatori su web3 e l’app Arc8 è una delle principali app decentralizzate al mondo. GAMEE conta su una base globale di 40 milioni di utenti, inserita da Marketing Week tra i 100 brand più disruptivi. L’azienda fa parte della famiglia Animoca Brands, leader globale nel settore dei giochi blockchain. Il ruolo di Bozena è quello di promuovere la strategia di GAMEE, introducendo i diritti di proprietà digitali e il valore della blockchain al pubblico dei giocatori. Prima di GAMEE, era responsabile della crescita di YouTube nei mercati europei.</p>
<h2 id="h2-Domande20e20risposte20da20Gateio915871"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Potresti20presentarti20e20il20progetto20per20favore566433"><a name="Q1: Potresti presentarti e il progetto per favore?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti presentarti e il progetto per favore?</h3><p><strong>Bozena</strong>: Sono uno dei co-fondatori e CEO di GAMEE.<br><img src="https://gimg2.gateimg.com/image/article/16823167513.jpg" alt=""><br>GAMEE si concentra sul gioco mobile, giochi in stile casual, abbiamo una enorme comunità globale di 40 milioni di giocatori. Le nostre stelle brillanti sono Arc8 App - competizioni con ricompense crittografiche, ovviamente il gioco mobile.</p>
<p>E G-Bots, il nostro contributo al metaverso, sono personaggi di gioco giocabili con tonnellate di utilità.</p>
<p>Questa è ArC8, la migliore Dapp su Gate.io <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> <a href="https://www.gamee.com/arc8" rel="nofollow noopener noreferrer" target="_blank">https://www.gamee.com/arc8</a></p>
<p>Ecco i nostri G-Bot! <a href="https://www.gamee.com/gbots" rel="nofollow noopener noreferrer" target="_blank">https://www.gamee.com/gbots</a></p>
<h3 id="h3-Q220Cosa20ti20ha20fatto20decidere20di20utilizzare20la20blockchain20nella20tua20piattaforma20di20gioco313928"><a name="Q2: Cosa ti ha fatto decidere di utilizzare la blockchain nella tua piattaforma di gioco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Cosa ti ha fatto decidere di utilizzare la blockchain nella tua piattaforma di gioco?</h3><p><strong>Bozena</strong> Guarda, siamo stati nel settore dei giochi mobili per 8 anni e abbiamo sempre avuto una comunità appassionata che voleva avere un peso nella crescita della piattaforma. Stavamo sperimentando anche con il concetto di gioca e guadagna anche prima della blockchain e siamo stati davvero entusiasti di renderlo ‘reale’.</p>
<p>Quindi prendendo tutto ciò che funziona e piace alla gente sulla nostra piattaforma e portandolo al livello successivo, dando loro la proprietà dei personaggi di gioco, della valuta di gioco che guadagni e puoi scambiare e anche la proprietà della piattaforma stessa.</p>
<p>Lanciando il token GMEE, abbiamo dato il via e stiamo implementando queste idee una dopo l’altra e la gente le adora.</p>
<h3 id="h3-Q320Parliamo20della20roadmap20Cosa20diresti20di20essere20pi20entusiasta20nel20tuo20prossimo20piano20di20lavoro871162"><a name="Q3: Parliamo della roadmap. Cosa diresti di essere più entusiasta nel tuo prossimo piano di lavoro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Parliamo della roadmap. Cosa diresti di essere più entusiasta nel tuo prossimo piano di lavoro?</h3><p><strong>Bozena</strong>: Ora abbiamo Arc8 con 12 giochi e una comunità attiva di giocatori.</p>
<p>La parte più eccitante è che offriremo ai giocatori la possibilità di possedere una parte di Arc8, come Arc8 LAND.</p>
<p>Ciò che non solo permetterà loro di votare, quali giochi saranno ospitati nel loro Arc8 Land, ma anche quali montepremi / sponsor prendere.</p>
<p>E, soprattutto, guadagna anche una parte dei ricavi raccolti nella loro Arc8 Land.</p>
<h3 id="h3-Fino20ad20allora20quale20sarebbe20il20modo20migliore20per20le20persone20di20iniziare20a20giocare20amp20guadagnare20ricompense357839"><a name="Fino ad allora, quale sarebbe il modo migliore per le persone di iniziare a giocare &amp; guadagnare ricompense?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fino ad allora, quale sarebbe il modo migliore per le persone di iniziare a giocare &amp; guadagnare ricompense?</h3><p><strong>Bozena</strong>: Con Arc8 è SUPER facile:<br>Scarica su iOS o Android<br>Gioca ai giochi e guadagna ricompense GMEE<br><a href="https://www.gamee.com/download" rel="nofollow noopener noreferrer" target="_blank">https://www.gamee.com/download</a></p>
<p>Per i giocatori più esperti, il modo migliore è ottenere un G-Bot <a href="https://opensea.io/collection/gbots-gamee" rel="nofollow noopener noreferrer" target="_blank">https://opensea.io/collection/gbots-gamee</a><img src="https://gimg2.gateimg.com/image/article/16823167274.jpg" alt=""><br>E con G-Bot ottieni l’accesso a tornei esclusivi su Arc8, che hanno super bei montepremi.</p>
<h3 id="h3-Q520Lavori20anche20con20concetti20DEFI20nei20tuoi20giochi36833"><a name="Q5: Lavori anche con concetti DEFI nei tuoi giochi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Lavori anche con concetti DEFI nei tuoi giochi?</h3><p><strong>Bozena</strong>: C’è ora un montepremi di 1M GMEE aperto ai proprietari di G-Bot e arriveranno altri eventi durante l’anno.</p>
<p>Defi sì!<br>Una opzione è prendere l’NFT, il G-Bot e guadagnare un token GMEE.</p>
<p>Un’altra opzione - lanciarsi alla fine della prossima settimana, è aggiungere liquidità a GMEE su <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> o Quickswap e scommetti il token LP sul nostro sito web.</p>
<p>Stiamo lanciando premi molto attraenti, soprattutto per il <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygona</a> rete, dato che la maggior parte dei nostri giocatori utilizza GMEE su <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> e vorremmo mostrar loro un po’ di DefI.</p>
<p>L’evento non è ancora in corso, quindi la cosa migliore è seguirci su Twitter: <a href="https://twitter.com/GAMEEToken" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/GAMEEToken</a></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 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>