DevLog #02 – Idle Space Miner 2 – Parte 1

Já faz algum tempo que não falo sobre um de meus jogos que estão sendo desenvolvidos. A última vez foi no primeiro DevLog, um post sobre como comecei a criar jogos, onde falei um pouco sobre Idle Space Miner, entre outros jogos, mas agora darei a você mais detalhes sobre sua história, seu desenvolvimento, o estado atual e o planejamento para o futuro.

Para não ficar muito longo, terei que dividir esse artigo em partes, mas garanto pra você que, se você cria jogos, esse relato será muito útil. Se você não é um(a) criador(a) de jogos, mas alguém que os ama, terá uma boa noção de quanto trabalho (e satisfação) nós desenvolvedores temos para te entreter e divertir.

Senta que lá vem história

Não posso falar de ISM2 sem antes contar a história de seu predecessor, o primeiro “Idle Space Miner“. Foi com esse jogo que aprendi os fundamentos de trabalhar com a Unity UI e aprendi muito sobre programação, interação entre objetos, progressão matemática e foi também quando fiz minha primeira animação 2D na Unity.

Naquele tempo eu não sabia fazer quase nada na Unity sem abrir um tutorial do YouTube junto, mas estava decidido a superar isso. Mesmo a dinâmica do jogo sendo incrivelmente simples (só alguns botões na tela e uma contagem de quanto ouro você tinha minerado enquanto um astronauta batia com uma picareta no chão liberando partículas douradas), me assustei com a quantidade de jogadores interessados. Em menos de uma semana já alcançava mais de 1.000 plays, em cerca de um mês foram quase 10.000 plays (acho que uns 50 fui eu testando). Acredito que grande parte dessa visibilidade se deu porque eu fazia pequenos updates a cada 2 ou 3 dias melhorando o jogo com base nos comentários deixados pelos(as) jogadores(as).

Importante também relembrar como consegui quebrar a barreira do tutorial. Apesar do desenvolvimento inicial ter sido todo com base em um vídeo sobre como desenvolver um jogo idle, todas as versões seguintes foram feitas através da experimentação, onde passei a implementar coisas que o vídeo não oferecia, pesquisando na documentação da engine e em tutoriais (escritos e em vídeo) sobre funcionalidades específicas. Isso me rendeu um aprendizado sem tamanho!

Tanto foi o aprendizado com o primeiro ISM (e a felicidade de ver o retorno da comunidade) que logo decidi incrementá-lo ainda mais. Quem já tentou desenvolver um jogo sabe o quão complicado pode ser fazer mudanças drásticas em um projeto já bem improvisado, então decidi começar do zero, até porque já haviam se passado 4 meses e a essa altura eu já tinha feito alguns cursos na Udemy e criado alguns outros jogos (como Infinite Space Run, Experimental Relaxing 3D 3-Match Game e Zack’s Unfinished Adventures), que me proporcionaram ainda mais conhecimento, além de novas ideias. Eu estava pronto para me desafiar a aplicar tudo que eu tinha aprendido e queria muito praticar as novas técnicas adquiridas até então.

Desenvolvendo o conceito do jogo

A primeira grande decisão que tomei foi que eu deveria manter a temática, mas ainda assim fazer algo totalmente diferente em termos de narrativa e jogabilidade. Analisei a dinâmica do jogo, suas mecânicas, o tema e a forma como ele era apresentado. Havia um certo tom humorístico no fato de o jogo se passar em um planeta sem nome onde um astronauta coletava ouro com uma picareta. Não que isso fosse ruim, afinal jogos com temas de humor costumam agradar o público, mas eu não estava focado em obter sucesso e sim aprender com o desenvolvimento. Pensei em me distanciar um pouco desse aspecto, criando um jogo que fizesse mais sentido. Foi durante uma madrugada assistindo um documentário sobre o sistema solar que tive a ideia de fazer o ISM2 sob uma outra perspectiva, onde o(a) jogador(a) controlaria não uma personagem, mas o sistema solar inteiro.

Com essa nova perspectiva teria que pensar mais sobre que tipo de recurso seria coletado e o que poderia ser feito com ele, mas deixaria essa etapa para um momento futuro.

Iniciando o desenvolvimento do jogo

No início só queria fazer um sistema solar funcional, algo simples. Então primeiro montei-o posicionando uma grande esfera tridimensional na cena e várias esferas menores ao seu redor… agora era só descobrir como fazê-las girar em volta da esfera maior. Já tinha uma noção de como programar movimentação de objetos, mas a maioria das minhas lições tinha a ver com comandos de entrada (input) de jogadores e eram muito mais simples no 2D. Por sorte encontrei boas explicações na própria documentação da Unity de como utilizar a função Vector3 para atualizar as posições de um objeto a cada frame, uma mecânica até bastante simples mesmo para um iniciante.

