Month: October 2018

Sistemas operativos – o inicio (SO1)

Instalar o software:
VirtualBox-5.2.18-124319-Win (LINK)
e o Oracle_VM_VirtualBox_Extension_Pack-5.2.18 (LINK)

de seguida criar uma virtualização do sistema operativo debian-9.5.0-i386-xfce-CD-1 (LINK) ou o torrent (LINK)

Aquando da instalação do VirtualBox em Windows ter em atenção:
desligar primeiro o sistema Hyper-V do windows;
e durante a instalação do VirtualBox solicitar/aceitar a instalação das extensões.

A configuração da máquina virtual deve ser feita tendo em conta os seguintes aspectos:
reservar/verificar 10 gigas de espaço em disco;
colocar a imagem do disto numa pasta perto do root (sem caracteres complexos);
instalar na maquina virtual um SSH server;
sistema de caracteres de UTF8;

já depois de instalado é necessário fazer:
sudo pico /etc/apt/sources.list e comentar o cdrom com #
apt install sudo
adduser username sudo
sudo apt update
sudo apt upgrade

Na interface do VirtualBox fazer clique em devices e escolher insert guest aditions..  e depois na janela de terminal fazer:
cd /media/cdrom
sudo sh ./VboxLinuxAdditions.run

instalar ferramentas de desenvolvimento:
sudo apt-get install build-essential module-assitant dkms
e
sudo m-a prepare

instalação de software adicional na máquina virtual:
1. (netbeans)
na máquina virtual fazer o download do ficheiro e na linha de comandos escrever sudo sh netbeans-8.2-cpp-linux-x86.sh

2. (cliente dropbox)
para instalar o dropbox (32 bits)no debian fiz o seguinte:
cd ~ && wget -O – “https://www.dropbox.com/download?plat=lnx.x86” | tar xzf –
e para correr
~/.dropbox-dist/dropboxd
ou
activar o autostart dropbox autostart y

se for de 64 bits é fazer:
cd ~ && wget -O – “https://www.dropbox.com/download?plat=lnx.x86_64” | tar xzf –

3.( SSH server)
para instalar o SSH server fiz o seguinte:
sudo apt-get install openssh-server
e para correr
sudo systemctl status ssh
ou
sudo systemctl start ssh
e para parar
sudo systemctl stop ssh
e retirar a sua inicialização
sudo systemctl disable ssh

4.(instalar o ncurses):
sudo apt-get install libncurses5-dev libncursesw5-dev
não esquecer que para compilar com o ncurses é necessário fazer:
gcc E1.c -o E1 -lncurses

e Coisas importantes a rever:
sistemas de ficheiros em disco, particionamento, processo de arranque da máquina, sectores MBR e sector boot
Sistema de ficheiros unix, Partições: /, /boot, /home, /etc, /dev, /opt
Comando básicos Unix para navegação no sistema de ficheiros
Gestão de software com apt / apt-get
Noção iniciais de atributos de utilizadores e de segurança em ficheiros Unix. Comando sudo

 

Tags : ,

finalistas dos PlayStation Prémios 2018 (em Portugal)

Redcatpig Studio com KEO

+infos: (estúdio)

OX (Game Nest) com Capture

+infos: (website);

Team Fayo (Game Nest) com Fayo

+infos (website);

SnakeWhirl (Game Nest), com Ink Knight

+infos(website);

Silver Lining, com Advanced Override

+infos(webiste);

Hone Game Studios, com Dark Things About

+infos(…);

Lobster Lord Studios (Game Nest), com Tin-Heart

+infos(webiste);

Flying Pan (Game Nest), com Keg Wars

+infos(webiste);

Once a Bird, com Outsider

+infos(website);

Mad Shark, com Deep Journey

DarkArts, com Under The Rain

Tags : ,

POO, conceitos (cap 3)

#funções overloaded, são funções com o mesmo nome se:
tiverem diferentes tipos de argumentos
tiverem diferentes números de argumentos
tiverem diferentes tipos e números de argumentos

#funções com argumentos por omissão:
deve ser feito na declaração da função usando o =

Tags : ,

POO, conceitos (cap 2)

Operadores de saída e entrada:
Operador de saída: << Operador de entrada: >>

