Guião laboratorial n.º 3 – exercício 3
altere a função da questão anterior de modo a garantir que as linhas do texto mostradas na consola surjam numeradas.
#include <stdio.h>
#include <stdlib.h>
void mostraC(char *t1){
FILE *f1;
char ch;
int i=1;
f1=fopen(t1, "r");
if(f1==NULL){
printf("\nerro ao abrir o ficheiro %s", t1);
return;
}
printf("\n%d. ",i);
while((ch=fgetc(f1))!=EOF){
printf("%c", ch);
if(ch=='\n'){
printf("%d. ",i+1);
i++;
}
}
printf("\n ..lido tudo com sucesso");
fclose(f1);
}
int main()
{
char s1[20];
printf("Qual o nome do 1 ficheiro?");
gets(s1);
mostraC(s1);
return 0;
}
Guião laboratorial n.º 3 – exercício 2
Desenvolva uma função que mostre o conteúdo de um ficheiro de texto na consola. O nome do ficheiro é passado como argumento.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void mostraC(char *t1){
FILE *f1;
char ch;
f1=fopen(t1, "r");
if(f1==NULL){
printf("\nerro ao abrir o ficheiro %s", t1);
return;
}
while((ch=fgetc(f1))!=EOF)
printf("%c", ch);
printf("\n ..lido tudo com sucesso");
fclose(f1);
}
int main()
{
char s1[20];
printf("Qual o nome do 1 ficheiro?");
gets(s1);
mostraC(s1);
return 0;
}
Guião laboratorial n.º 3 – exercício 1
1. Desenvolva um programa que duplique um ficheiro de texto. A informação de qual o nome do ficheiro original e do nome do novo ficheiro (cópia do original) deve ser feita através da linha de comando.
Exemplo (assumir que o programa se chama copia): ao ser chamado o programa copia com a linha de comando seguinte:
c: \> copia codigo.c novo.txt
é criado um novo ficheiro, novo.txt, que é uma réplica do ficheiro codigo.txt.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void copia(char *t1, char *t2){
FILE *f1, *f2;
char ch;
f1=fopen(t1, "r");
f2=fopen(t2, "w");
if(f1==NULL){
printf("\nerro ao abrir o ficheiro %s", t2);
return;
}
if(f2==NULL){
printf("\nerro ao abrir o ficheiro %s", t2);
return;
}
while((ch=fgetc(f1))!=EOF)
fputc(ch, f2);
printf("\n copia com sucesso");
fclose(f1);
fclose(f2);
}
int main()
{
char s1[20], s2[20];
printf("Qual o nome do 1 ficheiro?");
gets(s1);
printf("Qual o nome do 2 ficheiro?");
gets(s2);
copia(s1, s2);
return 0;
}
Guião laboratorial n.º 2 – exercício 4
O aeroporto de Coimbra pretende um programa para gerir a informação relativa às partidas de voos. Cada voo é identificado por: número do voo, nome da companhia, cidade destino e hora de partida (horas e minutos).
a) Crie um tipo estruturado chamado struct tempo que permita armazenar as componentes de uma determinada hora de um dia (horas e minutos).
b) Crie um tipo estruturado chamado struct voo que permita armazenar a informação relativa a um voo. O campo que armazena a hora de partida deve ser do tipo struct tempo.
c) Desenvolva uma função que escreva o conteúdo dos campos de uma variável estruturada do tipo struct voo. A função recebe como argumento a variável já preenchida.
d) Desenvolva uma função que permita introduzir informação relativa a um novo voo. É passado como argumento um ponteiro para a estrutura a inicializar.
e) Desenvolva uma função que altere a hora de partida de um voo. Recebe como argumento um ponteiro para uma estrutura já preenchida e solicita ao utilizador as novas componentes da hora para efetuar a alteração.
f) Desenvolva uma função que verifique se um determinado voo já partiu. Recebe como argumentos uma estrutura do tipo struct voo onde está armazenada a informação do voo e uma estrutura do tipo struct tempo onde está armazenada a hora atual. Devolve 1 se o voo já tiver partido, ou 0, se isso ainda não tiver acontecido.
g) Declare uma tabela que lhe permita armazenar informação relativa a 300 voos. A tabela deve ser uma variável local da função main().
h) Desenvolva uma função que permita adicionar novos voos à tabela. A função recebe como argumentos um ponteiro para o início da tabela e um ponteiro para o inteiro que indica quantos voos existem. É o utilizador que indica quantas novas entradas quer inserir e que especifica a informação relativa a cada um dos novos voos. A função deve atualizar a tabela e o inteiro referenciado pelo segundo argumento, indicando quantos voos passam a existir.
i) Desenvolva uma função que liste a informação completa de todos os voos armazenados na tabela. A função recebe como argumentos um ponteiro para o início da tabela e o número de voos que esta contém.
j) Desenvolva uma função que verifique quais os voos que partem nos próximos 30 minutos. Deve ser escrito o número, o destino e o tempo que falta para a partida de cada um desses voos. Um ponteiro para o início da tabela de voos, o número de elementos que esta contém e a hora atual são passados como argumentos.
k) Desenvolva uma função que retire da tabela todos os voos que já partiram. São passados como argumentos um ponteiro para o início da tabela, um ponteiro para um inteiro que indica quantos voos esta contém e a hora atual. A função deve atualizar a tabela e o contador de voos.
l) Crie um programa que construa um menu com o seguinte formato:
1. Introduzir novos voos
2. Listar todos os voos
3. Listar proximos voos
4. Atualizar tabela de voos
5. Terminar
O programa deve fazer a gestão das seleções que o utilizador for efetuando. Termina a execução quando for selecionada a opção 5.
Sugestão: Utilize a seguinte função para obter a hora atual do sistema. O resultado é devolvido numa estrutura do tipo struct tempo.
#include <stdio.h>
#include <time.h>
/* Estrutura auxiliar para guardar as componentes da hora */
struct tempo{
int h, m;
};
struct tempo hora_atual()
{
time_t a;
struct tm* b;
struct tempo atual;
time(&a);
b = localtime(&a);
atual.h = b->tm_hour;
atual.m = b->tm_min;
return atual;
}
/* Exemplo de utilização da função hora_atual() */
int main()
{
struct tempo t = hora_atual();
printf(" São %2.2d:%2.2d\n", t.h, t.m);
return 0;
}
Proposta de trabalho: Altere o programa de gestão do aeroporto de modo a que os voos fiquem ordenados na tabela por hora de partida. Efetue as alterações necessárias nas funções que implementou.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define ST_TAM 50
#define MAX 300
// Estrutura auxiliar para armazenar as componentes de uma hora: horas + minutos (alinea a))
struct tempo{
int h, m;
};
// Estrutura para armazenar informacao sobre um voo (alinea b))
struct voo{
int num; // Numero do voo
char companhia[ST_TAM]; // Companhia
char destino[ST_TAM]; // cidade de destino
struct tempo hora_p; // Hora de partida
};
// Funcao que obtem a hora do sistema e a devolve numa estrutura do tipo struct tempo
struct tempo hora_atual()
{
time_t a;
struct tm* b;
struct tempo atual;
time(&a);
b = localtime(&a);
atual.h = b->tm_hour;
atual.m = b->tm_min;
return atual;
};
// Funcao auxiliar para mostrar o menu e obter a opcao desejada pelo utilizador
// Devolve a opcao selecionada como resultado
int menu()
{
int op;
struct tempo t = hora_atual();
printf("\n%2.2d:%2.2d\n", t.h, t.m);
printf("\n1 - Introduzir novos voos");
printf("\n2 - Listar todos os voos");
printf("\n3 - Listar proximos voos");
printf("\n4 - Actualizar tabela de voos");
printf("\n5 - Veriricar se um voo ja partiu");
printf("\n6 - Terminar");
do{
printf("\nOpcao: ");
scanf("%d", &op);
}while(op<1 || op>6);
return op;
}
//------------------- funcoes a implementar
void alineac(struct voo *p, int t){
int i;
printf("\nTotal de registos: %d", t);
for(i=0; i<t;i++, p++){
//printf("\nvoo: %d\tcompanhia: %s\tindo para: %s\thorario: %d:%d", p->, p[i].companhia, p[i].destino, p[i].hora_p.h, p[i].hora_p.m);
printf("\nvoo: %d\tcompanhia: %s\tindo para: %s\thorario: %d:%d", p->num, p->companhia, p->destino, p->hora_p.h, p->hora_p.m);
// printf("\nvoo: %d", p->num);
}
}
void alinead(struct voo *p, int *t, int m){
char r;
do{
printf("\nQuer inserir?");
scanf(" %c", &r);
if(r=='s'){
printf("\n---------------------------");
printf("\nQual o numero do voo?");
scanf(" %d", &(p->num));
printf("Qual o nome da companhia?");
scanf(" %[^\n]", &(p->companhia));
printf("Qual o nome do destino?");
scanf(" %[^\n]", &(p->destino));
printf("Qual a hora e minutos de partida?");
scanf("%d %d", &(p->hora_p.h), &(p->hora_p.m));
(*t)++;
p=p+(*t);
}
}while(r=='s' && *t < m);
}
void alineae(struct voo *p, int t){
int r, i;
printf("\nQual o voo que quer alterar? 0 se nenhum");
scanf(" %d", &r);
for(i=0; i< t; i++, p++){
if(r==p->num){
printf("\n o horario atual e: %d:%d", p->hora_p.h, p->hora_p.m);
printf("Qual a NOVA hora e minutos de partida?");
scanf("%d %d", &(p->hora_p.h), &(p->hora_p.m));
}
}
}
void alienaf(struct voo *p, int t){
//nao vai devolver, escreve no final o valor 1 ou 0 dependendo
int i, sita;
struct tempo usa = hora_atual();
for(i=0; i<t;i++, p++){
if(p->hora_p.h < usa.h && p->hora_p.m < usa.m){
sita=1;
}else{
sita=0;
}
printf("\nsituacao: %d\tvoo: %d\tcompanhia: %s\tindo para: %s\thorario: %d:%d", sita, p->num, p->companhia, p->destino, p->hora_p.h, p->hora_p.m);
}
}
void alienaj(struct voo *p, int t){
struct tempo usa = hora_atual();
int i, auxHaM=0, auxHrM=0,y;
auxHaM=(usa.h*60)+usa.m;
for(i=0; i<t;i++, p++){
printf("\n%d:%d-%d:%d", usa.h, usa.m, p->hora_p.h, p->hora_p.m);
auxHrM=(p->hora_p.h*60)+p->hora_p.m;
// y= atoi(auxHrM);
if(auxHrM < auxHaM){
printf("\n%d\tcompanhia: %s\tindo para: %s\thorario: %d:%d", p->num, p->companhia, p->destino, p->hora_p.h, p->hora_p.m);
}else{
printf("\nno can do");
}
printf("\n%d-%d", auxHaM, auxHrM);
}
}
int main(int argc, char *argv[])
{
int i;
// Declaracao das variaveis locais: (alinea g)
struct voo aero[MAX];
int total=0;
//alinea c
struct voo testec ={11,"TAP", "London", {12,30}}, tested;
/*
struct voo testec ={
{11,"TAP", "London", {12, 00}},
{22,"RYN", "Faro", {13, 30}};
{33,"TAP", "Paris", {18, 00}};
{44,"RYN", "NY",{22, 30}}
};
*/
// Ciclo principal do programa
do{
i=menu();
switch(i){
case 1:
//aliena d
alinead(&aero, &total, MAX);
break;
case 2:
//aliena c
alineac(aero, total);
break;
case 3:
//alinea j)
alienaj(aero, total);
break;
case 4:
//alterar a hora do voo alinea e)
alineac(aero, total); //listar primeiro
alineae(&aero, total);
break;
case 5:
//verificar se um voo ja partiu f)
alienaf(aero, total);
break;
}
}while(i!=6);
return 0;
}
falta verificar as horas e a ultima aliena… :P
ajuda(atoi): LINK
ajuda(estruturas e arrays): LINK
Salary and Satisfaction Survey across the Gaming Industry
uma estudo acerca da satisfação sobre a remuneração na industria dos videojogos..
+infos: LINK
mais duas ferrametas open source
Mais duas ferramentas open source a explorar para o desenvolvimento de jogos ou instalações interativas ? :P
libgdx – http://libgdx.badlogicgames.com/
cocos2d-x – http://www.cocos2d-x.org/
Guião laboratorial n.º 2 – exercício 3
Pretende-se criar uma agenda para armazenar números de telefone (nome, rede e número).
a) Crie um tipo estruturado que lhe permita armazenar essa informação.
b) Declare uma tabela que lhe permita armazenar 100 números de telefones. A tabela deve ser uma variável local da função main().
c) Desenvolva uma função que inicialize uma estrutura do tipo telefone. É passado como argumento um ponteiro para a estrutura a inicializar. Os dados são fornecidos pelo utilizador.
d) Desenvolva uma função que liste todas as pessoas cujo telefone pertença a uma determinada rede. A função recebe como argumentos um ponteiro para o início da tabela, o número de elementos que esta contém e a indicação de qual a rede em causa.
e) Desenvolva uma função que descubra todas as pessoas que vivem na mesma casa. Considere que duas pessoas vivem na mesma casa se tiverem o mesmo número de telefone;
f) Desenvolva uma função para retirar da tabela a informação relativa a uma pessoa cujo nome é passado como parâmetro. Pode assumir que os nomes são únicos.
g) Criar um programa que inicialize tabela com informação sobre determinado número de pessoas (o número de pessoas é introduzido através da linha de comando). A seguir deve listar todas as pessoas que pertencem a uma determinada rede (cuja identificação também é passado como argumento da linha de comando). Finalmente, o programa deve pedir ao utilizador que introduza o nome de uma pessoa para ser retirada da tabela.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAM 100
struct agenda{
char nome[20];
char rede[20];
int numero;
};
void preenhcer(struct agenda *a, int *t, int tam){
char r;
do{
printf("\nQuer inserir?");
scanf(" %c", &r);
if(r=='s'){
printf("\n---------------------------");
printf("\nQual o nome?");
scanf(" %[^\n]", &(a->nome));
printf("\nQual a rede?");
scanf(" %[^\n]", &(a->rede));
printf("\nQual o numer?");
scanf(" %d", &(a->numero));
(*t)++;
a=a+(*t);
}
}while(r=='s' && *t < tam);
}
void listar(struct agenda *l, int *t){
int i, a = *t;
for(i=0;i<a;i++, l++){
printf("\n%s", l->nome);
printf("\n%s", l->rede);
printf("\n%d", l->numero);
}
}
void listar_filtro(struct agenda *l, int t, char *f){
struct agenda *k;
int i;
printf("\n--------------------------- listar com filtro1 %s", f);
for(i=0, k=l; i<t; i++, k++){
if(strcmp(f, k->rede)==0){
printf("\n%s", k->nome);
printf("\n%s", k->rede);
printf("\n%d", k->numero);
}
}
}
void listar_filtro2(struct agenda *r, int t, int f){
int i;
printf("\n--------------------------- listar com filtro2 %d", f);
for(i=0;i<t; i++, r++){
if(r->numero == f){
printf("\n %d: %s", i, r->nome);
}
}
r=0;
}
int retirar(struct agenda *l, int t, char *f){
struct agenda *k;
int i;
printf("\n--------------------------- retriar da lista: %s", f);
for(i=0, k=l; i<t; i++, k++, l++){
if(strcmp(f, k->nome)==0){
k[i]=k[i+1];
t=t-1;
}
}
return t;
}
void listaR(struct agenda *l, int t){
int i;
for(i=0;i<t;i++, l++){
printf("\n%s", l->nome);
printf("\n%s", l->rede);
printf("\n%d", l->numero);
}
}
int main()
{
//alinea a
struct agenda guarda[TAM];
int t=0;
preenhcer(guarda, &t, TAM);
//listar(guarda, t);
//alinea d - listar filtro
char filtro[20]="meo";
printf("total: %d", t);
//listar_filtro(guarda, t, filtro);
//alinea e - listar filtro mesma casa
int filtro2=91;
//listar_filtro2(guarda, t, filtro2);
//alinea f
char nome_retirar[20]="Pedro";
int auxR;
auxR=retirar(guarda, t, nome_retirar);
t=auxR;
listaR(guarda, t);
return 0;
}
entendo que a alinea g) é igual a todas as outras por isso não a fiz!
Guião laboratorial n.º 2 – exercício 2
polícia pretende armazenar informação sobre um conjunto de criminosos. Para cada um dos criminosos, a informação a armazenar é a seguinte: nome, altura (em cm) e peso (em Kg).
a) Crie um tipo estruturado que permita guardar a informação relativa a um criminoso;
b) Declare uma tabela que permita armazenar um máximo de 100 criminosos. A tabela deve ser uma variável local da função main().
Após ter declarado a tabela, inicialize-a com os criminosos: {“Joao Ratao”, 175 cm, 120 Kg};
{“Gato das Botas”, 199 cm, 67 Kg}; {“Mancha Negra”, 150 cm, 80 Kg}; {“Etelvina Seabra”,
156 cm, 45 Kg}.
c) Desenvolva uma função que escreva no monitor a informação relativa a um criminoso. A função recebe, como argumentos, um ponteiro para o início da tabela, o número de elementos que esta contém e a posição em que se encontra a estrutura relativa ao criminoso pretendido;
d) Desenvolva uma função que procure suspeitos de um determinado crime. A função recebe,como argumentos, um ponteiro para o início da tabela, o número de elementos que esta contém, o peso aproximado e a altura aproximada do suspeito. Deve percorrer a tabela e escrever no monitor a informação relativa a criminosos cuja diferença de peso e de altura não seja superior a 10% dos valores indicados como argumento.
e) Desenvolva uma função que permita retirar da tabela a informação relativa a uma pessoa. A função recebe, como argumentos, um ponteiro para o início da tabela, o número de elementos que esta contém e o nome da pessoa a retirar. Se existir alguém com esse nome na tabela a sua estrutura deve ser eliminada. Devolve como resultado o número de elementos que ficaram na tabela após a eliminação.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//alinea b
#define TAM 100
//alinea a
struct criminoso {
char nome[20];
int alturaCM;
int pesoKg;
};
void mostra_criminoso(struct criminoso *c,int t, int v){
int i;
for(i=0; i< t; i++, c++){
if(i==v){
printf("nome: %s", c->nome);
printf("\naltura: %dcm",c->alturaCM);
printf("\npeso: %dkg",c->pesoKg);
}
}
}
//d
void procura_criminoso(struct criminoso *p, int t, int a_procura, int p_procura){
int i;
float cimaK, baixoK, cimaA, baixoA;
baixoK=p_procura/1.1;
cimaK=p_procura*1.1;
baixoA=a_procura/1.1;
cimaA=a_procura*1.1;
printf("\nreferencias: %.2f--%.2f kg %.2f--%.2f cms", cimaK, baixoK, cimaA, baixoA);
for(i=0; i< t; i++, p++){
if(p->pesoKg >= baixoK && p->pesoKg <= cimaK && p->alturaCM >= baixoA && p->alturaCM <= cimaA){
printf("\nnome: %s", p->nome);
printf("\naltura: %dcm",p->alturaCM);
printf("\npeso: %dkg",p->pesoKg);
}
}
}
//alinea e
//notworking
int elemina_criminoso(struct criminoso *e, int t, char *nome){
struct criminoso *f;
int novot, i;
char aux[20];
for(i=0, f=e; i<t; i++, e++,f++){
if(strcmp(nome, e->nome)==0){
printf("\nexiste");
e[i]=e[i+1];
t=t-1;
}
}
novot= t;
return novot;
}
void mostra_T(struct criminoso *c,int t){
int i;
printf("\n---------------------------------------------");
for(i=0; i< t; i++, c++){
printf("\nnome: %s", c->nome);
printf("\naltura: %dcm",c->alturaCM);
printf("\npeso: %dkg",c->pesoKg);
}
}
int main()
{
//alinea b
struct criminoso tabela_crime[TAM] = {
{"Joao Ratao", 175, 120},
{"Gato das Botas", 199, 67},
{"Mancha Negra", 150, 80},
{"Etelvina Seabra", 156, 45}
};
int t=4;
int ver_criminoso=2;
//mostra_criminoso(tabela_crime, t, ver_criminoso);
//alinea d
int altura_procurar=160;
int peso_procurar=45;
//procura_criminoso(tabela_crime, t, altura_procurar, peso_procurar);
//aliena e
char nome_procurar[20]="Joao Ratao";
printf("\ntotal de elementos iniciais: %d", t);
mostra_T(tabela_crime, t);
t=elemina_criminoso(tabela_crime, t, nome_procurar);
printf("\ntotal de elementos atuais: %d", t);
mostra_T(tabela_crime, t);
return 0;
}
esta incompleto o eliminar não percebi a atualização!!!
+ajudas: LINK
+ajudas: LINK
+ajudas: LINK
Guião laboratorial n.º 2 – exercício 1
1. Considere que necessita de armazenar informação sobre figuras geométricas num espaço com duas dimensões.
a) Crie tipos estruturados que lhe permitam representar um ponto e um retângulo.
b) Desenvolva uma função que inicialize uma estrutura do tipo retângulo. Toda a informação necessária deve ser fornecida pelo utilizador. A função devolve a estrutura inicializada.
c) Desenvolva uma função que devolva a área de uma estrutura do tipo retângulo passada como argumento;
d) Desenvolva uma função que verifique se uma estrutura do tipo retângulo passada como
argumento é um quadrado. Se for, a função deve devolver 1. Caso contrário, devolve 0.
e) Desenvolva uma função que receba, como argumentos, uma estrutura do tipo retângulo e um ponto e devolva 1 se o ponto estiver dentro do retângulo.
f) Desenvolva uma função que desloque um retângulo no plano. A função recebe três argumentos: um ponteiro para o retângulo o deslocar, o deslocamento ao longo do eixo xx e o deslocamento ao longo do eixo yy.
g) Declare uma tabela que permita armazenar 4 retângulos. A tabela deve ser uma variável local da função main(). Utilize a função desenvolvida na alínea b) para preencher todos os elementos da tabela.
h) Desenvolva uma função que verifique se numa tabela onde estejam armazenados vários retângulos existem dois que tenham a mesma área. A função recebe como argumentos o endereço do primeiro elemento da tabela e o número de elementos que esta contém. Como resultado, deve devolver o valor 1 se existirem dois retângulos com a mesma área (devolve 0 se todos os retângulos tiverem áreas diferentes).
#include <stdio.h>
#include <stdlib.h>
#define TAM 4
struct ponto{
int oX;
int oY;
};
typedef struct retangulo{
struct ponto n;
int largura;
int altura;
} r1;
struct retangulo r;
struct ponto p;
void iniciaR(){
scanf(" %d", &r.n.oX);
scanf(" %d", &r.n.oY);
scanf(" %d", &r.largura);
scanf(" %d", &r.altura);
};
void iniciaP(){
scanf(" %d", &p.oX);
scanf(" %d", &p.oY);
};
void verdados(){
printf("\nOrigemX: %d, OrigemY: %d, Largura: %d, Altura: %d\n", r.n.oX, r.n.oY, r.largura, r.altura);
}
void verdados2(){
printf("\nPonto OrigemX: %d, Ponto OrigemY: %d\n", p.oX, p.oY);
}
int verarea(struct retangulo k){
int area;
area=k.altura*k.largura;
return area;
}
int verificaQ(struct retangulo k){
if(k.altura==k.largura){
return 1;
}
else{
return 0;
}
}
int verificaDentro(struct retangulo k, struct ponto pn){
if(pn.oX<(k.n.oX+k.largura) && pn.oY<(k.n.oY+k.altura) && pn.oX>=k.n.oX && pn.oY>=k.n.oY){
return 1;
}else{
return 0;
}
}
void deslocar(r1 *p, int ax, int ay){
printf("\no quadrado esta na origem em %d %d", p->n.oX, p->n.oY);
p->n.oX = p->n.oX+ax;
p->n.oY = p->n.oY+ay;
printf("\no quadrado foi deslocado para %d %d", p->n.oX, p->n.oY);
}
//g
void iniciaR2(struct rg *p, int d){
int i;
for(i=0;i<d;i++){
scanf(" %d", &r.n.oX);
scanf(" %d", &r.n.oY);
scanf(" %d", &r.largura);
scanf(" %d", &r.altura);
}
};
void verdados3(){
printf("\nOrigemX: %d, OrigemY: %d, Largura: %d, Altura: %d\n", r.n.oX, r.n.oY, r.largura, r.altura);
}
int main()
{
iniciaR();
verdados();
printf("A area tem o valor de: %d", verarea(r));
if(verificaQ(r)==1){
printf("\ne quadrado\n");
}else{
printf("\nnao e quadrado\n");
}
iniciaP();
if(verificaDentro(r, p)==1){
printf("\nesta dentro\n");
}else{
printf("\nnao esta dentro\n");
}
//f)
int deslocaX=2;
int deslocaY=2;
deslocar(&r, deslocaX, deslocaY);
//g)
struct retangulo rG[TAM];
iniciaR2(rG, TAM);
//verdados3(r1 tabela, TAM);
return 0;
}
//incompleto
Enabling students in a digital age: Charlie Reisinger at TEDxLancaster
Mt nice..
+infos: https://github.com/pennmanor
Send a string from arduino to processing
i would like to send a string with 2 letters and 1 to 3 random numbers from arduino to processing. The work is to send random values from a led RGB conected to an arduino, so in that in a stage in processing i can have a similar image with the same color from the led RGB
//in arduino
int colorRED, colorGREEN, colorBLUE;
int ledRedPin = 9;
int ledGreenPin = 10;
int ledBluePin = 11;
void setup()
{
Serial.begin(9600);
pinMode(ledRedPin, OUTPUT);
pinMode(ledGreenPin, OUTPUT);
pinMode(ledBluePin, OUTPUT);
}
void loop()
{
Serial.flush();
colorRED = random(0, 255);
colorGREEN = random(0, 255);
colorBLUE = random(0, 255);
analogWrite(ledRedPin, colorRED);
analogWrite(ledGreenPin, colorGREEN);
analogWrite(ledBluePin, colorBLUE);
delay(200);
Serial.print("rd");
Serial.print(colorRED);
Serial.print("\n");
delay(200);
Serial.print("gr");
Serial.print(colorGREEN);
Serial.print("\n");
delay(200);
Serial.print("bl");
Serial.print(colorBLUE);
Serial.print("\n");
delay(200);
}
//in processing
import processing.serial.*;
Serial porta;
String sinal_letra;
String sinal_tipo;
int valor_cor, valor_cor1, valor_cor2, valor_cor3;
int totalc;
void setup() {
size(400, 400);
porta = new Serial(this, "COM50", 9600);
porta.clear();
}
void draw() {
desenha_led();
}
void desenha_led() {
//a desenhar um led
background(valor_cor1, valor_cor2, valor_cor3);
}
void serialEvent(Serial porta) {
sinal_letra = porta.readStringUntil('\n');
if (sinal_letra != null) {
sinal_letra = trim(sinal_letra);
totalc = sinal_letra.length();
sinal_tipo = sinal_letra.substring(0, 2);
valor_cor = parseInt(sinal_letra.substring(2, totalc));
println(sinal_tipo+"-"+valor_cor);
if (sinal_tipo.equals("rd")) {
porta.clear();
valor_cor1=valor_cor;
}
if (sinal_tipo.equals("gr")) {
porta.clear();
valor_cor2=valor_cor;
}
if (sinal_tipo.equals("bl")) {
porta.clear();
valor_cor3=valor_cor;
}
}
}
Aprender umas coisas de C (iniciantes e nivel médio)
Aulas em video sobre programação em C
Conferência sobre a temática dos videojogos
Aqui está uma excelente conversa de “amigos” sobre a temática de videojogos. É a conferência ” – Red vs Blue” com os seguintes palestrantes:
Pedro Moreira Dias (moderador) – Salão de Jogos/Vodafone FM
Ricardo Flores Santos – Biodroid
Nuno Barreto – Titan Forged Games
Nuno Folhadela – Bica Studios
Filipe Pina – Nerd Monkeys
Sérgio Varanda – Miniclip
+infos(conferencia): https://app.sinfo.org/
+infos(Biodroid): http://www.biodroid-entertainment.com/
+infos(Titan Forged Games): http://www.titanforgedgames.com/
+infos(Bica Studios): http://www.bicastudios.com/home
+infos(Nerd Monkeys): http://www.nerdmonkeys.pt/
+infos(Miniclip): LINK
Scroll Back: The Theory and Practice of Cameras in Side-Scrollers, por Itay Keren
“Working on my game Mushroom 11, I was faced with many different design and technology challenges. I wasn’t expecting to find references to issues like dynamically changing shapes or vertex animation, but I was quite surprised that camera work, a subject with more than 30 years of history in games, was hardly discussed.
I decided to start a journey through the history of 2D gaming, documenting their challenges, approaches and how the evolution of their solutions. Also, since there’s a lack of proper terminology for the many different solutions, I started gathering and categorizing them into groups, providing my own glossary, if only for my personal reference.”
+infos(original): LINK
Eles fazem videojogos e são muito bons nisso por João Bonifácio
“A história de como alguns portugueses se fartaram de ver os meninos estrangeiros a brincar e resolveram montar uma indústria de videojogos em Portugal (e não estão nisto para perder)
Corrria o ano de 2001 e da agenda de Filipe Pina constava uma reunião com o director do Instituto Português da Juventude (IPJ), cujo único ponto de ordem era avaliar a possibilidade de aquela entidade investir na empresa de videojogos que Pina criara. Lá fora, é prática comum um investidor, público ou privado, colocar dinheiro a fundo perdido nas pequenas empresas que estão a começar neste negócio. Em Portugal, nunca tinha acontecido. Pina demorara meses a convencer o IPJ a recebê-lo. “Finalmente surgiu uma data”, lembra: 11 de Setembro de 2001. “Aconteceu o que aconteceu e não houve reunião.”
Este acaso simboliza o que foi, durante anos, a quase inexistente indústria de videojogos em Portugal: aos 21 anos, Pina deixara um emprego bem pago na televisão para montar uma empresa de videojogos, após associar-se a estudantes universitários que conhecera nos chats do IRC (um dos primeiros protocolos que permitiam que os cibernautas de todo o mundo conversassem entre si em tempo real). Para pôr o plano em marcha, era preciso um investidor externo, de modo que, com o apoio do IPJ, Pina conseguiria finalmente concretizar o seu sonho de infância: criar, no seu país natal, um jogo decente. E a tragédia que mudou o mundo “tinha logo de acontecer nesse dia”.
Não houve nova reunião no IPJ e a carreira de Pina nos videojogos podia ter acabado ali. Não acabou, mas foi no mínimo rocambolesca: os seus sócios encontraram, no Porto, investidores interessados, mas essa empresa acabou por falir; depois Pina montou outra, a Seed Studios, que, com a ajuda de um subsídio da União Europeia, criou Under Siege, um jogo cujo orçamento rondou os 1,4 milhões de euros, o maior de sempre para um jogo português.
Under Siege, foi lançado em 2011 para a PlayStation 3. Fazer um jogo para uma consola tão popular é o sonho de todo o criador de jogos, e o Under Siege ainda hoje é um caso de culto. Mas podia ter sido muito mais, podia ter sido um êxito estrondoso. Os azares, acasos e imponderáveis que o impediram dizem bem da dificuldade que havia em fazer jogos a partir de Portugal. Estava previsto que Under Siege fosse lançado em finais de Abril de 2011 — mas, na semana do lançamento, a PlayStation Network sofreu o único ataque de hackers da sua história e os clientes ficaram sem aceder aos jogos durante um mês. Quando os servidores foram novamente ligados, a Sony (dona da PlayStation) tinha ficado sem os registos dos seus 70 milhões de utilizadores. Com o tempo, a Sony recuperou a sua confiança, mas para a Seed Studios o mal já estava feito. As críticas foram óptimas mas comercialmente o jogo foi morto à nascença: como saiu durante o período em que os servidores estavam em baixo, não teve a alavanca mediática para poder ter sucesso.
Para agravar, o Estado não pagou a última tranche do subsídio, no valor de 120 mil euros e, sem esse dinheiro, a Seed Studios faliu nesse mesmo ano de 2011. Pina não desistiu: aproveitou o “boom do mobile” e reergueu-se: hoje está à frente da Nerd Monkeys, uma empresa que aposta, sobretudo, em jogos para smartphones e está a crescer dia após dia, encomenda após encomenda.
A palavra-chave, aqui, é esta: “mobile”. Foi o advento dos smarthpones que permitiu que os portugueses, até aí meros consumidores de jogos, se tornassem criadores. E neste momento há uma indústria de videojogos, feito por empresas portuguesas, com dinheiro português e trabalhadores portugueses, a explodir. Uma indústria, com gente experiente e com procura externa — e não apenas meia dúzia de entusiastas, como acontecia há uma década.
De 2011 para cá, o salto foi brutal — de quatro empresas passou-se para mais de quatro dezenas. “Na última contagem que efectuei, encontrei 43 empresas, que empregam pelo menos 250 pessoas”, explica Ivan Barroso, o “historiador oficial” do movimento.
Bacharel em Artes Plásticas e licenciado em Multimédia, Barroso, de 35 anos, é professor na ETIC, onde em 2011 começou a leccionar um curso de videojogos. Como os restantes developers (pessoas que desenvolvem videojogos) portugueses da sua geração, o seu trajecto é incomum: trabalhou em gabinetes de arquitectura, em teatro, galerias de arte, fez cinema, animação para a RTP África e, entre 2008 e 2010, esteve na Sérvia como director de arte de uma editora de livros. Trabalha em jogos há uma década, sempre como freelancer: “No total, devo ter feito cinco jogos para PC ou consolas e uns 40 para mobile”, diz. Mas não é o seu percurso ou a quantidade de jogos que o qualificam como historiador, antes os seus livros — o primeiro chama-se mesmo História dos Videojogos.
Segundo Barroso, os valores movimentados pela indústria portuguesa já ultrapassam a casa do milhão de euros por ano, isto fazendo as contas por baixo, devido ao secretismo do negócio: como em outras áreas das tecnologias de informação, as empresas (tanto as portuguesas como as outras) assinam muitas vezes NDA (Non-Disclosure Agreement), um acordo que obriga as partes que o assinam a não revelar publicamente nenhum dado acerca do negócio que estão a levar a cabo. Imaginemos que um investidor estrangeiro coloca dinheiro numa empresa portuguesa mas a obriga a assinar um NDA, ou que uma empresa estrangeira contrata uma empresa portuguesa para fazer os gráficos de um jogo — é muito possível que a obrigue a assinar um NDA. Isto torna mais complicado perceber exactamente com que quantias as empresas portuguesas de videojogos estão a trabalhar neste momento.
Nestes números não entra a Miniclip, uma empresa de capital estrangeiro mas sediada em Portugal, que é “a que emprega mais gente, cerca de 80 pessoas. Está sempre no top 50 internacional dos jogos mobile”, acrescenta o historiador. A Miniclip, segundo alguns dos seus ex-empregados, faz facilmente três ou quatro milhões de euros de facturação por mês. Elementos relevantes da indústria nacional de videojogos afiançam que os montantes com que as empresas portuguesas trabalham são maiores que os que Barroso avança.
O que está a acontecer não é um momento de sorte na vida de fãs que querem fazer joguinhos: trata-se do culminar de um longo, e por vezes penoso, processo protagonizado por fanáticos que querem criar jogões — e que, após terem batido com a cabeça na parede muitas vezes, querem fazer dinheiro.
Casos como os de Pina ou de Nuno Folhadela ou de Tiago Loureiro (que faz parte do Conselho Nórdico para os Videojogos, e por isso lhe chamam “Viking”), são ainda mais extraordinários se pensarmos que já receberam várias propostas milionárias para irem trabalhar para o estrangeiro, mas recusam-se a sair: o que os move é serem senhores do seu destino, fazerem os jogos que querem, no seu próprio país — e serem donos das suas empresas.
Os membros desta geração, nascida na década de 1970 e início de 80, têm em comum a ausência de percurso académico ou de carreira tradicional.
Pina, que Ivan Barroso descreve como “a cola” que une os profissionais dos videojogos em Portugal, não foi para a faculdade e começou por trabalhar em grafismo numa produtora de TV, antes de se lançar nos jogos; Loureiro, um programador de excelência reconhecido internacionalmente, já trabalhava aos 12 anos e frequentou pelo menos quatro licenciaturas sem ter terminado nenhuma; Nuno Folhadela acabou um curso de Cinema de Animação com 19 anos, trabalhou no McDonalds e vendeu jogos ao balcão de uma loja chamada Replay Games, enquanto ia aprendendo programação por conta própria, até acabar por fazer o site online da loja. Finalmente, em 2006, conseguiu trabalho numa empresa de videojogos. Hoje é o dono da Bica Studios — chamam-lhe “O empresário”, por considerarem que é o mais atento às necessidades do mercado.
Se o sonho americano é arriscar e enriquecer, o sonho português seria, para a geração de 1970, tirar um curso, arranjar emprego certo, comprar casa e carro. Não para Pina, não para Loureiro, não para Folhadela: o sonho deles era fazer jogos, aqui. E convencer os outros de que isto dá para brincar mas não é uma brincadeira.
Em alguma coisa hão-de ter acertado: tanto eles como as gerações mais novas fazem, a partir de Portugal, os seus jogos, para mobile e para consolas — a XBOX, a PlayStation, etc.
Era nas consolas que estava o dinheiro a sério — era preciso comprar a consola e o jogo, sendo este mais caro que o actual jogo de mobile. (O mobile veio alterar isto E já há jogos em consolas gratuitos.) É em consolas que a Tio Atum, uma empresa cujos donos nasceram na década de 1980, está a apostar agora. “Até há ano e meio, só fazíamos mobile”, conta Miguel Pedro Rafael, um dos três donos da empresa.
Quando alguém entra no “escritório” da Tio Atum, Miguel faz uma rábula: aponta para um quarto, onde um vulto se esconde atrás de um computador, e diz: “Este é o escritório do nosso sound designer.” Claro que não é um escritório — é o próprio quarto de Miguel Cintra, o sound designer. “Ele teve um desgosto amoroso e veio viver cá para casa”, explica Miguel. A rábula prossegue: “Este é o escritório do Afonso, o nosso programador” e, claro, não é escritório algum, é o quarto de Afonso. O “escritório” da empresa é a casa onde os donos da Tio Atum vivem. Quando chega à sala de estar, Miguel anuncia: “E esta é a nossa sala de reuniões.”
A rábula pode dar a ideia de tratar-se de um bando de garotos que, enquanto não têm filhos, brincam aos jogos — mas em menos de quatro anos a Tio Atum fez seis jogos para mobile que “ultrapassaram os dois milhões de downloads”. De há ano e meio para cá, estão a trabalhar no primeiro jogo para PC e consolas, chamado Greedy Guns (a demo está online). “A ida para PC está garantida — agora, quais consolas, isso ainda não sabemos.”
O trio da Tio Atum não precisou de investimento externo de modo a trabalhar em Greedy Guns: “Foi tudo feito com os rendimentos que tivemos dos jogos mobile”, diz Miguel, antes de atirar: “Arriscámos desde o início, foi assim que começámos e, se a empresa acabar, acaba a arriscar.”
Bem-vindos então ao novo sonho português.
Como é que se faz dinheiro com jogos para smartphones? Bem, primeiro faz-se o jogo, depois tenta-se que uma plataforma de venda (a App Store, por exemplo) o aceite. Os seis jogos da Tio Atum estão no Google Play e na App Store. “Esses jogos são gratuitos”, explica Pedro Rafael. “Nós ganhamos da publicidade ou com compras dentro dos próprios jogos.”
As compras dentro dos jogos funcionam assim: o jogador descarrega um jogo da Tio Atum e começa a jogá-lo no seu smartphone. Mas o jogo tem um número de armas limitado ou só meia dúzia de níveis de dificuldade. Este é um exemplo das múltiplas tácticas que as empresas encontram para viciar o jogador e levá-lo a querer jogar mais: quem quiser mais armas, ou mais níveis, tem de pagar.
Quanto à outra fonte de rendimento, a publicidade: “Nós colocamos um serviço de anúncios no jogo, directamente na aplicação. Por cada pessoa que vai ao anúncio a partir do nosso jogo, recebemos um valor que pode chegar a um euro por pessoa.” Há empresas (estrangeiras) que facturam um milhão por dia; os autores de Candy Crush Saga “gastam balúrdios por dia só a anunciar o seu jogo em outros jogos”.
Como dissemos, a palavra-chave é “mobile”. Os smartphones — em Portugal como no estrangeiro — mudaram tudo. Até ao advento dos smartphones, os jogos eram desenvolvidos para consolas (sendo a PlayStation e a Nintendo as mais fortes no mercado) ou para PC e Macintosh. De modo que há uns anos não era raro haver “600 a mil pessoas a trabalhar no mesmo jogo”, segundo Barroso, que nota que “esta é a maior indústria de entretenimento do mundo — vale mais que a do cinema e da música juntas. Só para se ter uma ideia, o orçamento de marketing do GTA 5 [Grand Theft Auto 5, que vendeu mais de 45 milhões de cópias] é superior ao orçamento de feitura do jogo”. E o mercado dos videojogos continuará a crescer: de 57 mil milhões de euros em 2012 para praticamente 70 mil milhões em 2017, segundo a Forbes.
Antes, um videojogo lançado em grande escala era uma manada de elefantes que implicava ter: artistas (que desenham os bonecos ou os posters); programadores (fazem o esqueleto do jogo); designers (de menus, de gráficos, de 3D); arquitectos (apesar de serem assim chamados, não são licenciados em Arquitectura, antes engenheiros que tratam da habitação do espaço do jogo, isto é, a forma como o jogador, através do boneco que controla, se move através do jogo); guionistas; game designers (que decidem que quando o boneco salta também pode atirar uma faca e assim desbloquear um puzzle); sonoplastas (que fazem os sons e também podem fazer a música); e animadores (gente vinda do cinema de animação e que melhora os movimentos dos bonecos).
E depois vieram os smartphones. Não é que antes não existissem jogos para telemóveis, mas eram muito precários, pouco aliciantes — e, portanto, pouco viciantes.
Para fazer jogos para mobile, não são precisas 600 pessoas e um orçamento de marketing superior ao salário delas durante quatro ou cinco anos — basta uma pessoa. Como David Amador — o primeiro português a ver um jogo aprovado no Humble Bundle, uma das principais plataformas de vendas de jogos. O jogo, Quest of Dungeons, foi também aprovado pelo Steam (outra grande plataforma de venda de jogos online) em apenas seis dias.
Amador é um rapaz de 31 anos que, como outros, não acabou o curso: nasceu em Vila Nova de Milfontes e começou a estudar Engenharia Informática no Instituto Politécnico de Portalegre aos 19 — chumbou um ano no secundário. “Tive sempre dificuldade na escola”, conta.
Ao contrário de Pina, Folhadela ou Loureiro, nunca pegou num Spectrum — o primeiro computador de tantos rapazes nascidos na década de 1970. David começou por um PC, um Pentium 2, “aos 14 ou 15 anos — tarde, para os padrões comuns”.
Na altura, os seus colegas “tinham jogos que [ele] não tinha”. Os jogos “nunca foram uma coisa que os meus pais achassem produtivo. Pelo que não me compravam muitos”. David cresceu a brincar nas consolas dos amigos: Nintendo, Megadrive, “ainda um pouco da primeira PlayStation”. A sua lista de jogos preferidos dessa época inclui Zelda, Super Mario e Prince of Persia, um jogo que marcou a geração anterior à dele.
Teria uns 16 anos quando começou “a mexer umas coisas em Pascal [uma linguagem de programação caída em desuso] e num programa em Basic [uma linguagem de programação básica, usada pelos iniciados da informática a meio da década de 1980]. Até ir para a universidade, não tive educação formal de informática”.
Para pagar as propinas, David procurou um part-time. Na altura, uma série de start-ups instalara-se no edifício da Câmara Municipal de Portalegre — uma delas foi a Spellcaster Studios. “Cheguei à entrevista, puseram-me um computador nas mãos e disseram-me: ‘Tens duas horas para fazer um jogo.’ Não me disseram que tipo de jogo, em que linguagem, nada.” Entrou. Fez um estágio e, quando a Spellcaster se mudou para Setúbal, David seguiu-os, deixando o curso para trás. Ainda por lá ficou mais dois ou três anos, a trabalhar em websites.
Em 2010, estava desempregado e decidiu fazer um jogo chamado Vizati, por si próprio, num mês. Levou-o a um concurso da Microsoft e ganhou o primeiro prémio. Vizati saiu em Junho de 2010 e teve boas críticas, estando disponível para iPhone, PC, Mac e iPad — o que lhe deu motivação para continuar.
“O meu currículo são os jogos”, diz. O último emprego que teve foi na Sapo, e descreve assim a contratação: “Levei o iPad para a entrevista e disse: ‘Tenho feito isto.’ Eles acharam graça e começaram a jogar: consegui o emprego.” Isto significa que houve uma mudança cultural: o patronato começa a ver o talento para criar jogos como uma qualificação, não uma coisa de garotos.
Em 2013, resolveu fazer, sozinho, Quest of Dungeons — um jogo em que o objectivo é recuperar a luz roubada por um senhor das trevas e que tem a particularidade de os diferentes níveis nunca se repetirem. Tinha passado anos a fazer jogos (fosse para empresas, fosse nos seus tempos livres) e conseguira um certo culto na comunidade nacional de jogadores. Trabalhou em Quest of Dungeons durante um ano e foi “mostrando o progresso do jogo em fóruns, no Twitter e no Facebook”. Quando achou que o jogo estava próximo de estar acabado, fez o trailer e no mesmo dia mandou-o para o Steam.
No Steam, os criadores submetem os jogos, os jogadores votam nos que mais gostam e, se um jogo conseguir entrar no top 100 de votos, a plataforma talvez o distribua. Era uma da manhã quando David enviou o jogo; quando acordou, Quest of Dungeons tinha 6% dos votos do 100.º jogo mais votado; no dia seguinte 18%; e foi a subir até chegar ao top 100. A 19 de Janeiro de 2014, seis dias depois de ter enviado o jogo, o Steam aprovou-o para a sua loja.
Quest of Dungeons foi também para PC e Mac, depois iOS (o sistema operativo dos iPhones e dos iPads) e acabou na Humble Bundle. Agora, David Amador está a passar o jogo para a XBOX. Foi ele quem apresentou o jogo à Microsoft (dona da XBOX). Está a fazer tudo sozinho, com o dinheiro que ganhou até agora.
Quando Amador era aluno universitário, Pina foi à sua escola falar com os estudantes. David pensou: “Estes gajos fazem o que eu quero fazer.” Sem a palestra de Pina, Amador não teria pensado que era possível viver dos jogos.
Um dos primeiros problemas com que Pina se deparou quando resolveu iniciar a indústria de videojogos em Portugal, há 15 anos, foi a dificuldade em chegar à fala com editoras que publicassem os jogos: “Todas as editoras eram estrangeiras e nós não tínhamos ainda o know-how.” Mas a grande barreira era económica e ainda subsiste: “Os bancos em Portugal não investem em videojogos.”
Segundo Ivan Barroso, “até hoje não houve um banco que investisse num jogo em Portugal”. Segundo Miguel Pedro Rafael, da Tio Atum, “a nossa cultura financeira não ajuda — não temos milionários a dar com pau”.
As nossas regras fiscais também não estão adaptadas à especificidade do negócio: na maior parte dos países ocidentais, as empresas de videojogos têm isenções fiscais nos primeiros anos, porque um jogo pode demorar um a dois anos a ser feito, e depois ainda pode ser preciso esperar outro ano até receber o dinheiro. Por cá é preciso pagar IRC e segurança social durante todo este período. É por isso que Rafael acredita que os criadores de videojogos têm de se “unir para fazer lobby”.
A questão do know-how foi resolvida com o tempo: quando Pina começou a sua mais recente empresa, a Nerd Monkeys, já tinha no currículo jogos como Toy Shop Tycoon (o primeiro jogo para a Nintendo criado em Portugal, distribuído em todo o mundo, em seis línguas, que saiu em 2008), além do Under Siege.
Graças aos seus próprios desaires, os pioneiros dos videojogos portugueses aprenderam a conhecer as necessidades do mercado e os seus agentes. Assim se compreende que a Nerd Monkeys já tenha lançado vários jogos para mobile e esteja a crescer, ao ponto de nos próximos meses ir contratar mais quadros, isto além de já contratar regularmente freelancers — por exemplo, a música dos jogos é feita por João Mascarenhas, líder da Stealing Orchestra, uma banda de culto. Há cada vez mais freelancers nesta área — seja a fazer grafismo, programação ou som. Ou seja: a estrutura das empresas portuguesas começa a assemelhar-se à das empresas convencionais ocidentais. Ou seja: começa a haver uma indústria portuguesa.
Também a crescer está a Bica Studios, de Nuno Folhadela, empresa “altamente centrada no mobile”, que, entre outros jogos, desenvolveu um que teve êxito, Smash It!. Ao ponto de entretanto ter lançado uma sequela, Smash Time. Folhadela, um homem que fala com um entusiasmo e confiança impressionantes, tem grandes planos: “Somos a empresa mais promissora [de jogos] em Portugal. Somos nove empregados, mas daqui a seis meses vamos passar a ser 15 — planeamos contratar artistas, programadores e analistas de dados.”
Quando Folhadela chegou à Game Invest, em 2006, tinha passado anos a “entregar currículos em empresas de animação, porque não havia empresas de jogos”. Bem, havia esta — ainda por cima portuguesa — mas, para azar de Folhadela, a Game Invest faliu em 2007, de modo que o dono da Bica Studios teve de esperar quatro anos até voltar aos jogos, na Biodroid, também portuguesa. Esteve lá de 2011 a 2013.
Na Game Invest — que fazia os seus próprios jogos —, fora game designer e argumentista; na Biodroid, foi também produtor. Mas como as empresas portuguesas são pequenas, acabou (como Loureiro ou Pina) a fazer um pouco de tudo. Na Biodroid, fazia a história, a mecânica e a arquitectura dos jogos.
Foi aí que encontrou “gente com vontade de fazer jogos para o mundo inteiro” e resolveu formar a sua própria empresa. A gente da Bica Studios tem sonhos mas é pragmática. Querem “uma marca”, fazer “um jogo que seja bom daqui a 20 anos”, daí a opção pelo seu próprio produto em detrimento das encomendas que possam surgir. (Neste negócio é muito comum uma empresa consignar a outra uma parte da feitura do jogo.) Mas também querem “chegar a muitas pessoas”.
Fizeram uma análise de mercado e descobriram que “faltavam smashers”, jogos em que se partem, esmagam e escavacam coisas. “São jogos simples, que se aprendem rapidamente e sem um grande campeão de vendas nas lojas digitais.” Foi assim que criaram a série Smash (cuja primeira versão saiu em Maio de 2013 e a última em Dezembro), disponível para AppStore, Windows Phone e Google Play.
A ideia é ser um sucesso global e “haver mais conteúdos todos os meses. Novas personagens, novos níveis, novas mecânicas”, explica Folhadela: “Ao contrário do que acontecia nos jogos tradicionais, em que o objectivo era chegar ao fim, o jogo para mobile não pára. É a beleza destes jogos.”
Com o êxito de Smash It! fizeram um acordo com um grupo de investidores portugueses — que se tornaram donos de uma parte da empresa. A Bica usou o dinheiro para desenvolver Smash Time, a sequela de Smash It!, e “fazer dele um campeão de vendas”. Folhadela recebeu duas propostas da King, que desenvolveu o Candy Crush Saga, e mesmo assim “não quis sair”. A King é a maior criadora de jogos no Facebook e está avaliada em mais de sete mil milhões de dólares. Folhadela prefere “pensar no que [pode] fazer por Portugal”. A ideia é um dia vender a empresa por uma batelada.
“O grande problema de Portugal”, explica, “é que somos muito novos a produzir entretenimento”. Isto dificulta coisas tão simples como encontrar financiamento externo ou chegar às grandes distribuidoras. O país é visto com desconfiança, mas por outro lado, sabe-se que aqui há talento e barato, o que explica a razão por que a Miniclip, cujo capital é estrangeiro, se estabeleceu cá.
Um dos seus grandes êxitos foi um jogo chamado 8 Ball Pool. Por trás dele está Tiago Loureiro: “Fui contratado pela Miniclip para coordenar a passagem do jogo para mobile no mercado americano e europeu.” Foi um êxito global em 2013.
Nenhum percurso é tão estranho como o do “Viking”, um homem que fala depressa, tem sentido de humor e um marcado pragmatismo — o que é igualmente notório nos restantes criadores de videojogos nacionais.
Aos 39 anos, Loureiro é dos mais velhos a trabalhar nesta indústria (embora Pina trabalhe na área há mais tempo). Teve um Spectrum, claro, mas começou a programar em Basic aos seis anos, num Texas Instruments — um computador com periféricos para disquetes e gravador de cassetes, sobretudo popular nos Estados Unidos. O gosto pelas tecnologias de informação percorre a família: “O meu pai viu aquilo e comprou-o — quem lhe vendeu o meu computador foi o meu actual padrasto.”
No 10.º ano, criou “um programa no Spectrum para resolver os problemas de Matemática”. Não tencionava estudar Informática: “No 9.º ano, a imagem que tinha dos cursos de Informática em Portugal era má.” Pelo que se candidatou a Psicologia — mas entrou em Matemática. Ainda se inscreveu em Gestão, Psicologia e Engenharia Informática, não terminando nenhuma destas licenciaturas.
Valha a verdade, nunca precisou: aos 12 anos já ganhava trocos a quebrar os galhos informáticos dos conhecidos, aos 14 criava softwares para empresas de amigos dos pais, aos 17 criou uma distribuidora de livros de role playing (em que o jogador encarna uma personagem por ele criada) e aos 18 tornou-se operador de registo de dados numa empresa. Aos 22 era chefe de equipa de um sistema interbancário de detecção de fraude em tempo real com cartões bancários. Depois foi para a SisCog, onde desenvolveu programas de suporte à decisão para sistemas ferroviários no Norte da Europa — onde criou nome. E esta é a versão super-resumida do seu currículo.
Foi capa de revistas especializadas, mas só em 2006 começou a trabalhar em definitivo na área dos jogos. Hoje, “gente no mundo inteiro” vem ter com ele, diz, muito à conta de “ter publicado jogos que ainda estão no top 30 da Appstore dos EUA”, como Gravity Guy, mas também pelo seu talento enquanto programador — é o programador mais admirado pelos portugueses que trabalham na indústria dos videojogos e um dos programadores portugueses mais requisitados.
E, no entanto, não se quer ir embora. De tal modo que agora tem a Raindance Studios, que anda por estes dias por feiras em Londres. “Antes era difícil, do ponto de vista técnico, entrar nesta indústria. Mas agora há tantas ferramentas de tão fácil utilização que qualquer um pode fazer jogos”, diz.
Além disso, ter estado na Miniclip abriu portas lá fora: “Hoje sei exactamente quem hei-de contactar e como.” O “como” refere-se ao modelo de negócio: a Raindance Studios conseguiu apoio de uma distribuidora, a Lace, que adiantou dinheiro para um jogo para Mac e, se tudo correr bem, para XBOX. A Raindance Studios faz o jogo, a Lace publica e depois partilham receitas.
O adiantamento só dá até Outubro. Loureiro tem uma filha de cinco anos. Como se mete numa coisa destas? “Se correr mal, vamos à nossa vida”, diz, no tom mais pacato que se possa imaginar. “Não estou nada preocupado com isso. Num mês, tenho emprego.”
Certo, mas e aqueles que não têm certeza de arranjar emprego num mês? “Devem seguir o que sonham mas não se devem definir por isso. Cada projecto é só um projecto. Se correu mal, correu. Foi o projecto que correu mal, não foi a pessoa. É circunstancial: naquela altura não foi possível fazer isto. ‘Bora fazer outra coisa.”
Agora é hora de fazer jogos.”
+infos(Jornal Publico): LINK
Onde está o investimento nacional para videojogos? por Ivan Cardoso
”
Que não haja dúvidas. Os videojogos representam a maior indústria de entretenimento do mundo e a mais lucrativa de sempre deste milénio. Há aqui dinheiro, projecção internacional e, mais importante, uma máquina imparável para criatividade e inovação. Mas então o que se passa no nosso país?
Deixem-me estabelecer aqui um paralelismo com a Itália para mais facilmente explicar a nossa situação no espaço europeu. Não só é um país latino, como era igualmente um território mais consumidor de jogos do que produtor. Mas, tal como nós, desde 2011 começaram a ter produção nacional e, neste momento, existem cerca de 100 empresas.
Recentemente, a associação de comércio italiana (AESVI), juntamente com o ministro italiano da economia e desenvolvimento compraram espaço na GDC de São Francisco (um dos maiores eventos de videojogos) para que uma dúzia de estúdios italianos promovessem os seus jogos com maior facilidade, trazendo assim igualmente investimento para o país. O vice-ministro, Carlo Calenda, até afirmou que o mercado dos videojogos representa actualmente “um emergente sector, entre a inovação e criatividade, que pode ajudar decisivamente a Itália”. “Estamos a dar esta oportunidade aos nossos estúdios para serem competitivos e lucrativos no mercado internacional”, disse.
Quando falo com os estúdios portugueses, a realidade é diferente e ao mesmo tempo semelhante. Tal como Itália, nós éramos um país mais consumista do que produtor de videojogos, mas essa situação mudou. Desde 2011 até agora temos mais de 50 empresas neste sector e a qualidade tem subido. Aliás, neste momento tanto a Microsoft como a Sony têm feito parcerias para que os “nossos” jogos apareçam nas suas plataformas. A Biodroid e a Upfall Studios têm títulos previstos para serem lançados este ano na Xbox One e em Novembro do ano passado o VP Sénior da Sony, James Anderson, esteve em Portugal com o objectivo de colocar os jogos portugueses nas consolas da sua marca. Sem esquecer que a Miniclip (uma das maiores produtoras internacionais) tem uma filial sediada em Portugal que produz todos os títulos “mobile” da empresa. Hambo, Gravity Guy ou 8 Ball Pool são todos jogos Made in Portugal que andam sempre no top 50 das principais lojas.
Quanto ao Governo português, continua com o seu discurso de “exportar o produto nacional” ou que é “necessário revitalizar a indústria nacional”. Na prática, estão completamente a ignorar a indústria mais lucrativa do mundo no ramo do entretenimento, assim como o produto mais facilmente exportável. Se houver dúvidas, deixo mais um exemplo: a empresa nacional Battlesheep tem um jogo com 10 milhões de “downloads”, quase tantos como a população portuguesa. Curiosamente, desses todos, só 20 são portugueses. O resto são internacionais.
A verdade é que o investimento praticamente não existe e o Estado ignora por completo esta indústria. Mas há uma excepção — as taxas e os impostos. Aí sim, não se esquecem dos portugueses que estão a tentar vingar neste competitivo mercado. A situação fiscal é tão drástica que nos últimos anos muitos estúdios nacionais saíram de Portugal e estão sediados em países que já se aperceberam que a indústria dos videojogos é um negócio sério, com muitas benesses para o seu país. Por outras palavras, a Alemanha, o Reino Unido e a França criaram programas de apoio fiscal com benefícios, isentando as empresas de videojogos de impostos durante um período entre 12 a 24 meses. Afinal produzir um videojogo leva tempo e mais vale que as empresas tenham espaço de trabalho do que serem afogadas em taxas e impostos logo a partir do dia 1. Só no Reino Unido esta estratégia de longo prazo rendeu ao seu território, em 2013, 2,4 milhões de libras (quase 3 milhões de euros), com uma taxa de crescimento prevista em 12% por ano.
Segundo o que apurei, tentativas juntos das entidades governamentais em Portugal têm sido fúteis. Nalguns casos quando é mencionada a indústria de videojogos nacional parece que estão a contar alguma anedota. Se continuarem a ignorar os estúdios nacionais, temo que estes continuem-se a mudar para outros países — esses sim, vão certamente rir-se como nós estamos a contribuir para a sua riqueza e não para a nossa.
”
+infos(original): LINK
Uma daquelas histórias..
Parece que a publicação de videojogos carece de algum cuidado, nomeadamente quando se solicita uma avaliação a um determinado grupo de pessoas.
Ao que parece (e tudo leva a crer que seja uma história verídica) um determinado individuo entregou (online) um jogo para ser avaliado por um reputado serviço de ajuda e esse mesmo serviço nunca deu resposta e o jogo acabou por ser publicado por outros associados a esse serviço..
+infos: LINK
Uma ferramenta…
Uma ferramenta para pesquisar as vendas de videojogos na Steam
+infos: http://steamspy.com/
Going Indie: 10 Questions to Help You Decide if It’s Right for You (Don Daglow)
Uma palestra por Don Daglow acerca do desenvolvimento de videojogos.
+infos: LINK
artigo a ler “Made in Portugal: Videojogos à conquista do mundo”
Encontrei este artigo e é para ler.. “Made in Portugal: Videojogos à conquista do mundo” por Rui Pereira
+infos(artigo): LINK
Guião laboratorial n.º 1 – exercício 21
“Considere que pretende resolver um quebra-cabeças que surgiu no seu jornal. Existe um retângulo, com um determinado número de linhas e um determinado número de colunas, preenchido com caracteres alfabéticos em cada uma das suas posições. Na figura pode ver um exemplo para um quebra cabeças com 5 linhas e 6 colunas.
Desenvolva uma função que procure todas as ocorrências de uma determinada palavra no quebra cabeças. A palavra pode ocorrer numa linha ou numa coluna. De cada vez que a função encontrar uma ocorrência da palavra deve escrever no monitor o número da linha e da coluna em que a palavra tem início. Considerando o exemplo da figura, se a palavra a pesquisar for lua a função deveria escrever:
A palavra lua surge:
– Ao longo da coluna 0 com início na linha 1
– Ao longo da linha 3 com início na coluna 3
A função recebe como argumentos o endereço inicial da matriz de caracteres, as suas dimensões (n.º de linhas e de colunas) e um ponteiro para a palavra a pesquisar.”
Guião laboratorial n.º 1 – exercício 20
“Escreva um programa que para um dado mês à escolha do utilizador, indique o seu correspondente em Língua Inglesa.”
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAM 12
void indica_mes(int t, char *m)
{
int *p, mes=1, i=0;
p=m;
printf("Qual o mes que deseja ver traduzido (1-12)?\n");
scanf("%d", &mes);
for(i=0; i<t+1; i++, p++){
if(mes==i){
puts(*(p-1));
}
}
}
int main()
{
char *mesesP[]={"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"};
indica_mes(TAM, mesesP);
return 0;
}
ajuda: LINK
Guião laboratorial n.º 1 – exercício 19
“Pretende-se reduzir uma imagem a metade do seu tamanho original. A imagem inicial consiste num tabela bidimensional com M×M valores inteiros onde cada pixel (ponto na imagem) pode tomar um valor inteiro entre 0 e 9 (tonalidades de cinza). A imagem reduzida é armazenada num tabela bidimensional com M/2×M/2 valores reais onde cada elemento (pixel) corresponde á média dos 4 elementos que substitui. Para melhor compreensão do enunciado veja o exemplo apresentado de seguida (neste caso, para M=8):
Escreva uma função em C que efetue esta operação. A função recebe 3 argumentos: endereço inicial da matriz original, endereço inicial da matriz reduzida e o valor M.”
#include <stdio.h>
#define TAM 8
void reduzir_i(float *o, float *r, int d)
{
int i,j, k,aux;
float *p, *s, *q, soma=0, media=0;
p=o;
q=r;
//imprimir a matriz original
printf("matriz original: \n");
for(i=0; i<d; i++){
for(j=0; j<d; j++, p++){
printf("%.f ", *p);
}
printf("\n");
}
p=o;
s=o+d;
printf("\n");
for(i=0; i<d; i=i+2, p=p+d, s=s+d){
for(j=0; j<d; j++, p++, s++){
for(k=0 ; k<j+1; k=k+d){
//printf("%.f-%.f ", *p,*s);
soma=soma+*p+*s;
}
if(aux<1){
aux++;
}else{
media=soma/4;
*q=media;
//printf("%2.f \n", *q);
aux=0;
soma=0;
media=0;
q++;
}
}
}
//imprimir a matriz reduzida
printf("\n");
q=r;
printf("matriz reduzida: \n");
for(i=0; i<d/2; i++){
for(j=0; j<d/2; j++, q++){
printf("%.1f ", *q);
}
printf("\n");
}
}
int main()
{
float matO[TAM][TAM]={{0,4,9,3,6,7,2,9},
{9,4,7,8,3,4,7,2},
{5,1,2,6,3,8,6,2},
{7,1,4,8,7,2,0,7},
{4,9,3,5,2,1,5,7},
{5,3,4,7,8,9,1,0},
{2,3,5,6,7,9,2,4},
{2,3,4,5,6,7,8,9}};
float matR[TAM/2][TAM/2]={{0,0,0,0},
{0,0,0,0},
{0,0,0,0},
{0,0,0,0}};
reduzir_i(matO, matR, TAM);
return 0;
}