E se você ficou com curiosidade de saber como fazer a órbita de um planeta na Unity, vai de brinde o script C# completo que criei para isso:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

// script made by Douglas d'Aquino @ https://games.dougweb.com.br - use at will, credits are appreciated

public class Orbit : MonoBehaviour {

	public GameObject sunSphere; // o objeto em cena representando o sol
	public float speed; // velocidade de órbita do planeta
	public GameObject planet; // o planeta que iremos mover
	public float rotationSpeed; // velocidade de rotação do planeta
	
	// Update is called once per frame
	void Update () {
		OrbitAround (); // chamado da função que fará a órbita
		SpinPlanet(); // chamado da função que fará a rotação
	}

	void OrbitAround(){
		transform.RotateAround (sunSphere.transform.position, Vector3.left, speed * Time.deltaTime); // faz o planeta girar ao redor do sol
	}

	void SpinPlanet(){
		transform.Rotate (-rotationSpeed * Time.deltaTime, 0, 0); // faz o planeta rotacionar no próprio eixo
		}
	}
}

Bem simples né? Também aproveitei para fazer desde o início uma boa organização das variáveis que poderiam ser modificadas mais tarde por outras partes do sistema, assim ao comprar upgrades para os planetas as suas órbitas e rotações também podiam ser alteradas. Sei que não é boa prática fazer variáveis públicas, mas isso irá ajudar a testar as diferentes configurações de velocidade sem precisar ficar voltando ao código.

Decidi também que iria simplificar outros aspectos do jogo. Enquanto o primeiro ISM tinha cerca de 5 recursos de mineração por clique e outros 8 de mineração por segundo, em Idle Space Miner 2 decidi fazer apenas 1 recurso de mineração por clique e todos os outros voltados à mineração por segundo. Decidi isso enquanto pensava sobre que tipo de recurso seria “minerado” no jogo. Considerando a narrativa e a perspectiva escolhidas, cheguei à conclusão de que faria mais sentido que o sol, como elemento central da cena, seria o recurso a ser explorado (no caso, sua energia). Mais tarde eu mudaria o nome do recurso para luz do sol (sunlight) afim de torná-lo mais compreensível, uma vez que “energia” é algo um tanto genérico e pode ser aplicado a várias coisas (como energia elétrica, potencial, cinética, mecânica, entre outras).

A mecânica central do jogo continuaria a mesma, ao clicar na tela, o sol libera partículas, que por sua vez são “absorvidas” pelos planetas. Era uma boa base para eu começar o gerenciamento de aquisição de recursos e seu devido gasto, mas permanecia ainda a questão do que fazer com esse recurso. Não demorou muito para que eu concluísse que o mais razoável seria habilitar a existência de cada planeta à medida em que jogadores pudessem comprá-los. Também foi nesse ponto que pude trabalhar no equilíbrio inicial dos ganhos e gastos, além de dar uma função aos planetas (além de girarem cada vez mais rápidos). Agora os planetas seriam responsáveis por gerar recursos por segundo, permitindo que quem jogasse não tivesse que depender somente de clicar repetidamente na tela (o que, apesar de viciante, é bem cansativo). Além do mais, com a progressão de custos crescendo exponencialmente, chega um ponto que é muito caro aumentar o poder de cada clique, então comprar um novo planeta ou melhorar um que já existisse seria uma alternativa viável. Isso também dá o aspecto mais importante de um jogo do tipo idle, em que o(a) jogador(a) pode evoluir seu sistema de coleta até certo ponto e deixar o jogo trabalhando sozinho até acumular uma grande quantidade de recursos.

Aproveito para compartilhar com você o script C# de gerenciamento de compra e upgrades dos planetas, que pode te ajudar a entender um pouco melhor como esse tipo de mecânica funciona:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

// script made by Douglas d'Aquino @ https://games.dougweb.com.br - use at will, credits are appreciated

public class ItemManager : MonoBehaviour {

    //new text variables for items
    public Text itemScreenName;
    public Text itemLevel;
    public Text itemCost;
    public Text itemProduction;

	public Text itemInfo;
	public Click click;
	public float cost;
	public int tickValue;
	public int count;
	public string itemName;
	private float baseCost;
        public Sprite standard;
	public Sprite affordable;
	public GameObject planetToSpawn;
	private string planetTag;
	public string itemType;

	void Start(){
		baseCost = cost;
		planetToSpawn.GetComponent<Orbit>();
	}

