CrossRoads

Introdução

Finalidade

Este documento tem como objetivo mostrar a aplicação de alguns dos pontos abordados da Gerência de Configuração de Software em um ambiente de desenvolvimento real, com o objetivo de ampliar a maturidade do projeto CrossRoads da disciplina de Introdução aos Jogos Eletrônicos e controlar as mudanças de uma maneira mais organizada e automatizada.

Contexto do Projeto

Descrição

O jogo é um 2D hack'n slash plataforma, onde o jogador controla um herói em sua longa aventura.

Visão Geral

Obejtivo é controlar o personagem por diversas fases.

Enfrentando seus inimigos em busca do Cálice Mágico.

Quando surgem desafios, é necessaria a ajuda, então, controlamos o segundo personagem, que possui diferentes habilidades

Plano de Gerência de Software

História

Gryth, um grande guerreiro conhecido por todos, vive sua vida em busca de grandes aventuras.. No meio do inverno, ele recebe uma chamada de aventura de Hiron, o grande padre, para uma missão. Nas profundezas da igreja de Pygon, proibida para as pessoas, reside um cálice cujos poderes são gigantescos, mas perigosos. A luta de Gryth é equilibrar seu corpo e mente, e controlar seu poder para derrotar os inimigos no caminho.

Objetivo

Empacotar e disponibilizar o jogo CrossRoads, sem dependências para execução.

Realizar a integração contínua, garantindo a integridade de build.

Utilizar um programa adequado para a execução da rotina de compilação.

Cronograma

Data início / término	Marco
24/04/2017 - 24/04/2017	Planejamento e Controle - GCS
25/04/2017 - 28/04/2017	Configurações de Integração contínua
29/04/2017 - 02/05/2017	Definição e escrita da Wiki do projeto
03/05/2017 - 06/05/2017	Estudo de conceitos - Empacotamento
08/05/2017 - 12/05/2017	Implementação do Empacotamento
29/05/2017	Ponto de Controle 1
30/05/2017 - 03/05/2017	Revisão pós o PC1
04/05/2017 - 04/06/2017	Conclusão empacotamento do projeto
05/06/2017	Ponto de Controle 2
06/06/2017 - 15/06/2017	Revisão pós PC2
16/06/2017 – 18/06/2017	Desenvolvimento da apresentação final
19/06/2017	Apresentação Final

Escopo

Executar as atividades listadas abaixo até o ponto de entrega final:

Criar tutorial para auxílio na instalação do jogo;
Integração contínua do projeto;
Empacotamento do jogo CrossRoads.

Projeto CrossRoads

O projeto é o objeto de avaliação da disciplina Introdução a Jogos Eletrônicos, cursada no primeiro semestre de 2017.

São responsáveis pelo desenvolvimento do projeto:

Programadores

Fernando Ribeiro Aguilar
Caio Ribeiro
Ulysses Guimarães

Artista

Gustavo Nunes

Músico

Pedro Neder

Dependências e Ferramentas

Ferramenta	Descrição
C++	Linguagem de Programação utilizada.
SDL 2	Biblioteca de desenvolvimento e acesso ao Hardware.
Cmake	Ferramenta para dar Build, testar e Enpacotar
Github	Versionamento e Repositório remoto
Travis CI	Ferramenta de integração contínua

Cmake

O Cmake gerencia e automatiza o processo de build do jogo. O trecho do código abaixo mostra como foi configurado o arquivo CMakeLists.txt que é a base de configuração do cmake e a partir dele o build é gerado:

cmake_minimum_required(VERSION 3.0.2)
project(game LANGUAGES CXX)

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

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

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

#### Compilation ####

# Compilation Flags
set(COMPILE_FLAGS "")

if (${CMAKE_CXX_COMPILER_ID} STREQUAL Clang)
    set(COMPILE_FLAGS "${COMPILE_FLAGS} -std=c++11 -W -Wall -pedantic -std=c++11 -Wshadow -O2 -g")
elseif (${CMAKE_CXX_COMPILER_ID} STREQUAL GNU)
    set(COMPILE_FLAGS "${COMPILE_FLAGS} -std=c++11 -W -Wall -pedantic -std=c++11 -Wshadow -O2 -g")