podemos usar o namespace para organizar ou evitar conflitos, inclusive podemos criar o nosso próprio exemplo:
namespace exemplo {
// definições de funções, variáveis,
// classes, etc.
}

e para evitar o uso dos operadores :: aquando da biblitoeca iostream
std::cout
faz-se:
using namespace std;

Bibliotecas a usar:
#include <iostream>
#include <string>

Cast: conversão explícita de tipo:
static_cast, de ponteiros do tipo void* para ponteiros de outros tipos
exemplo:
double d = 0.0;
int x = d;
x = static_cast(d);

const_cast,
reinterpret_cast,
dynamic_cast, Converte um ponteiro para um uma classe, num ponteiro para uma classe derivada, derivada da derivada
auto, o compilador determina automaticamente o tipo de uma variável
exemplo:
double val1 = 1;
double val2 = 2;
auto x = val1 + val2;

Ciclo for range-based, para quando todos os elementos de uma colecção (array, vector, …) devem ser processados
for(auto & elemento: tabela)
exemplo:
int a[10];
for(auto & elemento: a){
elemento = 4;
}

A constante nullptr em C++11, A constante nullptr pode ser usada para inicializar ponteiros nulos.

Referências,pode:
ser passada a uma função
ser retornada por uma função
ser criada de forma independente.

Ponteiro como parâmetro de uma função
exemplo:
void f(int *n);

int main() {
int i = 0;
f(&i);
cout << “\nNovo valor de i:” << i << endl;
return 0;
}

void f(int *n) {
*n = 100;
}

Referência como parâmetro de uma função
exemplo:
void f(int & n);

int main() {
int i = 0;
f(i);
cout << “\nNovo valor de i:” << i << endl;
return 0;
}
void f(int & n) {
n = 100;
}

Referência como retorno de uma função
exemplo:
int & f( );
int x = 0; //tem que ser global
int main( ){
f( ) = 100;
cout << x << endl;
return 0;
}
int & f( ){
return x;
}

Constantes, uma constante deve ser inicializada, já que não é possível fazer-lhe atribuições.
A palavra const antes do * impede qualquer alteração ao objecto apontado através do ponteiro em causa
A palavra const depois do * torna constante o ponteiro.
A palavra const antes e depois do * torna impossivel alterar o objeto apontado

Quando usar: quando uma função nao deve alterar uma variavel

Parâmetros do tipo referência para constante
_ganhar eficiencia de passar a referência ao invés do valor

exemplo conclusão

#include <iostream>

void t(int*) {}

void u(const int* cip) {
//*cip = 2; // ERRO: modifica valor
int i = *cip; // OK: copia valor
//int* ip2 = cip; // ERRO: ip2 nao é pont. para const
}

const char* v() {
// Retorna o endereço de uma string: 
return "result of function v()";
}


void main()
{
int x = 0;
int* ip = &x;
const int* cip = &x;
t(ip);
//t(cip);//Erro:t() nao pode receber ponteiro para constante
u(ip);  // OK u() pode receber ponteiro sem restricoes
u(cip); // OK u() pode receber ponteiro para constante 
//char* cp = v(); // Erro: nao deve ser possivel alterar 
// a string retornada por v() 
const char* ccp = v(); // OK 
system("pause");
}

faltou:
referências a lvalue e rvalue

Tags : ,

poo – parte 1 (início)

POO

//—->classe
_uma classe representa a especificação do novo tipo de dados que representa a entidade.
_a classe é definida por: dados e funções
_essas funções são apenas para esses dados e só essas funções é que podem manipular os dados
_o objecto é uma instância (variavel) de uma classe

//—->mecanismos
_existem mecanismos de encapsulamento (o código que manipula os dados estão na mesma classe. existem mecanismos de acesso a esses dados ao exterior da classe)
_existem mecanismos de herança (os dados podem herdar as propriedades e ter as suas propriedades especificas)
_existem mecanismos de polimorfismo (manipular diferentes dados através de algo que têm em comum. faz uso da herança e do nome da classe base)

