Laboratório de Jogos do IST: Alumni Meeting 2020

Cheguei a tempo de assistir à palestras do LabJogos, e fiquei a saber de mais um tuga que anda lá por fora a desenvolver o seu percurso no mundo dos videojogos, de nome João Oliveira que trabalha na Ubisoft.

+infos(a conversa): https://fb.watch/1Vk72BUeZN/

Tags : , ,

Dice Command

Esteve a decorrer uma campanha acerca deste jogo de tabuleiro. Uma vez mais achei interessante o tema… mas achei caro com os portes de envio! Mas fica o registo da sua existência :)

+infos(oficial): https://www.ejectedplanet.com/

+infos(campanha): LINK

Tags : , , ,

Sea of Roses, um videojogo


Sea of Roses
Desenvolvido por: Ariana Parrilha (FBAUL), Andreia Santos Batista (FBAUL) & André Fidalgo Silva (IST)

Tags : , , ,

Humble Game Dev STEM, Humble software bundle (uma campanha)

Está a decorrer mais uma campanha no Humble com algumas coisas interessantes para acerca de GameDev, nomeadamente alguns programas para a construção da documentação e alguns extras para uso com o software Game Creator. Da lista consta:
SoftWeir Game Design Documentation Builder
SoftWeir Project Management Documentation
SoftWeir World Design Worksheet
SoftWeir Map & Dungeon Design Worksheet
SoftWeir User-Interface Design Worksheet
SoftWeir Character & Animation Design Worksheet
SoftWeir Story & Storyboard Design Worksheet
SoftWeir Script & Logic Design Worksheet
SoftWeir Item Design Worksheet
SoftWeir Weapon & Armour Design Worksheet
001 Game Creator
001 Basics E-Book + E-Learning Home Assignments
001 Resource E-Book + E-Learning Home Assignments
DLC 001 Game Creator – Point & Click Adventure Kit
DLC 001 Game Creator – Dragons Den Resource Pack
DLC 001 Game Creator – Retro Fantasy Music Pack Volume 1
DLC 001 Game Creator – Sound Effects Pack Volume 1
DLC 001 Game Creator – Enhanced RPG Kit
DLC 001 Game Creator – 3D FPS / Survival Horror Kit
DLC 001 Game Creator – MMORPG Kit
DLC 001 Game Creator – Visual Novel Kit

+infos(campanha): LINK

 

Tags : , , , , ,

VGPT, Arquivo online de videojogos portugueses

Um site interessante, que ainda está a crescer, mas que funciona como uma espécie de museu/catálogo virtual acerca dos videojogos que foram desenvolvidos em Portugal ao longos dos tempos..  a acompanhar.

+infos(oficial): https://videogamept.wordpress.com/

Tags : , , ,

Novo curso online pela Gamedev.tv

A malta da Gamedev.tv está a disponibilizar mais um curso online com o Unity: Unity Multiplayer: Intermediate C# Coding & Networking. Desta vez é um curso com o qual tenho um particular interesse já que é sobre o desenvolvimento de um RTS com a possibilidade de ser jogado com dois ou mais jogadores.

+infos(oficial): LINK

Tags : , ,

Proposta de trabalho

A ONTOP (www.ontopstudios.com) está à procura de um game designer de AR.

+infos(oficial): https://www.ontopstudios.com/

+infos(rede social, promotor): LINK

Tags : ,

Concurso de talentos acerca de videojogos

A empresa Fnac está novamente a promover um concurso nacional acerca dos videojogos, nomeadamente para quem os desenvolve. O prazo de candidatura termina no dia 31 de dezembro e está a aberto a todos os que andem ainda a desenvolver algum jogo no ultimos dois anos.

+infos(oficial): https://www.fnac.pt/novostalentos-videojogos

Tags : , ,

Referências acerca do motor Godot!

