R2F0ZS5pbyBBTUEgbWV0IEZvcmVzdEtuaWdodCAtIEVlbiB0dXJuLWJhc2VkIHN0cmF0ZWdpZSBtb2JpZWxlIGdhbWUgd2Fhcm1lZSBzcGVsZXJzIGh1biBkcm9vbXRlYW0ga3VubmVuIHNhbWVuc3RlbGxlbg==

<p><img src="https://gimg2.gateimg.com/image/article/16835288461.jpg" alt=""><br><strong>Tijd: 2 maart 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hosted een AMA (Ask-Me-Anything) sessie met Behfar, CEO van ForestKnight in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io uitwisselingsgemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://www.forestknight.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.forestknight.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/ForestKnight_io" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ForestKnight_io</a></strong><br><strong>Volg ForestKnight op <a href="https://t.me/Forestknight" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/thxGhkB" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16835290682.png" alt=""><br><strong>Behfar - CEO van ForestKnight</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio124567"><a name="Vragen en antwoorden van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vragen en antwoorden van Gate.io</h2><h3 id="h3-Q120Hallo20Behfar20kun20je20jezelf20eerst20even20voorstellen142266"><a name="Q1: Hallo Behfar, kun je jezelf eerst even voorstellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Hallo Behfar, kun je jezelf eerst even voorstellen?</h3><p><strong>Behfar</strong>: Natuurlijk!<br>Wij zijn een team van gepassioneerde gamers, ontwikkelaars en artiesten die proberen een geweldig spel te creëren dat ook als doel heeft om normale mobiele gamers kennis te laten maken met de NFT-wereld zonder een stapel boeken door te moeten spitten of een fortuin te betalen om toegang te krijgen.</p>
<p>Onze filosofie is eerst gamen en vervolgens blockchain gebruiken om de spelervaring van onze spelers te verbeteren door middel van NFT’s, zodat er een eerlijke en leuke Play2Earn-omgeving ontstaat waarin spelers daadwerkelijk eigenaar zijn van hun activa.</p>
<h3 id="h3-Q220Kun20je20het20Forest20Knightproject20uitleggen20en20hoe20werkt20het20Wat20heb20je20tot20nu20toe20gedaan153226"><a name="Q2: Kun je het Forest Knight-project uitleggen en hoe werkt het? Wat heb je tot nu toe gedaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je het Forest Knight-project uitleggen en hoe werkt het? Wat heb je tot nu toe gedaan?</h3><p><img src="https://gimg2.gateimg.com/image/article/16835290883.jpg" alt=""><br><strong>Behfar</strong>: Forest Knight is een mobiel spel dat beschikbaar is op de Google Play Store als Early Access en binnenkort ook op IOS zal zijn. Het spel is volledig functioneel en we hebben het play-to-earn mechanisme al geïmplementeerd in het spel. De economie van het spel zal naar verwachting voor het einde van deze maand beginnen te functioneren. Je kunt onze website hier bekijken. <a href="https://bit.ly/3HQ6cnD" rel="nofollow noopener noreferrer" target="_blank">https://bit.ly/3HQ6cnD</a> en als je het spel nog niet hebt geprobeerd, voel je vrij om het te proberen.</p>
<h3 id="h3-Q320Kun20je20de20prestaties20delen20die20het20team20tot20nu20toe20heeft20geboekt20Wat20zijn20enkele20belangrijke20doelstellingen20die20het20project20nog20moet20bereiken20Indien20mogelijk20deel20ook20je20roadmap20missie20en20visie324029"><a name="Q3: Kun je de prestaties delen die het team tot nu toe heeft geboekt? Wat zijn enkele belangrijke doelstellingen die het project nog moet bereiken? Indien mogelijk, deel ook je roadmap, missie en visie." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kun je de prestaties delen die het team tot nu toe heeft geboekt? Wat zijn enkele belangrijke doelstellingen die het project nog moet bereiken? Indien mogelijk, deel ook je roadmap, missie en visie.</h3><p><strong>Behfar</strong>: Het is moeilijk om een prominente plek op de markt te veroveren.<br>We willen het beste van beide werelden combineren, de meeste blockchain-spellen zijn vrij eenvoudig en hebben niet zoveel functies. Als het niet om de betaling/spelen om te verdienen mechanismen ging, zouden de meeste spelers het zelfs niet spelen, wat Forest Knight probeert te doen. Is de brug te zijn tussen leuke/competitieve mobiele games en de wereld van blockchain spelen om te verdienen.</p>
<p>Ons doel is om een spel te hebben dat elke soort speler kan genieten, van PVE tot PVP tot gilde/realm oorlogen, zelfs als ze niet uit zijn op geld. Omdat we zelf gamers zijn en we gamers kennen. Echte gamers zullen zich niet druk maken om de technologie, ze willen gewoon plezier hebben met spelen.</p>
<h3 id="h3-Q420Bovendien20zijn20er20de20laatste20tijd20veel20playtoearn20en20metaverseprojecten20gelanceerd20Wat20maakt20Forest20Knight20beter20dan20de20concurrentie20Het20is20moeilijk20om20een20prominente20plaats20op20de20markt20te20veroveren988788"><a name="Q4: Bovendien zijn er de laatste tijd veel play-to-earn- en metaverse-projecten gelanceerd. Wat maakt Forest Knight beter dan de concurrentie? Het is moeilijk om een prominente plaats op de markt te veroveren." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Bovendien zijn er de laatste tijd veel play-to-earn- en metaverse-projecten gelanceerd. Wat maakt Forest Knight beter dan de concurrentie? Het is moeilijk om een prominente plaats op de markt te veroveren.</h3><p><strong>Behfar</strong>: Ik denk dat onze aanpak zeer gericht is op gaming en dat we het zullen kunnen laten zien. De gamingmarkt is al enorm en naarmate er steeds meer mensen overgaan naar de NFT- en play2Earn-markt, hebben we in dat opzicht een goede bereikbare markt. Door de best mogelijke en leukste ervaring te bieden en de spelers zelfs te laten vergeten dat ze te maken hebben met een Play2own / Play2Earn-spel, denk ik dat we in een goede positie zullen zijn.</p>
<h3 id="h3-Q520Klinkt20goed20ik20ben20ook20van20mening20dat20er20een20perfecte20balans20zal20zijn20tussen20Earn20en20Fun20spelen20maar20uiteindelijk20zal20het20meer20in20balans20zijn20met20hoe20leuk20het20spel20daadwerkelijk20is20Ik20weet20niet20zeker20of20puur20verdienen20op20dit20moment20duurzaam20zal20zijn20Wat20zou20jij20zeggen20dat20jouw20belangrijkste20doel20is20om20te20bereiken20in202022464314"><a name="Q5: Klinkt goed, ik ben ook van mening dat er een perfecte balans zal zijn tussen Earn en Fun spelen, maar uiteindelijk zal het meer in balans zijn met hoe leuk het spel daadwerkelijk is. Ik weet niet zeker of puur verdienen op dit moment duurzaam zal zijn. Wat zou jij zeggen dat jouw belangrijkste doel is om te bereiken in 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Klinkt goed, ik ben ook van mening dat er een perfecte balans zal zijn tussen Earn en Fun spelen, maar uiteindelijk zal het meer in balans zijn met hoe leuk het spel daadwerkelijk is. Ik weet niet zeker of puur verdienen op dit moment duurzaam zal zijn. Wat zou jij zeggen dat jouw belangrijkste doel is om te bereiken in 2022?</h3><p><strong>Behfar</strong> Gamen moet altijd in de eerste plaats een leuke activiteit zijn en geen ‘baan’. Tenminste voor 99% van de spelers.</p>
<p>Wat ontwikkeling betreft, is ons doel om onze volledige routekaart af te ronden, maar wat aantallen betreft, streven we ernaar om in 2022 onze mijlpaal van 1 miljoen spelers te bereiken en een blockchain-spel te hebben dat echt leuk is om te spelen, met of zonder het blockchain-aspect.</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 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>