GESTÃO E PROGRAMAÇÃO DE SISTEMAS INFORMÁTICOS

ANO LETIVO 2021/2022

DESENVOLVIMENTO DE JOGOS 2D EM

RELATÓRIO FINAL DA
PROVA DE APTIDÃO PROFISSIONAL

Autor: Pedro Miguel Teixeira de Matos

Orientador: Carlos Almeida

Vila Real, junho de 2022

Agradecimentos

Este projeto é o resultado do meu caminho e evolução ao longo do Ensino

Secundário. Caminho que não seria possível realizar sem o contributo de muitas
pessoas e entidades.

Antes de mais quero agradecer à Escola Profissional NERVIR, por colocar à

disposição dos jovens de Vila Real cursos como este, voltados para a vida profissional
e ao mesmo tempo para o ensino superior;

Agradeço também a todos os professores que, com muita paciência nos

ensinaram o melhor que souberam. Mesmo quando não nos apetecia mesmo nada
aprender.

Ao mesmo tempo, agradeço aos colegas e amigos que partilharam tantos bons
momentos comigo e que também me ajudaram, umas vezes a aprender, outras, a
passar aqueles momentos mais chatos.

Agradeço também à minha família por todo apoio, motivação, ajuda e

paciência, sempre disponíveis para ajudar a aprender e a combater a preguiça que
tantas vezes me invadia.
Índice
Índice de Figuras...................................................................................................................................................4

Visão Geral............................................................................................................................................................5

Objetivos do Projeto.............................................................................................................................................6

Objetivos gerais...................................................................................................................................6

Objetivos específicos...........................................................................................................................6

Processo de Desenvolvimento..............................................................................................................................7

Escolha de Software............................................................................................................................8

Arquitetura do Sistema.......................................................................................................................9

Como funciona?................................................................................................................................12

Protótipo do Projeto...........................................................................................................................................14

Casos de Uso.......................................................................................................................................................16

Diagrama de Classes ou Entidade Relacionamento............................................................................................17

O produto Final...................................................................................................................................................18

Explicação técnica de todo o projeto desenvolvido...........................................................................................19

Resultados e Discussão.......................................................................................................................................25

Considerações Finais...........................................................................................................................................26

Bibliografia..........................................................................................................................................................27

Anexo I – Esboço da PAP

Anexo II – Plano da PAP

Anexo III – Autoavaliação

Anexo IV – Curriculum Vitae

Página 3 de 35
Índice de Figuras
Figura 1 Unreal Engine............................................................................................................................8
Figura 2 Godot Engine.............................................................................................................................8
Figura 3 Ambiente Gráfico do GoDot...................................................................................................10
Figura 4 Ambiente Gráfico do GoDot...................................................................................................11
Figura 5 Ambiente Gráfico do GoDot...................................................................................................11
Figura 6 Editor GoDot...........................................................................................................................12
Figura 7 Editor GoDot...........................................................................................................................13
Figura 8 Imagem do mapa e dos personagens.....................................................................................14
Figura 9 Casos de Uso...........................................................................................................................16
Figura 10 Diagrama de Classes.............................................................................................................17
Figura 11 Menu e Cenário Inicial..........................................................................................................18
Figura 12 Código...................................................................................................................................19
Figura 13 Código...................................................................................................................................19
Figura 14 Código...................................................................................................................................19
Figura 15 Código...................................................................................................................................20
Figura 16 Regras Cenário......................................................................................................................20
Figura 17 Código...................................................................................................................................21
Figura 18 Código...................................................................................................................................22
Figura 19 Código...................................................................................................................................22
Figura 20 Código...................................................................................................................................23
Figura 21 Código...................................................................................................................................23
Figura 22 TileMap.................................................................................................................................24

Página 4 de 35
Visão Geral
Desde os primeiros passos da “informática de massas”, acessível ao utilizador comum,
com os primeiros computadores pessoais que dariam origem em meados da década de 80 à
designação “PC”, o mercado de jogos foi um dos maiores motores de desenvolvimento de
novos processadores e processos de programação.