Godot Tutorials (2D, GDScript, Programming Basics).
Emilio (2D, GDScript and VisualScript).
GDQuest (2D and 3D, GDScript, VisualScript and C#).
Game Development Channel (2D, GDScript).
Game Endeavor (2D, GDScript).
Game from Scratch (2D and 3D, GDScript and C#).
HeartBeast (2D, GDScript).
Jeremy Bullock (2D and 3D, GDScript, VisualScript and C#).
KidsCanCode (2D and 3D, GDScript and VisualScript).
Mister Taft Creates (2D, GDScript).
Miziziziz (2D, GDScript).
P1X / Krzysztof Jankowski (3D).
Pigdev (2D, GDScript).
Steincodes (2D, GDScript and VisualScript).
TheBuffED (2D, GDScript).
Code with Tom (2D and 3D, GDScript).
BornCG (3D, GDScript).
Gonkee (2D, 3D, GDScript, Shaders).

+infos(oficial): LINK

Tags : , ,

Estatísticas…

Interessante que apesar de tudo e nas consolas os jogos USA Made continuam a vender e a ter fãs, e no PC parece continuar tudo na mesma :)

“NBA 2K21 was the top-earning title of the month, selling 1.9M digital units. Digital console sales were up 19% over NBA 2K20 at launch, and in-game revenue similarly increased by 8%. The game benefited from the rescheduling of the delayed NBA postseason. In August, NBA 2K20 also performed better than usual thanks to the return of the NBA on TV.

Marvel’s Avengers from Square Enix sold 2.2M digital units in September. This was the second-biggest digital launch for a Square Enix title behind Final Fantasy VII Remake. Total digital sales were roughly the same as the last major superhero game, PlayStation 4 exclusive Marvel’s Spider-Man. Avengers also took design cues from the looter shooter subgenre and had a launch performance that fell between Destiny 2 and Tom Clancy’s The Division 2.

Nostalgia was a powerful sales driver in September. Tony Hawk’s Pro Skater 1 + 2 from Activision Blizzard sold 2.8M digital units, a significantly higher launch figure than the publisher’s previous remakes of Crash Bandicoot or Spyro games. Also in September, Nintendo’s Super Mario 3D All-Stars sold 1.8M digital units, which was by far the biggest launch ever for a Mario title on Switch.

Crusader Kings III from Paradox broke records for PC strategy games, selling 1.1M digital units in September. The medieval dynasty simulator sold more units in its launch month than either Total War: Three Kingdoms from Sega or Sid Meier’s Civilization VI from 2K. Crusader Kings III did earn slightly less at launch than its closest competitors because it was priced at $49.99 instead of the more common $59.99.

In September, the mobile version of Among Us reached nearly as many players as Pokémon GO did during the peak of its popularity in August 2016. While the indie game originally launched in July 2018, interest in the game skyrocketed during the past summer as popular Twitch streamers took up the game. However, the high player numbers have remained subdued as in-game spending was limited to a handful of cosmetic items and the ability to remove ads. The game’s mobile revenue was not enough for it to break into the top 40 on mobile. Earnings were, however, still extremely high for a game made by only three developers.

Rocket League’s transition to a free-to-play business model paid off for developer Psyonix (now a subsidiary of Epic Games). Player numbers nearly tripled in September, up 193% a week after the shift. Revenue-wise, total digital sales from September 23 to 30 (when the game was free to play) nearly matched the three previous weeks. The game’s esports ecosystem should also benefit from a boost in potential viewers on streaming platforms such as Twitch.”

+infos(oficial): LINK

Tags : , ,

Palestras sobre jogos e videojogos (online)

Encontrei umas palestras acerca de jogos e videojogos que são “patrocinadas” pelo The Birmingham Centre for Media and Cultural Research (BCMCR). Das próximas destaco as seguintes:
Rethinking PC Games Pricing, por Oscar Clark
Truth, Contingency and Necessity: the rhetoric of historical games

E também pela Georgetown University Wargaming Society (GUWS) do qual destaco:
Game Design & Self-Publication by Brian Train
Play to Learn: Historical Board Games as Educational Tools

+infos(BCMCR Research Events): https://www.bcu.ac.uk/media/research
+infos(Georgetown University Wargaming Society): https://www.guwargaming.com/
+infos(eventbrite, as sessões): LINK

Tags : ,

Empresa Sega faz 60 anos..

Esta é uma imagem que partilha um pouco da história da empresa Sega nos últimos sessenta anos.

Tags :

Criando jogos com Flutter e Flame, com Renan Araújo

Não conhecia esta “framework” de nome Flutter (made by Google), parece interessante para o desenvolvimento de apps hibridas, mas também dá para jogos usando o Flame. Fica a referência para um pequeno workshop online acerca deste tema.

+infos(o video): https://youtu.be/0nl6CZJiFnY?t=4456

+infos(o autor): http://caraujo.me/

+infos(flutter): https://flutter.dev/

+infos(flame): https://pub.dev/packages/flame

Tags : , , ,

Pós-Graduação em Game Design (em Oeiras)

Estam abertas as candidaturas para a Pós-Graduação em Game Design na IADE – Faculdade de Design Tecnologia e Comunicação da Universidade Europeia (IADE) em Oeiras. Do plano de estudos faz parte:

Intro – Introduction to Game Design
Introduction to Game Development, por Nélio Códices (Co-Fundador e Diretor, Battlesheep e Docente no IADE)
History of Ideas, por Flávio Almeida (Docente no IADE)
Game Design, por Lexicon Wilson Almeida (Game Designer, Bica Studios e Nerd Monkeys)

M I – Game Design Foundations
Game Engines & Level Editors, por Filipe Pina (Game Designer e Motion Designer)
Game Design, por Wilson Almeida (Game Designer, Bica Studios e Nerd Monkeys)

M II – Visual Design in Games
Visual Culture, por Chris Solarski (Game Designer, Gestor do IGDA – Swiss Game Developers Association).
User Experience & Humane Design, por Lara Reis (Designer Gráfica e Docente no IADE)*Online module

M III – Applied Game Design
Level Design, por Edgar Jesus (Game Designer e Organizador de Game James)
Interactive Storytelling, por Filipe Pina (Game Designer e Motion Designer)
Game Design II, por Wilson Almeida (Game Designer, Bica Studios e Nerd Monkeys)

M IV – Game Design Project
Game Production, por Nélio Códices (Co-Fundador e Diretor, Battlesheep e Docente no IADE)
Final Project
Filipe Pina (Game Designer e Motion Designer)
Edirlei Lima (Docente no IADE)
Edgar Jesus (Game Designer e Organizador de Game James)

+infos(oficial): https://www.iade.europeia.pt/cursos/posgraduacoes/game-design

Tags : , ,

Proposta de trabalho (remoto)

A ONTOP (www.ontopstudios.com) está à procura de uma programador.

+infos(oficial): https://www.ontopstudios.com/

+infos(rede social, promotor): LINK

Tags : ,

Proposta de trabalho (remoto)

“Olá Malta! A ONTOP (www.ontopstudios.com) está à procura de artistas 3D.  Trabalho a tempo inteiro. Remoto com encontros mensais para socializar. Se quiserem saber mais ou tiverem recomendações, please talk”

+infos(oficial): https://www.ontopstudios.com/

Tags : ,

Proposta de trabalho (em Lisboa)

“Estamos à procura para contratar um Modelador Sénior 3D para ambientes aqui na Lockwood Publishing no estúdio de Lisboa. Trabalho a contracto a tempo inteiro. Remoto nos primeiros meses passando a local (Lisboa) com a melhoria da situação do Covid19.”

+infos(oferta): LINK

Tags : ,

Cursos e aprendizagens online (Unity)

Coleção interessantes sobre alguns dos assuntos de trabalhar com o Unity

+infos(): https://www.raywenderlich.com/unity

Tags :

Brackeys, the end.

O canal de youtube e comunidade do Brackeys vai terminar. Foi dos primeiros canais que segui já que tem vídeos muito interessantes para explicar o uso do Unity e assuntos correlacionados como é o caso da linguagem de programação c# ou de modelação de objectos.

Os vídeos e os outros canais de suporte vão ficar activos, apesar do projeto terminar.

+infos(listas no youtube): LINK

+infos(página oficial): https://brackeys.com/

Tags : , , ,

Generative Board Games

Existe um site online onde é possivel gerar jogos de tabuleiro de forma aleatória. Com recurso à inteligência artificial e numa questão de segundos é possível ter um layout de um jogo com as respectivas regras, bastando para isso atribuir um titulo ao jogo. O que existe é uma base de dados com inúmeras entradas que tenta combinar/construir algo interessante, mas no final cabe ao utilizador a vontade de concordar ou não com o que foi “criado”.

É um trabalho ainda numa fase de construção e de exploração, mas que pode vir a ser interessante, nem que seja para termos cenários diferentes de jogos que gostamos :)

+infos(oficial): https://www.generativeboard.games/

Tags : , ,

Um workshop/concurso interessante


Vai decorrer em Vila Real um concurso de design de jogo de cartas. Este concurso para além de ser efectivamente um concurso conta com a possibilidade de participar num workshop acerca do assunto. O workshop vai decorrer em Vila Real com a possibilidade de quem estiver longe de participar via Zoom :)

