R2F0ZS5pbyBBTUEgY29uIFBsYWNld2FyLSBNZXRhdmVyc28gZGkgY3VsdHVyYSBpbnRlcm5ldCBnYW1pZmljYXRvLCBnaW9jbyBzb2NpYWxlIFAyRSBHYW1lZmksIGdpb2NvIGQnYXJ0aWdsaWVyaWEgc3RyYXRlZ2ljbyBuZWxsJ2Vjb3Npc3RlbWE=

<p><img src="https://gimg2.gateimg.com/image/article/16880174931.jpeg" alt=""><br><strong>Ora: 19 novembre 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 Myrtle Anne Ramos, Co-fondatrice di PlaceWar in <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://placewar.io/#/" rel="nofollow noopener noreferrer" target="_blank">https://placewar.io/#/</a></strong><br><strong>Twitter: <a href="https://twitter.com/placewar_game" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/placewar_game</a></strong><br><strong>Segui PlaceWar su <a href="https://twitter.com/placewar_game" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/placewarANN" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16880177312.png" alt=""><br><strong>Myrtle Anne Ramos — Co-fondatrice di PlaceWar</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio378517"><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-Q120Puoi20per20favore20fare20una20presentazione20di20te20stesso20e20presentare20anche20PlaceWar11194"><a name="Q1: Puoi per favore fare una presentazione di te stesso e presentare anche PlaceWar?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi per favore fare una presentazione di te stesso e presentare anche PlaceWar?</h3><p><strong>Mirto</strong>: Grazie e buon pomeriggio a tutti, mi chiamo Myrtle e sono la fondatrice di PlaceWar. Prima di PlaceWar, ho creato Block Tides, una rinomata agenzia di PR nelle Filippine. Ho aiutato centinaia di aziende a trarre beneficio e trasformare i loro affari per interrompere, adattarsi o scalare utilizzando gli ultimi strumenti tecnologici, prodotti o aiutando a costruire da zero. Oltre a ciò, sono anche un influencer ufficiale di Coinmarketcap e il VP dello sviluppo e dei partenariati di Gokumarket.</p>
<p>Gestisco anche uno dei più grandi programmi di borse di studio nelle Filippine. In combinazione con i miei altri partner, siamo uno dei più grandi nel Sud-Est asiatico, insieme a MetaGaming Guild.</p>
<h3 id="h3-Q220Ci20sono20stati20molti20progetti20Metaverse20e20GameFi20e20ce20ne20saranno20ancora20di20pi20in20arrivo20La20competizione20si20fa20sempre20pi20agguerrita20Quali20sono20i20vantaggi20di20PlaceWar20rispetto20agli20altri20giochi608531"><a name="Q2: Ci sono stati molti progetti Metaverse e GameFi e ce ne saranno ancora di più in arrivo. La competizione si fa sempre più agguerrita. Quali sono i vantaggi di PlaceWar rispetto agli altri giochi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ci sono stati molti progetti Metaverse e GameFi e ce ne saranno ancora di più in arrivo. La competizione si fa sempre più agguerrita. Quali sono i vantaggi di PlaceWar rispetto agli altri giochi?</h3><p><strong>Mirto</strong>: PlaceWar è un universo di gioco sociale con gioco strategico play-to-earn, implementato su una multi-chain con un coinvolgente gameplay di artiglieria. La filosofia alla base del design è quella di voler creare un universo di gioco semplice, divertente e socialmente coinvolgente per far tornare gli utenti, consentendo loro di avere la possibilità di condividere i profitti mentre l’ecosistema cresce.</p>
<p>Siamo già un metaverso prima che Mark annunci che sono Meta.</p>
<p>Penso che Metaverse sia un titolo esagerato. Se ti riferisci a Ready Player One, allora siamo lontani da quel mondo. Penso che GameFi sia il primo passo più solido di tutti per i tentativi di Metaverse, più di quanto abbiano fatto altre grandi aziende: GameFi sta suggerendo una filosofia secondo cui in un metaverso, l’universo dovrebbe essere di proprietà, governato dai giocatori e quindi i profitti dovrebbero essere condivisi anche dai giocatori.</p>
<p>Siamo pienamente consapevoli che molti progetti gamefi stanno entrando nel mercato.</p>
<p>Ciò che la maggior parte di loro sta facendo è aggiungere NFT e tokenomics ai giochi esistenti. Questo è un buon modo di transizione per i giocatori tradizionali per passare alla blockchain. Tuttavia, questo modello potrebbe far sì che i giocatori si concentrino troppo sulla parte dei premi in token per creare l’economia reale del gioco.</p>
<p>Quello che facciamo invece è creare legami sociali e differenziazioni tra i giocatori in modo che ognuno possa trovare il proprio modo per divertirsi e guadagnare, non necessariamente solo interagendo con contratti intelligenti ma anche tra di loro.</p>
<p>Abbiamo effettivamente un meccanismo centrale che è ispirato da Worms.</p>
<p>Il semplice tiro di artiglieria è divertente, coinvolgente e nostalgico. I giocatori play-2-earn possono godere di ricompense attraverso la vittoria delle battaglie, che è un modo con cui sono familiari attraverso. <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a>. Possono anche guadagnare tramite l’interazione sociale nel sistema Pixel che spiegherò in seguito come facciamo questo.</p>
<h3 id="h3-Q320Come20gioco20metaverso20P2E20potresti20per20favore20presentare20il20sistema20di20gioco20di20PlaceWar20e20spiegare20come20gli20utenti20possono20giocare20per20guadagnare332451"><a name="Q3: Come gioco metaverso P2E, potresti per favore presentare il sistema di gioco di PlaceWar e spiegare come gli utenti possono giocare per guadagnare?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Come gioco metaverso P2E, potresti per favore presentare il sistema di gioco di PlaceWar e spiegare come gli utenti possono giocare per guadagnare?</h3><p><strong>Mirto</strong>: PlaceWar ha due sistemi:</p>
<p>Sistema di battaglia e sistema di pixel. Nel sistema di battaglia, sono necessari 3 tank NFT per avviare una sfida PVE affrontando NPC, o una battaglia PVP contro un giocatore casuale. Puoi vincere un token e altre ricompense vincendo. Questo è l’elemento play-to-earn con cui la maggior parte dei giocatori è familiare. Abbiamo anche una Guerra di Gilda che è un’arena che consente agli utenti di scommettere su se stessi utilizzando i nostri token $PLACE o $GEAR in una battaglia di tank 10 VS 10. Il vincitore prende tutto.</p>
<p>PVE e PVP saranno disponibili in V1 e V1.5 che saranno lanciati separatamente a dicembre.</p>
<p>Una demo sarà disponibile a novembre dopo il lancio.</p>
<p>Quando lanciamo V2, che è il sistema Pixel, avremo Placedonia, una mappa di tela divisa in 90k piccole terre pixel, dove i giocatori possono parcheggiare i loro carri armati, raccogliere risorse, costruire edifici e scegliere un colore per rappresentare la propria <a href="/price/terra-luna" target="_blank" class="blog_inner_link">terra</a> sulla mappa del mondo.</p>
<p>Come ho detto, è una mappa di tela, quindi l’obiettivo è far sì che gli utenti creino le proprie opere d’arte ma come? Permettiamo agli utenti di attaccarsi a vicenda. (Se conosci Clash of Clans, è praticamente la stessa ideologia)</p>
<p>Puoi invadere altri pixel sfidando i loro difensori in una battaglia di carri armati. In caso di vittoria sarai in grado di saccheggiare le loro risorse non raccolte e forzare il cambio di colore - far diventare il loro pixel parte del tuo territorio di pittura. Creare un’enorme opera d’arte richiederà molto sforzo e, alla fine, collaborazione, quindi dovrai lavorare con altri giocatori.<br><img src="https://gimg2.gateimg.com/image/article/16880177723.jpg" alt=""><br>Ciò significa mini DAO all’interno del gioco. Incoraggeremo questo obiettivo impostando una ricompensa per i creatori e invitando altre comunità di criptovalute nel gioco e mettendo taglie per incoraggiare i giocatori a creare i loro loghi nel gioco. Gli NFT sono sicuramente il fulcro del nostro sistema di asset. Non abbiamo solo carri armati come NFT, ma anche attrezzature (i dispositivi indossabili), tecnologia e pixel, edificio e difensore nel sistema pixel. Sarai in grado di personalizzare i tuoi migliori carri armati e le strategie per affrontare i tuoi nemici.</p>
<h3 id="h3-Q420Per20un20progetto20GameFi20la20progettazione20dei20tokenomics2020cruciale20Per20favore20presentare20i20tokenomics20in20PlaceWar65465"><a name="Q4: Per un progetto GameFi, la progettazione dei tokenomics è cruciale. Per favore, presentare i tokenomics in PlaceWar." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Per un progetto GameFi, la progettazione dei tokenomics è cruciale. Per favore, presentare i tokenomics in PlaceWar.</h3><p><strong>Mirto</strong>: PlaceWar è basato su un sistema di token duali.</p>
<p>$PLACE è il nostro token di governance che consente a terze parti esterne di partecipare al gioco a un livello meta come il voto.</p>
<p>Un’altra grande utilità di $PLACE è per la spesa in Crafting.</p>
<p>Il crafting è il processo di coniazione di tutti gli NFT nel nostro gioco.</p>
<p>$PLACE avrà più casi di spesa.</p>
<p>Il token $PLACE è limitato a 1 miliardo. $GEAR è la nostra valuta in-game, che non ha limiti di emissione ed è generata al 100% attraverso il gameplay. Puoi utilizzare $GEAR per pagare praticamente tutto all’interno del gioco, compresa la creazione.</p>
<p>C’è anche un meccanismo per rallentare l’inflazione di $GEAR che è il serbatoio di carburante.</p>
<p>Dovrai spendere $GEAR per tornare ai giochi PVE, altrimenti dovrai aspettare ore fino alla prossima partita PVE.</p>
<h3 id="h3-Q520PlaceWar20ha20dei20partner20Potresti20per20favore20presentare20la20partnership20di20PlaceWar684293"><a name="Q5: PlaceWar ha dei partner? Potresti per favore presentare la partnership di PlaceWar?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: PlaceWar ha dei partner? Potresti per favore presentare la partnership di PlaceWar?</h3><p><strong>Mirto</strong>: Sebbene la prima versione sarà implementata su Binance Chain, stiamo lavorando con più blockchain per implementare le nostre versioni, tra cui <a href="/price/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">IoTeX</a>, Conflux, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>. Abbiamo effettivamente ricevuto investimenti anche da <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> China e IoTeX. Per facilitare il trasferimento di NFT, stiamo lavorando con BoringDAO per costruire il ponte NFT.</p>
<p>Le gilde sono una fazione essenziale nell’industria GameFi, e abbiamo Pixelchaser la gilda ufficiale della comunità di Axie Infinity, MGG, JRN, ExNetwork, Woodson e Terabyte (guidata da Hydra, campione del mondo di Starcrafts) che investono direttamente in noi.<br><img src="https://gimg2.gateimg.com/image/article/16880177844.jpg" alt=""><br>Lavoreremo con loro per avviare la nostra vendita di NFT e il programma di borse di studio. Lavoreremo anche a stretto contatto con i nostri partner di gilda per lanciare i nostri programmi di borse di studio. Forniremo un numero limitato di serbatoi gratuiti per espandere la nostra base di utenti.</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. Sarà consentito il riposting dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>