VmlyYWwgRmFuZG9tLCBXYWFyb20gaXMgZGl0IFRHIE1pbmkgR2FtZSB6byBnZWs/

2024-07-19, 03:17

<p><img src="https://gimg2.gateimg.com/image/article/1721358718rdzz.jpeg" alt=""></p>
<h2 id="h2-TLDR115065"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Dankzij de populaire promotie van verschillende kleine gameprojecten zoals Notcoin, Catizen en Hamster Kombat binnen zijn ecosysteem, hebben de dagelijkse actieve gebruikers van TON Chain het aantal overschreden. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en blijf maar klimmen.</p>
<p>Opkomende kleine spelprojecten zoals Catizen en Hamster Kombat hebben een enorme gebruikersbasis aangetrokken door hun eenvoudig te spelen en zeer interactieve ontwerpen, maar ze worden geconfronteerd met langetermijnuitdagingen van ontoereikende speelbaarheid.</p>
<p>De incentive- en acceleratorprogramma’s van de TON Foundation ondersteunen meerdere gaming- en infrastructuurprojecten, bevorderen innovatie en welvaart in het ecosysteem.</p>
<h2 id="h2-Introductie646003"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In schril contrast met de recente fluctuaties op de cryptomarkt, blijven de TVL en de activiteit van de gemeenschap van het TON (Telegram Open Network) blockchain-ecosysteem stijgen. Een reeks eenvoudige en gemakkelijk te spelen games op de keten hebben snel aan populariteit gewonnen, en zijn daarmee een belangrijke kracht die de welvaart van het TON-ecosysteem en de voortdurende stijging van de marktwaarde stimuleert.</p>
<p>We zullen nu een diepgaande analyse geven van veel populaire TON-spellen in de afgelopen tijd om de ontwikkelingsruimte en toekomstperspectieven van het TON-ecosysteem te verkennen.</p>
<h2 id="h2-Dagelijks20actieve20gebruikers20overtreffen20ETH20TON20Market20Cap20stijgt38238"><a name="Dagelijks actieve gebruikers overtreffen ETH, TON Market Cap stijgt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dagelijks actieve gebruikers overtreffen ETH, TON Market Cap stijgt</h2><p>Onlangs heeft het ecosysteem van TON met zijn unieke ecosysteemopbouw en sterke gebruikersbasis, voornamelijk dankzij de rijke en diverse kleine spelprojecten binnen zijn ecosysteem, een explosieve groei laten zien, en zijn dagelijkse actieve gebruikersaantallen hebben stilletjes <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> overtroffen.<br><img src="https://gimg2.gateimg.com/image/article/17213588341.jpeg" alt=""><br>Bron: Artimes</p>
<p>Specifiek heeft Telegram 900 miljoen maandelijkse actieve gebruikers, waardoor TON een enorme potentiële gebruikersbasis heeft. De beveiliging, privacybescherming en wereldwijde invloed van Telegram geven het TON-ecosysteem een uniek voordeel bij het bevorderen van de grootschalige adoptie van Web3.</p>
<p>Met TON’s marktwaarde die de $17 miljard overtreft, overtreft <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> en stevig op de negende plaats staat in de marktwaarderanglijst, en TVL onlangs steeg naar $740 miljoen, het weerspiegelt verder de erkenning en verwachtingen van de markt ten aanzien van het TON-ecosysteem.<br><img src="https://gimg2.gateimg.com/image/article/17213588542.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Het MEME GameFi valt op tussen veel gebieden in het TON-ecosysteem vanwege zijn hoge populariteit en brede verspreiding, wat het tot het middelpunt van de aandacht heeft gemaakt voor investeerders en spelers.</p>
<p>Zoals bekend heeft Notcoin, als een iconische aanwezigheid in het TON-ecosysteem, niet alleen een groot aantal spelers aangetrokken met zijn WeChat mini-programma, inclusief gameplay en een airdrop-beloningssysteem, maar heeft het ook succesvol een reeks MEME mini-games op verschillende ketens aangestuurd om de trend te volgen.</p>
<p>Ondertussen hebben opkomende kleine spelprojecten zoals Pixelverse, MomoAI, Hamster Kombat, Catizen, enz. een groot aantal gebruikers in staat gesteld om naadloos over te stappen naar <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> dankzij hun gebruiksgemak, hoge interactiviteit, uitnodigingsbeloningen en directe voldoening, waarbij zij een enorm marktpotentieel aantonen.</p>
<p>Natuurlijk is dit onafscheidelijk van de sterke steun van de TON Foundation. Uit de gegevens blijkt dat de TON Foundation een kernrol speelt bij het bevorderen van de ontwikkeling van het TON-ecosysteem door meer dan $ 200 miljoen aan ecosysteemfondsen en gemeenschapsbeloningsprogramma’s op te zetten om innovatie te bevorderen. Het acceleratieprogramma ondersteunt meerdere games en game-infrastructuurprojecten en heeft onlangs het TONX-acceleratieprogramma gelanceerd.</p>
<p>Onlangs zal de TON-gemeenschap offline hackathons organiseren op meerdere locaties, waarbij gameprojecten aanzienlijk succes behalen en populaire spellen zoals Catizen de ranglijsten aanvoeren.</p>
<p>Volgens de statistieken van Delphi Digital heeft de TON Foundation alleen al in totaal $22,4 miljoen aan beloningen uitgereikt voor activiteiten zoals airdrops, LP Boosts en The Open League Battles, waarbij gamingprojecten de lijst aanvoeren met een aandeel van 17%.<br><img src="https://gimg2.gateimg.com/image/article/17213588723.jpeg" alt=""><br>Bron: ton.org</p>
<p>We zullen deze trending games hieronder kort introduceren.</p>
<h2 id="h2-Catizen20Een20kattenthema20synthese20spel874303"><a name="Catizen: Een kattenthema synthese spel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Catizen: Een kattenthema synthese spel</h2><p>Catizen werd opgericht door het team van Pluto Studio en wordt geleid door CEO en medeoprichter David, Chief Marketing Officer Pierce en Chief Product Officer Stanislav. Ze lanceerden dit innovatieve kattenthematische synthesespel op Telegram in maart 2024, gebruikmakend van hun uitgebreide ervaring in gaming, investeringen en technologie.</p>
<p>In Catizen kunnen spelers een kattenwinkel runnen, munten verdienen door katten te aaien en vervolgens hoger niveau katten kopen en synthetiseren om meer munten te verdienen in een cyclus.</p>
<p>Eenmaal gelanceerd, trok Catizen een groot aantal spelers aan met zijn eenvoudige synthese mechanisme en zeer vermakelijk businessmodel. Binnen twee maanden overschreed het aantal geregistreerde gebruikers de 20 miljoen en momenteel heeft het de 25 miljoen overschreden, met meer dan 700.000 betalende gebruikers, waardoor het het spel is met de hoogste in-game omzet via IAP op TON.<br><img src="https://gimg2.gateimg.com/image/article/17213589094.jpeg" alt=""><br>Bron: Catizen</p>
<p>Catizen, met zijn unieke spelontwerp en innovatieve platformfuncties, cultiveert een gemeenschap vol empathie, vriendelijkheid en maatschappelijke verantwoordelijkheid wereldwijd. Het aankomende evenement van 43% token-airdrop heeft de enthousiasme van spelers verder aangewakkerd.</p>
<h2 id="h2-Hamster20Kombat20Rollenspel20in20de20Slag20om20Hamsters47884"><a name="Hamster Kombat: Rollenspel in de Slag om Hamsters" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hamster Kombat: Rollenspel in de Slag om Hamsters</h2><p>In tegenstelling tot Notchin en Catizen, die vertrouwen op klik-om-te-verdienen strategieën en diep de Web3 gemeenschap cultiveren, werd Hamster Kombat snel populair vanwege zijn sterke sociale invloed.</p>
<p>Hamster Kombat is sinds maart van dit jaar online en heeft in 11 dagen 1 miljoen gebruikers aangetrokken, waarna het aantal actieve gebruikers in 80 dagen is gestegen naar een verbazingwekkende 158 miljoen, waarmee het een fenomenaal project is geworden na Notch.</p>
<p>Het spelverloop is relatief eenvoudig. Spelers spelen als de CEO van een cryptovaluta-uitwisseling in het spel. Ze verzamelen punten door op de hamster op het scherm te klikken en hebben de mogelijkheid om beloningen te verkrijgen via verschillende middelen, waaronder het kopen en synthetiseren van speciale kaarten, dagelijkse check-in, interactie op sociale media en het aanbevelen van vrienden.<br><img src="https://gimg2.gateimg.com/image/article/17213589815.jpeg" alt=""><br>Bron: Hamster Kombat</p>
<p>Volgens het officiële plan zal Hamster Kombat deze maand zijn token lanceren. In deze fase kunnen vroege spelers nog steeds deelnemen aan het spel om kans te maken op token airdrop-kansen. Specifiek heeft het handelsplatform Gate.io pre-market trading geopend voor Hamster Kombat (HMSTR).</p>
<h2 id="h2-Pixelverse20Cyberpunkthema20Game722265"><a name="Pixelverse: Cyberpunk-thema Game" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pixelverse: Cyberpunk-thema Game</h2><p>Pixelverse is een Web3-spel in cyberpunk-stijl waarin spelers de rol van freelancers op zich nemen, deelnemen aan verschillende missies, PvE-gevechten, robotontwikkeling en upgrades en genieten van het plezier van PvP-gevechten in de arena.</p>
<p>Na de lancering werd Pixelverse al snel populair en meldden zich in de eerste maand meer dan 50 miljoen gebruikers aan voor PixelTap. Het aantal dagelijks actieve gebruikers van het spel overtrof 10 miljoen. Deze prestatie overtreft niet alleen het traditionele klik-om-te-verdienen model op Telegram, maar toont ook de innovatieve kracht van Pixelverse in real-time PvP-gevechten.</p>
<p>Een belangrijk hoogtepunt van Pixelverse is dat het niet beperkt is tot traditionele gameplay, maar ook de populaire NFT-karakter Pudgy Penguin introduceert in zijn Telegram mini-game PixelTap om te concurreren met sterrenkarakters zoals Doge en Mew, waardoor spelers een geheel nieuwe ervaring krijgen. Als een van de meest herkenbare karakters in Web3 heeft Pudgy Penguin meer dan 4 miljoen Instagram-volgers en wereldwijd meer dan 1 miljoen speelgoed verkocht. Zijn toevoeging voegt ongetwijfeld meer aantrekkingskracht toe aan de Pixelverse.<br><img src="https://gimg2.gateimg.com/image/article/17213589986.jpeg" alt=""><br>Bron: Pixelverse</p>
<h2 id="h2-Yescoin20Notcoin20Altcoin347972"><a name="Yescoin: Notcoin Altcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Yescoin: Notcoin Altcoin</h2><p>Als nauwe metgezel van Notcoin, onderscheidt Yescoin zich op de markt met zijn unieke swipe-to-earn-muntenmodus (Swipe To Earn).</p>
<p>Spelers kunnen niet alleen munten verzamelen door eenvoudige schermacties, maar ook teams vormen, vrienden uitnodigen om mee te doen, en game-elementen zoals YesPac en Yesbox gebruiken om dubbele prikkels op en naast de keten te verkrijgen, waardoor de interactiviteit en het plezier van het spel aanzienlijk worden verbeterd.</p>
<p>Bovendien kunnen het voltooien van basis taken zoals het bijhouden van projectpartijrekeningen, deelnemen aan gemeenschappen, enz., ook rijke beloningen opleveren. Deze taken zijn ontworpen om eenvoudig en efficiënt te zijn, en zijn niet minderwaardig aan andere kleine spellen op het Telegram platform.<br><img src="https://gimg2.gateimg.com/image/article/17213590147.jpeg" alt=""><br>Bron: Yescoin</p>
<p>Het spel trok snel gebruikers aan met zijn virale verspreidingsstrategie en heeft sinds de lancering eind mei meer dan 18 miljoen spelers aangetrokken. Tegen de achtergrond van zeer competitieve MEME-spellen is de hoge kans op airdrop van Yscoin een van de belangrijkste factoren geworden die spelers aantrekken om tijd en energie te investeren.</p>
<h2 id="h2-Samenvattend734305"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>De ingebouwde mini-games van TON Chain, vertegenwoordigd door Notcoin, Catizen, Hamster Kombat en anderen, hebben met succes sociale entertainment geïntegreerd met dApps, waardoor een groot aantal gebruikers gemakkelijke en interessante interactie- en muntverdienende ervaringen hebben gekregen, wat een naadloze overgang van Web2-gebruikers naar Web3 bevordert.</p>
<p>Gate Web3 Wallet zal ook binnenkort TON ecosysteemspellen lanceren, waarmee het wallet-ecosysteem verder wordt uitgebreid en diverse gebruikersbehoeften worden bediend. Op dit moment bevat de Gate Web3 Wallet al verschillende functies voor het verdienen van munten, zoals Web3 Startup, Task Square, enz., waarmee gebruikers passief inkomen kunnen verdienen terwijl ze aan hun basiswalletbehoeften voldoen.</p>
<p>Ervaar het nu:</p>
<p>Web3 Startup: <a href="https://www.gate.io/web3/startup" target="_blank">https://www.gate.io/web3/startup</a></p>
<p>Web3 Taken: <a href="https://www.gate.io/web3/tasks" target="_blank">https://www.gate.io/web3/tasks</a></p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>