O evento é dinamizado pela empresa Art and Games. :)

+infos(o concurso): http://www.artandgames.pt/codec/

+infos(rede social): https://www.facebook.com/artandgames/

 

Tags : , , ,

Questões de C++ (parte3)


#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 1
//construir o construtor por cópia

class Funcionario{ /* ... */ };
class Reuniao
{
	//só faz uso das fichas funcionarios, convocados
	vector <Funcionario*> convocados;
	//é da posse exclusiva da Reuniao, ordemDeTrabalhos
	vector <string*> ordemDeTrabalhos;
public:
	//..
	~Reuniao()
	{
		for(string * s: ordemDeTrabalhos)
		{
			delete s;
		}
	}
	//do construtor por cópia
	Reuniao(const Reuniao & ob)
	{
		convocados = ob.convocados; //copiar vector Funcionario
		//porque é posse exclusiva, podes querer modificar
		for(string * o : ordemDeTrabalhos) //copiar as strings
		{
			ordemDeTrabalhos.push_back(new string(*o));
		}
	}
};

int main()
{
}

//regra dos três:
//destrutor
//construtor por cópia
//operador de cópia
//https://pt.wikipedia.org/wiki/Regra_dos_tr%C3%AAs_(C%2B%2B)#Regra_dos_Tr%C3%AAs
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 2
class Num
{
	int n;
	public:
		Num()
		{
			n = 0;
		}
	void setN(int nn)
		{
		n = nn;
		}
	int getN()const
		{
		return n;
		}
};

