Kays Against the World

Glossário

Termo	Descrição
'.deb'	Extensão "Debian" - arquivos voltados para a instalação em Sistemas Operacionais baseados no Debian, tais como o Ubuntu e o Mint.
Empacotamento	Ação de definir e reunir recursos que juntos, em um pacote, possuem alguma funcionalidade ou fazem parte de um sistema maior
FGA	Faculdade do Gama - UnB.
GCS	Gerência de Configuração de Software
IJE	Disciplina de Introdução à Jogos Eletrônicos - FGA.
KATW	Kays Against the World, o jogo usado como base no projeto

Introdução

Este documento provê a visão geral de Gerenciamento e configuração do projeto Kays Against the World executado na disciplina de Gerência de Configuração de Software.

Finalidade

Este documento apresenta o plano de Gerência de Configuração do jogo Kays Against the World, desenvolvido na disciplina de IJE. Neste documento serão especificadas diretrizes e atividades como suporte ao desenvolvimento, deploy e controle de versão da aplicação.

Link para o repositório: https://github.com/fgagamedev/Kays-Against-the-World

Escopo

Como objetivos deste trabalho, foi definido que as contribuições abrangerão:

• Automatização de ambiente - Cheff
• Empacotamento Debian
• Explicar o funcionamento do jogo e instalação - atualizar o README.
• Utilizar CMAKE (no lugar do Makefile)

• Definir a política de commits e branches da aplicação.
• Realização de integração contínua
• Análise de qualidade do software - codeclimate (TALVEZ)

Planejamento de GCS

Aqui será detalhado o planejamento das atividades de Gerencimento de Configuração a serem executados ao longo do semestre. Foi definido um cronograma para orientar a execução das atividades a fim de alcançar os objetivos propostos.

Link para o repositorio do projeto de GCS:

https://github.com/AlexandreTK/trabalho_gcs

Cronograma

Data - Início / Previsão de Término	Atividade
22/04 – 24/04	Criação do plano de gerênciamento de configuração
25/04 – 30/04	Configuração do ambiente para o projeto
01/05 – 08/05	CMake
08/05 – 15/05	Chef
15/05 – 28/05	Realizar Empacotamento Debian
29/05	Andamento dos projetos - Ponto de Controle 1
01/05 – 05/06	Atualizar o Readme + Realizar integração contínua com Travis
05/06	Andamento dos projetos - Ponto de Controle 2
05/06 – 16/06	Finalizar possíveis pendências
16/06 – 19/06	Preparar Apresentação final
19/06	Apresentação final

Ferramentas

Ferramenta	Descrição
Git	Sistema de versionamento
Github	Repositorio de aplicações que utiliza do sistema de versionamento GIT
Travis CI	Ferramenta de integração continua
Debhelper	Debhelper é usado para ajudar a construir um pacote debian
codeclimate	Ferramenta de análise estática de código
cmake	Ferramenta de automatização de Build multi-plataforma
cheff	Ferramenta de configuração de ambiente

Gerência de Configuração 

Git 

Dentre os diversos sistemas de controle de versão como Git, SVN, Mercurial, CVS, Bazar. Foi escolhida a ferramenta GIT, principalmente pela sua popularidade.

A utilização de ferramentas de controle de versão são várias, dentre elas é possível citar: Facilidade em controlar diferentes versões, registro das mudanças, facilita o trabalho em equipe, possiblita a criação de branches (ramificações) do software, etc.

GitHub 

É um repositório, servidor remoto, no qual todas as versões e configurações são salvas. Nesse projeto está sendo utilizado o github.

Outras alternativas são: Gitlab, SourceForge, BitBucket, etc.

O link do repositório onde o trabalho está sendo feito é:

https://github.com/AlexandreTK/trabalho_gcs

O link do repositório original do projeto é:

https://github.com/fgagamedev/Kays-Against-the-World

 Configuração de Ambiente

CHEF

O conceito de automação de ambiente está presente em um contexto de Infrastructure as Code (IaC). Dessa forma, um código descreve o ambiente, infraestrutura, necessária para determinado software executar. Dentre as diversas vantagens, a automação de ambientes facilita a manutenção, atualização e auditoria de sofwares; Diminui a quantidade de tutoriais e scripts necessários para configuração de ambiente; Provê um mapeamento de dependências e configurações junto ao código.