Desde o famoso “ZX Spectrum” do tempo dos nossos pais, com um z80 ZILOG e um
interpretador de comandos BASIC, onde os jogos eram carregados em cassetes de fita
magnética após o comando «Load “”» e a tecla play do leitor de cassetes, em sinais áudio
analógicos que mais pareciam um FAX a “chilrear” alegremente enquanto esperavam que os
primeiros gráficos aparecessem também num vulgar monitor de televisão CRT ligado com um
cabo de antena coaxial de sinal analógico… Velhos tempos, dos quais não me lembro,
obviamente, porque ainda o meu pai era um estudante adolescente. Ao analisar o impacto das
crescentes exigências multimédia dos jogos de computador, vimos surgir os x86, x64,
coprocessadores matemáticos, multi-core, multi-treading, placas de som, chips gráficos
dedicados, placas gráficas mais potentes que os próprios CPU’s, diskettes há muito
ultrapassadas, CD-R/RW, DVD-R/RW, Blue-Ray, HDD’s sempre maiores, SSD sempre mais
rápidos, DIM’s de RAM cada vez melhores, comandos específicos, joysticks, volantes,
monitores (LCD, LED, OLED, planos, curvos etc…), óculos VR, e ainda não sabemos onde
isto vai parar. O que sabemos é que, provavelmente, não vai parar.

Esta é uma sinergia em que, cada avanço tecnológico do hardware é motivado pela
exigência de melhor desempenho, ao mesmo tempo que abre as portas ao desenvolvimento de
novas técnicas e potencialidades de programação, e assim sucessivamente. É um processo em
movimento acelerado em que o número de possibilidades de desenvolvimento abertas com cada
avanço tecnológico do hardware, leva a um crescimento exponencial das possibilidades de
novos avanços tecnológicos que multiplicarão ainda mais as possibilidades de desenvolvimento
de software.

Página 5 de 35
Objetivos do Projeto
Objetivos gerais

Este trabalho constitui é si mesmo uma oportunidade de aprendizagem, procurando em

primeiro lugar a aplicação do conjunto de aprendizagens e conteúdos adquiridos nos diversos
módulos ao longo de todo o curso.

O jogo elaborado é apenas um pretexto para investigar e conhecer um dos mais

conhecidos motores “open-sorce” de desenvolvimento de jogos e outro software.

Testar as potencialidades e aplicações deste motor é outro dos objetivos, proporcionando

a criação de hábitos de programação.

Objetivos específicos
1. Criar um projeto de jogo em GoDot;
2. Construir a estrutura e os elementos do jogo
3. Criar o algoritmo principal e as rotinas secundárias
4. Relacionar e aplicar conhecimentos de programação
5. Apresentar um resultado final (demo) jogável

Página 6 de 35
Processo de Desenvolvimento
Na dinâmica em que se insere o tema escolhido para o desenvolvimento do trabalho e
relatório da minha PAP, temos de ter em conta que, atualmente, existe uma variedade de
plataformas de desenvolvimento de jogos, com linguagens próprias e bibliotecas de recursos
que possibilitam a criação de ambientes, cenários, personagens, mapas, ações…

O processo de escolha da plataforma e o desenvolvimento de um produto, estarão na base

deste projeto.

Ao longo dos seguintes pontos, procuraremos evidenciar os diversos passos,

recursos e momentos que conduziram à elaboração deste relatório, num processo autónomo de
investigação, descoberta e aprendizagem que integram conteúdos da quase totalidade dos
módulos frequentados ao longo do curso GPSI

Página 7 de 35
Escolha de Software
Inicialmente, investiguei a possibilidade de usar a última versão do “Unreal Engime”.

Figura 1 Unreal Engine

Contudo, os elevados requisitos de hardware depressa se mostraram um grande

obstáculo, pois tornariam inviável a demonstração de resultados no contexto dos recursos
limitados disponibilizados. Por isso optei antes pela “GoDot” por ser uma plataforma mais leve
e ao mesmo tempo, poderosa.

Figura 2 Godot Engine

O desafio deste projeto é a exploração da plataforma GoDot usando como pretexto a

criação de um pequeno jogo 2D, ao estilo “RPG / Arcade” com base em tutoriais e exemplos
existentes na “nuvem”.

Os recursos de programação evoluíram muito. Já não temos de “reinventar a roda”, pois

existe uma vasta gama de “peças” de código que podem servir como “tijolos” de uma
construção. O importante é a forma como se combinam essas peças para obter construções
lógicas e algoritmos diferentes.

Assim, o mais importante não será o jogo obtido, mas o caminho percorrido para o seu
desenvolvimento e os problemas resolvidos nesse processo.

Página 8 de 35
Arquitetura do Sistema

