R2F0ZS5pbyBBTUEgbWV0IENyeXB0b0NhcnMgLSBXaW4gcmFjZXMgb20gZXJ2YXJpbmdzcHVudGVuIGVuIG1hdGVyaWFsZW4gdGUga3Jpamdlbg==

<p><img src="https://gimg2.gateimg.com/image/article/16862936021.jpeg" alt=""><br><strong>Tijd: 17 december 2021, 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 Bao Thai, CPO van CryptoCars 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://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>Volg CryptoCars op <a href="https://twitter.com/cryptocarsgame" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio247310"><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-Q120Kunt20u20alstublieft20uw20team20en20het20CryptoCarsproject20aan20de20gemeenschap20introduceren20om20meer20te20weten20te20komen5669"><a name="Q1: Kunt u alstublieft uw team en het CryptoCars-project aan de gemeenschap introduceren om meer te weten te komen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u alstublieft uw team en het CryptoCars-project aan de gemeenschap introduceren om meer te weten te komen?</h3><p><strong>Bao</strong>: Hallo Gate.io gemeenschap, ik ben erg blij hier te zijn en met jullie allemaal te delen over ons project - CryptoCars - dat recentelijk op Gate Exchange is genoteerd, zoals jullie misschien weten.</p>
<p>Voordat ik naar de introductie van het project ga, wil ik mezelf en mijn teamgenoten voorstellen.</p>
<p>Ik ben Bảo Thái, Chief Product Officer bij CryptoCars. Ik ben geboren in Vietnam, mijn specialisatie aan de Foreign Trade University was Accounting en Auditing, wat voor mij een perfecte basis creëerde op het gebied van Economie en Financiën, die ik elke dag gebruik om onze projecten te verbeteren.</p>
<p>Ik ben trots om deel uit te maken van het uiterst getalenteerde en gepassioneerde CryptoCars-team.</p>
<p>Onze CEO en oprichter, Ly Tran, begon zijn carrière als Full Stack Web Developer en ging later over op het ontwikkelen van mobiele applicaties. Daarna bouwde hij een team van gepassioneerde jonge professionals om verschillende onafhankelijke blockchain-projecten te starten.<br><img src="https://gimg2.gateimg.com/image/article/16862937822.jpg" alt=""><br>En er zijn ook andere leden die een belangrijke rol spelen in onze projecten, je kunt meer informatie vinden op onze website.</p>
<h3 id="h3-Q220En20heel20openbaar20Goed20om20te20weten20dat20dit20zeker20vertrouwen20genereert20Dus20hoe20is20het20concept20tot20stand20gekomen20Waarom20heb20je20CryptoCars20gemaakt818915"><a name="Q2: En heel openbaar! Goed om te weten dat dit zeker vertrouwen genereert! Dus, hoe is het concept tot stand gekomen? Waarom heb je CryptoCars gemaakt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: En heel openbaar! Goed om te weten dat dit zeker vertrouwen genereert! Dus, hoe is het concept tot stand gekomen? Waarom heb je CryptoCars gemaakt?</h3><p><strong>Bao</strong>: Ik wil het hebben over de reden voor de oprichting van CryptoCars.</p>
<p>Het heeft te maken met onze gemeenschappelijke liefde voor auto’s. We houden van auto’s, wie niet, toch?</p>
<p>We hadden ook veel motivatie om een ​​spelproject te creëren op basis van blockchaintechnologie. CryptoCars is het eerste racespel op Binance Smart Chain waar spelers unieke auto’s kunnen bezitten, deelnemen aan de race en genieten van een meeslepende, echte race-ervaring, en tegelijkertijd waardevolle $CCAR-tokens verdienen.<br><img src="https://gimg2.gateimg.com/image/article/16862938303.jpg" alt=""><br>We hebben verschillende spelmodi gemaakt waar iedereen van kan genieten: PVC, PVF en binnenkort PVP.</p>
<p>Als speler in CryptoCars is jouw missie om races te winnen om ervaringspunten en materialen te verdienen. Om deel te nemen aan een race, moeten auto’s dagelijks worden bijgetankt.<br><img src="https://gimg2.gateimg.com/image/article/16862938184.jpg" alt=""><br>Je kunt ook items kopen en aan je auto vastmaken om hem te upgraden en daardoor meer beloningen te verdienen.<br>Items en auto’s zijn verhandelbaar op onze eigen marktplaats.</p>
<h3 id="h3-Q320En20wat20betreft20mijlpalen20Welke20andere20mijlpalen20heb20je20tot20nu20toe20bereikt918573"><a name="Q3: En wat betreft mijlpalen… Welke andere mijlpalen heb je tot nu toe bereikt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: En wat betreft mijlpalen… Welke andere mijlpalen heb je tot nu toe bereikt?</h3><p><strong>Bao</strong>: Ja, zoals je kunt zien, hebben we tot nu toe meer dan 500.000 gebruikers bereikt.</p>
<p>Dat zijn een half miljoen actieve spelers in het spel.</p>
<p>CryptoCars is nu erg populair in Vietnam in vergelijking met andere vroege projecten, we hebben een vaste reputatie en worden door veel groepen zoals Beng Beng Gaming, Ancient8 gekend.</p>
<p>CryptoCars is ook genoteerd op Coingecko en Coinmarketcap, Pancake voor kopen en verkopen; En bovendien hebben we een grote gemeenschap met meer dan 80.000 leden in het Global Channel en vele lokale groepen zoals PH, Thailand, Vietnam, Spaanstalige landen…</p>
<p>Nog iets waarover ik zou willen praten, is onze technologie.</p>
<p>Je kunt zien hoe we 47.000.000 miljoen USD hebben bespaard voor gebruikers!</p>
<p>We gebruiken BigchainDB, een blockchain technologie die Cryptocars spelers in staat stelt om geen gas kosten te betalen bij het spelen, wat de winst voor spelers verhoogt.<br><img src="https://gimg2.gateimg.com/image/article/16862938435.jpg" alt=""><br>Naast de spelmodus (Virtual Race) op pc, hebben we andere spelmodi zoals PvC, PvP, Car betting voor entertainment … en deze worden bijgewerkt volgens de routekaart. Ja, we brengen altijd een nauwkeurige routekaart voor gebruikers.</p>
<p>Nog iets dat maar weinig NFT-projecten kunnen doen, heeft te maken met apps. Op 15 september hebben we een app gelanceerd voor smartphones (inclusief Android en iOS).</p>
<p>Dit zal een grote pluspunt zijn voor CryptoCars.</p>
<h3 id="h3-Vraag20420Wat20is20de20visie20die20Cryptocars20heeft602662"><a name="Vraag 4: Wat is de visie die Cryptocars heeft?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 4: Wat is de visie die Cryptocars heeft?</h3><p><strong>Bao</strong>: Eerst praten we over de visie die we altijd nastreven, we geven altijd prioriteit aan het creëren van een balans tussen inkomsten en uitgaven.</p>
<p>Het beste bewijs om het evenwicht te bewijzen, is om onze spelers en supporters te laten zien dat we het bijna 4 maanden hebben ‘overleefd’ en nog steeds groeien in vergelijking met veel ‘dode spellen’ van dezelfde leeftijd als wij.</p>
<p>Maar daar stopt het niet, we reageren altijd op hun meningen en behoeften door functies zoals Fuel, Color Changes, Staking level, Quick Race te lanceren om meer voordelen voor hen te brengen. In de toekomst zullen we meer inspanningen leveren om de beste functies en game-ervaringen naar spelers te brengen.</p>
<p>Het tweede waar ons team aan werkt, is het creëren van een <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> tussen al onze drie huidige projecten.<br>Misschien omdat sommige spelers nog steeds niet echt begrijpen wat we doen en een klein deel van hen denkt dat we een derde project zullen lanceren met andere voertuigen.</p>
<p>Gebruikers begrijpen dat het lijkt alsof we een andere kopie van onszelf creëren, maar nee, dat is niet wat we hier bedoelen en dat zullen we ook nooit doen. Dit is ook de reden waarom CryptoCity Metaverse Story is vrijgegeven.<br>Op onze whitepaper moeten jullie het lezen…</p>
<p>Je kunt zien dat we ernaar streven dat spelers de verbinding tussen de projecten duidelijker zien</p>
<h3 id="h3-Q520Dat20is20erg20innovatief20Laten20we20het20nu20hebben20over20Beveiliging20het20is20echt20belangrijk20voor20een20NFTproject20om20hun20spelers20te20beschermen20tegen20het20verliezen20van20hun20fondsen20Hoe20heeft20CCAR20dat20tot20nu20toe20gedaan113476"><a name="Q5: Dat is erg innovatief!!!! Laten we het nu hebben over Beveiliging, het is echt belangrijk voor een NFT-project om hun spelers te beschermen tegen het verliezen van hun fondsen. Hoe heeft CCAR dat tot nu toe gedaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Dat is erg innovatief!!!! Laten we het nu hebben over Beveiliging, het is echt belangrijk voor een NFT-project om hun spelers te beschermen tegen het verliezen van hun fondsen. Hoe heeft CCAR dat tot nu toe gedaan?</h3><p><strong>Bao</strong>: Ik hoop dat iedereen blijft genieten van de komende hoofdstukken van deze serie en zeker in de toekomst. In de toekomst zal ons team proberen om je de stripversie van CryptoCity Metaverse te brengen, momenteel is alles geleidelijk geschetst zodat spelers gemakkelijk de plot van alle 3 spellen kunnen visualiseren en begrijpen.<br><img src="https://gimg2.gateimg.com/image/article/16862938696.jpg" alt=""><br>Dit zou een geweldige stap voor ons zijn om onze gemeenschap te erkennen, niet alleen maar een ‘klik om te verdienen’ model of gewoon een normaal voertuig. We streven naar iets groters, een ecosysteem en een ‘echte Metaverse’.</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>