Algumas das ferramentas utilizadas para isso são Puppet, Ansible, Chef, SaltStack.

Para este projeto foi utilizado o Chef-solo.

Repositório contendo as receitas chef:

https://github.com/AlexandreTK/chef_game_environment

Receita:

package 'git-core'
package 'build-essential'
package 'cmake'
package 'make'
package 'clang'

package 'libsdl2-dev'
package 'libsdl2-image-dev'
package 'libsdl2-mixer-dev'
package 'libsdl2-ttf-dev'
package 'zlib1g-dev'

# Pacotes adicionais usados pelo pacode .deb
package 'libc6'
package 'libgcc1'
package 'libsdl2-2.0-0'
package 'libsdl2-image-2.0-0'
package 'libstdc++6'


#password MD5 - teste123  -- openssl passwd -1 "<password>"
user node[:user][:name] do
	password node[:user][:password] 
	gid "sudo"
	home "/home/#{node[:user][:name]}"
	manage_home true
end

template "/home/#{node[:user][:name]}/templateTest" do
	source "templateTest.erb"
	owner node[:user][:name]
end

Node.json:

{
	"run_list": ["recipe[main]"],

	"user": {
		"name": "gameuser",
		"password": "$1$QNdlBW2R$G73Lo/TXZDAkuA8A.rDpY0"
	}
}

Script

Achei interessante para criar um script um para a configuração do ambiente para sistemas operacionais debian, tornando assim mais simples de instalar do que utilizar a receita chef.

• environment.sh

sudo apt-get update
echo "Install some required packages for compilation"
sudo apt-get install make cmake  libsdl2-dev libsdl2-ttf-dev libsdl2-image-dev libsdl2-mixer-dev zlib1g-dev clang build-essential

echo "Install some required packages for the debian package"
sudo apt-get install libc6 libgcc1 libsdl2-2.0-0 libsdl2-image-2.0-0 libstdc++6

• install.sh

echo "Setting up environment"
sh environment.sh
echo "Installing the game"
sudo make install
make clean
echo "Game installed"
echo "Type 'katw' to play it"

• uninstall.sh

echo "Uninstalling the game"
sudo make uninstall
make clean
echo "Game uninstalled"

CMAKE 

O nome CMake é uma abreviação de "cross plataform make”, ou seja, é um sistema multiplataforma que gerencia e automatiza o processo de “build". O CMake, além disso, é um software gratuito e open-source, cujo o desenvolvimento iniciou em 1999, patrocinado pela Biblioteca Nacional de Medicina dos Estados Unidos.

O CMake é comparado ao “make utility", no sentido de que ambos providenciam um sistema de “build" que podem ser utilizados para compilar programas. Porém, o CMake é mais recomendado para projetos mais complexos e multiplataformas. O CMake inclusive gera automaticamente um Makefile para o projeto e também pode ser utilizado em conjunto de diversas IDEs como Microsoft Visual Studio e Xcode.

No projeto, foram criados 2 arquivos CMakeList.txt, um na pasta root do projeto, com o seguinte conteúdo:

cmake_minimum_required(VERSION 2.8)
project(katw)

include(FindPkgConfig)
PKG_SEARCH_MODULE(SDL2 REQUIRED sdl2)
PKG_SEARCH_MODULE(SDL2IMAGE REQUIRED SDL2_image>=2.0.0)

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

add_subdirectory(src)

E outro na pasta src da aplicação.

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")

file( GLOB SRCS *.c *.cpp *.h)
add_executable(${PROJECT_NAME} ${SRCS})
target_link_libraries(${PROJECT_NAME} ${SDL2_LIBRARIES} ${SDL2IMAGE_LIBRARIES})

Alterações no CMAKE para gerar o pacote 

O seguinte CMake funciona normalmente para realizar a Build e a instalação do projeto. Porém ao tentar criar o pacote debian, ele não funcionou em computadores x64, só em x32. Dessa forma, decidi utilizar o Makefile para a geração do pacote e o CMake para a realização da build.

