Terracota

Contexto do Projeto

Propósito

Este projeto tem o intuito de salientar o conteúdo exposto na disciplina de Gerência de Configuração de Software da Universidade de Brasília, onde terá como objetivo a Integração Contínua, o Deploy e o empacotamento de um jogo desenvolvido na disciplina de Introdução aos Jogos Eletrônicos.

Conceito do Jogo

A temática é a de um mundo pós-apocalíptico, onde várias tecnologias se extinguiram e a humanidade volta a comunicar-se de forma arcaica por meio de figuras e indicações corporais. O jogador tem que, entre outros desafios, resolver puzzles decifrando códigos audiovisuais para completar as quests.

Controles do Jogo

Movimentos

• d ou right arrow Andar para a direita
• a ou left arrow Andar para a esquerda
• w ou up arrow Andar para cima
• s ou down arrow Andar para baixo

Ações

• c Trocar de Personagem
• n Conversar
• space Atacar

Imagens do Jogo

Personagens

image

image

image

Cenário

image

image

image

image

Conceitos

image

Menu

image

Controles

image

Vídeo Jogo

https://drive.google.com/open?id=0B_UQAEXwMDM6TV82TTFVbkJNdUk

Repositorio GitHub

Terracota

Escopo

O projeto irá desenvolver a ideia de aplicar a gerência de configuração no jogo Terracota de acordo com esses objetivos principais:

• Migração do Make para o CMake
• Deploy Automatizado
• Empacotamento

Plano de Gerenciamento de Configuração de Software

Cronograma

Release	Milestone	Sprint	Período	Atividade	Status
1	Planejamento	1	19/04 ~ 22/04	Redigir o plano de GCS	Feito
		2	22/04 ~ 24/04	Pesquisar Ferramentas	Feito
2	Preparação	3	25/04 ~ 01/05	Criar README do jogo	Feito
		4	01/05 ~ 05/05	Preparar ambiente	Feito
3	Execução	5	06/05 ~ 20/05	Implementar o CMake	Feito
		6	21/05 ~ 02/06	Implementar o Deploy	Incompleto
		7	03/06 ~ 10/06	Realizar o Empacotamento	Incompleto
		9	11/06 ~ 15/06	Criar Documentação Necessária	Feito
		10	16/06 ~ 18/06	Estruturar a apresentação do Projeto	Feito
4	Apresentação	11	19/06/2017	Apresentação Final do Projeto	A Realizar
			26/06/2017
			03/07/2017

Papéis

Papel	Responsabilidade	Responsável
Gerente de Configuração	Ajustar a infra-estrutura geral do gerenciamento de software, fazendo com que o projeto obtenha um ambiente adequado para desenvolvimento e realização de testes do software.	Kássia Catarine
Gerente de Configuração	Ajustar a infra-estrutura geral do gerenciamento de software, fazendo com que o projeto obtenha um ambiente adequado para desenvolvimento e realização de testes do software.	Edson Gomes

Ferramentas

Ferramenta	Descrição	Objetivo
CMake	Sistema multiplataforma que gerencia e automatiza o processo de "build"	Migração do Make para o CMake
Ansible	Ferramenta de automatização de tarefas.	Deploy Automatizado
VirtualBox	Ferramenta para gerenciar máquinas virtuais	Deploy Automatizado
Vagrant	Sistema para criação de Máquinas Virtuais	Deploy Automatizado
debootstrap	Ferramenta utilizada para criar uma nova instalação do Debian em um subdiretório de uma distribuição Debian já instalada.	Criação de um ambiente "limpo" (jaula) para realizar o empacotamento .deb
build-essential, dpkg-dev, devscripts	Pacotes Debian necessários no processo de empacotamento Debian.	Empacotamento .deb
rpmbuild e rpmdevtools	Pacotes RPM necessários no processo de empacotamento RPM	Empacotamento .rpm

Implementação

Preparando Ambiente

Entre neste repositório Terracota (faça um fork se desejar), no seu terminal execute os seguintes comandos:

$ git clone https://github.com/nullpointercorporation/terracota.git