GoDot é um motor de jogo recheado de recursos sempre em crescimento. Com alguns

milhares de funcionalidades, há muito para aprender e algo novo todos os dias. Para aproveitar
as suas potencialidades ao máximo, é necessária uma boa base de programação. A equipa de
desenvolvimento faz um esforço contínuo para tornar o motor acessível, mas o utilizador
beneficiará muito se aprender primeiro a pensar como um programador.

Godot assenta no paradigma da programação orientada para/por objetos. É importante

estar familiarizado com alguns conceitos chave, como classes e objetos e integração modular.

Trata-se de um motor de jogos multiplataforma com elevado potencial para criar jogos
2D e 3D a partir de uma interface unificada, que fornece um grande conjunto de ferramentas
comuns, para que os utilizadores possam criar jogos sem precisar “reinventar a roda”.

Os jogos podem ser exportados com um clique para várias plataformas, incluindo as
principais plataformas de desktop (Linux, macOS, Windows), além de plataformas móveis
(Android, iOS) e as baseadas na Web (HTML5).

O Godot é completamente gratuito e de código aberto conforme licença MIT. Sem

limitações, nem direitos de autor, nada. Os jogos desenvolvidos pelo utilizador são dele, até a
última linha de código. O desenvolvimento do Godot é totalmente independente e voltado para
a comunidade, motivando os utilizadores a ajudar a moldar seu motor para atender às suas
expectativas. Melhor ainda, a manutenção e atualização deste motor é feita pela “Software
Freedom Conservancy”, uma entidade sem fins lucrativos.1

Ambiente Gráfico

1
https://docs.godotengine.org/

Página 9 de 35
 Figura 3 Ambiente Gráfico do GoDot

No seu início, o GoDot foi desenvolvido por um estúdio da Argentina. Nasceu em 2001,
sendo reescrito e melhorado sem cessar desde a abertura de seu código, lançado em 2014.

Entre os exemplos de jogos criados com GoDot podemos referir Ex-Zodiac e Helms of
Fury.

Figura 4 Ambiente Gráfico do GoDot

Já no campo dos aplicativos, o programa voltado para desenho de “Pixel Art”,

Pixelorama foi e continua a ser desenvolvido no Godot, assim como o criador de RPG em voxel
RPG in a box.

Página 10 de 35
 Figura 5 Ambiente Gráfico do GoDot

Podemos encontrar muitos outros exemplos nos vídeos oficiais de demonstração:

 Demonstração de desktop e consola de abril de 2020

 Demonstração para dispositivos móveis de abril de 2020

Como funciona?
O GODOT integra um editor de jogos completo com ferramentas dedicadas, ao serviço
das necessidades mais comuns. Possui um editor de códigos dedicado, um editor de animação,
um editor de mapas 2D, um editor de shaders, um depurador, um profiler e muito mais,
podendo expandir-se de acordo com as exigências de cada projeto e de cada utilizador.

Página 11 de 35
 Figura 6 Editor GoDot

A equipe desenvolvimento procura oferecer um editor de jogos rico e com uma

experiência de utilizador consistente. Há sempre espaço para melhorias no GUI, em constante
aperfeiçoamento.

Se preferirmos, podemos usar programas externos. É suportada a importação de cenários

construídos no Blender e a adição de plugins de programação em VSCode,  Emacs para
GDScript e C#. Também suporta Visual Studio para C# no Windows.

Figura 7 Editor GoDot

Página 12 de 35
Linguagens de programação

Podemos programar um jogo em GDScript, uma linguagem específica do Godot e

diretamente integrada com uma sintaxe simples, ou C#, muito popular na indústria de jogos.
Essas são as duas principais linguagens de scripts suportadas. O GoDot faz uso de uma
linguagem de programação visual baseada em “nós” VisualScript.

Com a tecnologia GDNative, você também podemos escrever o algoritmo de

jogabilidade ou algoritmos de alto desempenho em C ou C++ sem recompilar o motor. É
possível utilizar esta tecnologia para integrar bibliotecas de terceiros e outros kits de
desenvolvimento de software (SDK) no motor.

Naturalmente, também poderemos adicionar módulos e recursos ao motor, já que ele é

completamente gratuito e de código aberto.

Estas são as cinco linguagens de programação oficialmente suportadas. A comunidade de

programadores desenvolve continuamente novas potencialidades e ferramentas de
programação, como por exemplo: GDDNative third-party bindings.

