SSBnaW9jaGkgbWluaSBkaSBUT04gQ2hhaW4gc29ubyBhdW1lbnRhdGksIHBvc3Nvbm8gZGF2dmVybyBzdXBlcmFyZSBpIGRpbGVtbWkgZGVsbCdpbm5vdmF6aW9uZT8=

2024-11-13, 07:20

<p><img src="https://gimg2.gateimg.com/image/article/17314821351690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR571533"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Dalla detenzione del fondatore di Telegram, Durov, l’ecosistema TON ha affrontato una pressione di vendita e una perdita di utenti, portando a un significativo calo dei prezzi di una serie di token GameFi, mettendo alla prova la costruzione dell’ecosistema e l’immagine di reputazione.</p>
<p>Recentemente, il mercato nel complesso ha registrato un rimbalzo e i token dei mini giochi della TON chain hanno iniziato a salire e smettere di scendere, aumentando la fiducia del mercato. I prezzi della TON hanno ricevuto un forte supporto e hanno superato la soppressione della linea di tendenza al ribasso.</p>
<p>In futuro, i mini giochi dovrebbero esplorare più tipi di mini programmi, combinati con forme come pagamenti e bot, per portare nuovi punti di crescita a TON. L’ecosistema della catena TON ha ancora vantaggi e potenzialità senza precedenti.</p>
<h2 id="h2-Introduzione992785"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dopo l’arresto del fondatore di Telegram Durov a Parigi alla fine di agosto, TON, che è strettamente legato a lui, ha affrontato sfide. Dopo una serie di prestazioni deludenti, tra cui il continuo declino dei token Meme GameFi, l’ecosistema TON ha attraversato un periodo di adattamento lento.</p>
<p>In questo contesto, mentre BTC sale costantemente e raggiunge la cifra intera di $ 90.000, l’ecosistema TON si sta gradualmente riprendendo. Quindi, cosa c’è da aspettarsi per il futuro di TON? Questo articolo esplora in profondità questo argomento.</p>
<h2 id="h2-Con20il20raggiungimento20del20culmine20una20volta20lanciato20la20strada20per20la20svolta20dei20mini20giochi20TON2020gi20irrisolvibile808520"><a name="Con il raggiungimento del culmine una volta lanciato, la strada per la svolta dei mini giochi TON è già irrisolvibile?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Con il raggiungimento del culmine una volta lanciato, la strada per la svolta dei mini giochi TON è già irrisolvibile?</h2><p>L’ecosistema TON ha attirato molta attenzione e attività da parte degli utenti nel secondo e terzo trimestre di quest’anno, grazie alla popolarità del mini-programma GameFi. Il mercato lo ha persino considerato il miglior ingresso per gli utenti Web2 per connettersi a… <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a>.</p>
<p>Tuttavia, a partire dall’arresto del fondatore di Telegram Durov a Parigi alla fine di agosto, il <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">prezzo TON</a> ha affrontato una pressione venditrice e una serie di token GameFi come CATI, HMSTR, DOGS, ecc., sulla catena sono scesi bruscamente al loro picco, causando una perdita continua di utenti attivi. La costruzione dell’ecosistema TON e l’immagine di reputazione stanno affrontando sfide senza precedenti.<img src="https://gimg2.gateimg.com/image/article/17314821851.jpeg" alt=""><br>Fonte: Gate.io</p>
<p>Come settore principale di TON Chain, i mini giochi sono stati continuamente quotati su grandi borse, con sempre più studi che si uniscono, così come il miglioramento dell’educazione degli utenti e la produzione di massa di mini giochi fungibili. L’effetto di creazione di ricchezza di mercato ha iniziato a mostrare una tendenza significativamente decrescente.</p>
<p>OGenLab ha monitorato fino a 820 progetti Telegram nel mese scorso e ha scoperto che nonostante l’accumulo di 879 milioni di utenti attivi mensili, i dati non duplicati hanno mostrato una diminuzione di 296 milioni di MAU (una diminuzione del 33%), indicando un rapido calo dell’attività degli utenti. Inoltre, il declino sta mostrando una tendenza amplificante, soprattutto con progetti su larga scala con oltre 5 milioni di utenti che accelerano il loro declino nella fase successiva, indicando che anche i progetti principali non possono resistere alla perdita di utenti e l’ecosistema ha incontrato problemi profondi.<img src="https://gimg2.gateimg.com/image/article/17314822172.jpeg" alt=""><br>Origine: @OGenLab</p>
<p>Prendiamo come esempio il gioco una volta molto ricercato ‘Hamster Kombat’. Il suo processo di crescita e declino riflette profondamente il dilemma attuale dell’ecosistema di TON. Questo gioco una volta vantava di avere 300 milioni di utenti, ma ora ha perso la maggior parte dei giocatori, lasciando solo circa 41 milioni di utenti attivi mensili. Anche il prezzo del suo token ha subito un significativo declino, scendendo dal picco al lancio a meno del 30% oggi.<br><img src="https://gimg2.gateimg.com/image/article/17314822443.jpeg" alt=""><br>Origine: Protos</p>
<p>Il fallimento di Hamster Kombat non è stato accidentale. In primo luogo, il suo gameplay è monotono e noioso e l’arte dell’IA sembra essere stata rapidamente messa insieme, il che non può attirare i giocatori a lungo. In secondo luogo, molte controversie circondano i token airdrop nel gioco, con molteplici rinvii e squalifiche di molti giocatori, causando una significativa diminuzione della fiducia dei giocatori. Inoltre, ci sono segnalazioni di manipolazioni di mercato nel gioco, che aggravano ulteriormente la crisi della sua reputazione.</p>
<p>Più seriamente, la tortuosa storia del Hamster Kombat ha suscitato un’attenzione sociale diffusa e polemiche. Alcuni governi lo vedono addirittura come uno “strumento morbido” che minaccia la sicurezza nazionale e la stabilità sociale, e chiedono di vietare questo gioco. Questo contesto di opinione pubblica ha indubbiamente un impatto negativo significativo sullo sviluppo futuro dell’ecosistema TON.</p>
<p>Non è difficile vedere dal caso di Hamster Kombat che, sebbene l’ecosistema TON possa fare affidamento sul grande traffico di Telegram per attirare l’attenzione a breve termine degli utenti, ci sono ancora molti problemi nel mantenimento degli utenti, nella qualità dei giochi, nella costruzione della fiducia e nella supervisione del mondo reale.</p>
<h2 id="h2-Quali20sono20i20nuovi20punti20salienti20dei20giochi20Mini20TON20Chain20con20prezzo20di20moneta20mista118248"><a name="Quali sono i nuovi punti salienti dei giochi Mini TON Chain con prezzo di moneta mista?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i nuovi punti salienti dei giochi Mini TON Chain con prezzo di moneta mista?</h2><p>Nel contesto della ripresa complessiva del mercato negli ultimi tempi, anche il token del mini-gioco TON chain, precedentemente in calo, ha iniziato a salire e smettere di cadere.</p>
<p>Il giorno della stesura, i guadagni di TON, CATI, NOT, DOGS, HMSTR e REDO erano tutti oltre il doppio delle cifre, indicando un leggero rimbalzo della fiducia di mercato.</p>
<p>Prendendo TON come esempio, anche se i suoi recenti guadagni sono stati inferiori rispetto a BTC ed ETH, da un punto di vista dell’analisi tecnica, il prezzo della moneta ha ricevuto un forte supporto intorno a $4,5. Inoltre, il prezzo di TON ha superato la soppressione della linea di tendenza al ribasso, il che viene spesso visto nell’analisi tecnica come un’aspettativa rialzista che apre ulteriormente lo spazio superiore.<img src="https://gimg2.gateimg.com/image/article/17314822884.jpeg" alt=""><br>Origine: Gate.io</p>
<p>In base alle nostre osservazioni, il settore dei mini-giochi della catena TON ha mostrato di recente alcuni nuovi punti salienti e tendenze, in particolare alcuni progetti emergenti come DuckChain, COINFISH Bot, OpenLeague, ecc., che hanno fornito una crescita positiva e si prevede che inietteranno una nuova vitalità nel mercato.</p>
<p>Come primo progetto consumer basato su TON, DuckChain ha superato 1,8 milioni di utenti di rete di test, con oltre 2 milioni di utenti attivi giornalieri sull’app Mini e quasi 10 milioni di utenti totali, dimostrando un forte slancio di crescita. Grazie al recente lancio del programma di innovazione cross-chain “Synergy” da parte di TON Accelerator, DuckChain può collegare in modo più conveniente TON con ecosistemi come EVM e BTC, fornendo un ambiente di sviluppo EVM efficiente per gli utenti di Telegram e TON e riducendo significativamente la soglia on-chain tramite un sistema di account unificato.<img src="https://gimg2.gateimg.com/image/article/17314823155.jpeg" alt=""><br>Fonte: duckchain.io</p>
<p>Inoltre, il gioco COINFISH Bot del ecosistema TON ‘click-to-fishing’, ufficialmente annunciato da MEETLabs, è stato lanciato e ha ottenuto oltre 130.000 utenti del canale comunitario Telegram. L’ambientazione e le impostazioni dei personaggi del gioco hanno una grande affinità e identità culturale, aumentando ulteriormente il suo appeal.</p>
<p>Si può vedere che il campo del mini-gioco della catena TON sta subendo uno sviluppo e una trasformazione rapidi. Questi nuovi giochi non sono più limitati alla competizione di traffico a breve termine, ma esplorano più modi per essere compatibili tra le catene e aumentare la giocabilità.</p>
<h2 id="h2-Lecosistema20TON20pu20decollare20di20nuovo582129"><a name="L’ecosistema TON può decollare di nuovo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ecosistema TON può decollare di nuovo?</h2><p>Anche se l’ecosistema TON è stato in calo negli ultimi tre mesi, dal punto di vista della crescita a lungo termine delle catene pubbliche come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, le prestazioni attuali dei dati sono dati che inevitabilmente compaiono con il ciclo durante il processo di crescita delle chain pubbliche.<br><img src="https://gimg2.gateimg.com/image/article/17314823446.jpeg" alt=""><br>Origine: DeFiLlama</p>
<p>Naturalmente, se l’ecosistema TON può raggiungere un secondo decollo nella fase successiva, richiede ancora più innovazione tecnologica e costruzione dell’ecosistema per attirare abbastanza utenti e attenzione di capitale.</p>
<p>In realtà, come un ecosistema che sfuma i confini tra DEX e CEX, l’interazione di TON con Web2 sfuma le categorie delle transazioni e abbassa la soglia per le transazioni native <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Le transazioni per accedere a Web2. Questo enorme vantaggio è ancora ineguagliabile da altri concorrenti.<br><img src="https://gimg2.gateimg.com/image/article/17314823627.jpeg" alt=""><br>Origine: @ton_blockchain</p>
<p>Secondo la comprensione dell’autore, il futuro dei mini-giochi non è limitato ai semplici meccanismi di clic o ai sistemi di sviluppo della strategia, ma dovrebbe esplorare ulteriori tipi di mini-programmi in campi come l’educazione, la finanza e il social networking. Attraverso la combinazione di pagamento, bot e altre forme, può fornire agli utenti metodi di interazione più ricchi e una maggiore comodità, portando nuovi punti di crescita a TON per attrarre una gamma più ampia di gruppi di utenti.</p>
<p>In sintesi, l’ecosistema della catena TON sta vivendo dolore e cambiamento, e i mini-giochi, come componente importante di esso, stanno affrontando sfide a breve termine e opportunità a lungo termine. Attraverso investimenti strategici e collaborazioni, sfruttando il potenziale diversificato dei mini-programmi, sviluppando DEX e DeFi e esplorando la convalida di mercato, l’ecosistema della catena TON continuerà a promuovere lo sviluppo e l’innovazione dei mini-giochi, e il suo ecosistema ha ancora vantaggi e potenziali senza pari.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle 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. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ripostaggio dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>