void f(const Num * p)
{
	p->setN(5); //<- erro
	//é const o Num
	//logo não são do mesmo tipo
	p = new Num();
}

void g(Num * const p)
{
	p->setN(5);
	p = new Num(); //<- erro
	//é const o p
	//logo não pode ser modificado
}

int main()
{
	Num ob;
	ob.setN(4);
	f(&ob);
	g(&ob);
}
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 3

class Erro {
	string msg;
public:
	Erro(const string & s = "") :msg(s)
	{
	}
	string what()
	{
		return msg;
	}
};

void calculaArea(int lado)
{
	try
	{
		if(lado < 0)
		{
			throw Erro("lado negativo");
		}else if(lado >10)
		{
			throw new string("lado superior ao limite");
		}
	}catch(Erro & e)
	{
		lado = 0;
	}catch(string & e)
	{
		lado = 10;
	}
	cout << "area = " << lado * lado << ";";
}
int main()
{
	try
	{
		calculaArea(-2);
		cout << "depois; ";
	}catch (Erro & e)
	{
		cout << "catch main; \n";
	}catch(string & e)
	{
		cout << "catch main; \n";
		
	}
	cout << "fim main;\n";
}

ouput:
area = 0
depois;
fim main
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 4

class Canideo
{
	int peso;
	string dieta;
public:
	Canideo(int a, string b = "Carne"): peso(a), dieta(b)
	{
	}
	Canideo() = default;
	virtual	~Canideo()
	{
	};
	virtual double dose() const
	{
		return peso * 0.1;
	};
	int getPeso() const
	{
		return peso;
	}
	string getDieta() const
	{
		return dieta;
	}
};