Página 13 de 35
Protótipo do Projeto

Usando as potencialidades acima referidas, meti mãos à obra, vi os tutoriais necessários

para me familiarizar com a mecânica deste software e comecei a dar os primeiros passos.

Figura 8 Imagem do mapa e dos personagens

Uma das etapas mais intuitiva e criativa é o desenvolvimento do mapa de jogo: o cenário
onde decorrerá a ação. Para isso é necessário conceber uma pequena “Game story”:

Página 14 de 35
 Esta história de jogo é muito simples: o nosso herói é uma pequena raposa aventureira
em terreno desconhecido que terá de descobrir dominar, deslocando-se pelo mapa e enfrentando
os inimigos (morcegos). Conscientes da sua presença, os inimigos seguem o nosso pequeno
herói. Este pode esquivar-se caminhando ou rolando em 4 direções. Para enfrentar e matar os
inimigos, podemos usar a espada que anda sempre “à mão”, com golpes rápidos e certeiros. Ao
ser morto, cada morcego “dropa” um coração de vida que permanece alguns segundos no chão,
podendo ser recolhido se necessário para revitalizar o “Life stock” do player, constituído por 4
corações. Podemos também interagir com algumas plantas, destruindo-as (sem qualquer
finalidade que não seja vê-las cair e desaparecer – totalmente anti-ecológico).

Para construir o cenário/mapa com todos os seus elementos, utilizamos a vasta biblioteca
e objetos passivos e ativos com gráficos e animações predefinidas. Abordamos esse conteúdo
no ponto seguinte.

Página 15 de 35
Casos de Uso

Figura 9 Casos de Uso

Página 16 de 35
Diagrama de Classes ou Entidade Relacionamento

Figura 10 Diagrama de Classes

Página 17 de 35
O produto Final
O resultado final de toda a programação e recursos envolvidos é compilado para dois
ficheiros:

Um ficheiro executável “Jogo 2D.exe” com aproximadamente 35 MB e um ficheiro PCK

com os recursos usados pelo jogo. Estes dois ficheiros têm de ter o mesmo nome e estar sempre
na mesma pasta para o jogo funcionar.

Os requisitos deste programa são muito baixos, possibilitando o seu funcionamento em

praticamente todos os PCs do nosso tempo.

Figura 11 Menu e Cenário Inicial

Página 18 de 35
Explicação técnica de todo o projeto desenvolvido
Menu Principal:
Na sequência de código abaixo definimos a área onde vai ser apresentado o menu e as
opções possíveis, na forma de variáveis

Figura 12 Código

Depois definimos a opção por defeito do menu e as regras de navegação e seleção de

opções bem como as teclas a usar para esse efeito.

Figura 13 Código

No código abaixo são atribuídas as ações de cada botão: Jogar, Opções, Sair

Figura 14 Código

Para definirmos a animação do seletor do menu usamos o código abaixo

Página 19 de 35
 Figura 15 Código

A verdadeira ação começa quando selecionamos a opção “Jogar”. Então é chamado o

cenário criado no mapa/mundo, com todas as rotinas e objetos associados: Jogador, Fundo,
Morcegos, TileMaps, Camera, Regras de Colisão e interação com os objetos do cenário, Nível
de Vida e teclas a utilizar.

Esta parte do jogo, dado o grande nível de integração do GoDot é definida em ambiente
GUI.

Na imagem abaixo podemos mesmo observar as áreas de colisão e interação com objetos,
paredes e personagens

Figura 16 Regras Cenário

Código do Jogador:

Página 20 de 35
 Nas linhas de código abaixo é inicializado o personagem do jogador com as
regras/variáveis de movimento e físicas bem como o som a executar quando o personagem leva
dano, regras de animação e área de armazenamento de estatísticas do jogador e outros dados.

Figura 17 Código

Página 21 de 35
 Para que o jogo possa começar é importante definir o status inicial do jogador, as
possibilidades de ação

Figura 18 Código

O código abaixo define os vetores de movimento e associa-os a teclas ou combinações de

teclas

Figura 19 Código

Página 22 de 35
 As funções abaixo definem as regras de animação desencadeadas por cada tecla premida
pelo Jogador

Figura 20 Código

Concluindo o código relativo ao personagem do jogador definimos as ações a

desencadear na situação de ser atacado por um morcego bem como o status de animação e de
vida do personagem