cmake_minimum_required(VERSION 2.8)
project(katw)

set (PROJECT_SRC_DIR     "${PROJECT_SOURCE_DIR}/src")
set (INCLUDES_SRC_DIR    "${PROJECT_SOURCE_DIR}/include")

include(FindPkgConfig)
PKG_SEARCH_MODULE(SDL2 REQUIRED sdl2)
PKG_SEARCH_MODULE(SDL2IMAGE REQUIRED SDL2_image>=2.0.0)

include_directories(include ${SDL2_INCLUDE_DIRS} ${SDL2IMAGE_INCLUDE_DIRS} ${PROJECT_DATA_DIR})

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")

file(GLOB_RECURSE SOURCES "${PROJECT_SRC_DIR}/*.cpp" "${PROJECT_SRC_DIR}/*.c" "${INCLUDES_SRC_DIR}/*.h")

add_executable(${PROJECT_NAME} ${SOURCES})

target_link_libraries(${PROJECT_NAME} ${SDL2_LIBRARIES} ${SDL2IMAGE_LIBRARIES})

# Instala o jogo na pasta /bin
INSTALL(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}  DESTINATION /bin)

# Copia a pasta data para /var/lib/katw
add_custom_command(TARGET katw POST_BUILD
                   COMMAND ${CMAKE_COMMAND} -E copy_directory
                   ${CMAKE_CURRENT_SOURCE_DIR}/data /var/lib/katw/data)

Makefile 

Apesar de ter sido utilizado o CMake para compilar o arquivo, acabei utilizando o Makefile para realizar o empacotamento, principalmente pela facilidade de comandos shell.

O "core" makefile é o seguinte

CC = clang++
CFLAGS = -Wall -W -Wno-unused-private-field -Wno-unused-parameter -Wno-reorder -Wno-delete-non-virtual-dtor -ansi -pedantic -g -Iinclude/ -O2 `pkg-config --cflags --libs zlib` -ld
SDL_FLAGS = `sdl2-config --cflags`
SDL_LIBS = `sdl2-config --libs` -lSDL2_image

SRC_DIR = src
OBJ_DIR = obj
DATA_DIR = data

