QXhpZSBJbmZpbml0eSB3b3JkdCBnZWNvbmZyb250ZWVyZCBtZXQgZWVuIGJlYXJpc2ggbW9tZW50dW0gdGUgbWlkZGVuIHZhbiBlZW4gYWZuYW1lIHZhbiBzcGVsZXJz

2023-08-15, 08:22

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR654880"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> is een op blockchain gebaseerd videospel waarmee spelers digitale tokens kunnen verdienen.</p>
<p>Axie Infinity Shards (AXS) en Smooth Love Potions (SLP) zijn de belangrijkste tokens voor de Axie blockchain.</p>
<p>De spelers kunnen Axies verwerven, fokken, grootbrengen en verhandelen, die huisdieren zijn die bestaan in de vorm van NFT’s.</p>
<p>De AXS-token bevindt zich in een bearish momentum en de prijs zal waarschijnlijk verder dalen.</p>
<h2 id="h2-Introductie623889"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De populariteit en het voortbestaan van blockchain-spellen hangt af van het aantal actieve gebruikers dat ze hebben. Als gevolg hiervan maken de makers zich zorgen wanneer het aantal actieve gebruikers van een gamingplatform afneemt. Axie Infinity, het eerste <a href="/web3" target="_blank" class="blog_inner_link">web3</a> gamingprotocol dat het play-to-earn model gebruikt, wordt geconfronteerd met een opmerkelijke afname van het aantal spelers, wat een negatieve invloed heeft op de prijs van zijn eigen token, AXS.</p>
<p>In deze gids behandelen we de huidige gebruikersstatus van <a href="/price/axie-infinity-axs" target="_blank" class="blog_inner_link">Axie Infinity</a> en de uitdagingen waarmee het wordt geconfronteerd. We zullen ook de prijsprestaties bespreken.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/516" target="_blank">Axie Infinity: De koning van On-Chain P2E Gaming</a></p>
<h2 id="h2-Begrijpen20van20het20Axie20Infinity20Blockchainspel329372"><a name="Begrijpen van het Axie Infinity Blockchain-spel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Begrijpen van het Axie Infinity Blockchain-spel</h2><p>Voordat we de daling bespreken <a href="https://www.gate.io/learn/articles/what-is-axie-infinity/148" target="_blank">Axie Infinity</a> Gebruikers, laten we eens kijken wat het te bieden heeft. Ontwikkeld door de Vietnamese Sky Mavis en gelanceerd in 2018, is Axie Infinity een blockchain gaming platform dat zich bezighoudt met het fokken, opvoeden en verhandelen van wezens genaamd Axies, die tegen elkaar strijden. Deze wezens bestaan als non-fungible tokens (NFT’s) voor deze play-to-earn gaming economie.</p>
<p>Axie Infinity is een play-to-earn spel waar spelers verschillende in-game items zoals onroerend goed, accessoires en Axies verwerven en verkopen via haar NFT-marktplaats. Axie Infinity lijkt op de meeste videospellen behalve dat het bestaat op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<p>Het Axie-spel is leuk, vermakelijk en leerzaam, wat veel spelers heeft aangetrokken in de afgelopen jaren. Elke speler moet ten minste drie Axies hebben om het spel te kunnen spelen. Deze Axies hebben echter verschillende eigenschappen, een reden waarom een speler er mogelijk meer dan drie nodig heeft om competitief te worden tijdens de games.</p>
<p>Axie blockchain heeft twee belangrijke tokens, namelijk Axie Infinity Shards (AXS) en Smooth Love Potions (SLP), die investeerders kunnen kopen, vasthouden en verkopen. AXS is het governance-token van het blockchain gaming platform, waarmee houders kunnen bijdragen aan het besluitvormingsproces met betrekking tot de ontwikkelingsagenda ervan.</p>
<p>Aan de andere kant wordt SLP voornamelijk gebruikt in het spel om de spelers te belonen. Zowel SLP als AXS zijn ERC-20 omdat ze bestaan op het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/796/axie-infinity-and-its-mission-to-be-decentralized" target="_blank">Axie Infinity en haar missie om gedecentraliseerd te zijn</a></p>
<h2 id="h2-Axie20Infinity20presteert20ondermaats270736"><a name="Axie Infinity presteert ondermaats" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Axie Infinity presteert ondermaats</h2><p>Sinds het begin van dit jaar presteert Axie Infinity ondermaats om verschillende redenen, waaronder de angst voor een wereldwijde recessie. Hoewel de waarde van AXS steeg na het populaire AxiETH-gamingevenement dat plaatsvond in Thailand, is die momentum voorbij en is de prijs gedaald tot ongeveer $6. De belangrijkste reden achter de bearish prestaties is een scherpe daling in het aantal gebruikers.</p>
<p>De historische gegevens over Axie Infinity tonen aan dat het in 2022 een afname van zijn gebruikersbestand begon te ervaren. Deze trend heeft echter voortgeduurd tot op de dag van vandaag. In november 2022 verloor Axie Infinity ongeveer 20% van zijn spelers. Er was ook een merkbare afname van gebruikers in februari, zoals blijkt uit het volgende diagram.<br><img src="https://gimg2.gateimg.com/image/article/1692087551WechatIMG651.jpg" alt=""><br>Spelersdaling voor Axie Infinity - Actieve speler</p>
<p>Zoals het diagram aangeeft, was er een geleidelijke toename van het aantal spelers van Axie Infinity van oktober 2020 tot februari 2022. Vanaf dat moment nam de spelersbasis geleidelijk af gedurende de rest van het jaar. Nog erger is dat het sinds maart van dit jaar kleine aantallen actieve spelers registreert, wat ook een negatieve invloed heeft gehad op de waarde van zijn token, AXS.</p>
<p>Gedurende de afgelopen vier maanden is het aantal actieve gebruikers gedaald tot slechts een kwart miljoen. Volgens gegevens van Santiment zijn op 21 juli 345 nieuwe portefeuille-adressen geregistreerd op Axie Infinity. Desondanks groeide het AXS-netwerk op 2 augustus slechts met 75 nieuwe portefeuille-adressen, een afname van ongeveer 78%.</p>
<p>Een dergelijke daling van het aantal nieuwe portefeuille-adressen duidt op een groeiend bearish momentum. Het is essentieel om op te merken dat de Network Growth, die het aantal dagelijkse nieuwe portefeuille-adressen laat zien, aangeeft hoe een netwerk nieuwe gebruikers aantrekt.</p>
<p>Een afname van het aantal nieuwe portemonnee-adressen of gebruikers geeft aan dat de vraag naar de crypto-activa van het netwerk, zoals AXS, waarschijnlijk zal afnemen in de nabije toekomst, wat kan leiden tot een daling van de prijs. Daarom toont de afname van het aantal nieuwe portemonnee-adressen op het AXS-netwerk een afnemende interesse in de token, wat heeft geleid tot een bearish momentum.</p>
<p>Lees ook: <a href="https://www.gate.io/price/view/axie-infinity" target="_blank">Top axie-infinity Crypto Coins &amp; Tokens op basis van marktkapitalisatie</a></p>
<h2 id="h2-Redenen20achter20de20daling20van20de20groei20van20het20AXSnetwerk459518"><a name="Redenen achter de daling van de groei van het AXS-netwerk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Redenen achter de daling van de groei van het AXS-netwerk</h2><p>Verschillende factoren kunnen bijdragen aan de afname van het aantal nieuwe gebruikers van het AXS-netwerk.</p>
<p>Een factor die bijdraagt aan de daling van AXS Network Growth is de aanhoudende afname van de waarde van de AXS-token. Volgens IntoTheBlock heeft 98% van de AXS-houders ongerealiseerd verlies. Dit ontmoedigt andere investeerders om zich bij het netwerk aan te sluiten.</p>
<p>De lancering van verschillende play-to-earn games in de afgelopen maanden betekent dat het potentiële marktaandeel van Axie Infinity is afgenomen. Bijvoorbeeld, StepN, een “move-to-earn game, heeft de afgelopen maanden veel spelers aangetrokken.</p>
<p>Ook is er de afgelopen maanden een afname geweest in het verdienpotentieel van Axie Infinity. De afname in zijn verdienpotentieel heeft veel spelers uit landen als de Filipijnen weggejaagd, die hun deelname aan Axie Infinity vroeger als een baan behandelden.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2562/upcoming-token-unlock-axie-infinity-looms" target="_blank">Aankomende ontgrendeling van $156 m Token van Axie Infinity dreigt nu AXS verliezen verpleegt</a></p>
<h2 id="h2-AXS20Prijsvoorspelling26732"><a name="AXS Prijsvoorspelling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AXS Prijsvoorspelling</h2><p>De <a href="https://www.gate.io/price/axie-infinity-axs" target="_blank">AXS prijs</a> van $6,03 is momenteel meer dan 58% lager dan zijn hoogtepunt in 2023 dat in januari werd opgetekend. Het hoge ongerealiseerde verlies beïnvloedt langetermijnbeleggers om eruit te stappen, wat meer bearish druk creëert.</p>
<p>De gegevens van IntoTheBlock’s In/Out of Money Around Price (IOMAP) geven aan dat de AXS-prijs mogelijk verder zal dalen naar $5 als de daling in dagelijkse actieve gebruikers aanhoudt. Er is ook angst dat de waarde richting het weerstandsniveau van $4 kan dalen.</p>
<p>Toch, als de AXS-stieren stoppen met het verkopen van hun bezittingen, kan de prijs herstellen naar $7 of zelfs stijgen naar $8. Helaas kunnen de 10.170 portemonnee-adressen die 103,2 miljoen AXS-tokens hebben gekocht tegen een prijs van ongeveer $6,12 veel weerstand bieden.</p>
<h2 id="h2-Conclusie619778"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Axie Infinity, het eerste gamenprotocol dat het play-to-earn-model gebruikt, staat voor zorgwekkende tijden nu het aantal dagelijkse actieve gebruikers en nieuwe portemonnee-adressen blijft afnemen. Als gevolg hiervan is de prijs van AXS voortdurend aan het dalen. De token is momenteel bearish en wordt verhandeld tegen $6.03.</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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>