R2F0ZS5pbyBBTUEgbWV0IEFyYWRlbmEgLSBIZXQgYm91d2VuIHZhbiBkZSB2b2xnZW5kZSBnZW5lcmF0aWUgdmFuIFRyYWRpbmcgQ2FyZCBHYW1pbmc=

<p><img src="https://gimg2.gateimg.com/image/article/16873326791.png" alt=""><br><strong>Tijd: 20 juni 2023, 13:00 uur (UTC)</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Liam Bacon, de CEO en medeoprichter van Aradena in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Community</a>.</strong><br><strong>Twitter: <a href="https://twitter.com/AradenaWarrior" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/AradenaWarrior</a></strong><br><strong>Volg Aradena op <a href="https://t.me/Aradena_Official_Community" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/AradenaWarrior" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16873328922.png" alt=""><br><strong>Liam Bacon - de CEO en medeoprichter van Aradena</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio856237"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-V120Kunt20u20kort20beschrijven20wat20Aradena20Battlegrounds20is20amp20hoe20het20werkt873869"><a name="V1: Kunt u kort beschrijven wat Aradena: Battlegrounds is &amp; hoe het werkt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Kunt u kort beschrijven wat Aradena: Battlegrounds is &amp; hoe het werkt?</h3><p><strong>Liam</strong>: Battlegrounds is een boeiende tactische TCG die verzamelkaarten tot leven brengt in strategische 3D-gameplay. Gevestigd in het middeleeuwse fantasiekoninkrijk van Aradena, biedt het een uniek en meeslepend gevechtssysteem dat de deck-buildmechanica van CCG’s zoals Hearthstone combineert met de strategische gameplay die te vinden is in titels zoals Civilisation, Warhammer en XCOM.</p>
<p>Op het 3D-hex-veld gebruiken spelers spannende nieuwe TCG-mechanismen zoals teleportatie, entreeplays en strategische formaties om hun tegenstanders te slim af te zijn en te verslaan. Deze mechanismen worden meer in detail uitgelegd in dit mediumartikel:<br><a href="https://aradena.medium.com/3-incredible-new-mechanics-game-design-update-11-05-23-45704bacd8fd" rel="nofollow noopener noreferrer" target="_blank">https://aradena.medium.com/3-incredible-new-mechanics-game-design-update-11-05-23-45704bacd8fd</a></p>
<p>Één opvallende kenmerk van Aradena is de Golem, die zowel dient als de gezondheid van de speler als de overkoepelende winstvoorwaarde. Elke speler begint met een <a href="/price/golem-glm" target="_blank" class="blog_inner_link">Golem</a> op het bord, die fungeert als hun gezondheidsreserve. Het spel wordt gewonnen door de Golem van de tegenstander naar nul gezondheid te reduceren, terwijl men zijn eigen Golem beschermt. Aan het einde van elke beurt zetten de Golems stappen naar het midden van het bord en gaan ze bij aankomst de strijd aan. Dit medium artikel biedt verdere inzichten in de Golem-modus:<br><a href="https://aradena.medium.com/" rel="nofollow noopener noreferrer" target="_blank">https://aradena.medium.com/</a> <a href="/price/golem-glm" rel="nofollow noopener noreferrer" target="_blank">Golem</a>-mode-update-een-spannende-nieuwe-functie-voor-battlegrounds-gameplay-cf94a6c64c6<br><img src="https://gimg2.gateimg.com/image/article/16873329723.png" alt=""><br>Aradena biedt een game-ervaring die diepgang in strategie combineert met snelle opwinding. Of je nu een ervaren TCG-veteraan bent of nieuw bent in het genre, dit spel belooft een uitdagend en lonend avontuur. Om meer te weten te komen over het spelen van Aradena: Battlegrounds, kun je deze informatieve gameplay-tutorial bekijken met een van onze game-ontwerpers:<br><a href="https://www.youtube.com/watch?v=VqxFbNXEqZQ" rel="nofollow noopener noreferrer" target="_blank">https://www.youtube.com/watch?v=VqxFbNXEqZQ</a></p>
<h3 id="h3-Q220Kunt20u20ons20vertellen20over20de20partners20en20supporters20van20Aradena20Battlegrounds993861"><a name="Q2: Kunt u ons vertellen over de partners en supporters van Aradena: Battlegrounds?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kunt u ons vertellen over de partners en supporters van Aradena: Battlegrounds?</h3><p><strong>Liam</strong>: Litoja Labs is een bedrijf opgericht door experts uit de industrie op het gebied van technologie, <a href="/web3" target="_blank" class="blog_inner_link">web3</a> en gaming om de manier waarop we online spelen en communiceren te revolutioneren. De belangrijkste investeerder van Litoja Labs is Animoca Brands, en ze hebben belangrijke partnerschappen met verschillende marktleiders zoals Immutable X.</p>
<p>BELANGRIJKE ADVISEURS - Mohamed Ezeldin: Hoofd van Tokenomics bij Animoca Brands - Benjamin Lee: Medeoprichter van Blowfish Studios en Phantom Galaxies - Mark Cheng: Oprichter bij GameFi Ventures en Senior Adviseur bij Animoca Brands - Carey Chico: Meer dan 20 jaar ervaring als uitvoerend producent en senior game lead bij EA en Activision. Voorheen hoofd van nieuwe projecten en monetisatiedesign bij Splinterlands.</p>
<p>BACKERS - Leidende Strategische Investeerder: Animoca Brands Animoca Brands, Atesis Capital, Avocado Guild, Double Peak, Enzac Research, GameFi Ventures, Gate Labs, Good Games Guild, Jump Crypto, Legion Ventures, Maven Capital, Path DAO, Red Swiss Capital Ventures, RR2 Capital, SkyVision Capital en meer.</p>
<h3 id="h3-V320De20gemeenschap20is20cruciaal20voor20het20succes20van20een20project20Gezien20de20aanzienlijke20toename20van20activiteit20in20uw20gemeenschap20sinds20de20lancering20van20de20bta20hoe20van20plan20bent20u20om20meer20gebruikers20aan20te20trekken20en20uw20gemeenschap20uit20te20breiden342019"><a name="V3: De gemeenschap is cruciaal voor het succes van een project. Gezien de aanzienlijke toename van activiteit in uw gemeenschap sinds de lancering van de bèta, hoe van plan bent u om meer gebruikers aan te trekken en uw gemeenschap uit te breiden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3: De gemeenschap is cruciaal voor het succes van een project. Gezien de aanzienlijke toename van activiteit in uw gemeenschap sinds de lancering van de bèta, hoe van plan bent u om meer gebruikers aan te trekken en uw gemeenschap uit te breiden?</h3><p><strong>Liam</strong>: Sinds de lancering van het bètaseizoen begin juni heeft de Aradena-gemeenschap een opmerkelijke groei doorgemaakt, met meer dan 20.000 nieuwe leden die zich aansluiten op platforms zoals Twitter, Discord en Telegram. Om de gemeenschap wereldwijd verder uit te breiden, heeft het team een strategisch plan bedacht.</p>
<p>Allereerst zullen ze gebruikmaken van sleutelfiguren, door samenwerkingsverbanden aan te gaan met invloedrijke personen die kunnen helpen bij het aantrekken van nieuwe gebruikers op belangrijke geografische locaties. Bovendien zal het team organische contentstrategieën toepassen om de gemeenschap te betrekken en bewustwording te verspreiden. Er zullen betaalde advertenties gericht op Web3 worden ingezet om een breder publiek te bereiken en spelers naar het Aradena-ecosysteem te lokken.</p>
<p>Spannende toernooien zullen ook worden georganiseerd om gamers te boeien en hun deelname aan Aradena aan te moedigen. Deze initiatieven, samen met de interne marketingprofessionals van het team en samenwerkingen met toonaangevende marketingbureaus, zullen een belangrijke rol spelen bij het behalen van hun doel van 50.000 maandelijkse actieve gebruikers (MAU’s) tegen het einde van het vierde kwartaal van 2023.</p>
<p>Om het vermogen van het team om TCG- en strategiegamers te boeien te laten zien, hebben ze onlangs een cinematische trailer gelanceerd voor Aradena: Battlegrounds. In slechts drie dagen kreeg de trailer meer dan 180.000 views op YouTube, wat voor opwinding zorgde voor de aankomende lancering van Seizoen 1. Je kunt de trailer hier bekijken:<br><a href="https://www.youtube.com/watch?v=g34z8a0hdtw" rel="nofollow noopener noreferrer" target="_blank">https://www.youtube.com/watch?v=g34z8a0hdtw</a></p>
<h3 id="h3-Q420Kun20je20ons20vertellen20over20AG20jouw20IDO20en20wat20is20het20nut20van20de20AGtoken33894"><a name="Q4: Kun je ons vertellen over $AG, jouw IDO, en wat is het nut van de $AG-token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je ons vertellen over $AG, jouw IDO, en wat is het nut van de $AG-token?</h3><p><strong>Liam</strong>: De Aradenean Gold-token ($AG) dient meerdere doeleinden binnen het Aradena: Battlegrounds-ecosysteem. Het stelt gebruikers in staat om digitale activa, zoals goud-tier NFT’s, te verwerven uit de Aradena Store. Via de winkel kunnen spelers seizoensgebonden packs kopen of specifieke goud-tier kaarten die beschikbaar zijn in roterende winkelsleuven. Naast het verwerven van activa kan $AG worden gebruikt voor diverse in-game functies en verbeteringen.</p>
<p>Gebruikers kunnen $AG uitgeven om spel-cosmetica te verkrijgen, deel te nemen aan toernooien, quests te verbeteren, zilver om te zetten, RNG (Random Number Generator) te manipuleren, spel-avatar te rekruteren, gilden te vormen, kaartsacrifices uit te voeren, inzetten voor beloningen, en liquiditeit te bieden aan gedecentraliseerde beurzen.</p>
<p>Om vanaf het begin een robuuste economie te garanderen, zal $AG directe bruikbaarheid hebben bij de lancering. Enkele van de initiële toepassingen zijn onder meer Aradena: Questing, een mini-spel waarmee spelers hun Warrior NFT’s kunnen upgraden, en Aradena: Staking, waarmee spelers de mogelijkheid krijgen om aantrekkelijke jaarlijkse rentetarieven (APR’s) te verdienen. De APR’s worden bepaald door factoren zoals de stakingsduur, het gestorte bedrag en het aantal Aradena NFT-activa dat de speler bezit. Tot slot zal de Aradena Store live zijn, waardoor spelers de spannende mogelijkheid krijgen om loot-kisten te kopen met waardevolle in-game activa met hun Aradenean Gold.</p>
<p>Om vanaf het begin een robuuste economie te garanderen, zal $AG direct bruikbaarheid hebben bij de lancering. Enkele van de initiële bruikbaarheden zijn onder andere Aradena: Questing, een minigame waarmee spelers hun Warrior NFT’s kunnen upgraden, en Aradena: Staking, waarbij spelers de mogelijkheid hebben om aantrekkelijke jaarlijkse rentepercentages (APR’s) te verdienen. De APR’s worden bepaald door factoren zoals de stakingsduur, het gestorte bedrag en het aantal Aradena NFT-activa in bezit van de speler. Ten slotte zal de Aradena Store live zijn, waardoor spelers de spannende kans krijgen om lootkisten te kopen met waardevolle in-game activa met hun Aradenean Gold.</p>
<p>Door $AG-tokens te bezitten, kunnen gebruikers toegang krijgen tot een scala aan functies en voordelen, waardoor hun spelervaring wordt verbeterd en ze mogelijk beloningen verdienen door te staken.<br><img src="https://gimg2.gateimg.com/image/article/16873329874.png" alt=""><br>De IDO vindt plaats op 20 juni deze week! En we zullen op 21 juni op Gate.io worden vermeld voor iedereen die de eerste verkoop mist!</p>
<h3 id="h3-Q520Waar20kunnen20we20meer20informatie20vinden20over20Aradena20inclusief20het20spel20de20btalaunch20en20de20tokenlancering20en20hoe20kunnen20mensen20betrokken20raken952670"><a name="Q5: Waar kunnen we meer informatie vinden over Aradena, inclusief het spel, de bètalaunch en de tokenlancering, en hoe kunnen mensen betrokken raken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Waar kunnen we meer informatie vinden over Aradena, inclusief het spel, de bètalaunch en de tokenlancering, en hoe kunnen mensen betrokken raken?</h3><p><strong>Liam</strong>: Battlegrounds organiseert momenteel de bèta-showdown 2, die op 16 juni begon. Spelers krijgen de kans om te strijden voor een prijzenpot van $15.000, bestaande uit $AG en exclusieve NFT-beloningen. Voor uitgebreide toernooidetails kunt u verwijzen naar dit medium artikel:<br><a href="https://aradena.medium.com/the-aradena-beta-showdown-continues-21ce7c39db96" rel="nofollow noopener noreferrer" target="_blank">https://aradena.medium.com/de-aradena-beta-showdown-gaat-door-21ce7c39db96</a></p>
<p>Om het spel te starten, meld je hier aan voor een Aradena spelaccount:<br><a href="https://game.aradena.io/enter/register/" rel="nofollow noopener noreferrer" target="_blank">https://game.aradena.io/enter/register/</a> en download het spel vanaf:<br><a href="https://launcher.elixir.app/games/aradena#overview" rel="nofollow noopener noreferrer" target="_blank">https://launcher.elixir.app/games/aradena#overzicht</a> om vandaag in actie te komen.</p>
<p>Na de lancering van de Aradenean Gold ($AG) token, zal Fase 1 van de game store live gaan. Spelers hebben verschillende opties om hun gameplay-ervaring te verbeteren door $AG-tokens te gebruiken om te kopen, pre-release bundels, gouden kaartpakketten, buitkisten, zilveren pakketten, zilveren munten, wijn, toverdranken, beestbloed, kaartzijden (IMX NFT), trofeeën (IMX NFT), en Golems (IMX NFT)<br>Alle winkelaankopen zullen vereisen dat er $AG is gestort, wat met één enkele blockchain-transactie kan worden gedaan. Zodra de $AG op de game-account is gestort, kunnen spelers vrijelijk hun gestorte $AG uitgeven zonder extra blockchain-transacties.<br>Naast het aansluiten bij de eerder genoemde communitykanalen, is de Aradena-website een uitstekende bron voor nieuwe spelers. De website biedt toegang tot de Aradena-bibliotheek, waar spelers meer kunnen leren over de lore van het spel. Ze kunnen ook de interactieve 3D-kaart van de wereld van Aradena verkennen en zich aanmelden voor een game-account om hun gratis krijger op te eisen, die kan worden geüpgraded ter voorbereiding op de volledige lancering van Aradena: Battlegrounds later dit jaar!<br>Website &gt; <a href="https://aradena.io/home/" rel="nofollow noopener noreferrer" target="_blank">https://aradena.io/home/</a><br>Twitter &gt; <a href="https://twitter.com/AradenaWarrior" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/AradenaWarrior</a><br>Discord &gt; <a href="https://discord.gg/aradena-864511755504713789" rel="nofollow noopener noreferrer" target="_blank">https://discord.gg/aradena-864511755504713789</a><br>Telegram &gt; <a href="https://t.me/Aradena_Official_Community" rel="nofollow noopener noreferrer" target="_blank">https://t.me/Aradena_Official_Community</a></p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Gemeenschap<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 voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>