R3VpZGEgZGVmaW5pdGl2YSBkaSBDYXRpemVuOiBJbXBhcmEgYSBndWFkYWduYXJlIENhdGl6ZW4gQWlyZHJvcHMgY29uIHVuIGFydGljb2xv

2024-07-24, 09:04

<p><img src="https://gimg2.gateimg.com/image/article/1721811256rdzz.jpeg" alt=""></p>
<h2 id="h2-TLDR155750"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Sin dal suo lancio, il gioco dei gatti Catizen ha avuto oltre 26 milioni di utenti registrati e 1,3 milioni di giocatori attivi quotidiani, formando una comunità attiva e migliorando la fedeltà degli utenti.</p>
<p>Questo gioco combina metaverso, GameFi e tecnologia AI per offrire un’esperienza interattiva altamente coinvolgente. I giocatori possono guadagnare ricompense in token attraverso il meccanismo di mining senza investimenti diretti.</p>
<p>Il progetto lancerà il suo primo token $CATI a luglio, cosa che vale la pena di tenere d’occhio da parte di molti giocatori.</p>
<h2 id="h2-I20Cos20Catizen709913"><a name="I. Cos’è Catizen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I. Cos’è Catizen?</h2><p>Catizen è gestito congiuntamente da David Mak e Pierce Tam, co-fondatori di Pluto Studio. È un popolare gioco <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> costruito sulla catena TON. Fornisce ai giocatori un viaggio avventuroso nel Meow Metaverse che combina la cura, la sintesi, il gioco e la guadagna di airdrops.</p>
<p>Il gameplay principale del gioco Catizen ruota attorno allo sviluppo dei personaggi gatto, dove i giocatori guadagnano punti e token migliorando il livello del loro gatto e partecipando alle attività nel gioco. Vale la pena menzionare che il gioco incorpora anche un meccanismo di mining, dove i giocatori possono ottenere ricompense in token attraverso attività senza investimenti diretti. Questo design innovativo aumenta ulteriormente la giocabilità e la partecipazione al gioco.</p>
<p>Alla data di scrittura il gioco ha oltre 26 milioni di giocatori, ha guadagnato 16 milioni di dollari attraverso gli acquisti in-app e ha donato il 1% per il salvataggio dei gatti randagi.</p>
<h2 id="h2-II20Come20partecipare20agli20Airdrops20di20Catizen196909"><a name="II. Come partecipare agli Airdrops di Catizen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>II. Come partecipare agli Airdrops di Catizen</h2><ol>
<li>Cerca @catizenbot su Telegram e clicca su “START” per aprire il gioco.<br><img src="https://gimg2.gateimg.com/image/article/17218120316.png" alt=""></li><li>Dopo aver inserito la pagina principale del gioco, segui le istruzioni per completare lo stadio per principianti, clicca il pulsante del gatto direttamente sotto per acquistare e sfamare 12 gatti.<br><img src="https://gimg2.gateimg.com/image/article/17218120565.png" alt=""></li><li>Il livello iniziale del gatto è il livello 1, che è il numero 1 segnato in alto a destra del gatto nel gioco. I giocatori possono seguire la freccia nel diagramma e trascinare un gatto su un altro gatto dello stesso livello per sintetizzarlo e aumentare il livello. Più avanzato è il gatto, più velocemente può guadagnare punti.<br><img src="https://gimg2.gateimg.com/image/article/17218120784.png" alt=""></li><li>Man mano che il livello aumenta, emergeranno molti nuovi gameplay o strumenti. In fondo al gioco, vediamo altri quattro menu dove gli utenti possono utilizzare il token TON per acquistare monete del pesce nel Negozio (il negozio occasionalmente mostra gatti di alto livello gratuiti), fare clic su Guadagna per completare alcune attività sociali per aumentare i punti, visualizzare i tipi di gatti acquistati in Feed e fare clic su Invita per invitare gli amici a giocare al gioco e ricevere ricompense.<br><img src="https://gimg2.gateimg.com/image/article/17218120963.png" alt=""></li><li>Il gioco occasionalmente presenterà meme di anatre, rane, o <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a>, e i giocatori possono cliccare per ricevere ricompense di airdrop per diversi gatti e monete di gatto $Kitty.<br><img src="https://gimg2.gateimg.com/image/article/17218121202.png" alt=""></li><li>Ci sono anche molte attività interessanti nel gioco, dove i giocatori possono aprire regali casuali, girare la ruota della roulette (SPIN) indovinando le scatole cieche per aumentare le ricompense, il tutto sarà visualizzato in popup grandi e piccoli.<br><img src="https://gimg2.gateimg.com/image/article/17218121381.png" alt=""></li><li>Alcune opzioni di gioco avanzate includono la creazione del proprio club, guadagnare $Fish completando compiti, invitare amici a comprare gatti o andare a pescare e incontrare occasionalmente PNG con bonus di potenziamento. Ad esempio, i giocatori possono fare clic su ‘Auto’ per utilizzare Fish Coin per acquistare varie funzioni di operazione automatica per ridurre il carico di lavoro delle operazioni manuali.<br><img src="https://gimg2.gateimg.com/image/article/17218121587.png" alt=""></li><li>Se vuoi richiedere l’airdrop, collega il tuo spazio TON al tuo portafoglio Telegram e richiedi con successo l’airdrop.</li></ol>
<p>Dopo aver cliccato su Earn, i giocatori possono associare il proprio account Twitter e il portafoglio facendo clic sulla barra orizzontale. <a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON</a> sul lato destro del loro avatar.<br><img src="https://gimg2.gateimg.com/image/article/172181177316.jpeg" alt=""></p>
<h2 id="h2-III20Il20potenziale20di20valore20di20Catizen674328"><a name="III. Il potenziale di valore di Catizen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>III. Il potenziale di valore di Catizen</h2><h3 id="h3-120Ampia20base20di20utenti20e20comunit20attiva513241"><a name="1. Ampia base di utenti e comunità attiva" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Ampia base di utenti e comunità attiva</h3><p>Dalla sua fase di test beta, Catizen ha registrato una rapida crescita degli utenti. Ci sono oltre 26 milioni di utenti registrati, 1,3 milioni di giocatori attivi giornalieri, 1,5 milioni di utenti on-chain e oltre 5 milioni di iscrizioni ai canali. Continuando ad incorporare funzionalità sociali e attività della comunità, Catizen ha migliorato la fedeltà degli utenti e ha creato una comunità attiva.</p>
<h3 id="h3-220Modalit20di20gioco20innovative20e20gameplay3977"><a name="2. Modalità di gioco innovative e gameplay" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Modalità di gioco innovative e gameplay</h3><p>Catizen combina anche metaverse, GameFi (financializzazione dei giochi), tecnologia AI e molte opzioni di gameplay interessanti, per offrire ai giocatori un’esperienza interattiva estremamente coinvolgente, attirando molti giocatori a partecipare.</p>
<h3 id="h3-320Solida20base20tecnica20e20team20di20sviluppo894648"><a name="3. Solida base tecnica e team di sviluppo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Solida base tecnica e team di sviluppo</h3><p>Catizen ha sviluppato il suo esclusivo motore di gioco - Catizen Game Engine, che supporta un caricamento multi-threading ad alta performance a livello millisecondo, il tracciamento dei dati e la tecnologia di caricamento distribuito globale, offrendo ai giocatori un’esperienza di gioco fluida e stabile.</p>
<p>Il team di sviluppo Pluto Studio si è concentrato sui giochi mini-programma Web2 dal 2018, accumulando una ricca esperienza nello sviluppo e nella distribuzione. Nell’anno prossimo, il team lancerà circa 20 nuovi giochi casual con i gatti come tema principale.</p>
<h3 id="h3-420Scenari20di20applicazione20diversificati20e20collaborazioni245534"><a name="4. Scenari di applicazione diversificati e collaborazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4. Scenari di applicazione diversificati e collaborazioni</h3><p>Nella terza fase, Catizen ha intenzione di trasformarsi in una piattaforma di giochi Telegram, collaborando con altri mini-giochi popolari per ampliare gli scenari di applicazione. Inoltre, attraverso attività come “CatizenVibe—Heal the World,” Catizen ha collaborato con la comunità per salvare gatti randagi, migliorando così la propria immagine di marca e l’influenza sociale.</p>
<h3 id="h3-520Supporto20ufficiale20e20riconoscimento20da20parte20delle20istituzioni20di20investimento244140"><a name="5. Supporto ufficiale e riconoscimento da parte delle istituzioni di investimento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>5. Supporto ufficiale e riconoscimento da parte delle istituzioni di investimento</h3><p>Come progetto chiave nell’ecosistema TON, Catizen ha ricevuto tre round di supporto finanziario dalla Fondazione TON e da molte istituzioni di investimento, mentre la sua azienda madre Pluto Studio ha ricevuto finanziamenti anche da The Open Platform (TOP), dimostrando il potenziale e le prospettive di mercato del progetto.</p>
<h2 id="h2-IV20AFQs926862"><a name="IV. AFQs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>IV. AFQs</h2><h3 id="h3-120Quali20sono20i20Piani20Pi20Recenti20per20Catizen185263"><a name="1. Quali sono i Piani Più Recenti per Catizen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Quali sono i Piani Più Recenti per Catizen?</h3><p>Secondo la roadmap, ci saranno le seguenti azioni nel Q3 2024:</p>
<ol>
<li>Presentare l’economia della piattaforma GameFi con lo staking di token.</li><li>Abilita lo staking di token per i nuovi NFT del gioco e gli airdrop.</li><li>Introdurre la condivisione dei ricavi per i nuovi rilasci di giochi.</li></ol>
<p>È degno di nota che la conferma ufficiale darà il via al primo airdrop di token a luglio.</p>
<p>Nel Q4 del 2024, svilupperà e lancerà gatti AI e AR. Attraerà utenti tradizionali con soluzioni innovative di accompagnamento.<br><img src="https://gimg2.gateimg.com/image/article/172181182717.jpeg" alt=""></p>
<h3 id="h3-220Qual2020il20processo20di20Catizen20Token20Airdrop451922"><a name="2. Qual è il processo di Catizen Token Airdrop?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Qual è il processo di Catizen Token Airdrop?</h3><p>Il token Catizen è $CATI, e i giocatori possono scambiarlo con $CATI tramite $Kitty.</p>
<p>Secondo il white paper, il token sarà utilizzato per il Launch Pool, l’Education Mini Game, la piattaforma di video brevi, il Game Center &amp; Trading bot, l’E-commerce e altro ancora.</p>
<p>L’ultima assegnazione dei token mostra che il 43% dei token verrà utilizzato per airdrop ed ecosistemi.<br><img src="https://gimg2.gateimg.com/image/article/172181184318.jpeg" alt=""></p>
<h2 id="h2-Conclusione619253"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>In sintesi, Catizen ha dimostrato un enorme potenziale di valore con la sua vasta base di utenti, le modalità di gioco innovative, il forte supporto tecnico, i diversi scenari di applicazione e il riconoscimento di numerose istituzioni di investimento.</p>
<p>È importante menzionare che anche Gate Web3 Wallet parteciperà all’ecosistema TON, lanciando mini giochi in evidenza con meccaniche di gioco semplici e divertenti e ricompense ricche e sorprese pasquali per consentire a un numero maggiore di utenti di partecipare all’ecosistema TON. Benvenuti a continuare a seguire le notizie ufficiali di Gate Web3 Wallet.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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></div>