class Cao: public Canideo
{
	string nome;
public:
	Cao(int a, string b = "Racao", string c = "Bobi") : Canideo(a,b), nome(c)
	{
	}
	virtual double dose() const override
	{
		return getPeso() * 0.05;
	}
};
class Lobo: public Canideo
{
	string habitat;
public:
	Lobo(int a, string b = "galinha", string c = "floresta") : Canideo(a), habitat(c)
	{
	}
};
int main()
{
	Lobo a(120);
	Canideo* c = new Cao(20);

	cout << a.getDieta() << " " << c->getDieta() << " ";
	cout << a.dose() << c->dose() << endl;
}

output
carne racao 12 1

//A especificação = default após a declaração do construtor por omissão,
//indica ao compilador para disponibilizar o construtor por omissão, trivial
//O construtor por omissão, trivial faz as seguintes ações:
//É aplicada a inicialização dos membros variáveis, feita na declaração
//Relativamente aos restantes membros variáveis:
//Os membros variáveis de tipo primitivo não são inicializados
//Os membros que são objetos de classes são inicializados pelos seus
//construtores por omissão
//Se a classe for derivada de uma classe base, o subobjeto da classe base
//é inicializado pelo construtor por omissão desta classe base
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 5

//acrescentar um novo tipo de cao, o Galgo
//que tem um determinada velocidade, indicada na criação deste objecto
//a velocidade tem impacto na sua dose diaria
//qual a solução?
//a) criar uma classe derivada de Canideo com atributo velocidade. esta classe deve
//ter um construtor e tem que redefinir o método virtual dose()
//b) criar uma classe derivada de Cao com atributo velocidade. esta classe
//deve ter um construtor e tem que redefinir o método virtual dose();
//c) criar uma classe derivada de Cao com atributo velocidade. esta classe
//deve ter um construtor, mas pode utilizar o método virtual dose() da classe
//base
//d) acrescentar um atributo booleano tipo à classe Cão, indicando se os
//objectos são Galgos. adpatar o método dose() desta classe, para calcular
//a dose diária correta se os cães em questão forem galgos.

class Canideo
{
	int peso;
	string dieta;
public:
	Canideo(int a, string b = "Carne"): peso(a), dieta(b)
	{
	}
	Canideo() = default;
	virtual	~Canideo()
	{
	};
	virtual double dose() const
	{
		return peso * 0.1;
	};
	int getPeso() const
	{
		return peso;
	}
	string getDieta() const
	{
		return dieta;
	}
};

class Cao: public Canideo
{
	string nome;
public:
	Cao(int a, string b = "Racao", string c = "Bobi") : Canideo(a,b), nome(c)
	{
	}
	virtual double dose() const override
	{
		return getPeso() * 0.05;
	}
};

class Galgo : public Cao
{
	int velocidade;
public:
	Galgo(int a, int v, string b = "Racao") : Cao(a,b), velocidade(v)
	{
	}
	virtual double dose() const override
	{
		return getPeso() * 0.05 / velocidade;
	}
};

resposta:
b) criar uma classe derivada de Cao com atributo velocidade.esta classe
deve ter um construtor e tem que redefinir o método virtual dose();
//porque é um tipo Cao, e a velocidade afecta paenas o tipo Galgo
Tags : , , ,

Questões de C++ (parte2)

#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 1