//—->várias coisas
_operador de saida (<<) e de entrada (>>)
_fazer uso do using namespace std; para evitar ,p.e., usar std::cout
_faz-se uso do “if” se ? “true” : “false”
_conversões de tipo (implicita fazer uso do static_cast) static_cast<int>i
_e ainda o const_cast (????)
_determinar o tipo de variavel: auto x
_ciclo for, para todos os elementos de uma coleção (array, vector,..) (for range-based)
for (auto & elemento: tabela) instrução
_funções: void imprime(int val);
_funções overloaded (são usadas/substituias dependendo dos dados)

//—->a referencia é uma variavel e que pode:
__ser passada a uma função
__ser retornada por uma função
__ser criada de forma independente
__mas se for uma variavel não pode ser alterada

//—->o uso de um ponteiro como parametro de uma função:
f(&i) >> void f(int *n); em que
void f(int *n){
*n=…;
}

//—->o uso de uma referencia como parametro de uma função:
f(i) >> void f(int & n); em que
void f(int & n){
n=…;
}

//—->o uso de uma referencia como retorno de uma função:
global >> int x
f() -> int & f(); em que
int & f(){
return x;
}

//—->constantes (variaveis, arrays)
na sua area de validade não pode ser alterado
const antes do * impede a alteração do apontado >> int const * p;
const depois * torna constante o ponteiro >> int * const p = &i;

const antes e depois do P (nao é possivel qualquer alteração) >> int const * const a = &i;

quando uma função nao deve alterar uma variavel >> ponteiro para constante

//—->referencias a lvalue e rvalue (????)

//—->funções inline
sao expandidas inline
inline void par(int x) return !(x%2);
int main(){
if(par(10)) cout << “\npar..”<< endl;
}

//—->funções overloaded
funções com o mesmo nome mas
__diferentes

#a_lista dos includes “normais/regulares”
#include <iostream>
#include <string>
#include <iostream>
using namespace std;

Tags : , ,

No gamedev mas gamificação, que também é interessante (em gráficos)

O que é:

O planeamento:

Tags :

Gamedev, explicado em modo gráficos! :)

Open source developer

 

Unreal developer

Game deve artist

Unity developer

fonte: gameDev.tv

Tags :

Gaming, é mais ou menos isto o que se passa nos nossos dias..

Tags :

POO, conceitos

Uma classe representa a especificação do novo tipo de dados que representa a entidade. Definida por:
Dados
Funções
Essas funções só possam ser aplicadas a esses dados
Esses dados só podem ser manipulados por essas funções
Um objecto é uma variável (instância) de uma classe

A programação orientada a objectos utiliza os mecanismos de:
encapsulamento
_Dados e código que manipula esses dados são reunidos dentro da mesma entidade (classe), formando uma unidade íntegra e indivisível, autónoma em termos de dados e funcionalidade, que vai funcionar como um bloco de construção do programa
herança
_A herança é o processo pelo qual um tipo de dados pode herdar as propriedades de outro e ter ainda as suas propriedades específicas e sem ter que repetir código
polimorfismo
O polimorfismo um mecanismo/propriedade que permite manipular dados diferentes por aquilo que têm de comum, sem necessidade de repetir código nem estruturas de dados. O mesmo interface (molde) pode usar-se para especificar diversas acções com significado análogo

Tags :

ZX Spectrum 48k

Encontrei uma malta no reino unido que andar a reconstruir e a recuperar os velhinhos ZX Spectrum e não só, para depois os revendem a funcionar em pleno. O contacto inicial que fiz indica que o custo de uma ZX Spectrum ronda as 100 libras + portes de envio. Acho caro para a máquina que é e o que se pode fazer com ela, mas .. fica para já o registo aqui da coisa.

+infos(loja): http://www.mutant-caterpillar.co.uk/shop/

 

Tags : ,

Indie X

Está a decorrer em Lisboa uma chamada de jogos Indie, tanto nacionais como internacionais. Ao todo são esperadas até um máximo de cinquenta participações, que vão ser analisadas e mostradas num evento que depois vai decorrer no espaço da Lisboa Games Week

+infos(oficial): https://indiex.pt

Tags :

Dreams

Aqui está uma daquelas coisas que acho que vou precisar, um a Mochila para Portátil do género da Odyssey Backpack da HP.

Coisas positivas:
+suficiente para o portátil que uso;
+com espaço para levar outras coisas que devo precisar (ao invés de andar com dois sacos atrás).

-preço apenas de referência (link)

Tags :