Figura 21 Código

Página 23 de 35
 Morcego:
Ao contrário das ações do jogador que dependem das teclas premidas, as ações dos
nossos inimigos/morcegos no jogo são desencadeadas por inteligência artificial que define as
ações e movimento do morcego com base na interseção de áreas sensíveis por parte do
personagem. O código associado a este elemento do jogo é em tudo semelhante ao do
personagem exceto na definição de teclas e de regras de movimento.

TileMap

Todo o cenário é construído à base de texturas. Para saber os limites de movimentação e

construção do cenário o Godot usa os chamados TilesMaps que não são mais do que matrizes
de combinações possíveis de peças (Tiles) entre si. No GUI de elaboração do mapa as peças
aplicadas mudam de acordo com as peças adjacentes. A vermelho está assinalada a área
“Bitmask” usada para detetar as peças adjacentes selecionar que melhor se ajusta.

Figura 22 TileMap

Página 24 de 35
Resultados e Discussão

O resultado deste projeto é uma compilação executável, que pode ser perfeitamente
enviada por via eletrónica, dispensando qualquer instalação, correndo de forma autónoma em
qualquer plataforma Windows.

Pode também ser gerada uma APK para Android capaz de correr em qualquer smartfone
ou tablet com esse sistema operativo.

Duvido que este jogo seja capaz de criar qualquer tipo de adição, pois é muito pequeno e
fácil de concluir. Procurei aumentar recentemente o grau de dificuldade com maior dano dos
morcegos que dará algumas dores de cabeça à nossa pequena “Foxy”.

A jogabilidade é bastante acessível e fluida com animações muito simples e eficazes.

Podem existir alguns “bugs”, como em qualquer outro exemplo de software. Se os

encontrarem podem enviar comentários para o meu email: ninetailstp@gmail.com

Para uma primeira experiência com este motor de desenvolvimento de jogos, penso que
foi interessante. Existe uma larga coleção de exemplos de jogos elaborados nesta plataforma
que pode ser observada no Youtube (ver links na bibliografia).

Quaisquer sugestões podem ser enviadas também para o meu e-mail.

Página 25 de 35
Considerações Finais

No campo das tecnologias da informação, tudo evolui e cresce continuamente. O código

programado hoje pode ser revisto amanhã e reconstruído. Coisas com que apenas sonhávamos
há uma década e que apenas poderíamos conceber em teoria, tornam-se possíveis a cada novo
desenvolvimento do hardware e das técnicas de programação.

Assim, no final deste trabalho, estou, certamente mais preparado para começar. O
caminho percorrido, abriu novos caminhos. Agora é só “caminhar”, o melhor, programar.

Cada aprendizagem realizada no curso foi, em maior ou menor grau, aplicada aqui. Ao
mesmo tempo, verificamos que, ao longo do curso, não abordamos nada específico sobre
GoDot. Por isso, considero valiosa esta oportunidade, pela novidade que constitui, levando à
descoberta de novos conhecimentos para lá do que aprendemos nas aulas.

O resultado? Um novo jogo, muito simples e sem pretensões de fazer grande sucesso.
Um pequeno exemplo de criatividade em que tive de imaginar e criar um mapa de jogo, uma
história, personagens e ações.

Foi um tempo de crescimento e de alargamento dos meus conhecimentos. Espero não

ficar por aqui.

Página 26 de 35
Bibliografia
https://godotengine.org/download/windows
https://www.youtube.com/watch?v=fSMTf_kg6mY&ab_channel=GamesNow%21
https://pt.wikipedia.org/wiki/Godot
https://docs.godotengine.org
https://github.com/vnen/godot-portugues
https://satellasoft.com/artigo/godot/uma-proposta-chamada-godot
https://www.youtube.com/watch?v=42HKCFf5Lf4&ab_channel=GDQuest
https://www.youtube.com/watch?v=iAceTF0yE7I

Página 27 de 35
Anexo I – Esboço da PAP

Curso: Gestão e Programação de Sistemas informáticos Ano: 3º Ano Letivo: 2021 / 2022

Nome Aluno: Pedro Miguel Teixeira de Matos Nº15

Tema: Criação de um jogo 2D

Fundamentação do Tema:
Eu escolhi este tema porque sempre joguei jogos de todos os tipos e tinha curiosidade de como se faziam e de saber oque difícil seria.

Objetivos:

O meu objetivo é criar um jogo 2D utilizando a engine GODOT, testar os níveis, procurar por bugs e elaborar um relatório de como eu realizei o meu trabalho
e como o software funciona

Projeto Prático:

Como funciona a engine GODOT, como funciona a linguagem GD, criar níveis a nível de design e de programação, adicionar features, trabalhar no visual dos
níveis, utilização de sprites grátis.

Recursos / Orçamento(caso necessário)

Internet, Computador, Orientador, Professores

Anexo II – Plano da PAP
Curso: Gestão e Programação de um Sistema informático Ano: 3º Ano Letivo: 2021 / 2022
Nome Aluno: Pedro Miguel Teixeira de Matos Nº15
Tema Criação de um jogo 2D

Objetivos Gerais Objetivos Específicos Atividades / Estratégias Recursos Calendarização

Entender o
funcionamento da
Out/Nov: Fazer mecânicas
engine GODOT Consultar multimédia
do jogo
em relação a engine
Internet
Criação de níveis usando GODOT
Criação e programação de Dezembro: Design dos
as ferramentas da engine
um jogo 2D Computador níveis
Uso de assets da internet
Uso de sprites gratis que poderei usar durante
Jan/Fev: Retoques e novas
Programação de features a criação do jogo
features
Melhoramento Visual
 Anexo III – Autoavaliação
Ano Letivo:
Curso: Técnico de Gestão Programação e Sistemas Informáticos 2021 / 2022
Tema: Criação de um jogo 2D
Professor Acompanhante: Carlos Eduardo da Silva Almeida Rubrica 
Aluno: Pedro Miguel Teixeira Matos Rubrica 
Momento de Autoavaliação: 1º x   2º     3º   Data:  

Comportamentos/Aquisição de Conhecimentos Classificação

Cumprimento da Calendarização 16
Assiduidade
Apresentação Periódica 20

Sentido de Responsabilidade ao longo do processo 18

Atitude

Cumprimento das tarefas/regras de trabalho 18

Organização Responsabilidade
Hábitos individuais de trabalho 18

Interesse e motivação 17

Conhecimentos Capacidade de relacionar o saber científico com o

mundo atual 17

Capacidade de resolução de problemas 19

Motivação empenho e autonomia 17

Autonomia

Espírito de iniciativa 17

Classificação 17,7

Observações:
 

 
 
 
 Ano Letivo:
Curso: Técnico de Gestão Programação e Sistemas Informáticos 2021 / 2022
Tema: Criação de um jogo 2D
Professor Acompanhante: Carlos Eduardo da Silva Almeida Rubrica 
Aluno: Pedro Miguel Teixeira Matos Rubrica 
Momento de Autoavaliação: 1º   2º x    3º   Data:  

Comportamentos/Aquisição de Conhecimentos Classificação

Cumprimento da Calendarização 16

Assiduidade
Apresentação Periódica 20

Sentido de Responsabilidade ao longo do processo 17

Atitude

Cumprimento das tarefas/regras de trabalho 17

Organização Responsabilidade
Hábitos individuais de trabalho 17

Interesse e motivação 17

Conhecimentos Capacidade de relacionar o saber científico com o

mundo atual 17

Capacidade de resolução de problemas 18

Motivação empenho e autonomia 17

Autonomia

Espírito de iniciativa 17

Classificação 17,3

Observações:
 

 
 
 
 Ano Letivo:
Curso: Técnico de Gestão Programação e Sistemas Informáticos 2021 / 2022
Tema: Criação de um jogo 2D
Professor Acompanhante: Carlos Eduardo da Silva Almeida Rubrica 
Aluno: Pedro Miguel Teixeira Matos Rubrica 
Momento de Autoavaliação: 1º   2º   3º  x Data:  

Comportamentos/Aquisição de Conhecimentos Classificação

Cumprimento da Calendarização 17

Assiduidade
Apresentação Periódica 20

Sentido de Responsabilidade ao longo do processo 17

Atitude

Cumprimento das tarefas/regras de trabalho 17

Organização Responsabilidade
Hábitos individuais de trabalho 18

Interesse e motivação 16

Conhecimentos Capacidade de relacionar o saber científico com o

mundo atual 18

Capacidade de resolução de problemas 18

Motivação empenho e autonomia 16

Autonomia

Espírito de iniciativa 17

Classificação 17,4

Observações:
 

 
 
 
Anexo IV – Curriculum Vitae