Após clonar o repositório na sua maquina, existe duas possibilidades para instalar e desenvolver o jogo, sendo elas a instalação no seu computador (Instalação Normal) ou a instalação por meio de uma maquina virtual (Instalação na MV). Os passos das duas possibilidades se encontra descrito abaixo, escolha um a seguir e realize as instruções sugeridas.

Instalação Normal

Entre na pasta do jogo

$ cd Terracota/terracota

De permissão ao arquivo setup.sh

$ chmod 777 setup.sh

Execute o setup.sh

$ ./setup.sh

Com isso o seu ambiente estará configurado com a instalação das dependências, a instalação da ijengine e a criação do executável do jogo. Se quiser executar o jogo, digite o seguinte comando:

$ ./terracota.exe

Instalação na MV

Para seguir com essa instalação, presume-se que a sua maquina tem instalado os seguintes programas:

VirtualBox

Vagrant

Ansible

Se o seu sistema operacional for do tipo Debian/Ubuntu existe a necessidade de instalação do seguinte programa para que o Vagrant possa conectar via nfs com o seu computador. Execute o comando seguinte para instalar:

$ sudo apt-get install nfs-kernel-server

Após esse comando é necessário instalar dois Plugins no Vagrant, execute os seguintes passos no seu terminal:

$ vagrant plugin install vagrant-vbguest
$ vagrant plugin install vagrant-bindfs

O primeiro comando é um plugin que auxilia a atualização da maquina virtual sempre que for iniciada e o segundo comando auxilia as configurações nfs no Vagrantfile. Com a conclusão desses passos entre na pasta do jogo

$ cd Terracota/terracota

Execute o seguinte comando:

$ vagrant up --provision

A seguir o Vagrant irá pedir a sua senha para que ele possa ter permissão para configurar o nfs. A conclusão deste comando irá demorar por volta de 5 a 10 minutos na primeira vez, pois ele irá baixar o sistema operacional e configurar todo o ambiente para desenvolvimento, ao executar uma segunda vez o ambiente será levantado com mais rapidez.

Todos os passos necessários para instalação das dependências, ijengine e geração do executável serão executadas automaticamente, assim que terminar o ambiente estará pronto para desenvolvimento.

Para acessar a maquina virtual execute este comando:

$ vagrant ssh

Agora para acessar a pasta do jogo na maquina virtual digite:

$ cd /vagrant/

Todos os arquivos contidos nesta pasta são refletidos na pasta do jogo no seu computador, ou seja, você pode alterar no seu computador ou na maquina virtual que os arquivos serão os mesmo nos dois locais. Com isso o ambiente de desenvolvimento estará pronto.

OBS: Após o desligamento da maquina, se caso deseje subir o ambiente novamente não é necessário realizar o comando $ vagrant up --provision, basta um

$ vagrant up que o seu ambiente irá ser iniciado.

Criando CMake

Cmake gerencia e automatiza o processo de "build". O código abaixo (ainda em construção) mostra o arquivo CMakeLists.txt que é a base do CMake.

cmake_minimum_required(VERSION 2.8)
project(Terracota)

# Set directory folders
set (PROJECT_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/include")
set (PROJECT_SRC_DIR "${PROJECT_SOURCE_DIR}/src")
set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR})

# Gets the list of files inside the src directory
file(GLOB_RECURSE SOURCES "${PROJECT_SRC_DIR}/*.cpp")

# Include Headers
include_directories("${PROJECT_INCLUDE_DIR}")

#### Compilation ####

# Compilation Flags
set(CMAKE_CXX_FLAGS "-Wall -W -pedantic -std=c++11 -g3")

#### Dependencies ####

# Add ijengine
set (PROJECT_ENGINE_DIR "/usr/local/include/ijengine")
include_directories(${PROJECT_ENGINE_DIR})

#### Executable ####

add_executable(Terracota ${SOURCES})

include(FindPkgConfig)

