VmFuIFBsYXktdG8tRWFybiBuYWFyIFRhcC10by1FYXJuOiBEZSBldm9sdXRpZSB2YW4gR2FtaW5nIFJld2FyZHM=

2024-07-23, 08:54

<p><img src="https://gimg2.gateimg.com/image/article/1721724663sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR19193"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Het tikken-om-te-verdienen spelmodel is populairder geworden dan het speel-om-te-verdienen model.</p>
<p>Sommige experts vrezen dat T2E, net als P2E, mogelijk niet duurzaam is, wat kan bijdragen aan hun mislukkingen.</p>
<p>Notcoin, Catizen, Hamster Kombat, Yescoin, PixelTap en TapSwap zijn enkele van de toonaangevende T2E-spellen.</p>
<h2 id="h2-Introductie914826"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Er is veel concurrentie in de <a href="/web3" target="_blank" class="blog_inner_link">web3</a> gaming sector, aangezien er nieuwe spellen opduiken die veel fantasie bieden. Met financiële prikkels als een van de belangrijkste aantrekkingspunten van op blockchain gebaseerde spellen, stappen spelers over van <a href="https://www.gate.io/learn/articles/what-are-play-to-earn-games-and-why-play-them/1514" target="_blank">spelen-om-te-verdienen spellen</a> om te tikken om te verdienen. Dit artikel onderzoekt de redenen waarom web3-gamers de voorkeur geven aan tik-om-te-verdienen (T2E) games boven de speel-om-te-verdienen (P2E) games. We zullen ook kijken naar het T2E gaming model.</p>
<h2 id="h2-PlaytoEarn20P2E20versus20TaptoEarn20T2E20Waarom20de20overgang887991"><a name="Play-to-Earn (P2E) versus Tap-to-Earn (T2E): Waarom de overgang?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Play-to-Earn (P2E) versus Tap-to-Earn (T2E): Waarom de overgang?</h2><p>Een reden waarom de meeste <a href="https://www.gate.io/learn/articles/abcde-deciphering-the-matr1x-economic-model-the-sustainable-growth-path-of-web3-gaming/2402" target="_blank">web3-games evolueren in de loop van de tijd</a> en nieuwe komen erbij, is hun complexiteit. In tegenstelling tot traditionele spellen die vaak gemakkelijk te navigeren zijn, moeten web3-spelers de technische aspecten van elk web3-spel begrijpen voordat ze ervan kunnen genieten. Helaas kan het veel tijd kosten om te begrijpen en waarderen hoe elk spel gespeeld wordt. Het wordt daardoor erg moeilijk voor spelers om gemakkelijk van het ene spel naar het andere over te schakelen.</p>
<p>Een van de trends in de game-industrie is de upgrade van de game-modellen als gevolg van opkomende eisen en voorkeuren. Zo zijn game-ontwikkelaars gekomen met een nieuwe dimensie voor de play-to-earn games. Als gevolg daarvan hebben ze het tap-to-earn crypto gaming model ontwikkeld, momenteel trending in de sector.</p>
<p>Tap-to-earn games zijn veel makkelijker te spelen dan de traditionele play-to-earn games. Het tap-to-earn verdienmodel voor gaming vereist dat spelers tikken op munten of pictogrammen op het scherm om punten of gerelateerde beloningen zoals digitale activa te verdienen. De belangrijkste reden waarom de T2E-games populair zijn geworden, is de mogelijkheid voor spelers om een deel van de crypto airdrops als extra stimulans te krijgen.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/play-to-earn-in-2024-web3-games-requirements-and-trends/3051" target="_blank">Play-to-Earn in 2024: Web3 Games vereisten en trends</a></p>
<h2 id="h2-Het20analyseren20van20de20overgang20De20opkomst20en20ondergang20van20Playtoearn20P2E20spellen743413"><a name="Het analyseren van de overgang: De opkomst en ondergang van Play-to-earn (P2E) spellen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het analyseren van de overgang: De opkomst en ondergang van Play-to-earn (P2E) spellen</h2><p>Een paar jaar geleden kwamen play-to-earn web3-games op de markt met de lokkende belofte van digitale gaming-beloningen die <a href="https://akcdn.gate.io/de/blog_detail/234/how-nft-and-blockchain-bring-new-potential-to-play-to-earn" target="_blank">inclusief NFT’s en cryptocurrencies</a>. Desalniettemin was de belangrijkste reden voor de kortstondige populariteit van play-to-earn games hun gebrek aan duurzaamheid. Hoewel de spelers redelijke beloningen konden verdienen, slaagden de P2E-spellen er niet in om hun interesse vast te houden. Bovendien waren veel van de spelers mensen die een inkomen wilden verdienen met het spelen van het spel, niet om erin te investeren. Volgens <a href="https://blockworks.co/news/play-to-earn-gaming-is-dead" rel="nofollow noopener noreferrer" target="_blank">Palemos, zoals vermeld door Blockworks, een P2E-spel</a>‘trekt een publiek aan dat op zoek is naar het extraheren van waarde uit het ecosysteem van een spel, in plaats van eraan bij te dragen.’ Daarom moesten de ontwikkelaars nieuwe game-elementen opnemen om de interesse van de gamers te behouden, wat erg duur en onhoudbaar werd.</p>
<p>De andere belangrijke reden voor het verval van de meeste play-to-earn spellen is de inflatoire aard van het <a href="https://www.gate.io/price/view/play-to-earn &quot;in-game assets (native cryptocurrencies" rel="nofollow noopener noreferrer" target="_blank">in-game bezittingen (native cryptocurrencies)</a> Wanneer de waarden van deze cryptocurrencies blijven dalen, verliezen de spelers uiteindelijk hun interesse in de games. Wat meestal zorgt voor de daling van de prijzen van de games is de toestroom van nieuwe spelers die, nadat ze de tokens hebben verdiend, deze snel verkopen om contant geld te krijgen om aan hun dagelijkse behoeften te voldoen.</p>
<p>Ook zijn de meeste van deze web3 play-to-earn-games middelmatig van aard, omdat de ontwikkelaars zich concentreren op geldelijke beloningen in plaats van op de gamefantasie. Bovendien zijn de modellen bijna hetzelfde, ondanks een paar variaties, waardoor ze er niet in zijn geslaagd de interesse van de spelers vast te houden. Vanwege onze ervaring met traditionele spellen zou de echte aantrekkingskracht van een spel het plezier moeten zijn dat ze genereren in plaats van de financiële beloningen. De bovenstaande aspecten hebben geleid tot de “dood” van de meeste play-to-earn-spellen. Het is veelbetekenend dat de P2E-games die nog op de markt zijn, afnemen.<br>Lees ook: <a href="https://www.gate.io/zh/learn/articles/how-to-stake-myth/3066" target="_blank">De Top 15 GameFi in 2024</a></p>
<h2 id="h2-De20duurzaamheid20van20T2Egames20in20twijfel20getrokken20hoe20ze20verschillen20van20hun20voorgangers217765"><a name="De duurzaamheid van T2E-games in twijfel getrokken: hoe ze verschillen van hun voorgangers" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De duurzaamheid van T2E-games in twijfel getrokken: hoe ze verschillen van hun voorgangers</h2><p>De tap-to-earn spellen werken op dezelfde manier als play-to-earn spellen, aangezien financiële beloningen hun belangrijkste aspect zijn. In feite tikken de spelers op munten of vergelijkbare pictogrammen om beloningen te verdienen. Deze spellen hebben veel populariteit en mainstream tractie gekregen.</p>
<p>Ondanks kleine variaties zijn de meeste van deze spellen vergelijkbaar. Ten eerste moeten de gamers verschillende taken uitvoeren om upgrades en boosters te krijgen. Een van de meest voorkomende taken van dit spel is dat spelers zich moeten aansluiten bij verschillende sociale mediaplatforms zoals Telegram en Discord-kanalen. Bovendien verdienen ze bepaalde punten door mensen uit te nodigen om deel te nemen aan de spellen. Om de spelers te stimuleren om veel vrienden en familieleden uit te nodigen voor de spellen, verdienen ze een aantal punten wanneer hun genodigden bepaalde mijlpalen bereiken, zoals het uitnodigen van 10 nieuwe leden.</p>
<p>De meeste T2E-spellen hebben boosters die hun punten vermenigvuldigen wanneer ze bepaalde doelen bereiken. Bijvoorbeeld, een van de boosters kan de energiebalk in een bepaalde periode vullen. Een ander veelvoorkomend element in T2E-spellen zijn de “Tap-bots”. Hoewel de namen van zo’n element kunnen verschillen, zijn de functionaliteiten hetzelfde. Eerst gebruikt de speler de verdiende punten om een tap-bot te kopen. Vervolgens zal de bot automatisch op de munt tikken of <a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON</a> Zelfs wanneer de game-app is gesloten.<br>In totaal kunnen spelers hun voordelen maximaliseren door deel te nemen aan verschillende activiteiten, zoals anderen uitnodigen om deel te nemen aan de games, het verwerven van de tap-bots en het behalen van andere belangrijke mijlpalen. Natuurlijk zullen de beloningen groter zijn naarmate ze meer moeite doen om de games te spelen.</p>
<p>Op dit moment bestaan de meeste tik-om-te-verdienen spellen zoals Notcoin, TapSwap, Yescoin en Hamster Kombat op de sociale media app Telegram. Als gevolg van het grote aantal gebruikers op Telegram hebben deze spellen grote spelerbasissen. Zo kreeg TapSwap bijvoorbeeld meer dan 50 miljoen gebruikers binnen een maand, terwijl Yescoin meer dan 24 miljoen actieve spelers heeft. Interessant genoeg heeft Hamster Kombat meer dan 200 actieve gebruikers, terwijl Notcoin meer dan 35 miljoen gamers heeft.</p>
<h2 id="h2-Gaming20Mechanica2020P2E20Vs20T2Emodellen21398"><a name="Gaming Mechanica - P2E Vs. T2E-modellen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gaming Mechanica - P2E Vs. T2E-modellen</h2><p>Deze twee soorten spellen hebben één ding gemeen: de gamers verdienen terwijl ze spelen. Wat het meest verschilt, zijn hun verdienmodellen, hun digitale gamingbeloningen en technische aspecten. In tegenstelling tot de complexe P2E-spellen nemen de spelers een informele benadering bij het spelen van de tap-to-earn-spellen. Vanwege hun eenvoud is de leercurve korter dan die van play-to-earn-spellen. Daarom hebben T2E-spellen lagere toegangsdrempels dan de P2E-spellen.</p>
<p>Het kost minder moeite en tijd om T2E gaming beloningen te verdienen dan spelers met play-to-earn beloningen. Dat is de reden waarom de T2E spellen meer spelers aantrekken dan de P2E spellen. Ook zijn de T2E spellen toegankelijker dan de P2E spellen, omdat ze bestaan op Telegram, wat een gebruiksvriendelijk sociaal media platform is. Een andere factor die de T2E spellen populairder heeft gemaakt dan de P2E spellen is de airdrop die de meeste van hen aan hun gebruikers distribueren. Daarom vertegenwoordigt het T2E gaming model een paradigma verschuiving van de P2E en andere web3 spellen. Aangezien de toekomst van gaming afhankelijk is van hun duurzaamheid, zouden de ontwikkelaars verschillende aspecten moeten opnemen die kunnen helpen om de interesse van de spelers te behouden.</p>
<h2 id="h2-Analyse20van20het20T2E20Gaming20Model20Reden20waarom20TaptoEarn20Games20populair20zijn20bij20ontwikkelaars677487"><a name="Analyse van het T2E Gaming Model: Reden waarom Tap-to-Earn Games populair zijn bij ontwikkelaars" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analyse van het T2E Gaming Model: Reden waarom Tap-to-Earn Games populair zijn bij ontwikkelaars</h2><p>We hebben al de belangrijkste voordelen van T2E-games voor de spelers besproken, de financiële beloningen. Laten we nu kort bespreken waarom de ontwikkelaars de voorkeur geven aan het T2E-gamingmodel boven het P2E-model. De belangrijkste reden waarom gamedevelopers zich richten op T2E-games is de eenvoud van het ontwikkelen ervan. Het kost veel minder tijd om T2E-games te ontwerpen en te ontwikkelen dan de meeste andere web3-games. Op dezelfde manier hebben de ontwikkelaars veel minder middelen nodig om ze te ontwikkelen dan wat de P2E-games vereisen.</p>
<p>Het is ook belangrijk om te beseffen dat de ontwikkelaars verschillende manieren kunnen gebruiken om geld te verdienen aan de games, wat betekent dat er een groot potentieel is om veel geld te genereren uit de T2E-games. Zo kunnen de ontwikkelaars virtuele bezittingen opnemen die de gamers kunnen kopen. Op basis van bestaande trends moeten de spelers mogelijk boosters, power-ups en cosmetische items kopen.</p>
<p>De ontwikkelaars kunnen korte videoadvertenties opnemen of incentives geven aan de spelers om bepaalde acties binnen het gaming-ecosysteem uit te voeren. Hierdoor genereren ze inkomsten via advertenties van derden en verhogen ze de financiële beloningen voor de spelers. Ten slotte kunnen de ontwikkelaars geschikte cryptocurrencies zoals ETH integreren met hun platforms, waardoor ze hun eigen in-game economieën creëren die hen financieel ten goede komen.</p>
<p>Ondanks de voordelen van de T2E-spellen voor zowel de spelers als de ontwikkelaars is de grootste uitdaging of ze op lange termijn levensvatbaar zullen zijn. Dit komt omdat de meeste van deze spellen geen inherente waardecreatie hebben. Gewoonlijk hangt hun korte termijn levensvatbaarheid af van de toestroom van nieuwe spelers. Helaas beïnvloeden meer spelers de dynamiek van de inheemse digitale activa vaak wanneer ze meedoen, wat kan leiden tot hoge prijsvolatiliteit en depreciatie. Belangrijk is dat als de in-game activa onder bepaalde niveaus deprecieren, veel spelers de spellen kunnen verlaten.</p>
<h2 id="h2-De20Top20Tikomteverdienen20Spellen771396"><a name="De Top Tik-om-te-verdienen Spellen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Top Tik-om-te-verdienen Spellen</h2><p>We hebben al gesproken over de voordelen van het spelen van de T2E-spellen, laten we nu kort kijken naar de toonaangevende tik-om-te-verdienen spellen. Notcoin, Catizen, Hamster Kombat, Yescoin, PixelTap en TapSwap zijn enkele van de top T2E-spellen. Zoals eerder aangegeven, bestaan de meeste van deze spellen op Telegram, een reden waarom ze grote spelersgroepen hebben. Notcoin was het eerste T2E-spel. Gemaakt door Open Builders en gelanceerd aan het begin van 2024, lanceerde Notcoin zijn eigen cryptocurrency (NOT) op The Open Network (TON). Het andere zeer populaire T2E-spel is Hamster Kombat, een klikspel op basis van Telegram, met meer dan 200 miljoen actieve gebruikers.</p>
<h2 id="h2-Conclusie544955"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Play-to-earn en tap-to-earn zijn enkele van de meest populaire web3-spellen vanwege de financiële prikkels die de spelers krijgen. Desalniettemin zijn de meeste P2E-spellen complex, maar zijn de meeste T2E-spellen eenvoudig te gebruiken, een reden waarom ze veel spelers hebben aangetrokken. Notcoin, Catizen, Hamster Kombat, Yescoin, PixelTap en TapSwap, allemaal gebaseerd op Telegram, zijn de top T2E-spellen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Mashell C. </strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten 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>