elseif (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC)
    set(COMPILE_FLAGS "${COMPILE_FLAGS} /Wall")
endif()

# Cmake compilation flags redefinition
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMPILE_FLAGS}")

#### Dependencies ####

# Add engine
set (PROJECT_ENGINE_DIR "${PROJECT_SOURCE_DIR}/engine")
add_subdirectory(${PROJECT_ENGINE_DIR})
include_directories(${ENGINE_INCLUDE_DIR})

#### Executable ####

add_executable(game ${SOURCES})

target_link_libraries(game
                      engine
                      SDL2 SDL2_image SDL2_ttf SDL2_mixer)

#### Custom Commands ####

# Copy assets folder to build
add_custom_command(TARGET game POST_BUILD
                   COMMAND ${CMAKE_COMMAND} -E copy_directory
${PROJECT_ASSETS_DIR} ${CMAKE_BINARY_DIR}/assets)

Integração Contínua: Travis CI

Visando manter a integridade do código e o acompanhamento de alterações foi implementado a integração contínua no projeto utilizando a ferramenta Travis CI. Abaixo, o código do arquivo .travis.yml que é base da configuração da integração contínua no projeto:

{
  "dist": "trusty",
  "sudo": "required",
  "language": "cpp",
  "compiler": "gcc",
  "addons": {
    "apt": {
      "sources": [
        "ubuntu-toolchain-r-test"
      ],
      "packages": [
        "gcc-6",
        "g++-6",
        "cmake",
        "libsdl2-dev",
        "libsdl2-image-dev",
        "libsdl2-mixer-dev",
        "libsdl2-ttf-dev",
        "make"
      ]
    }
  },
  "script": [
    "sudo ln -s /usr/bin/gcc-6 /usr/local/bin/gcc",
    "sudo ln -s /usr/bin/g++-6 /usr/local/bin/g++",
    "export CC=/usr/bin/gcc-6",
    "export CXX=/usr/bin/g++-6",
    "mkdir build && cd build",
    "cmake .. && make"
  ],
  "group": "stable",
  "os": "linux"
}

Configurando o Jogo

Manual de Instalação

1ª Passo: Instalando as dependências

$ sudo apt-get install cmake libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev

2ª Passo: Baixar repositório do Github

$ git clone https://github.com/fernand0aguilar/ije-fga-UnB.git

3ª Passo: Compilação do jogo

$ cd ije-fga-unb
$ mkdir build && cd build
$ cmake ..
$ make

4ª Passo: Execução do jogo

$ ./game

Log de informações

$ cat log.txt

Controles

W A S D - Movimentar
Espaço - Atacar
Q - Defender

Empacotamento

Como uma das finalidades da disciplina é a realização do empacotamento do jogo. Foram feitos o empacotamento para sistemas Debian Based e para os sistemas Red Hat Based. Abaixo você encontra os dois empacotamentos que se encontram prontos para serem instalados em seus sistemas.

Empacotamento Debian

Para o empacotamento Debian foi utilizado a ferramenta Debreate para auxílio da criação do pacote, visto que de forma manual os sprites do jogo estavam sendo desconsiderados na geração do pacote. Sua utilização é simples mas precisa ser feita com cuidado para não errar alguma parte dos passos. Basicamente segue-se os seguintes passos:

Passo 1: Instalação da ferramenta via terminal com os seguintes comandos:

$ sudo add-apt-repository ppa:antumdeluge/debreate
$ sudo apt-get update
$ sudo apt-get install debreate

Passo 2: Configuração do arquivo CONTROL que contém informações como: Nome do pacote, versão, mantenedor, email e Arquitetura
Passo 3: Configuração das dependências e dos conflitos
Passo 4: Arquivos que fazerão parte do pacote a ser construído
Passo 5: Os scripts necessários para instalação do pacote
Passo 6: Changelog
Passo 7: Licença de Copyright
Passo 8: Criação do Menu Launcher do pacote
Passo 9: Gerar build e iniciar construção do pacote

As imagens ao lado em formato thumb são os prints da ferramenta com os passos descritos acima para gerar o pacote:

