R2F0ZS5pbyBBTUEgY29uIEtuaWdodCBXYXIgLSBJbCBwcmltbyBnaW9jbyBQbGF5LVRvLUVhcm4gbmVsIGdlbmVyZSBJZGxlIERlZmVuc2U=

<p><img src="https://gimg2.gateimg.com/image/article/16868079971.jpg" alt=""><br><strong>Ora: 17 dicembre 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con LUU Anh Thinh &amp; LE Quynh Anh, rappresentanti delle relazioni con gli investitori e i partner di Knight War nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://knightwar.io/" rel="nofollow noopener noreferrer" target="_blank">https://knightwar.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/knightwarp2e" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/knightwarp2e</a></strong><br><strong>Segui Knight War su Twitter e Telegram</strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16868082122.jpg" alt=""><br><strong>LE Quynh Anh - Rappresentante delle relazioni con i partner di Knight War</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio657510"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Puoi20brevemente20presentare20Knight20War20The20Holy20Trio520840"><a name="Q1: Puoi brevemente presentare Knight War The Holy Trio?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi brevemente presentare Knight War The Holy Trio?</h3><p><strong>Quynh Anh</strong> Certamente, risponderò a questa domanda!</p>
<p>Knight War The Holy Trio è un gioco Play-To-Earn nel genere Idle Defense. Abbiamo lanciato il gioco su Binance Smart Chain e l’IDO è stato a settembre 2021.</p>
<p>Successivamente, parlerò un po’ della storia del gioco. Il gioco è ambientato in un luogo chiamato Kahlla, precedentemente colonizzato dai Demoni. I giocatori dovranno creare una squadra di eroi diversi per difendersi dai demoni.<br><img src="https://gimg2.gateimg.com/image/article/16868082293.png" alt=""><br>Tuttavia, il nostro sistema NFT non riguarda gli eroi o i personaggi, ma le armi in-game. Le armi NFT sono oggetti di valore in-game e sono il cuore della nostra economia Play-To-Earn.</p>
<h3 id="h3-Q220Hai20lanciato20il20tuo20gioco20ufficiale20Se20no20qual2020il20tuo20programma20pianificato20per20lanciare20il20gioco846878"><a name="Q2: Hai lanciato il tuo gioco ufficiale? Se no, qual è il tuo programma pianificato per lanciare il gioco?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Hai lanciato il tuo gioco ufficiale? Se no, qual è il tuo programma pianificato per lanciare il gioco?</h3><p><strong>Quynh Anh</strong>: All’inizio di novembre, abbiamo introdotto la nostra Alpha Testnet e la versione beta del gioco. La versione beta durerà fino al 29 novembre. E il nostro gioco ufficiale è stato lanciato il 30 novembre.</p>
<p>Finora abbiamo ricevuto molti feedback e suggerimenti dalla nostra community. Gli sviluppatori stanno lavorando continuamente per migliorare il nostro gioco con nuove funzionalità, quindi rimanete sintonizzati!</p>
<h3 id="h3-Q320Appena20lanciato20Che20emozione20Potrei20dover20andare20a20provarlo20Quindi20quali20caratteristiche20ha20la20Versione20Ufficiale429320"><a name="Q3: Appena lanciato! Che emozione. Potrei dover andare a provarlo! Quindi, quali caratteristiche ha la Versione Ufficiale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Appena lanciato! Che emozione. Potrei dover andare a provarlo! Quindi, quali caratteristiche ha la Versione Ufficiale?</h3><p><strong>Quynh Anh</strong>: Sì, vi diamo il benvenuto tutti a unirvi alla Comunità della Guerra dei Cavalieri.</p>
<p>Riguardo alla versione ufficiale, attualmente ha le seguenti caratteristiche: modalità campagna, creazione di NFT, personaggi &amp; castello.</p>
<p>Inoltre, nella versione ufficiale, stiamo eseguendo la funzione Caccia al Boss in cui i giocatori possono collaborare per sconfiggere Boss super potenti. I giocatori con il maggior danno inflitto al Boss riceveranno grandi ricompense! La seconda stagione del torneo di caccia al Boss sta accadendo proprio ora.</p>
<h3 id="h3-Q420Con20il20lancio20ufficiale20del20gioco20il20valore20di20KWS20aumenter20Possiamo20aspettarci20un20KWS20da20120a20breve365855"><a name="Q4: Con il lancio ufficiale del gioco, il valore di KWS aumenterà? Possiamo aspettarci un KWS da $1 a breve?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Con il lancio ufficiale del gioco, il valore di KWS aumenterà? Possiamo aspettarci un KWS da $1 a breve?</h3><p><strong>Quynh Anh</strong>: Si prega di comprendere che nessuno può controllare il prezzo del token KWS in quanto è determinato dal mercato pubblico. Tuttavia, il team sta lavorando duramente per diffondere le notizie, promuovere il gioco il più possibile nelle comunità, soprattutto nella regione del Sud-Est asiatico, Sud-Asia e Africa, dove i giochi play-2-earn stanno diventando un argomento caldo.</p>
<p>Quindi speriamo davvero di ricevere un grande aumento del valore di KWS con questa strategia. Inoltre, crediamo nel nostro prodotto, nel nostro team e soprattutto nella capacità della comunità di aiutare la crescita dell’ecosistema. Chi sa? $1, $2 o anche $5 sono possibili se abbiamo la comunità con noi.</p>
<h3 id="h3-Q520Come20pianifichi20il20tuo20Marketing20e20lAcquisizione20di20Clienti840064"><a name="Q5: Come pianifichi il tuo Marketing e l’Acquisizione di Clienti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come pianifichi il tuo Marketing e l’Acquisizione di Clienti?</h3><p><strong>Quynh Anh</strong> In primo luogo, iniziamo dalle comunità dei nostri partner. Cerchiamo di organizzare molte campagne e AMA con molte grandi comunità come la comunità di Gate.io qui per attirare i giocatori e gli investitori.</p>
<p>Abbiamo anche stretto partnership con molti streamer per pubblicizzare e presentare i nostri giochi. In seguito, collaboriamo con grandi marchi Blockchain per acquisire veterani della criptovaluta e investitori esperti nelle loro comunità.</p>
<h3 id="h3-Q620E20per20gli20eventi20importanti20Knight20War20ha20qualche20grande20evento20alla20fine20dellanno651295"><a name="Q6: E per gli eventi importanti? Knight War ha qualche grande evento alla fine dell’anno?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: E per gli eventi importanti? Knight War ha qualche grande evento alla fine dell’anno?</h3><p><strong>Quynh Anh</strong>: Oltre ai grandi eventi come il torneo di caccia al boss e il lancio delle funzionalità PVP, prepariamo anche molti piccoli eventi per la community come il quiz settimanale, il concorso NFT, il concorso di design di adesivi!<br><img src="https://gimg2.gateimg.com/image/article/16868082414.jpg" alt=""><br>Puoi dare un’occhiata alla nostra tabella di marcia!</p>
<h3 id="h3-Q720E20per20concludere20prima20di20passare20alle20domande20del20nostro20pubblicoChe20ne20dici20del20Torneo20della20Campagna20in20Knight20War20Ce20ne20sar20uno20in20arrivo886840"><a name="Q7: E per concludere prima di passare alle domande del nostro pubblico…Che ne dici del Torneo della Campagna in Knight War? Ce ne sarà uno in arrivo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: E per concludere prima di passare alle domande del nostro pubblico…Che ne dici del Torneo della Campagna in Knight War? Ce ne sarà uno in arrivo?</h3><p><strong>Quynh Anh</strong>: Il torneo di campagna è la caratteristica principale di Knight War, quindi stiamo lavorando per migliorarlo nel prossimo futuro! Potrebbero essere aggiunte nuove mappe e classi di personaggi, quindi rimanete sintonizzati per questo! Sarà sicuramente molto interessante!</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rio Fu.</strong>, Comunità Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>