pkg_search_module(SDL2 REQUIRED sdl2)
pkg_search_module(SDL2IMAGE REQUIRED SDL2_image>=2.0.0)
pkg_search_module(SDL2TTF REQUIRED SDL2_ttf>=2.0.0)
pkg_search_module(SDL2MIXER REQUIRED SDL2_mixer>=2.0.0)

include_directories(include ${SDL2_INCLUDE_DIRS} 
			${SDL2IMAGE_INCLUDE_DIRS}
			${SDL2TTF_INCLUDE_DIRS}
			${SDL2MIXER_INCLUDE_DIRS})

target_link_libraries(Terracota 
		ijengine
		${SDL2_LIBRARIES} 
		${SDL2IMAGE_LIBRARIES}
		${SDL2TTF_LIBRARIES}
		${SDL2MIXER_LIBRARIES})

A partir do código acima a build do jogo será gerada.

Para a geração da build é necessário seguir os comandos abaixo, a partir da pasta raiz do jogo (terracota):

$ mkdir build

$ cd build

$ cmake ..

$ make

$ ./terracota

Criando o Deploy Automatizado

Criação da Máquina Virtual

Para a realização do Deploy usa-se as ferramentas para o provisionamento e automatização do ambiente de desenvolvimento, e elas são o Ansible e Vangrant respectivamente.

Para criar um ambiente virtual com o Vagrant foi necessário seguir os seguintes passos:

$ vagrant init

A `Vagrantfile` has been placed in this directory. You are now
ready to `vagrant up` your first virtual environment! Please read
the comments in the Vagrantfile as well as documentation on
`vagrantup.com` for more information on using Vagrant.

Com isso o Vagrant gera um arquivo Vagrantfile, esse arquivo é o "controle" da máquina virtual, nele será escrito a estrutura necessária para a configuração da maquina virtual. Apos configurar o arquivo com as configurações requeridas no ambiente, o arquivo Vagrantfile ficou desta forma:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|
  # Tipo de sistema operacional
  config.vm.box = "ubuntu/xenial64"
  # Ip da MV para comunicação
  config.vm.network "private_network", ip: "192.168.33.10"
  # Pastas sincronizadas na MV e Desktop
  config.vm.synced_folder "../terracota", "/vagrant", type: "nfs", mount_options: ['nolock', 'vers=3', 'udp', 'noatime', 'actimeo=1']
  # Criar grupos e user na MV
  config.bindfs.bind_folder "/vagrant", "/vagrant",
    perms: "u=rwX:g=rD:o=rD",
    create_as_user: true

  # Retirar necessidade de entrar com senha
  config.ssh.insert_key = false
  # Provedor da MV, setando memória e nome
  config.vm.provider "virtualbox" do |vb|
    vb.customize ["modifyvm", :id, "--memory", "2048"]
    vb.name = "terracota-machine"
    # vb.gui = true
  end
  # Configurando Provisionamento Automatizado
  config.vm.provision "ansible" do |ansible|
    ansible.playbook = "provisioning/terracota.yml"
  end
end

Após o termino do arquivo Vagrantfile precisa-se subir a máquina virtual, assim é necessário a execução do seguinte comando:

$ vagrant up --provision

Ele irá subir o ambiente e ao mesmo tempo rodar o script de provisionamento para a instalação de componentes necessários na maquina. Apos a inserção do comando irá aparecer essas mensagens:

Bringing machine 'default' up with 'virtualbox' provider...
==> default: Importing base box 'ubuntu/xenial64'...
==> default: Matching MAC address for NAT networking...
==> default: Checking if box 'ubuntu/xenial64' is up to date...
==> default: Setting the name of the VM: terracota-machine
==> default: Clearing any previously set network interfaces...
==> default: Preparing network interfaces based on configuration...
    default: Adapter 1: nat
==> default: Forwarding ports...
    default: 22 (guest) => 2222 (host) (adapter 1)
==> default: Running 'pre-boot' VM customizations...
==> default: Booting VM...
==> default: Waiting for machine to boot. This may take a few minutes...
    default: SSH address: 127.0.0.1:2222
    default: SSH username: ubuntu
    default: SSH auth method: password