Abaixo segue como foi gerado o arquivo de configuração CONTROL para geração do pacote:

Package: cross-roads-game
Version: 0.0.2
Maintainer: @fernand0aguilar <fernando@aguilar.net.br>
Section: games
Source: https://github.com/fernand0aguilar/ije-fga-UnB
Homepage: https://github.com/fernand0aguilar/ije-fga-UnB#crossroads
Architecture: amd64
Priority: optional
Depends: libsdl2-dev , libsdl2-image-dev, make, cmake, libsdl2-mixer-dev, libsdl2-ttf-dev
Description: A 2D game made with SDL2
 A 2D game made with SDL2 for a subject called Introduction to Eletronic Games. Coursed in the first semester of 2017 in University of Brasilia.

Para instalar o pacote na sua máquina Debian Based. Basta fazer o download através do seguinte link:

CrossRoads.deb

Pode-se instalar usando o gerenciador de aplicativos de seu sistema. Basta lembrar que é precisa permissão de super usuário para tal ação. Para iniciar o jogo, basta procurar pelo nome CrossRoads no meu de aplicações. Ou se preferir pode ser feita a instalação através do terminal rodando o seguinte comando:

$ sudo dpkg -i cross-roads-game_0.0.2_amd64.deb

Para desinstalar o jogo, pode-se utilizador o seu gerenciador de aplicativos e clicar em "Remover", ou se preferir pode-se rodar o seguinte comando no terminal:

$ sudo apt-get remove crossroads

Empacotamento RPM

Para realização do empacotamento RPM, foi utilizado a ferramenta de conversão de pacotes Alien. Alien é uma ferramenta de linha de comando que permite você converter pacotes DEB para RPM e pacotes RPM para DEB. Foram feito os seguintes passos para gerar o pacote RPM:

Primeiramente deve-se instalar o Alien via terminal:

$ sudo apt-get install alien

Após a instalação, guiando o terminal até o diretório ao qual o pacote debian se encontra e foi realizado o seguinte passo:

$ sudo alien -r  -c -v cross-roads-game_0.0.2_amd64.deb

Após rodar o comando o pacote RPM foi criado e pronto para ser instalado em sistemas Red Hat Based.

Para instalar o pacote na sua máquina Red Hat Based. Basta fazer o download através do seguinte link:

CrossRoads.rpm

Pode-se instalar usando o gerenciador de aplicativos de seu sistema. Basta lembrar que é precisa permissão de super usuário para tal ação. Para iniciar o jogo, basta procurar pelo nome CrossRoads no meu de aplicações. Ou se preferir pode ser feita a instalação através do terminal rodando o seguinte comando:

$ sudo rpm -i cross-roads-game-0.0.2-2.x86_64.rpm

Para desinstalar o jogo, pode-se utilizador o seu gerenciador de aplicativos e clicar em "Remover", ou se preferir pode-se rodar o seguinte comando no terminal:

$ sudo rpm -e remove crossroads

Imagens do jogo

Abaixo é possível ver algumas imagens acerca do jogo:

Matéria - Gerência de Configuração de Software

Experiência

A aplicação dos conteúdos abordados em Gerẽncia de Configuração de Software foi de bom proveito, pois mostra como é importante o GCS aplicado na prática. Notou-se também que um plano bem definido é de extrema importânciaa para a boa execução do mesmo durante as fases do projeto, deixando bem claro e respeitando as datas do plano para evitar atrasos e perda de tempo com tarefas que deveriam ser concluídas. Também foi visto o quanto é importante fazer de maneira correta o empacotamento, para evitar problemas de bugs e crashs na máquina a ser instalada, podendo até mesmo gerar erros no sistema.

Desafios e Dificuldades

Jogo sendo desenvolvido na matéria de Jogos Eletrônicos e utilizado ao mesmo tempo em Gerência de Configuração de Software
Problemas ao empacotar o jogo devido que na hora do empacotamento as sprites do jogo não eram reconhecidas
Bugs ao tentar rodar o jogo utilizando placa de vídeo dedicada. Placas de vídeo nativa não ocorriam bugs