R2F0ZS5pbyBBTUEgY29uIENyeXB0b0NhcnMtVmluY2kgbGUgY29yc2UgcGVyIG90dGVuZXJlIHB1bnRpIGVzcGVyaWVuemEgZSBtYXRlcmlhbGk=

<p><img src="https://gimg2.gateimg.com/image/article/16862936021.jpeg" alt=""><br><strong>Ora: 17 dicembre 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 Bao Thai, CPO di CryptoCars nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web Ufficiale: <a href="https://cryptocars.me/" rel="nofollow noopener noreferrer" target="_blank">https://cryptocars.me/</a></strong><br><strong>Twitter: <a href="https://twitter.com/cryptocarsgame" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/cryptocarsgame</a></strong><br><strong>Segui CryptoCars su <a href="https://twitter.com/cryptocarsgame" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong></p>
<h2 id="h2-QampA20da20Gateio107706"><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-Q120Potresti20per20favore20presentare20il20tuo20team20e20il20progetto20CryptoCars20alla20comunit20per20saperne20di20pi913239"><a name="Q1: Potresti per favore presentare il tuo team e il progetto CryptoCars alla comunità per saperne di più?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti per favore presentare il tuo team e il progetto CryptoCars alla comunità per saperne di più?</h3><p><strong>Bao</strong>: Ciao comunità di Gate.io, sono davvero felice di essere qui e condividere con tutti voi il nostro progetto - CryptoCars - che è stato recentemente quotato su Gate Exchange, come potreste sapere.</p>
<p>Prima di passare all’introduzione del progetto, vorrei presentarmi e presentare i miei compagni di squadra.</p>
<p>Sono Bảo Thái, Chief Product Officer di CryptoCars. Sono nato in Vietnam, la mia specializzazione all’Università del Commercio Estero era la contabilità e la revisione contabile che hanno creato per me una base perfetta per l’economia e la finanza che sto utilizzando per migliorare i nostri progetti ogni giorno.</p>
<p>Sono orgoglioso di far parte del team di CryptoCars, che è composto da persone estremamente talentuose e appassionate.</p>
<p>Il nostro CEO e fondatore, Ly Tran, ha iniziato la sua carriera come sviluppatore web full stack, per poi passare allo sviluppo di applicazioni mobili in seguito. Dopo di che, ha creato un team di giovani professionisti appassionati per iniziare a creare vari progetti indipendenti di blockchain.<br><img src="https://gimg2.gateimg.com/image/article/16862937822.jpg" alt=""><br>E ci sono altri membri che svolgono un ruolo importante nei nostri progetti, potresti voler vedere di più sul nostro sito web.</p>
<h3 id="h3-Q220E20molto20pubblico2020bello20sapere20che20questo20genera20sicurezza20Quindi20come2020nato20il20concetto20Perch20hai20creato20CryptoCars950381"><a name="Q2: E molto pubblico! È bello sapere che questo genera sicurezza! Quindi, come è nato il concetto? Perché hai creato CryptoCars?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: E molto pubblico! È bello sapere che questo genera sicurezza! Quindi, come è nato il concetto? Perché hai creato CryptoCars?</h3><p><strong>Bao</strong>: Voglio parlare del motivo per cui sono state istituite le CryptoCars.</p>
<p>È legato al nostro amore comune per le auto. Amiamo le auto, chi non lo fa, vero?</p>
<p>Abbiamo avuto molta motivazione anche per creare un progetto di gioco basato sulla tecnologia blockchain. CryptoCars è il primo gioco di corse su Binance Smart Chain dove i giocatori possono possedere auto uniche, partecipare alla gara e godersi un’esperienza di corse reale e coinvolgente, allo stesso tempo, guadagnando preziosi token $CCAR.<br><img src="https://gimg2.gateimg.com/image/article/16862938303.jpg" alt=""><br>Abbiamo creato vari modalità di gioco per far divertire tutti: PVC, PVF e presto PVP.</p>
<p>Come giocatore in CryptoCars, la tua missione è vincere le gare per ottenere punti esperienza e materiali. Per partecipare a una gara, le auto devono essere rifornite quotidianamente.<br><img src="https://gimg2.gateimg.com/image/article/16862938184.jpg" alt=""><br>È possibile acquistare e allegare oggetti per aggiornare la tua auto e quindi guadagnare più ricompense.<br>Gli oggetti e le auto sono negoziabili sul nostro Marketplace.</p>
<h3 id="h3-Q320E20parlando20di20traguardi20Quali20altri20traguardi20hai20raggiunto20finora798454"><a name="Q3: E parlando di traguardi… Quali altri traguardi hai raggiunto finora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: E parlando di traguardi… Quali altri traguardi hai raggiunto finora?</h3><p><strong>Bao</strong>: Sì, come puoi vedere, finora abbiamo raggiunto oltre 500.000 utenti.</p>
<p>Che è la metà dei milioni di giocatori in gioco.</p>
<p>CryptoCars al momento è piuttosto popolare in Vietnam rispetto ad altri progetti precoci, abbiamo una reputazione consolidata e siamo conosciuti da molti gruppi come Beng Beng Gaming, Ancient8.</p>
<p>CryptoCars è stato anche elencato su Coingecko e Coinmarketcap, Pancake per acquisto e vendita; E inoltre, abbiamo una grande comunità con oltre 80.000 membri in Global Channel e molti gruppi locali come PH, Thailandia, Vietnam, paesi di lingua spagnola…</p>
<p>Un’altra cosa di cui vorrei parlare è la nostra tecnologia.</p>
<p>Puoi vedere come abbiamo risparmiato 47.000.000 milioni di USD per gli utenti!</p>
<p>Utilizziamo BigchainDB, una tecnologia blockchain che consente ai giocatori di Cryptocars di non dover pagare commissioni di gas durante il gioco, il che aiuta ad aumentare i profitti per i giocatori.<br><img src="https://gimg2.gateimg.com/image/article/16862938435.jpg" alt=""><br>Oltre alla modalità di gioco (Virtual Race) su pc, abbiamo altre modalità di gioco come PvC, PvP, scommesse sulle auto per l’intrattenimento… e saranno aggiornate secondo la roadmap<br>Sì, portiamo sempre una roadmap accurata per gli utenti.</p>
<p>Un’altra cosa che pochi progetti NFT possono fare riguarda le app. Il 15 settembre abbiamo lanciato un’app per smartphone (inclusi Android e iOS).</p>
<p>Questo sarà un grande vantaggio per CryptoCars.</p>
<h3 id="h3-Q420Qual2020la20visione20che20Cryptocars20ha230748"><a name="Q4: Qual è la visione che Cryptocars ha?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Qual è la visione che Cryptocars ha?</h3><p><strong>Bao</strong>: Prima di parlare della visione che cerchiamo sempre di perseguire, diamo sempre la priorità a creare un equilibrio tra l’entrata e l’uscita di denaro.</p>
<p>La migliore prova per dimostrare l’equilibrio è mostrare ai nostri giocatori e sostenitori che abbiamo “sopravvissuto” così per quasi 4 mesi e stiamo ancora crescendo rispetto a molti “giochi morti” della stessa età che noi.</p>
<p>Non ci fermiamo qui, rispondiamo sempre alle loro opinioni e necessità lanciando funzionalità come Fuel, Cambi di Colore, Livello di Stake, Gara Veloce per offrire loro ulteriori vantaggi. In futuro, faremo ulteriori sforzi per portare ai giocatori le migliori funzionalità e esperienze di gioco.</p>
<p>La seconda cosa su cui il nostro team sta lavorando è creare un <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> tra tutti e tre i nostri attuali progetti. Forse perché alcuni giocatori ancora non capiscono davvero cosa stiamo facendo e una piccola parte di loro pensa che lanceremo un terzo progetto coinvolgente altri veicoli.</p>
<p>Gli utenti capiscono che è come se stessimo creando un’altra copia di noi stessi, ma no, non è quello che intendiamo qui e non lo faremo mai. Questo è anche il motivo per cui è stata rilasciata la CryptoCity Metaverse Story. Nel nostro whitepaper, dovete leggerlo…</p>
<p>Puoi vedere quello che stiamo cercando di far vedere ai giocatori in modo più chiaro il collegamento tra i progetti</p>
<h3 id="h3-Q520Questa2020davvero20innovativa20Ora20parliamo20di20sicurezza2020davvero20importante20per20un20progetto20NFT20proteggere20i20loro20giocatori20dal20perdere20i20loro20fondi20Come20ha20fatto20CCAR20fino20ad20ora967976"><a name="Q5: Questa è davvero innovativa!!!! Ora parliamo di sicurezza, è davvero importante per un progetto NFT proteggere i loro giocatori dal perdere i loro fondi. Come ha fatto CCAR fino ad ora?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Questa è davvero innovativa!!!! Ora parliamo di sicurezza, è davvero importante per un progetto NFT proteggere i loro giocatori dal perdere i loro fondi. Come ha fatto CCAR fino ad ora?</h3><p><strong>Bao</strong>: Spero che tutti continueranno a godersi i prossimi capitoli di questa serie e sicuramente in futuro. In futuro, il nostro team cercherà di portarti la versione a fumetti di CryptoCity Metaverse, attualmente tutto è stato gradualmente delineato in modo che i giocatori possano facilmente visualizzare e comprendere la trama di tutti e 3 i giochi.<br><img src="https://gimg2.gateimg.com/image/article/16862938696.jpg" alt=""><br>Questo sarebbe un grande passo per noi per riconoscere la nostra comunità, non solo un modello di “clicca per guadagnare” o solo un veicolo normale. Miriamo a qualcosa di più grande, un ecosistema e una “vera Metaverse”.</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 riposting dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>