class Jogador
{
public:
	void treinar() { cout << "\n treinar"; }
	virtual void jogar() { cout << "\n jogar"; }
};

class Defesa: public Jogador
{
public:
	void treinar(){ cout << "\n treinar defesa"; }
	void jogar() override { cout << "\n jogar defesa"; }
	//override: redefinição de uma função virtual da classe base
};

class Atacante : public Jogador
{
public:
	void treinar() { cout << "\n treinar ataque"; }
	void jogar() override { cout << "\n jogar ataque"; }
};

class PontaDeLanca : public Atacante
{
};
int main()
{
	vector<Jogador*> jogadores;
	jogadores.push_back(new Defesa);
	jogadores.push_back(new Atacante);
	jogadores.push_back(new PontaDeLanca);
	for(Jogador * j: jogadores)
	{
		j->treinar();
		j->jogar();
	}
}

output:
treinar
jogar defesa
treinar
jogar ataque
treinar
jogar ataque
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 2
class Ponto
{
	int x, y;
public:
	Ponto(int x0 = 0, int y0 = 0)
	{
		x = x0;
		y = y0;
	}
};
class Figura
{
	string nome;
public:
	Figura(const string & n)
	{
		nome = n;
	}
	void setNome(const string &n )
	{
		nome = n;
	}
};
class Circulo : public Figura
{
	Ponto centro;
	const int raio;
public:
	//qual sera o construtor..
	//resposta1:
	Circulo(int x0, int y0, int r) : centro(x0, y0), raio(r), Figura("circulo")
	{
	};
	//resposta2
	Circulo(int r) : raio(r), Figura("circulo")
	{
	};
};

int main()
{
}
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 3

class SerVivo
{
public:
	virtual void f() = 0;
	virtual void g() = 0;
};
class Animal : public SerVivo
{
public:
	virtual void h() = 0;
	void f() override { /* ... */}
};

class Ave : public Animal
{
public:
	//a classe Ave tem que ser concreta
	//...
	//sabe-se que:
	//Uma classe abstrata é uma classe para a qual um ou mais
	//métodos são declarados, mas não definidos
	//O polimorfismo permite que classes abstratas consigam
	//receber comportamentos através de classes concretas
	//As classes derivadas das classes abstratas são conhecidas
	//como classes concretas
	//f e g são funções virtuais puras logo têm de ser definidas
	//em Ave para que esta classe seja concreta
	virtual void g(){}
	virtual void h() {}
};
int main()
{
}
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 4
class Erro
{
	string msg;
public:
	Erro(const string& s): msg(s){}
	string what()
	{
		return "(1) erro " + msg;
	}
};

void funcao()
{
	try
	{
		cout << "(2) antes; ";
		throw Erro("(3) em funcao ...");
		cout << "(4) depois; ";
	}catch (Erro & e)
	{
		cout << e.what() << "(5) ;";
	}catch(string & e)
	{
		cout << "(6) catch string;";
	}
	cout << "(7) fim funcao; ";
}
int main()
{
	try
	{
		funcao();
	}
	catch (Erro & e)
	{
		cout << "(8) catch erro main;";
	}
	cout << "(9) fim main; \n";
}

output:
(2) antes;
(1) erro (3) em funcao ... (5);
(7) fim funcao;
(9) fim main;
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 5

//inicio extra enunciado
class FichaAnimal
{
	FichaAnimal(){}
};
//fim extra enunciado

class Gaiola
{


private:
	vector <FichaAnimal*> animais; //um vector
	string* ocorrencias;
	int nOcorrencias;
public:
	//...
	//inicio extra enunciado
	Gaiola(const vector<FichaAnimal*>& ficha_animals, string* ocorrencias, int ocorrencias1)
		: animais(ficha_animals),
		ocorrencias(ocorrencias),
		nOcorrencias(ocorrencias1)
	{
	}
	//fim extra enunciado
	//resposta:
	~Gaiola()
	{
		delete[] ocorrencias;
	}
};

