Terracota
Contexto do Projeto
[editar | editar código-fonte]Propósito
[editar | editar código-fonte]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
[editar | editar código-fonte]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
[editar | editar código-fonte]Movimentos
[editar | editar código-fonte]d
ouright arrow
Andar para a direitaa
ouleft arrow
Andar para a esquerdaw
ouup arrow
Andar para cimas
oudown arrow
Andar para baixo
Ações
c
Trocar de Personagemn
Conversarspace
Atacar
Imagens do Jogo
[editar | editar código-fonte]Personagens
[editar | editar código-fonte]Cenário
[editar | editar código-fonte]Conceitos
[editar | editar código-fonte]Menu
[editar | editar código-fonte]Controles
[editar | editar código-fonte]Vídeo Jogo
[editar | editar código-fonte]https://drive.google.com/open?id=0B_UQAEXwMDM6TV82TTFVbkJNdUk
Repositorio GitHub
[editar | editar código-fonte]Escopo
[editar | editar código-fonte]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
[editar | editar código-fonte]Cronograma
[editar | editar código-fonte]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
[editar | editar código-fonte]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
[editar | editar código-fonte]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
[editar | editar código-fonte]Preparando Ambiente
[editar | editar código-fonte]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
[editar | editar código-fonte]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
[editar | editar código-fonte]Para seguir com essa instalação, presume-se que a sua maquina tem instalado os seguintes programas:
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
[editar | editar código-fonte]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
[editar | editar código-fonte]Criação da Máquina Virtual
[editar | editar código-fonte]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
[editar | editar código-fonte]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
[editar | editar código-fonte]Empacotamento DEB
[editar | editar código-fonte]Empacotamento RPM
[editar | editar código-fonte]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
[editar | editar código-fonte]Dificuldades Encontradas
[editar | editar código-fonte]CMake
[editar | editar código-fonte]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
[editar | editar código-fonte]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
[editar | editar código-fonte]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
[editar | editar código-fonte]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/