	void Update(){
        
        //new itemInfo system

        itemScreenName.text = itemName;
        itemLevel.text = count.ToString();
        itemCost.text = "$ " +  cost.ToString();
        itemProduction.text = "$ " + tickValue.ToString() + " /s";

		if (click.matter >= cost) {
			GetComponent<Image> ().sprite = affordable;
		} else {
			GetComponent<Image> ().sprite = standard;
		}
	}

	public void PurchaseItem(){
		if (click.matter >= cost && itemType == "planets") {
			click.matter -= cost;
			count += 1;

			cost = Mathf.Round (baseCost * Mathf.Pow (0.33f, count));
			Orbit orbitScript = planetToSpawn.GetComponent<Orbit> ();
			orbitScript.speed += count / 10;

			//SaveValues ();
			// send statistics to kongregate everytime an item is purchased
			//gpcAchievments ();
			// save game
			if (planetToSpawn.tag == "Planet1" && count <= 1) {
				planetToSpawn.SetActive (!planetToSpawn.activeInHierarchy);

				Debug.Log ("planet 1 activated");
			
			}
			if (planetToSpawn.tag == "Planet2" && count <= 1) {
				planetToSpawn.SetActive (!planetToSpawn.activeInHierarchy);

				Debug.Log ("planet 2 activated");
			
			}
			if (planetToSpawn.tag == "Planet3" && count <= 1) {
				planetToSpawn.SetActive (!planetToSpawn.activeInHierarchy);

				Debug.Log ("planet 3 activated");
			
			}
			if (planetToSpawn.tag == "Planet4" && count <= 1) {
				planetToSpawn.SetActive (!planetToSpawn.activeInHierarchy);

				Debug.Log ("planet 4 activated");
				
			}
			if (planetToSpawn.tag == "Planet5" && count <= 1) {
				planetToSpawn.SetActive (!planetToSpawn.activeInHierarchy);

				Debug.Log ("planet 5 activated");

			}
            if (planetToSpawn.tag == "Planet6" && count <= 1)
            {
                planetToSpawn.SetActive(!planetToSpawn.activeInHierarchy);

                Debug.Log("planet 6 activated");

            }
            if (planetToSpawn.tag == "Planet7" && count <= 1)
            {
                planetToSpawn.SetActive(!planetToSpawn.activeInHierarchy);

                Debug.Log("planet 7 activated");

            }
            if (planetToSpawn.tag == "Planet8" && count <= 1)
            {
                planetToSpawn.SetActive(!planetToSpawn.activeInHierarchy);

                Debug.Log("planet 8 activated");

            }
            if (planetToSpawn.tag == "Planet9" && count <= 1)
            {
                planetToSpawn.SetActive(!planetToSpawn.activeInHierarchy);

                Debug.Log("planet 9 activated");

            }
        }
	}
}

Sei que esse não está tão fácil de compreender para quem está começando, até porque não gastei muito tempo comentando o código. Alguns programadores defendem que se um código precisa ser comentado é porque ele não está bom o suficiente. Hoje em dia eu tenho muito mais noção de como escrever um código fácil de compreender, mas na época não tinha esse cuidado todo na escolha das variáveis e métodos. De qualquer maneira, se tiver alguma dúvida de como utilizar o script, deixa um comentário que farei o possível para te ajudar.

No próximo capítulo…

Ainda há muito o que falar sobre o desenvolvimento de Idle Space Miner 2 (muito mesmo), uma história repleta de aprendizados e dicas, mas eu não quero fazer você ler um livro aqui, então trarei a segunda parte desse relato muito em breve para que você possa aprender ainda mais e acompanhar essa louca jornada. Aconselho a você assinar a minha lista de e-mails usando o formulário na barra lateral do site ou logo aqui embaixo do post, pois assim eu vou te mandar as novidades assim que estiverem no ar (além de estar preparando materiais especiais só para assinantes).

Se você tiver interesse em ajudar na produção de Idle Space Miner 2, seu apoio é muito importante, adquirindo a versão para PC (muito mais bonita que a versão web) agora, você ganha acesso antecipado às versões de desenvolvimento e também a todas versões futuras, ajuda um desenvolvedor independente e ainda participa de promoções em todos os meus lançamentos futuros, basta usar o link abaixo.

Muito obrigado por me acompanhar até aqui e fazer parte dessa história, comente abaixo sobre o que você achou e o que você gostaria de ver aqui no blog que ficarei muito feliz de ler o que você tem a dizer 🙂

Deixe uma resposta

TRANSLATE
Optimized with PageSpeed Ninja