int main()
{
}
Tags : , , , , , ,

Questões de C++ (parte 1)

#include <iostream>
#include <string>
using namespace std;

//----------------------------------pergunta 1 
class Ser
{
public:
	void respirar() { cout << "\n respirar?"; }
	virtual void alimentar() { cout << "\n alimentar?"; }
};

class SerVivo : public Ser {
public:
	void respirar() { cout << "\n ser vivo respira"; }
	virtual void alimentar() { cout << "\n ser vivo alimenta-se "; }
};

class Planta : public SerVivo {
public:
	void respirar() { cout << "\n pelas folhas"; }
	virtual void alimentar() { cout << "\n pelas raizes "; }
};

void alimentarPorObjecto(Ser obj) {
	obj.alimentar();
}

void alimentarPorReferencia(Ser & ob) {
	ob.alimentar();
}

int main() {
	Ser* s1 = new Planta;
	cout << "\n---1---";
	//como respirar não é virtual,
	//vai executar a função do ponteiro ou referência (Ser)
	s1->respirar();
	//como alimentar é virtual,
	//vai executar a funlãi da classe deste objeto (Planta)
	s1->alimentar();

	cout << "\n---2---";
	SerVivo* s2 = new Planta;
	//como respirar não é virtual,
	//vai executar a função do ponteiro ou referência (SerVivo)
	s2->respirar();
	//como alimentar é virtual,
	//vai executar a funlãi da classe deste objeto (Planta)
	s2->alimentar();

	cout << "\n---3---";
	Planta arvore;
	//executa as funções deste objecto (Planta)
	arvore.respirar();
	//executa as funções deste objecto (Planta)
	arvore.alimentar();

	cout << "\n---4---";
	//executa as funções da base (Ser)
	alimentarPorObjecto(arvore);
	//executa as funções deste objecto (Planta)
	alimentarPorReferencia(arvore);
}

#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 2
class Ser
{
	string nome;
	string * local;
public:
	Ser(string s):nome(s)
	{
	}
	string getNome()
	{
		return nome;
	}
	//const antes e depois do *
	//não é possivel qualquer alteração
	const string* getLocal()const
	{
		return local;
	}
};
int main()
{
	//const, o objeto é constante
	const Ser ob("abc");
	//função getNome() tinha que ser depois const
	cout << ob.getNome();
	//p1 não é const, devia ser const string
	string *  p1 = ob.getLocal();
	const string* p2 = ob.getLocal();
	//p3 não é const, devia ser const string
	string * const p3 = ob.getLocal();
}
#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 3
class A
{
	int numA;
	string nome;
public:
	A():numA(0), nome("default1")
	{
	}
	A(int v):numA(v), nome("default2")
	{
	}
	int getNumA() { return numA; }
	string getNome() { return nome; }
};

class B1: public A
{
	int numB;
public:
	B1(int v):A(v+1), numB(v)
	{
	}
	B1(const B1 & orig):numB(orig.numB)
	{
	}
	void imprime()
	{
		cout << getNumA() << " " << getNome() << numB << endl;
	}
};

class B2 : public A
{
	int numB;
public:
	B2(int v):A(v+1), numB(v)
	{
	}
	void imprime()
	{
		cout << getNumA() << " " << getNome() << numB << endl;
	}
};

void f()
{
	//executa o construtor da base (A) com parametros
	//e executa o seu construtor (B) que recebe um parametro
	B1 bx(3);
	//executa o construtor da base (A) sem parametros
	//e executa o seu construtor (B) que recebe objeto do tipo B
	B1 by(bx);

	cout << "\n--funcao f()" << endl;
	//saida-> 4 default2 3
	bx.imprime();
	//saida-> 0 default1 3
	by.imprime();
}