Ao passar alguns minutos o sistema irá pedir a sua senha para que possa habilitar as configurações nfs. Quando terminar a execução digite o próximo comando:

$ vagrant ssh
Welcome to Ubuntu 16.04.2 LTS (GNU/Linux 4.4.0-78-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

  Get cloud support with Ubuntu Advantage Cloud Guest:
    http://www.ubuntu.com/business/services/cloud

1 package can be updated.
1 update is a security update.

ubuntu@ubuntu-xenial:~$

Com o ambiente rodando basta entrar na pasta do projeto com o seguinte comando:

$ cd /vagrant

Com isso o acesso ao ambiente já está disponível para o usuário, como visto abaixo.

ubuntu@ubuntu-xenial:/vagrant$ ls
docs  LICENSE  README.md  terracota

Provisionamento

Para que o usuário tenha um ambiente pronto para desenvolvimento é necessário instalar e realizar uma série de passo, para automatizar esses passos foi criado uma estrutura onde há os pacotes requeridos e o passos realizados automaticamente. Essa automatização é realizada por meio do Ansible, que facilita a implementação das tarefas na MV.

A estrutura criada para o provisionamento é a seguinte:

ubuntu@ubuntu:~/terracota/terracota$ tree provisioning/
provisioning/
├── roles
│   ├── core
│   │   └── tasks
│   │       ├── debian
│   │       │   └── main.yml
│   │       ├── main.yml
│   │       └── redhat
│   │           └── main.yml
│   ├── ijengine
│   │   └── tasks
│   │       └── main.yml
│   └── terracota
│       └── tasks
│           └── main.yml
└── terracota.yml

9 directories, 6 files

Onde o arquivo terracota.yml guia todas as tarefas a ser realizadas, como mostradas a seguir.

---
- name: Terracota Machine Setup
  hosts: default
  user: vagrant
  sudo: yes

  roles:
    - core
    - ijengine
    - terracota

As roles são as funções e ou papeis que serão executados na ordem descrita. A role core realiza a instalação de todas as dependências e pacotes necessários quando o desenvolvimento é visado, ela foi implementado para instalação nas seguintes famílias de sistemas operacionais, Redhat e Debian, podendo assim ser desenvolvido em qualquer um desses sistemas e ou derivados. A ijengine automatiza os passos para descompactação e instalação no sistema e a role terracota automatiza os passos necessários para a geração do executável do jogo.

A realização de tarefas como a seguinte é necessária em cada uma dessas roles, diferenciando somente o tipo de tarefas a ser realizada.

Exemplo da main.yml contida na role core.

---
- name: Install core packages
  package: name={{ item }} state=present
  with_items:
    - vim
    - git
    - unzip
    - gzip
    - g++
    - tar
    - cmake
    - make
    - wget

- name: Packages OS RedHat Distribuitions
  include: "redhat/main.yml"
  when: ansible_os_family | lower == 'redhat'

- name: Packages OS Debian Distribuitions
  include: "debian/main.yml"
  when: ansible_os_family | lower == 'debian'

Realizando o Empacotamento

Empacotamento RPM

O empacotamento necessita do rpmbuild e rpmdevtools, então para isso instale esses dois pacotes com o seguinte comando

$ sudo yum install rpmbuild rpmdevtools

Para que um pacote seja criado existe a necessidade de criar os diretórios do rpmbuild com o seguinte comando

$ rpmdev-setuptree

Após isso as pastas necessárias serão criadas, o proximo passo é por o tarball do projeto em ~/rpmbuild/SOURCES, ao realizar esse passo é necessário criar um arquivo .spec, pois ele é responsável para a geração do empacotameto. Vá a pasta ~/rpmbuild/SPECS e digite o seguinte comando:

$ rpmdev-newspec terracota.spec

Esse comando criará um arquivo molde para o preenchimento das informações e instruções do pacote. Ao preencher esse arquivo o arquivo final ficou da seguinte forma:

Name:           terracota
Version:        1.0.0
Release:        1%{?dist}
Summary:        Game of strategy Terracota

License:        MIT
URL:            https://github.com/nullpointercorporation/terracota
Source0:        %{name}-%{version}.tar.gz


BuildRequires:  gcc SDL2-devel SDL2_ttf-devel SDL2_image-devel SDL2_mixer-devel

%description
The main theme is a post-apocalyptic world, where various technologies have become extinct and humanity is communicating in an archaic way through figures and body indications. The player will have to, among other challenges, solve puzzles deciphering audio-visual codes to complete the quests.

%prep
%autosetup %{name}-%{version}
cd %{_builddir}/%{name}-%{version}/%{name}/lib
tar -vzxf ijengine-0.0.5.tar.gz
%make_build
sudo make install


%build
cd %{_builddir}/%{name}-%{version}/%{name}/
mkdir build && cd build/
cmake ..
%make_build


%install
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT/%{_bindir}
# Jogo Executavel
install -m0755 $RPM_BUILD_DIR/%{name}-%{version}/%{name}/Terracota $RPM_BUILD_ROOT/%{_bindir}
#Jogo Assets
mkdir -p $RPM_BUILD_ROOT/%{_datadir}/%{name}/res/
cp -rf $RPM_BUILD_DIR/%{name}-%{version}/%{name}/res/* $RPM_BUILD_ROOT/%{_datadir}/%{name}/res/



%clean
rm -rf $RPM_BUILD_ROOT


%files
%defattr(-,root,root)
%license LICENSE
%doc README.md
%attr(755,root,root) /%{_bindir}/Terracota
%attr(755,root,root) /%{_datadir}/%{name}/res/*


%changelog
* Sun Jun 11 2017 Kássia Catarine <kassia_catarine.15@hotmail.com> 1.0.0-1
- Initial Packager
- CMake building

Com o .spec pronto é só executar o seguinte comando no terminal que irá gerar o pacote rpm.

$ rpmbuild -v -bb terracota.spec

Relatório Final

Dificuldades Encontradas

CMake

A maneira que o makefile funciona é diferente de como o CMake faz a compilação da build, isso dificultou o entendimento do funcionamento da compilação do executável do jogo. Em razão disso, a implementação do CMake atrasou, atrasando as demais atividade do projeto. Além disso, as libs que eram utilizadas de certa maneira no Makefile, não funcionaram no CMake. Só foi possível utilizar as libs de maneira correta no Cmake, utilizando o módulo FindPkgConfig.

Deploy Automatizado

O planejamento inicial do deploy era com Docker e Ansible, por encontrar uma dificuldade do Docker com o trabalho de interface gráfica essa ideia foi substituída e o ambiente foi implantado no Vagrant, por esse possui uma aceitabilidade maior em relação a GUI, assim esse plano foi alterado devido a imprevistos decorrente ao tipo de arquitetura da ferramenta escolhida. Houve um atraso considerável por causa da procura de um meio de execução no Docker, então escolhemos priorizar os empacotamentos do jogo.

Empacotamento RPM

A maior dificuldade foi sobre descobrir como setar os assets a pasta correta, mas fora isso houve uma dificuldade relativamente baixa para encontrar documentos explicativos sobre como é o empacotamento rpm, pois cada pacote possui a sua característica e os manuais simples não serviam ao propósito do jogo.

Empacotamento DEB

A grande dificuldade no empacotamento DEBIAN foi entender como ele funciona. Há alguns arquivos que precisam ser configurados que se tornam bastante complexos quando o projeto tem algumas especificidades. E os erros não são mostrados de maneira que se possa identificá-los logo e corrigi-los, eles demandam bastante tempo.

Referências

http://web.mit.edu/rhel-doc/3/rhel-sag-pt_br-3/ch-rpm.html

https://www.ibm.com/developerworks/br/linux/library/l-rpm1/

Empacotamento - RPM

https://cmake.org/cmake-tutorial/

https://docs.fedoraproject.org/en-US/Fedora_Draft_Documentation/0.1/html/Packagers_Guide/sect-Packagers_Guide-Creating_a_Basic_Spec_File.html