Terracota

Da wiki Wikiversidade
Saltar para a navegação Saltar para a pesquisa

Contexto do Projeto[editar | editar código-fonte]

Propósito[editar | editar código-fonte]

Logo inicial.jpg

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 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[editar | editar código-fonte]

Personagens[editar | editar código-fonte]

image
image
image

Cenário[editar | editar código-fonte]

image
image
image
image

Conceitos[editar | editar código-fonte]

image

Menu[editar | editar código-fonte]

image

Controles[editar | editar código-fonte]

image

Vídeo Jogo[editar | editar código-fonte]

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

Repositorio GitHub[editar | editar código-fonte]

Terracota

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:

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[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.

 1 cmake_minimum_required(VERSION 2.8)
 2 project(Terracota)
 3 
 4 # Set directory folders
 5 set (PROJECT_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/include")
 6 set (PROJECT_SRC_DIR "${PROJECT_SOURCE_DIR}/src")
 7 set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR})
 8 
 9 # Gets the list of files inside the src directory
10 file(GLOB_RECURSE SOURCES "${PROJECT_SRC_DIR}/*.cpp")
11 
12 # Include Headers
13 include_directories("${PROJECT_INCLUDE_DIR}")
14 
15 #### Compilation ####
16 
17 # Compilation Flags
18 set(CMAKE_CXX_FLAGS "-Wall -W -pedantic -std=c++11 -g3")
19 
20 #### Dependencies ####
21 
22 # Add ijengine
23 set (PROJECT_ENGINE_DIR "/usr/local/include/ijengine")
24 include_directories(${PROJECT_ENGINE_DIR})
25 
26 #### Executable ####
27 
28 add_executable(Terracota ${SOURCES})
29 
30 include(FindPkgConfig)
31 
32 pkg_search_module(SDL2 REQUIRED sdl2)
33 pkg_search_module(SDL2IMAGE REQUIRED SDL2_image>=2.0.0)
34 pkg_search_module(SDL2TTF REQUIRED SDL2_ttf>=2.0.0)
35 pkg_search_module(SDL2MIXER REQUIRED SDL2_mixer>=2.0.0)
36 
37 include_directories(include ${SDL2_INCLUDE_DIRS} 
38 			${SDL2IMAGE_INCLUDE_DIRS}
39 			${SDL2TTF_INCLUDE_DIRS}
40 			${SDL2MIXER_INCLUDE_DIRS})
41 
42 target_link_libraries(Terracota 
43 		ijengine
44 		${SDL2_LIBRARIES} 
45 		${SDL2IMAGE_LIBRARIES}
46 		${SDL2TTF_LIBRARIES}
47 		${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:

 1 # -*- mode: ruby -*-
 2 # vi: set ft=ruby :
 3 
 4 Vagrant.configure("2") do |config|
 5   # Tipo de sistema operacional
 6   config.vm.box = "ubuntu/xenial64"
 7   # Ip da MV para comunicação
 8   config.vm.network "private_network", ip: "192.168.33.10"
 9   # Pastas sincronizadas na MV e Desktop
10   config.vm.synced_folder "../terracota", "/vagrant", type: "nfs", mount_options: ['nolock', 'vers=3', 'udp', 'noatime', 'actimeo=1']
11   # Criar grupos e user na MV
12   config.bindfs.bind_folder "/vagrant", "/vagrant",
13     perms: "u=rwX:g=rD:o=rD",
14     create_as_user: true
15 
16   # Retirar necessidade de entrar com senha
17   config.ssh.insert_key = false
18   # Provedor da MV, setando memória e nome
19   config.vm.provider "virtualbox" do |vb|
20     vb.customize ["modifyvm", :id, "--memory", "2048"]
21     vb.name = "terracota-machine"
22     # vb.gui = true
23   end
24   # Configurando Provisionamento Automatizado
25   config.vm.provision "ansible" do |ansible|
26     ansible.playbook = "provisioning/terracota.yml"
27   end
28 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.

 1 ---
 2 - name: Terracota Machine Setup
 3   hosts: default
 4   user: vagrant
 5   sudo: yes
 6 
 7   roles:
 8     - core
 9     - ijengine
10     - 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.

 1 ---
 2 - name: Install core packages
 3   package: name={{ item }} state=present
 4   with_items:
 5     - vim
 6     - git
 7     - unzip
 8     - gzip
 9     - g++
10     - tar
11     - cmake
12     - make
13     - wget
14 
15 - name: Packages OS RedHat Distribuitions
16   include: "redhat/main.yml"
17   when: ansible_os_family | lower == 'redhat'
18 
19 - name: Packages OS Debian Distribuitions
20   include: "debian/main.yml"
21   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/

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