void g()
{
	//executa o construtor da base (A) com parametros
	//e executa o seu construtor (B) que recebe um parametro
	B2 bw(3);
	//nao tem nada de especial para executar
	//o bz faz uma "copia" do que tem o bw
	B2 bz(bw);
	cout << "\n--funcao g()" << endl;
	//saida-> 4 default2 3
	bw.imprime();
	//saida-> 4 default2 3
	bz.imprime();
}

int main()
{
	f();
	g();
}
#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 4


class Produto
{
	string nome;
	int quantidade;
public:
	Produto(string s, int q)
	{
		nome = s;
		quantidade = q;
	}
	// += operador membro: (a += b) += c
	Produto& operator += (const Produto a)
	{
	}
};
// + operador global: c = a + b
Produto operator+(Produto a, Produto b)
{
};

// << operador global: cout << a << b
ostream & operator << (ostream& str, const Produto& k)
{
};

// << operador global: (a << 4) << 5;
int operator<<(const Produto& a, const int& b)
{
};

Produto & operator++(const Produto & produto);

int main()
{
	Produto a("aaa", 10), b("bbb", 20), c("ccc", 30);
	c = a + b; //implementar Global: Produto operator+(Produto a, Produto b)
	cout << a << b;//implementar Global: ostream & operator<<(ostream& str, const Produto& k)
	(a += b) += c;//implementar membro: Produto& operator += (const Produto a)
	(a << 4) << 5;//implementar Global: int operator<<(const Produto& a, const int& b)
	++a;//implementar Global: Produto & operator++(const Produto & produto);
}

#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 5

class Ponto
{
	int x;
	int y;
public:
	Ponto(int x0, int y0)
	{
		x = x0;
		y = y0;
	}
};

class Figura
{
	string nome;
public:
	Figura(string s){
		nome = s;
	}
	string getNome()const
	{
		return nome;
	}
};

class Rectangulo: public Figura
{
	Ponto cantoSupEsq;
	Ponto cantoInfDir;
public:
	//implementar o que falta:
	Rectangulo(int a, int b, int c, int d): Figura("rectangulo"), cantoSupEsq(a, b), cantoInfDir(c, d)
	{
	}
};

int main()
{
	Rectangulo rect(1, 1, 4, 4);
	cout << rect.getNome(); //aparece rectangulo no ecrã
}
#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 6

class A
{
public:
	virtual void f() = 0;
	virtual void g() = 0;
};

class B: public A
{
public:
	virtual void h() = 0;
	virtual void g(){}
};

//definir uma class C, concreta, derivada de B
//func f e a func h são virtuais puras logo têm de ser definidas 
//em C para que esta classe seja concreta
class C : public B
{
	virtual void f();
	virtual void h();
	virtual void g() {}
};

int main()
{
}
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 7

class Animal
{
public:
	//completar aqui
	//não deve ser possivel criar objectos da classe Animal
	//função virtual pura
	virtual void Fala() = 0;
};

//a relação entre Jaula e Animal é agregação
//a relação entre Jaula e alimentos é composição
class Jaula
{
	vector <Animal * > animais;
	string ** alimentos; //array dinamico de ponteiros para string
	int nAlimentos; //numero de alimentos do array dinâmico
public:
	Jaula()
	{
		alimentos = new string * [2];
		nAlimentos = 2;
		alimentos[0] = new string("agua");
		alimentos[1] = new string("cereais");
	}
	~Jaula()
	{
		//completar aqui, os destrutores desta classe
		for (Animal* a : animais) {
			delete a;
		}
		delete alimentos;
	}
	//..
	//por ter uma virtual na base
	void Fala(){}
};

//a relação entre Zoo e Animal é composição
//a relação entre Zoo e Jaula é composição
class Zoo
{
	vector <Animal* > animais;
	vector<Jaula* > jaulas;
public:
	~Zoo()
	{
		//completar aqui, os destrutores desta classe
		for(Animal * a: animais) {
			delete a;
		}
		for (Jaula* j : jaulas) {
			delete j;
		}
	}
	//..
	//por ter uma virtual na base
	void Fala() {}
};
Tags : , , , , , , , ,