Z2F0ZUxpdmUgQU1BIFJlY2FwLVdBR01JIEdhbWVz

2023-07-27, 06:23

<p><img src="https://gimg2.gateimg.com/image/article/1690438995wagb.jpg" alt=""></p>
<h2 id="h2-Chi2020WAGMI20Games166109"><a name="Chi è WAGMI Games?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi è WAGMI Games?</h2><p><strong>Ian Bentley (CEO di WAGMI Games)</strong><br><strong>Scott Herman (VP di WAGMI Games)</strong><br>WAGMI Games è un franchise transmedia <a href="/web3" target="_blank" class="blog_inner_link">web3</a> che colma il divario tra la tecnologia blockchain e i giochi tradizionali. Siamo un’azienda non finanziata da VC, autonoma, con una comunità appassionata che crede nella nostra visione e comprende dove stiamo andando.</p>
<p>Il nostro primo titolo, WAGMI Defense, è un gioco di strategia mobile simile a Clash Royale ed è pronto per arrivare immediatamente sui negozi di applicazioni. È una delle prime app mobili al mondo che accetta fiat per l’acquisto di NFT in-app (oggetti di gioco). L’azienda non si concentra solo su un gioco, ma si sta espandendo anche in fumetti, collezionabili fisici e digitali, film, serie TV e anime.</p>
<h2 id="h2-Chi2020il20team20dietro20a20WAGMI20Games559662"><a name="Chi è il team dietro a WAGMI Games?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi è il team dietro a WAGMI Games?</h2><p><strong>Ian Bentley（CEO di WAGMI Games）</strong><br><strong>Scott Herman（VP di WAGMI Games）</strong><br>WAGMI Games vanta un potente team di leadership con il CEO Ian Bentley al timone. La vasta esperienza di Ian nella costruzione di aziende ha permesso a WAGMI Games di raggiungere il suo attuale status. Ha lasciato la sua azienda precedente in un’acquisizione di oltre $20 milioni e successivamente ha co-fondato WAGMI Games insieme ad altri 3 co-fondatori. Veloce avanzamento di 12 mesi, la leggenda del settore e l’ex Direttore delle Operazioni presso Electronic Arts, Brent Pease, ha deciso di unirsi a WAGMI Games come COO / General Manager, portando con sé numerosi dirigenti di alto livello, consulenti e talenti AAA, tra cui Esteban Gil, Lead Product Manager presso Respawn Entertainment. Il team di WAGMI Games è affamato di successo e ha giurato di non riposare un solo giorno finché non raggiungeranno il loro obiettivo riassunto nella citazione del franchise, “We Are All Going To Make It!”</p>
<h2 id="h2-Puoi20dirci20alcune20cose20sul20tuo20evento20WAGMISummer368330"><a name="Puoi dirci alcune cose sul tuo evento “#WAGMISummer”?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Puoi dirci alcune cose sul tuo evento “#WAGMISummer”?</h2><p><strong>Ian Bentley（CEO di WAGMI Games）</strong><br><strong>Scott Herman（VP di WAGMI Games）</strong><br>L’estate WAGMI è il nostro momento. Abbiamo costruito per 19 mesi durante un mercato orso e ora siamo usciti dall’altro lato più forti che mai e con più di qualche cosa da mostrare.</p>
<p>In realtà, abbiamo preparato un bombardamento infinito di importanti catalizzatori, consulenti, annunci e partnership insieme a un marketing e PR estremamente aggressivi che colpirà presto il mercato. Abbiamo anche un catalizzatore molto potente che verrà annunciato a breve, che riteniamo farà sì che il nome WAGMI Games risuoni in tutto lo spazio web3, nonché in tutto il mondo. Rimanete sintonizzati!</p>
<h2 id="h2-Dove20vedi20la20tua20azienda20tra202520anni745747"><a name="Dove vedi la tua azienda tra 2-5 anni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove vedi la tua azienda tra 2-5 anni?</h2><p><strong>Ian Bentley (CEO di WAGMI Games)</strong><br><strong>Scott Herman (VP di WAGMI Games)</strong><br>Stiamo costruendo attivamente per diventare la “Meraviglia del Web3”. Non stiamo solo costruendo un singolo gioco; Questo ci renderebbe uno studio di giochi per dispositivi mobili. Siamo un franchising di intrattenimento web3 e stiamo costruendo per espanderci nel settore dell’intrattenimento, che include fumetti, oggetti da collezione fisici, streetwear e, in futuro, anime, serie TV e film. Puntiamo a diventare il progetto web3 leader a livello mondiale nel settore del GAMING ed essere tra i primi a raggiungere l’adozione di massa e una presenza globale.</p>
<h2 id="h2-Quali20sono20le20tue20opinioni20sul20futuro20del20gaming20web320Quali20sono20le20tue20opinioni20sul20futuro20del20gaming20web3562781"><a name="Quali sono le tue opinioni sul futuro del gaming web3? Quali sono le tue opinioni sul futuro del gaming web3?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono le tue opinioni sul futuro del gaming web3? Quali sono le tue opinioni sul futuro del gaming web3?</h2><p><strong>Ian Bentley (CEO di WAGMI Games)</strong><br><strong>Scott Herman (VP di WAGMI Games)</strong><br>È vero che il gaming web3 ha subito un calo negli ultimi 12-15 mesi, e per una buona ragione. Non ci sono stati giochi che si avvicinano a un lancio globale, e anche se ci fossero, sarebbe impossibile ottenere una diffusione di massa a causa delle alte barriere all’ingresso e di ciò che ci piace chiamare ‘attrito’.</p>
<p>I giocatori tradizionali non apprezzano essere chiesto di creare un portafoglio, detenere NFT, acquistare terreni nel metaverso, o anche creare un account per giocare a un gioco. Infatti, scappano da questo. Il futuro dei giochi web3 è il free-to-play, e noi stiamo proprio costruendo quello. Crediamo che una volta che i giocatori saranno in grado di vedere che un gioco web3 non è diverso da qualsiasi dei loro giochi preferiti, ma che possono effettivamente possedere i loro asset in-game oltre a tutto il resto, è lì che i giochi web3 esploderanno. Prevediamo che un enorme boom dei giochi web3 avverrà nei prossimi 1-3 anni, e siamo perfettamente posizionati per rivendicare una quota sostanziale di quella torta.</p>
<div class="blog-details-info"><br><div>Autore:<strong> GateLive</strong>, Team di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista 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 ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>