R2F0ZS5pbyBBTUEgY29uIEJvdmluZVZlcnNlIC0gVW5hIHBpYXR0YWZvcm1hIGRpIGdpb2NvIE1ldGF2ZXJzZSBHZW5lc2lzIEZpKyBHYXRlLmlvIEFNQSBjb24gQm92aW5lVmVyc2UgLSBVbmEgcGlhdHRhZm9ybWEgZGkgZ2lvY28gTWV0YXZlcnNlIEdlbmVzaXMgRmkr

<p><img src="https://gimg2.gateimg.com/image/article/167765532111.jpeg" alt=""><br><strong>Ora: 23 agosto 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 Anna, CMO di BovineVerse 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://www.bovine-verse.games/" rel="nofollow noopener noreferrer" target="_blank">https://www.bovine-verse.games/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/BovineVerse" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/BovineVerse</a></strong></p>
<p><strong>Segui BovineVerse su <a href="https://discord.com/invite/bovineverse" rel="nofollow noopener noreferrer" target="_blank">Discord</a> e <a href="https://t.me/Bovine_Verse_Official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/167765545112.jpg" alt=""><br><strong>Anna Alumbaiva - CMO a BovineVerse</strong><br>Mi sono unito al grande team di BovineVerse a febbraio per aiutare a espandere il mercato estero e la costruzione del marchio di mercato. Prima lavoravo in una società di giochi in Kazakistan come direttore marketing per circa due anni. Ho scoperto BV in un incontro criptato, il progetto è stato eseguito in modo molto professionale e aveva anche una visione di sviluppo molto chiara. Pertanto, ho deciso di iniziare la mia carriera <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> da BovineVerse.</p>
<h2 id="h2-Domande20e20risposte20da20Gateio37856"><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-Q120Potresti20presentare20il20progetto20inizialmente958336"><a name="Q1: Potresti presentare il progetto inizialmente?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti presentare il progetto inizialmente?</h3><p><strong>Anna</strong>: BovineVerse è una piattaforma di gioco metaversale di genesis Fi+ sotto Web 3.0 con giochi on-chain e sistema di previsioni sportive, integrando profondamente Defi, Gamefi e Socialfi, progettata con molteplici asset NFT, fornendo agli utenti elevata flessibilità e pieno controllo sulla propria identità nel mondo virtuale.<br>Attualmente ci sono 3 mondi paralleli multipli in BovineVerse, Interstellar Rangeland, Interstellar Trek e Interstellar Sandbox. Il primo gioco, Interstellar Rangeland, ha appena lanciato la sua open beta su <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>. È pieno svolgimento in questo momento. Il secondo gioco Interstellar Trek è attualmente in fase di sviluppo. E il terzo gioco Interstellar Sandbox è ispirato a Minecraft. A causa del tempo limitato, non mi addentrerò troppo su questi due giochi oggi. Se qualcuno è interessato, maggiori dettagli possono essere trovati sul nostro sito ufficiale o sul nostro Gitbook.</p>
<p><a href="https://www.bovine-verse.games/" rel="nofollow noopener noreferrer" target="_blank">https://www.bovine-verse.games/</a></p>
<p><a href="https://doc-en.bovine-verse.games/part-01-welcome/about-the-project" rel="nofollow noopener noreferrer" target="_blank">https://doc-it.bovine-verse.games/part-01-welcome/about-the-project</a></p>
<p>In BovineVerse, i giocatori si incarnano come bovini interstellari per stabilire gilde, saccheggiare stelle, gestire la propria attività (fattoria), allevare vitelli, prestare bovini premium per l’allevamento, puntare mucche per la mungitura, godersi le corride in Arena, ecc. Ci saranno molti modi per guadagnare BVT o BVG! Se segui i nostri principali media, vedrai persone che seguono e studiano il progetto ogni giorno e che addirittura formano team per giocare insieme. Inoltre, il team del progetto include esperti di tutto il mondo, con una forte esperienza lavorativa nel campo del GameFi.</p>
<p>Abbiamo un obiettivo a lungo termine di creare una festa multigioco.</p>
<p>Non stiamo solo attirando gli appassionati di giochi per godersi il primo gioco Fi+, ma anche incentivando gli sviluppatori di giochi tradizionali a passare senza soluzione di continuità allo sviluppo di giochi decentralizzati, unirsi alla piattaforma e costruire il proprio ecosistema. Quindi costruiamo!</p>
<h3 id="h3-Q220Rispetto20ad20altri20giochi20blockchain20sul20mercato20cosa20distingue20BV20dal20resto20Come20potete20garantire20la20qualit20del20gioco20e20la20fedelt20degli20utenti468061"><a name="Q2: Rispetto ad altri giochi blockchain sul mercato, cosa distingue BV dal resto? Come potete garantire la qualità del gioco e la fedeltà degli utenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Rispetto ad altri giochi blockchain sul mercato, cosa distingue BV dal resto? Come potete garantire la qualità del gioco e la fedeltà degli utenti?</h3><p><strong>Anna</strong>: Molti progetti Gamefi stanno emergendo anche in un mercato orso! Quindi abbiamo fatto grandi sforzi per farci risaltare! Ci sono diverse caratteristiche principali di BovineVerse, per competere tra gli altri progetti.</p>
<p>La interoperabilità multi-chain degli asset NFT è inarrestabile sulla piattaforma. In futuro, quando rilasceremo giochi uno dopo l’altro, tutti gli NFT sulla piattaforma saranno interoperabili.</p>
<p>Tassazione<br>Interstellar Rangeland è il primo gioco di battaglia che prevede la tassazione. Pagare le tasse è responsabilità di tutti i membri della gilda per una migliore governance e comunità. Oppure, dopo aver ottenuto il pianeta e diventare il presidente della gilda, il presidente otterrà il 70% del ricavato fiscale della gilda, e i membri della gilda continueranno a fare contributi fiscali al pianeta/gilda durante il processo di mining e battaglia, gioco-per-guadagnare. Come detentore della gilda, il periodo di rimborso è relativamente breve.</p>
<p>Integrazione approfondita di SocialFi.<br>Sfrutta le connessioni sociali per guadagnare di più e, allo stesso tempo, le amicizie dei giocatori e le relazioni sindacali nel gioco sono interconnesse in tutti i giochi sulla piattaforma, per aiutare al massimo il sindacato offline a ottenere la massima retention degli utenti.</p>
<p>Controllo della popolazione<br>Abbiamo effettuato un controllo scientifico della popolazione nel gioco. I nostri bovini vivranno solo per 30 giorni.</p>
<p>P2E in the futuro non sarà più difficile</p>
<p>—–Ottimizzazione genetica<br>il bestiame di origine può ottenere un upgrade di attributi</p>
<p>–Pioniere del concetto Fi+<br>BovineVerse integra DeFi+GameFi+SocialFi e ha un ricco e colorato ecosistema NFT integrato, che soddisfa ampiamente le esigenze degli utenti per finanza decentralizzata, giochi e social network, e aiuta gli utenti ad adattarsi senza soluzione di continuità al portale Web3.</p>
<p>Queste sono solo alcune delle principali caratteristiche del gioco, abbiamo ancora delle sorprese che scoprirete nel gioco. Questi punti salienti garantiranno la qualità del gioco, la fedeltà degli utenti e la giocabilità, aiutandoci a salire in cima agli altri progetti.</p>
<h3 id="h3-Q320Potrebbe20darci20un20aggiornamento20sugli20sviluppi20in20corso26818"><a name="Q3: Potrebbe darci un aggiornamento sugli sviluppi in corso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Potrebbe darci un aggiornamento sugli sviluppi in corso?</h3><p><strong>Anna</strong>: Ecco elencati alcuni sviluppi eccezionali.</p>
<ol>
<li><p>Innanzitutto, dal termine di luglio, BovineVerse ha ufficialmente lanciato il primo gioco della piattaforma di gioco, Interstellar Rangeland public beta, e in una settimana ci sono state oltre 100.000 indirizzi che hanno richiesto asset sul sito web.</p>
</li><li><p>Dopo due round privati di finanziamento, ricevendo investimenti da <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a>, Progetto Galaxy, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> Con l’aiuto di CoinFund, Coin98 e altre importanti istituzioni, stiamo per concludere il round con una valutazione di 48 milioni. Penso che sia un risultato piuttosto buono in un mercato in ribasso.</p>
</li><li><p>Siamo estremamente entusiasti di annunciare la grande notizia che - l’IDO di BovineVerse su DODO e POOlZ sono stati entrambi venduti con successo al 100% in 10 minuti! L’IDO su DoDo ha addirittura raccolto oltre il 240%. E che meravigliosa notizia! Pensiamo che questo IDO sia una mossa monumentale sia per noi che per la nostra comunità, e crediamo fortemente che il nostro ecosistema otterrà più visibilità da questo avvenimento storico.</p>
</li><li><p>I NFT saranno elencati sul mercato Binance NFT a settembre</p>
</li><li><p>La scorsa settimana siamo stati invitati a promuovere il progetto nella comunità persiana di Binance e abbiamo avuto un concorso hackathon che è stato trasmesso anche nello studio live di Binance con grande attenzione.</p>
</li></ol>
<h3 id="h3-Q420Potresti20darci20una20panoramica20della20Tokenomics20e20dellutilit20di20BVT788425"><a name="Q4: Potresti darci una panoramica della Tokenomics e dell’utilità di BVT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Potresti darci una panoramica della Tokenomics e dell’utilità di BVT?</h3><p><strong>Anna</strong>:<br>Nel BovineVerse ci sono due tipi di token, BVG e BVT.<br>I token BVG vengono ottenuti generandoli direttamente dal sistema, partecipando al gioco, ricevendo airdrop, effettuando mining, staking, PVE, ecc. Possono essere utilizzati per acquistare oggetti di gioco e per eseguire transazioni, aggiornare la fattoria, ecc. Puoi considerare BVG come un ‘consumabile quotidiano’ nella versione attuale del gioco. Nel caso di quotazione di BVG, è già su Pancake, aggiungeremo liquidità dopo la quotazione di BVT.</p>
<p>BVT è il nostro token di governance con un’offerta totale di 1 miliardo, dotato di un meccanismo deflazionario</p>
<p>Ecco un riassunto di $BVT Utility<br>Mining di liquidità / Acquisto di beni da gioco / Pagamento delle attività in-game / Aggiornamento degli attributi di gioco / Scambio nel Marketplace / Voti per DAO</p>
<h3 id="h3-Q520Quali20sono20secondo20te20i20vantaggi20di20detenere20BVT20come20investimento20a20lungo20termine191882"><a name="Q5: Quali sono, secondo te, i vantaggi di detenere BVT come investimento a lungo termine?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quali sono, secondo te, i vantaggi di detenere BVT come investimento a lungo termine?</h3><p><strong>Anna</strong>:</p>
<ol>
<li><p>BVT è il nostro token di governance con un’offerta totale di 1 miliardo, con un meccanismo deflazionistico. In futuro, man mano che i giochi saranno lanciati uno dopo l’altro, BVT sarà inarrestabile in tutta la piattaforma, garantendo costantemente una valutazione elevata di BVT.</p>
</li><li><p>Dopo che il gioco -InterstellarRangeland è ufficialmente lanciato a settembre, la quantità di BVT sta per essere consumata, bruciando attraverso la riproduzione, la costruzione di un nuovo pianeta e il livellamento del pianeta (gilda), ecc. Di conseguenza, la domanda di BVT aumenterà, garantendo ulteriormente che il prezzo aumenti.</p>
</li><li><p>Abbiamo anche una rete di protocolli sottostanti che supportano il BV. Fornisce un’API facile da usare che consente agli sviluppatori on-chain di distribuire facilmente i loro giochi e ai giocatori di accedervi con commissioni di gas più basse. Fornisce un ampio database standardizzato e introduce funzionalità estensibili, che saranno uno strumento importante per aiutare a espandere la piattaforma. Aiuta gli sviluppatori tradizionali a distribuire i loro giochi e garantisce la sopravvivenza a lungo termine del progetto e il mantenimento del prezzo del token.</p>
</li></ol>
<h3 id="h3-Q620Come20pensi20che20la20meccanica20di20gioco20possa20mantenere20lattenzione20del20pubblico78359"><a name="Q6: Come pensi che la meccanica di gioco possa mantenere l’attenzione del pubblico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Come pensi che la meccanica di gioco possa mantenere l’attenzione del pubblico?</h3><p><strong>Anna</strong>: Altre campagne possono essere trovate sul nostro DC e Twitter, ti invierò un <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> più tardi!</p>
<p>Le caratteristiche del gioco e i modelli di costruzione di Web3 che ho menzionato in precedenza sono le caratteristiche più insolite di BV. Oltre a queste, qui elenco qualche altra cosa.</p>
<ol>
<li><p>Abbiamo un meccanismo fiscale molto innovativo che consente a tutti di partecipare veramente al modello economico di BV. Il presidente dei pianeti (guide) gode del 20% di tasse, il che significa che tutti i redditi generati sul pianeta vengono tassati dal presidente. I diversi tipi di pianeti hanno diversi limiti di popolazione e tassi di imposta. I pianeti possono anche saccheggiarsi a vicenda. Ci sono partite di classifica ogni stagione e i pianeti in cima alla classifica hanno anche premi aggiuntivi.</p>
</li><li><p>I giocatori appassionati di combattimento possono partecipare alle corride, come le battaglie PVP, la partita normale, la partita classificata e GVG per guadagnare BVT</p>
</li><li><p>I giocatori non hanno abbastanza tempo per giocare nel gioco ogni giorno in grado di scommettere NFT per il mining</p>
</li></ol>
<p>Abbiamo integrato una varietà di meccanismi di gioco in un unico sistema, per fare in modo che i giocatori rimangano dipendenti dal gioco. Dal reclamo di token tramite il nostro sito web, fino alla creazione dei propri token durante il gioco, assicuriamo la fedeltà dell’utente in questo modo.</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. La ripubblicazione dell'articolo sarà consentita a condizione che sia fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>