SOURCES = $(wildcard $(SRC_DIR)/*.cpp)
OBJS = $(addsuffix .o, $(addprefix $(OBJ_DIR)/, $(basename $(notdir $(SOURCES)))))

.PHONY: clean mkdir_mod

$(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp
        $(CC) -c -o $@ $< $(CFLAGS) $(SDL_FLAGS)

all: 
        @mkdir -p $(OBJ_DIR)
        @make KATW

KATW:  $(OBJS)
        $(CC) -o $@ $(OBJS) $(SDL_LIBS)

clean:
        @rm -f $(OBJ_DIR)/*
        @rm -f KATW

install: KATW
        @mkdir -p /var/lib/katw
        @cp -r $(DATA_DIR) /var/lib/katw
        install -D KATW \
                $(DESTDIR)$(prefix)/bin/katw

uninstall:
        @rm -rf /var/lib/katw
        -rm -f $(DESTDIR)$(prefix)/bin/katw

Somado a isso, existem outros comandos voltados para a instalação que serão citados posteriormente

Integração Contínua 

Apesar desse projeto já estar finalizado, e a integração contínua não possuir muito valor, ela foi realizada. Para a integração contínua foi utilizado o TravisCI, e o objetivo dela é de apenas verificar se é possível realizar a Build do sistema. Abaixo está o arquivo .travis.yml utilizado:

sudo: required
dist: trusty
language: cpp

# whitelist
branches:
  only:
    - master

install:
  - sudo apt-get install libsdl2-dev -y
  - sudo apt-get install libsdl2-image-dev -y
  - sudo apt-get install libsdl2-mixer-dev -y
  - sudo apt-get install libsdl2-ttf-dev -y
  - sudo apt-get install zlib1g-dev -y
  - sudo apt-get install make -y
  - sudo apt-get install cmake -y
  - sudo apt-get install clang -y
  - sudo apt-get install build-essential -y

compiler:
  - clang++

script:
  - make

Empacotamento Debian 

Tutorial de criação

Os passos seguidos para a criação do pacote Debian foram:

  1) Renomear a pasta do projeto seguindo a convensao “<nome>-<versao>”

katw-1.0

2) Gerar o tar.gz da pasta do programa o qual desejamos empacotar seguindo o padrão “<nome>_<versao>.orig”

katw_1.0.orig.tar.gz

3) Entrar na pasta do projeto e executar o comando "dh_make"

dh_make

Caso tudo der certo, a seguinte mensagem aparecera:

Type of package: single binary, indep binary, multiple binary, library, kernel module, kernel patch?

[s/i/m/l/k/n]

4) Digite “s” e de enter.

5) Depois enter novamente para confirmar.

6) Após isso, entre na pasta “debian” criada e edite os arquivos

Os arquivos que eu editei foram:

• changelog

katw (1.0-1) unstable; urgency=low

  * Local build for GCS.

 -- alex <alexandretk@unknown>  Sat, 17 Jun 2017 20:26:37 -0300

• control (Principalmente setar as dependencias, pode ser visto abaixo).

Source: katw
Section: unknown
Priority: optional
Maintainer: alex <alexandretk@unknown>
Build-Depends: debhelper (>= 8.0.0),
               make,
               clang,
               git-core,
               build-essential,
               libsdl2-dev,
               libsdl2-image-dev,
               libsdl2-mixer-dev,
               libsdl2-ttf-dev,
               zlib1g-dev
Standards-Version: 3.9.4
Homepage: https://github.com/fgagamedev

Package: katw
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: Katw from FGA games
 Packaging Katw from FGA games

• copyright

Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: katw
Source: <url://example.com>

Files: *
Copyright: 2017 katw dev
License: GPL-2
 See bellow.

Files: debian/*
Copyright: 2017 alex <alexandretk@unknown>
License: GPL-2+
 This package is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 .
 This package is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 .
 You should have received a copy of the GNU General Public License
 along with this program. If not, see <http://www.gnu.org/licenses/>
 .
 On Debian systems, the complete text of the GNU General
 Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".

A pasta debian utilizada pode ser vista no seguinte link do GitHub:

7) Agora execute o comando

debuild -us -uc

8) Espera-se que seja gerado o pacote .deb corretamente.

Dificuldades encontradas e Soluções

A principal dificuldade encontrada, foi o fato das sprites e imagens utilizadas pelo jogo eram carregadas da pasta data. Dessa forma, após instalar o jogo, a tela ficava preta, enquanto o jogo rodava.

Para corrigir isso, alterei o código fonte do jogo para procurar pelas imagens na seguinte pasta:

/var/lib/<nome do projeto>

A pasta "data" no diretório root do projeto é copiada para esse outro diretório (/var/lib/katw) durante a instalação. Ao desinstalar esse diretório também é removido.

Devido aos problemas citados acima, foi utilizado o Makefile para a Build do projeto ao invés do CMake. Apesar do CMake estar funcionando, achei complicado de executar comandos shell para criar diretórios, cópia-los (durante a instalação) e removê-los (durante a desinstalação). Foram utilizados, portanto, os seguintes comandos no Makefile para a instalação e desinstalação:

install: KATW
        @mkdir -p /var/lib/katw
        @cp -r $(DATA_DIR) /var/lib/katw
        install -D KATW \
                $(DESTDIR)$(prefix)/bin/katw


uninstall:
        @rm -rf /var/lib/katw
        -rm -f $(DESTDIR)$(prefix)/bin/katw

Observação

Todas as dependencias devem ser instaladas antes de utilizar o gerenciador de pacotes do Debian.

Para instalar o .deb os comandos executados são:

dpkg -i <pacote_do_jogo.deb>

O nome do pacote do jogo nesse caso será "katw_1.0-1_i386.deb"

Para desinstalar o .deb os comandos executados são:

dpkg --remove <nome do jogo>

O nome do jogo nesse caso será "katw"

Link para o pacote debian

Pode ser encontrado no link do repositório

Imagens e videos do Projeto 

Video:

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