R2F0ZS5pbyBBTUEgbWV0IENhc3RsZSBvZiBCbGFja3dhdGVy

<p><img src="https://gimg2.gateimg.com/image/article/17120412661.jpg" alt=""><br><strong>Tijd: 1 april 2024, 13:00 UTC</strong><br><strong>Gate.io organiseerde een AMA (Ask-Me-Anything) sessie met Joren Meylaerts, CEO &amp; Co-Founder Castle of Blackwater in de <a href="https://t.me/gateio_en" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://castleofblackwater.com/" rel="nofollow noopener noreferrer" target="_blank">https://castleofblackwater.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Blackwater_Town" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Blackwater_Town</a></strong><br><strong>Volg Castle of Blackwater op <a href="https://discord.com/invite/castle-of-blackwater-932559991720775690" rel="nofollow noopener noreferrer" target="_blank">Onenigheid</a> en <a href="https://twitter.com/Blackwater_Town" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong></p>
<h2 id="h2-Q120Kun20je20jezelf20voorstellen20aan20de20leden20van20de20gemeenschap262654"><a name="Q1: Kun je jezelf voorstellen aan de leden van de gemeenschap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je jezelf voorstellen aan de leden van de gemeenschap?</h2><p>Joren: Mijn naam is Jojo en ik ben medeoprichter en CEO van Castle of Blackwater. Ik heb een achtergrond in economie, zaken en ondernemerschap, en heb ook een paar jaar gewerkt als technologie-recruiter, waar ik heb geleerd om de juiste mensen te vinden en hen samen te brengen rondom een gecentraliseerde visie. Mijn medeoprichter, Remo, is een goede vriend van mij. We zijn samen Castle of Blackwater gestart eind 2021, uit frustratie met de play to earn games op dat moment. We waren ervan overtuigd dat blockchain games leuker en duurzamer moesten zijn om mainstream geaccepteerd te worden.</p>
<h2 id="h2-Q220Wat20is20het20basisidee20van20uw20project240553"><a name="Q2: Wat is het basisidee van uw project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat is het basisidee van uw project?</h2><p>Joren: Castle of Blackwater is een spannend <a href="/web3" target="_blank" class="blog_inner_link">web3</a> sociaal deductiespel dat in samenwerking met Merit Circle is gemaakt. Het combineert een mysterieuze wereld van vertrouwen en bedrog met krachtige Web3-functies die spelers belonen voor hun vaardigheid en betrokkenheid. Het verheft het sociaal deductie-genre door innovatieve gameplay te verweven met een op eigendom gerichte sociale ervaring, waardoor spelers diep betrokken kunnen raken en een gepassioneerde gemeenschap kunnen vormen rond de intrige en magie van Blackwater Town.<br><a href="https://castleofblackwater.com/" rel="nofollow noopener noreferrer" target="_blank">https://castleofblackwater.com/</a></p>
<h2 id="h2-V320Wat20maakt20jouw20spel20anders20dan20bestaande20sociale20deductiespellen716249"><a name="V3: Wat maakt jouw spel anders dan bestaande sociale deductiespellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3: Wat maakt jouw spel anders dan bestaande sociale deductiespellen?</h2><p>Joren: Castle of Blackwater heeft als doel de beste ideeën te nemen van verschillende social deduction games die vandaag de dag bestaan.</p>
<p>Ons spel heeft de vrijheid van beweging en de opwindende gameplay die Among Us biedt, zij het met meer leuke en boeiende minigames. En tegelijkertijd hebben we ook de strategische complexiteit, diepte en herspeelbaarheid die spellen zoals Town of Salem en Deceit hebben, bijvoorbeeld. Tegelijkertijd is een groot deel van wat Castle of Blackwater zo bijzonder maakt, het ingewikkelde achtergrondverhaal en de wet die de basis legt voor onze spelwereld. Dit opent echt veel toekomstige mogelijkheden voor ons om verschillende media van storytelling te verkennen, misschien via visuele geanimeerde series of via merchandising, enzovoort.</p>
<p>Iedereen die geïnteresseerd is in meer te weten te komen over de achtergrond van het Kasteel van Blackwater en hoe deze mystieke structuur tot stand kwam. Voel je vrij om onze Medium pagina te bekijken.</p>
<h2 id="h2-Q420Wat20is20het20releaseschema20van20Castle20of20Blackwater196260"><a name="Q4: Wat is het releaseschema van Castle of Blackwater?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Wat is het releaseschema van Castle of Blackwater?</h2><p>Joren: In maart hebben we ons publieke Beta-seizoen, $COBE IDO en TGE. Zoals je je kunt voorstellen, vergde dit veel nauwkeurige planning, organisatie en uitvoering.</p>
<p>Nu dat achter ons ligt, is het eerste wat we gaan doen het verzamelen van de berg feedback die we hebben gekregen van onze bèta-spelers en ze sorteren op prioriteit van wat we moeten aanpakken. Tegelijkertijd zullen we doorgaan met het verbeteren van de stabiliteit van het spel en de functionaliteit, waarbij we eventuele overgebleven bugs en problemen oplossen.</p>
<p>Zodra dat gedaan is, zullen we doorgaan met het uitbreiden van nieuwe en die de kern van de gameplay volledig speelbaar maken. Denk aan sociale functies, beheeren, voortgangsen, noem maar op. Zodra dit klaar is, zullen we een volledig uitgewerkt spel hebben dat klaar is voor de openbare release en zullen we een enorme marketingcampagne doen met veel gaming-influencers, die wordt gelanceerd op Steam, om deze eerste versie van ons spel naar de massa’s te krijgen. Gericht op eind van dit jaar.</p>
<p>Als dat succesvol is geweest, zullen we doorgaan met het porteren van het spel naar het mobiele platform en een andere grote release op mobiele platforms doen.</p>
<p>Na de mobiele release zullen we blijven uitbreiden op de Web 3 versie van het spel en ervoor zorgen dat deze stabiel is. Tegelijkertijd zullen we de gamified wereld rondom het Castle of Blackwater uitbreiden. Deze 2D open wereld RPG-stijl editie van het spel zal faction schuilplaatsen, leuke puzzels, mini-games en andere manieren bevatten waarop je Castle of Blackwater zuren binnen de IP die we aan het creëren zijn, gebruikt kunnen worden.</p>
<h2 id="h2-Q520Hoe20zit20het20met20de20tokenomics20van20Castle20of20Blackwater883795"><a name="Q5: Hoe zit het met de tokenomics van Castle of Blackwater?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe zit het met de tokenomics van Castle of Blackwater?</h2><p>Joren: De Castle of Blackwater tokenomics zijn mede-ontworpen met <a href="https://blacktokenomics.com/" rel="nofollow noopener noreferrer" target="_blank">https://blacktokenomics.com/</a> om eerlijk, duurzaam en op de lange termijn gericht te zijn.</p>
<p>De totale voorraad $COBE is 100M tokens, en de huidige circulerende voorraad is 4.3M (excl. Liquiditeit)</p>
<p>Een overzicht van de specifieke tokenomics-toewijzingen is hier te vinden:<br><a href="https://castleofblackwater.com/news/introducing-the-cobe-token/" rel="nofollow noopener noreferrer" target="_blank">https://castleofblackwater.com/nieuws/de-cobe-token-introduceren/</a><br>Of<br><a href="https://cryptorank.io/price/castle-of-blackwater/vesting" rel="nofollow noopener noreferrer" target="_blank">https://cryptorank.io/price/castle-of-blackwater/vesting</a></p>
<h2 id="h2-Q620Welke20functies20vervullen20de20NFTs41294"><a name="Q6: Welke functies vervullen de NFT’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Welke functies vervullen de NFT’s?</h2><p>Joren: Het doel van Castle of Blackwater personage NFT’s is om toekomstige spelers wat meer controle te geven over welk personage ze in de spellen kunnen spelen. In de Web 3-versie, door het bezitten van een van de personage NFT’s, kun je een uitrusting instellen en een bepaalde hoeveelheid Cobbs-tokens bieden om je kansen te vergroten om dat personage in je volgende spel te spelen. In wezen word je door deel te nemen aan deze mechanica deel van de Value Injector-spelersgroep, omdat je ‘betaalt voor plezier’. (vind ze hier: <a href="https://sphere.market/beam/collection/0x51a7479de5C6c937e75c4e496a2514Dc2bEa8161" rel="nofollow noopener noreferrer" target="_blank">https://sphere.market/beam/collection/0x51a7479de5C6c937e75c4e496a2514Dc2bEa8161</a>)</p>
<p>Andere spelers die misschien een van de personages willen proberen, maar niet meteen willen <a href="/how-to-buy/harmony-one" rel="nofollow noopener noreferrer" target="_blank">koop er een</a> je zou ervoor kunnen kiezen om een personage te huren van een andere speler. Dus er is nog een huurmarkt die draait om die economische activiteit.</p>
<p>Daarna hebben we de cosmetische NFT’s, variërend van hoeden en rugzakken tot coole doodanimaties en huisdieren die je kunt dragen. Dit zijn allemaal dingen die je kunt dragen in het spel op je anonieme geestpersonage om jezelf een gevoel van unieke identiteit als speler te geven. (Vind ze hier: <a href="https://sphere.market/beam/collection/0xd0f4e6d8d78f4c116dab55bc887f396e212d8d53" rel="nofollow noopener noreferrer" target="_blank">https://sphere.market/beam/collection/0xd0f4e6d8d78f4c116dab55bc887f396e212d8d53</a>)</p>
<p>Op dit moment zijn de verzamelobjecten allemaal beschikbaar op de Sphere Marketplace van Merit Circle, wat we overigens absoluut geweldig vinden, veel beter dan OpenSea. In de toekomst is het echter mogelijk dat we Sphere nog dieper integreren in het spel en een vergelijkbare ervaring bieden binnen het eigenlijke spel.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Gate.io Community.</strong>, Gate.io Team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>