R2F0ZS5pbyBBTUEgbWV0IEhlcm9lcyBDaGFpbmVkIC0gRWVuIG1lZXNsZXBlbmRlIGZhbnRhc2llIFJQRy1hdm9udHV1ciB3YWFyaW4gamUgZGUgcm9sIHZhbiBlZW4gZ2lsZGUgbWVlc3RlciBvcCBqZSBuZWVtdCBlbiBlZW4gc2NhbGEgYWFuIGhlbGRlbiBzYW1lbnN0ZWx0Lg==

<p><img src="https://gimg2.gateimg.com/image/article/17018367041.jpeg" alt=""><br><strong>Tijd: 1 december 2023 om 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA-sessie (Ask-Me-Anything) met Ersin Taskin, CTO van Heroes Chained in de <a href="https://twitter.com/i/spaces/1ZkKzjadMBoKv" rel="nofollow noopener noreferrer" target="_blank">Twitter Space</a>.</strong><br><strong>Officiële website: <a href="https://heroeschained.com/" rel="nofollow noopener noreferrer" target="_blank">https://heroeschained.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/HeroesChained" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/HeroesChained</a></strong><br><strong>Volg Heroes Chained op <a href="https://twitter.com/HeroesChained" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/HeroesChainedOfficial" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/17018365412.jpeg" alt=""><br><strong>Ersin Taskin - CTO van Heroes Chained</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio716560"><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-Q120Hallo20Ersin20welkom20Kun20je20jezelf20en20het20team20even20voorstellen714102"><a name="Q1: Hallo Ersin, welkom! Kun je jezelf en het team even voorstellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Hallo Ersin, welkom! Kun je jezelf en het team even voorstellen?</h3><p><strong>Ersin</strong>: Ik heb een BS-graad in Elektrotechniek en Elektronica van de Bogazici Universiteit. Ik heb meer dan 20 jaar ervaring in de software- en IT-industrie, als ontwikkelaar, ingenieur, verkoopdirecteur, manager, CEO, ondernemer. Voorafgaand aan Heroes Chained was ik mede-oprichter, chief software architect en hoofdontwikkelaar van een van de top tien IT- en softwarebedrijven van het land.</p>
<p>De medeoprichters hebben voornamelijk technische achtergronden, zoals informatica, elektrotechniek, enz. Ze zijn serieuze ondernemers met een indrukwekkende staat van dienst.</p>
<p>Ik ben medeoprichter van een softwarebedrijf dat in de top tien van het land staat, bijvoorbeeld samen met mijn broer Erhan, die hier ook medeoprichter is. Vervolgens hebben Salih, Alp en Battal start-up- en exit-succes in de VS, Canada en Turkije. Hun laatste exit was naar Iron Mountain, de wereldwijde gigant in records en documentbeheer.</p>
<p>We hebben een geweldig team voor game-ontwikkeling opgericht, geleid door geweldige leiders zoals Mev, de ervaring omvat wereldwijd bekroonde spellen voor Activision, Ubisoft, Super Nintendo, enz.</p>
<h3 id="h3-Q220Kunt20u20ons20alstublieft20vertellen20over20het20spel20en20wat20Heroes20Chained20uniek20maakt249256"><a name="Q2: Kunt u ons alstublieft vertellen over het spel en wat Heroes Chained uniek maakt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kunt u ons alstublieft vertellen over het spel en wat Heroes Chained uniek maakt?</h3><p><strong>Ersin</strong>: HC is een fantasie actie RPG waar de speler een guild master is en helden verzamelt.</p>
<p>We hebben een sterke lore. We hebben ook het diepgaande meesterschap van gameplay van spellen zoals Magic the Gathering gecombineerd met dat van Diablo. Als Baldurs Gate maar niet turn-based, real-time actie.</p>
<p>Je kunt het zien als Magic TG op adrenaline. Of Baldurs Gate op meer adrenaline.</p>
<p>Je beheert je heldenteam op het slagveld in real-time via vaardigheids- en spreukkaarten. Het is als Hearthstone met adrenaline.<br><img src="https://gimg2.gateimg.com/image/article/17018365563.jpeg" alt=""><br>Spelers bezitten een ‘Guild’ en verzamelen helden, concurreren tegen anderen en voltooien missies om de ultieme guild te worden in de stad Last Hope! Spelers kunnen PvE spelen door hun helden buiten de muren van de stad te sturen, om vijanden op de kaart te verslaan, nodes te ontdekken, dungeons te vinden en artefacten te claimen, missies te voltooien, middelen te verzamelen en uitrusting te maken, enzovoort. Later zullen we PvP-modus lanceren die toernooien en competities (officieel of niet-officieel) mogelijk maakt. Bouw, verken, handel, strijd, bundel krachten, socialiseer.</p>
<h3 id="h3-Q320Kunt20u20ons20alstublieft20vertellen20over20uw20routekaart20Wat20heeft20u20tot20nu20toe20bereikt20en20wat20kunt20u20verwachten20in202024333909"><a name="Q3: Kunt u ons alstublieft vertellen over uw routekaart? Wat heeft u tot nu toe bereikt en wat kunt u verwachten in 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kunt u ons alstublieft vertellen over uw routekaart? Wat heeft u tot nu toe bereikt en wat kunt u verwachten in 2024?</h3><p><strong>Ersin</strong>: We zijn twee jaar geleden met het project begonnen en hebben tot nu toe veel bereikt. We hadden <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> Foundation als de belangrijkste ondersteuner. We hadden andere ondersteuners, zoals Kucoin, OKX ventures, YGG SEA, GGG, Avocado guild, Avatar, Kyros, Panony, enz. We wonnen de eerste ooit <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> hackathon aan het einde van 2021. Daarna hadden we een enorme IDO op 17 januari 2021 met records van zowel Seedify als Avalaunch. We zijn genoteerd op <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> Global, Gate.io, Whitebit, enz. We hebben een sterke organische gemeenschap van 55K Twitter-volgers. Vergelijkbare kracht op Telegram en Discord.</p>
<p>We hadden twee succesvolle NFT-verkoopbatches van Mayinhara-helden. Geïmplementeerde staking- en DeFi-programma’s, brachten ons minispel uit voor de Mayinhara-houders als een aanvullende levering aan ons roadmaps. We hadden succesvolle testuitgaven van verschillende modi van ons spel. Nu brengen we de open bèta van het volledige spel uit.</p>
<p>Technisch gezien zullen we klaar zijn om het spel in Q1 2024 te lanceren. We zullen een druk schema hebben met marketing- en zakelijke ontwikkelingsactiviteiten tijdens de lancering.</p>
<h3 id="h3-Q420Welke20beloningen20kunnen20we20verdienen20met20de20bta394698"><a name="Q4: Welke beloningen kunnen we verdienen met de bèta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Welke beloningen kunnen we verdienen met de bèta?</h3><p><strong>Ersin</strong>: Helden Chained Open Beta Conquest Toernooi</p>
<p><strong>Prijs</strong>: We hebben exclusieve prijzen klaargemaakt voor degenen die missie-uitdagingen overwinnen en de felbegeerde top drie posities op het leaderboard bereiken in ons toernooi:</p>
<p>1e plaats: Legendarische Guild Card NFT en MayinHara NFT<br>2e plaats: MayinHara NFT<br>3e plaats: MayinHara NFT</p>
<p>Maar dat is nog niet alles! Degenen die op de 4e tot de 10e plaats staan, zullen elk een hoogwaardige Guild Card NFT ontvangen, met zijn unieke kenmerken, allemaal bestemd om je ervaring in de volledige release van Heroes Chained te verbeteren.</p>
<p>Houd een waakzaam oog op je voortgang terwijl je de rangen beklimt. Onze leaderboard, gestationeerd op <a href="https://heroeschained.com/betaleaderboard" rel="nofollow noopener noreferrer" target="_blank">https://heroeschained.com/betaleaderboard</a> zal uw baken van begeleiding zijn. Dagelijks bijgewerkt om 14.00 uur UTC, het zal uw positie en prestaties laten zien terwijl u streeft naar glorie.</p>
<p>Voor toernooi details kunt u onze website bezoeken: <a href="https://heroeschained.com" rel="nofollow noopener noreferrer" target="_blank">https://heroeschained.com</a></p>
<h3 id="h3-V520Hoe20kan20ik20me20nu20aanmelden20voor20de20open20bta61785"><a name="V5: Hoe kan ik me nu aanmelden voor de open bèta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: Hoe kan ik me nu aanmelden voor de open bèta?</h3><p><strong>Ersin</strong>: Vanwege de grote vraag en interesse in ons spel hebben we het ‘whitelist’-systeem uitgeschakeld. U kunt zich nu registreren voor ons spel met elk gewenst e-mailadres, inloggen en van het spel genieten.<br><img src="https://gimg2.gateimg.com/image/article/17018365774.jpeg" alt=""><br>“#HeroesChained Open Beta is beschikbaar op @AppStore en @GooglePlay”</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten 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>