Assistir a umas palestras sobre o desenvolvimento de videojogos..
acerca: “Take a deeper look at the principles of Game Design.” – 87 videos
pela malta do Extra Credits..
“Art” Is Not the Opposite of “Fun” – Why Analyzing Games Makes Them Better
A Case for Board Games – Why Board Games Help You Make Better Video Games
Accretion – Design by Landfill: A Longterm Strategy?
Achievements – Creating a Meaningful Meta-Game
Advanced Social Curve Design – Empowering the Community
Aesthetics of Play – Redefining Genres in Gaming
Affordances – How Design Teaches Us Without Words
Asymmetric Play – Can One Game Cater to Many Playstyles?
Awesome Per Second – Don’t Waste Time
Backtracking and Level Design – Making a Way Out
Balancing an MMO Ecosystem – Getting a Mix of Player Types
Balancing for Skill – The Link from Optimal Power to Strategy
Bartle’s Taxonomy – What Type of Player are You?
Big Bad – I: The Basics of Villains in Video Game Design
Big Bad – II: What Makes a Good Villain?
Choice and Conflict – What Does Choice Mean in Games?
Choices vs Consequences – What Player Decisions Mean in Games
Collectible Games – I: How Can We Make Good CCGs?
Collectible Games – II: Monetizing Our Collecting Urges
Collectible Games – III: What Makes a Good TCG or CCG?
Combining Genres – How to Pick the Right Design Mechanics For Your Game
Comedic Games – Can We Make More Funny Games?
Competitive Storytelling – How to Create Narrative in Multiplayer Games
Counter Play – Making Multiplayer Fun for the Opponent
Cutscenes – A Powerful (and Misused) Narrative Design Tool
De-Gamification – Flexibility to Play Your Way
Depth vs Complexity – Why More Features Don’t Make a Better Game
Designing for a Touch Screen – What Games Play Best on Mobile
Designing for Youth – Making Games for Players Under 14
Differences in Scale vs Differences in Kind – Keeping Players Interested
Digging Deeper – Do Games Have Less Value than Other Media?
Easy Games – What Happened to Hardcore Games?
Energy Systems – How Casual Games Suck You In
Exit Points – Putting Down the Game
Exploration in Games – Four Ways Players Discover Joy
Fail Faster – A Mantra for Creative Thinkers
First Move Advantage – How to Balance Turn-Based Games
Future Proofing Your Design – Looking at Hearthstone and Planning Ahead
Graphics vs. Aesthetics – Why High Resolution Graphics Aren’t Enough
Historical Games – Why Mechanics Must Be Both Good and Accurate
How Much Agency Do Games Need? – Choices in Linear Games
How To Start Your Game Narrative – Design Mechanics First
Humane Design – Games Must Be Good to Their Players
Idle Games – How Games Scratch Your Multitasking Itch
In Service to the Brand – Why Bioshock Infinite Failed
Intermediate Social Curve Design – Introducing Cooperation Rewards
Intrinsic vs Extrinsic – Designing Good Rewards in Games
Like a Ninja – What Makes a Good Stealth Game
Making Your First Game: Basics – How To Start Your Game Development
Making Your First Game: Launching! – How to Market Your Game
Making Your First Game: Minimum Viable Product – Scope Small, Start Right
Making Your First Game: Practical Rules – Setting (and Keeping) Goals
Mechanics as Metaphor – I: How Gameplay Itself Tells a Story
Mechanics as Metaphor – II: Creating Narrative Depth
MMO Economies – Hyperinflation, Reserve Currencies & You!
Negative Possibility Space – When Exploration Lets Players Down
Non-Combat Gaming – How to Make Social Mechanics Fun
Open World Design – How to Build Open World Games
Overlooked – The Hidden Potential of Hidden Object Games
Overwatch and Asymmetric Character Design – The Challenge of Varied Playstyles
Overwatch and Asymmetric Level Design – What Makes the Maps Fun?
Pacing – How Games Keep Things Exciting
Perfect Imbalance – Why Unbalanced Design Creates Balanced Play
Plan, Practice, Improvise – Understanding the Three Types of Play in Games
Playing Like a Designer – I: Examine Your Experiences
Playing Like a Designer – II: How to Analyze Game Design
Power Creep – The Trouble with Expansions and Time
Power Creep in Hearthstone – What It Teaches Us About Games
Quest Design – I: Why Many MMOs Rely on Repetitive Grind Quests
Quest Design – II: How to Create Interesting MMO and RPG Quests
Simulation Sickness – Causes and Cures for Game Headaches
Social Difficulty Curve – Easing Players into Communication
Spectacle Creep – When Sequels Try Too Hard
Speedrunning – Games Done Quick and Developer Tips
Starting Off Right – How the First Five Minutes Draw Players In
The Feeling of Agency – What Makes Choice Meaningful?
The Fighting Game Problem – How to Teach Complicated Mechanics
The Illusion of Choice – How Games Balance Freedom and Scope
The Magic Circle – How Games Transport Us to New Worlds
The Pre-Production Problem – How to Improve the Planning Process in Game Design
The Role of the Player – The Player is Both Audience and Storyteller
The Skinner Box – How Games Condition People to Play More
The Uncanny Valley – Why More Realistic Characters Look Less Human
Tutorials 101 – How to Design a Good Game Tutorial
What Is a Game? – How This Question Limits Our Medium
What Makes Us Roleplay? – Why Game Worlds Feel Real
When Difficult Is Fun – Challenging vs. Punishing Games
link: https://www.youtube.com/playlist?list=PLhyKYa0YJ_5BkTruCmaBBZ8z6cP9KzPiX
Consolas retro oficiais
Ando de olhos postos nas consolas retro. Algumas delas nunca brinquei nem experimentei, pois são demasiado antigas, outras sim :)
Eis a lista do que encontrei até ao momento à venda em Portugal :)
Consola SNES Nintendo Classic Mini,
Consola SEGA MEGA DRIVE 85 jogos (Preto),
Consola NINTENDO CLASSIC MINI NES,
Consola Retro ATARI Flashback 8 Gold,
Construir “Graphics Shaders”
Um tutorial/introdução que explica a construção de Graphics Shaders
+infos: LINK
Conversas gráficas (em Coimbra)
duas das palestras estão relacionadas com o desenvolvimento de videojogos:
O workflow geral do desenvolvimento de videojogos, por Guilherme Santos da Empresa ZPX
e Tecnologias de motion capture para videojogos, por Durate Duque professor no IPCA
Castle Jam (em Montemor o Novo)
“A Castle Jam é uma residência artística orientada para a criação colectiva de jogos digitais e analógicos. O evento decorre de dia 29 de Março 8PM a 31 de Março 8PM, decorrendo ao longo de cerca de 48h contínuas. Existem 15 vagas para participantes para a Castle Jam, providenciando-se acesso a duches e uma sala de descanso (os participantes devem trazer os seus próprios sacos de cama e produtos de higiene). Queremos sublinhar que a tua participação não está garantida por ter inscreveres neste formulário, uma vez que esta está sujeita a um processo de seleção, que decorrerá dia 16 de Março 2019.”
+infos(oficial): inscrição
MAD Game Jam (em Vila do Conde)
“As inscrições fecham à 00h do dia 17 de fevereiro e ainda temos 20 vagas para preencher!
– Inscrições validas para todas as idades
– Temos montes de prémios, ainda uns quantos por anunciar.
– Todas as refeições e snacks garantidos de borliu!
– Cafézinho do bô, Redbull pra todos…
– Salas para dormirem
– Internet toda XPTO
– Segurança all the time
– Estacionamento que nunca mais acaba
E acima de tudo, um ambiente único do qual vais querer fazer parte!”
+infos(oficial): http://eventos.esmad.ipp.pt/mad-gamejam/
9th Irish Conference on Game-Based learning (iGBL2019)
iGBL2019 will be held on 26th, 27th and 28th June 2019 in Cork City, and we welcome abstracts from developers, doctoral students, instructors and researchers for game demos, presentations or workshops on the themes of games for learning, motivation and change.
If you have used or conducted research on digital or non-digital games to support change, learning and motivation, and you would like to share your experience with like-minded researchers and practitioners, you may consider presenting at iGBL2019 and submit your abstract by 22nd February 2019.
Note that this year, we plan on organising a summer school on 26th June where research students (e.g., doctoral students) can discuss their work and obtain feedback from specialists in the field. There will also be a game jam where students will be able to work as a group to create a game based on a specific theme.
+infos(oficial): http://www.igbl-conference.com/cfp/
BiblioGameJam (em Marvila, Lisboa)
A Biblio Game Jam vai decorrer de 15 a 17 de Março na Biblioteca Municipal De Marvila, em Lisboa, com um prémio total de 3000€ a ser distribuído pelos vencedores.
A Biblio Game Jam insere-se no evento “Bibliogamers”, e os jogos desenvolvidos serão apresentados na sessão de jogos indie.
As equipas são de formação voluntária e podem incluir estudantes ou profissionais. O espaço estará disponível 24h por dia e serão disponibilizadas refeições ligeiras e completas aos participantes.
+infos(inscrição): https://goo.gl/forms/nfOMp4rj3NYPBuJ12
Prémios PlayStation Portugal 2018
Na passada semana decorreu em Lisboa a iniciativa Prémios PlayStation Portugal 2018.
Da lista de concorrentes deste ano surgiram os seguintes vencedores:
Melhor Jogo – KEO (Redcatpig Studio)
Melhor Utilização das Plataformas PlayStation – Capture (OX)
Jogo Mais Inovador – Keg Wars (Flying Pan)
Melhor Jogo de Competição Online – KEO (Redcatpig Studio)
Melhor Jogo Infantil – Fayo (Team Fayo)
Melhor Arte – Ink Knight (SnakeWhirl)
Prémio Imprensa – Capture (OX)
+infos(rede social): https://twitter.com/PlayStationPT
+infos(futurebehind): LINK
+infos(tek sapo): LINK
Sons, musica… aceder a uns quantos de forma gratuita
Alguns repositórios de sons e musicas gratuitas para serem usados em videojogos:
digccMixter (http://dig.ccmixter.org/)
PlayOnLoop (https://www.playonloop.com/)
Bensound (https://www.bensound.com/)
Twin Musicom (http://www.twinmusicom.org/)
ZapSplat (https://www.zapsplat.com/)
Incompetech (https://incompetech.com/)
MusOpen (https://musopen.org/)
Bandcamp (https://bandcamp.com/)
NetLabels (https://netlabels.org/)
PartnersInRhyme (https://www.partnersinrhyme.com/)
IndieGameMusic (http://indiegamemusic.com/)
FreeSoundtrackMusic (https://www.freesoundtrackmusic.com/)
Assets, aceder a uns quantos de forma gratuita
Alguns recursos para ajudar no desenvolvimento de videojogos (assets):
Open Game Art (https://opengameart.org/)
itch.io (https://itch.io/)
Game developer studio (https://www.gamedeveloperstudio.com/)
Game art 2d (https://www.gameart2d.com/)
Craftpix (https://craftpix.net/)
Cursos (2D e 3D) acerca do Godot Engine
Está a decorrer uma campanha no kickstarter acerca do desenvolvimento de jogos usando o Godot Engine.. a referencia é de 20 euros para um versão indie e 40 euros para lições para profissionais.
desta mesma malta existe um conjunto alargado de coisas gratuitas como videos e documentação
+infos(campanha): LINK
+infos(videos): LINK
+infos(documentação): LINK
SO1 – Escalonamento – Conceitos e Algoritmos
Escalonamento – Conceitos e Algoritmos
a multiprogramação simples consegue-se com:
dispositivos de memoria secundária e rápida;
boa gestão de E/S por parte do SO
mecanismo de gestão e partilha de memória
mecanismos no SO para partilhar e gerir recursos partilhados na maquina, entre todos os programas que estão em execução
a multiprogramação simples (não preemptiva: que prevê ou antecipa situações),
baseia-se na cedência voluntária (que pode ou não acontecer) do CPU, por parte do programa que está a ser executado
a multiprogramação preemptiva (ou “interactiva” ou “de tempo partilhado”),
o sistema força a cedência do CPU por parte do programa actualmente em execução, passado a CPU a outro programa e posteriormente voltando ao programa inicial
exemplo de algortimos preemptivos:
fim de quantum (interrupção do relógio, tempo partilhado)
processo mais prioritário
processo mais curto
objetivos do escalonamento preemptivo:
permitir que processos prioritários possam reagir rapidamente a um acontecimento
exemplo: windows NT, já o MSDOS é não preemptivo
exemplo de algortimos nao preemptivos:
o programa que terminou
o programa pediu acesso a um semáforo que estava fechado
o programa requisitou uma operação de E/S demorada
assim a preempção pode ser baseada em:
_intervalos de tempo fixo (um bocado de tempo à vez de todos)
_prioridade (o mais importante primeiro)
_critérios de performance (o mais pequeno/rápido primeiro)
o escalonamento multiprogramado simples:
consegue aproveitar esses tempo de E/S sem garantia que um programa impede outros de serem executados
aproveita melhor o CPU do que o monoprocessamento
o escalonamento multiprogramado:
o sistema consegue aproveitar os tempos de I/O de um programa para executar instruções de outros programas
existe a cedência do CPU
mas se existir um escalonamento preemptivo, baseado em intervalo de tempo, o utilizador obtém a garantia que todos os programas têm oportunidade de execução concorrente
Evolução dos sistemas operativos e do escalonamento
processamento em série (eniac)
processamento em lote on-line (uso de cartões perfurados junto do CPU, só existe um processo em cada instante)
processamento em lote off-line (uso de computadores auxiliares para ler os cartões perfurados, falhas na sincronização entre estes e o CPU, só existe um processo em cada instante)
processamento em lote o spooling (uso de mecanismos de interrupção, uso de discos)
multiprogramação (são sistemas de lote multi-programados ou concorrentes) e interactividade (são sistemas de tempo partilhado/time-sharing, com rotatividade de processos. Existe a pseudo execução em paralelo dos processos)
Parte 3 – conceitos de multiprogramação
o pseudo-paralelismo, consiste em ter várias actividades a decorrer ao mesmo tempo (em sistemas multiprogramados)
(existe um tempo de vista pelos processos e o que é a real desdestruição do processador)
Monoprocessamento vs multiprogramação simples
com esta acção de mutilprogramação simples o tempo total de execução diminui
Tempo não partilhado vs tempo partilhado (ou muliprogramação simples VS multiprogramação preemptiva)
resultados visíveis são errados, já que apesar do tempo de execução no tempo não partilhado (multiprogramação simples) ser menor que no tempo partilhado (multiprogramação preemptiva) o tempo apenas é explicado pelo aumento do numero de trocas entre os processos
Resumo das figuras:
sistemas multi-programados: optimização do processador
sistemas de tempo partilhado: optimizar a interactividade
As prioridades
surgem nos algoritmos de escalonamento e permite ao processo ser atendido que não fazendo uso do FIFO
As prioridades podem ser:
prioridades fixas (tem em conta o tipo de processo, associadas à importância dos acontecimentos. por exemplo: processo paginador)
prioridades dinâmicas (têm em conta o comportamento do processo, com o objectivo de ser justo, evitar a monopolização ou starvation. Neste caso são dadas prioridades aos processo que melhor se encaixam nos critérios de optimização global da máquina)
Os escalonadores
Os escalonadores podem ser:
escalonador de longo prazo (responsável por admitir um processo a execução. quantos mais processo maior a latência da máquina)
escalonador de médio prazo (através de um algoritmo determina quando e qual o processo, no estado de executável, que deve obter o processador)
escalonador de curto prazo (ou despacho, comuta os processos, após decisão do escalonado de médio prazo). O tempo de latência do despacho = tempo de parar um processo + tempo de recomeçar um processo
Quando se comuta de processo temos que ter em conta várias actividades:
invocação do despacho
salvaguarda do contexto do processo que estava a ser executado
recuperação do contexto para colocar o novo processo em execução
saltar para a localização do processo
Parte 4 – conceito de estado de processos
Modelo de dois estados:
faz uso do algoritmo de escalonamento, para determinar qual de dois processos que fica com o processo primeiro
Modelo de três estados:
surge o estado “novo” – serve para manter a informação acerca do processo, cuja criação foi pedida mas não foi admitido a execução
surge o estado “terminado” – serve para manter a informação acerca do processo, já terminado mas ainda não foi aproveitado
surge o estado de “suspenso” – pedido pelo próprio processo ou de outro processo
Modelo completo:
Parte 5 – conceitos usados em escalonamento
os diferentes algoritmos de escalonamento estão relacionados com respostas diferentes à forma como a gestão do processador tem que ser feita (desempenho, suporte, fiabilidade, robustez..).
qualquer algoritmo de escalonamento tem que manter todos os recursos do sistema. igualmente ocupados (para evitar picos de utilização)
aquando da gestão do processador tem que ter em conta os seguintes conceitos:
previsibilidade,
equilíbrio dos recursos,
justiça e starvation,
processos I/O bound e CPU bound
Existem dois tipos de processos/threads:
processos/threads I/O bound (que fazem muitas operações de E/S, bloqueando-se frequentemente)
processos/threads CPU bound (utilizam intensivamente o processador, quase nunca se bloqueando)
a Justiça
todos os processos/threads devem ter a mesma utilização dos recursos do sistema
a starvation
Surge quando o processo/thread nunca obtém o recurso pretendido, ou porque o recurso esta bloqueado ou porque o próprio processo/thread esta bloequeado
solução do starvation:
uso de prioridades dinâmicas (aumentar a prioridade para processos que estão à mais tempo à espera)
Parte 6 – indicadores de desempenho
este tipo de indicadores permitem que se verifique como está a eficiência com que o sistema gere a informação
exemplos de métricas/indicadores:
utilização do processador (importante para sistemas multiprogramados),
throughput (quantidade de processos concluídos por unidade de tempo)
tournaround (tempo de execução/conclusão. Desde a criação do processo/thread até à sua conclusão)
prazos (aplica-se em sistemas de tempo real). Exemplo:
três processos com um prazo de 15 minutos e outros com 3 com um prazo e 120 minutos
algoritmoA: todos os prazos são cumpridos à tangente
algoritmoB: os prazos dos processos de 15 minutos são ligeiramente excedidos enquanto os de 120 minutos são cumpridos com grande margem. Aparentemente o algortimo B seria melhor pois, em média, o throughput e o turnaround são melhores, mas a percentagem de prazos cumpridos é pior, pelo que o algortimo A é melhor
latência (tempo de resposta. Só se aplica a sistemas multiprogramados interactivos. É mais significado em sistemas interactivos que o throughut)
razão de penalização (é a razão entre o tempo total do processo e o tempo que demoraria se não tivesse outros processos)
exemplo:
tempo de espera (tempo total que um processo passou para o estado de executável)
previsibilidade (medida qualitativa do que quantitativa, e de implementação complexa, já que deve sempre necessitar do mesmo tempo para se executar independentemente da carga)
O escalonador tem que ser capaz de:
minimizar a latência,
maximizar o throughput,
maximizar o equilibro de uso dos periféricos,
justiça
Mas podem surgir problemas por via de:
dispositivos de E/S
optimização levar à starvation.
ocorrência de deadlocks
Parte 7 – algoritmos de escalonamento
Os algortimos de escalonamento podem ser:
preemptivos (round robin e SRT e Feedback)
não preemptivos (FCFS, SPN e HRRN) -> não servem para sistemas multiprogramados de tempo partilhado
algoritmo FCFS – Firts Come First Served
em que:
favorece o CPU Bound bloqueando os processos I/O Bound
não optimiza a utilização de dispositivos
para processos/threads nao interactivas, que têm o mesmo tempo de execução
tempo de conclusão não é importante
algoritmo RoundRobin
em que:
tem por base um quantum (intervalo de tempo)
força a interrupção de uma thread ao fim de um tempo
tempo partilhado em sistemas multiprogramados
é justo, independentemente do tamanho dos processos todos são atendidos da mesma forma
não surge o starvation
tournaround e tempo de espera melhors que o FCFS, quando a duração dos processos varia
Exemplo1 de FCFS e RoundRobin em que:
três processos do tipo CPU bound
existem um quantum
a duração do processo A=12q, do B=3q e do C=3q
ordem de chegada: A, instante 0; B, instante 1; C, instante 2
Exemplo2 de FCFS e RoundRobin em que:
duração dos processo igual para todos = 6q
algoritmo SPN, Shortest Process Next
em que:
o próximo processo a ser executado é o que se espera que demore menos tempo;
não é preemptivo, não serve para sistemas multiprogramados,
situação de starvation dos processos longos face aos curtos
tem um melhor tournaround
algoritmo SRT, Shortest Remaining Time
em que:
o próximo processo/thread a ser executada é aquele cujo tempo restante de processamento é menor,
preemptivo (se um processo que estava bloqueado passar a executável e tiver tempo restante de processamento menor do que actualmente em execução, ocorre a preempção),
não é baseado em quantum
dificuldade: e qt tempo demoram os processos
algoritmo HRRN, Highest response Ratio Next
em que:
eliminar a starvation dos processos longos
valoriza o tempo esperado e a idade do processo no sistema
escolhe sempre o processo que tiver maior response ratio
RR (response ratio) = tempo de espera (w) + tempo de execução esperado (s) / tempo de execução esperado (s)
algoritmo de Feedback
em que:
quando quando não é possivel estimar o tempo de processamento
faz-se uso de uma análise na máquina no passado, para prever o que vai acontecer
faz uso de prioridades dinâmicas: a prioridade vai diminuindo ao longo da idade do processo
faz uso de quantum variável: atribui um quantum maior ao processo que esteja a ser penalizado e vice-versa
A escalabilidade:
uma solução em engenharia é escalável, se o custo for proporcional à dimensão do problema
um algoritmo de escalonamento é escalável se o seu overhead de execução for proporcional ao numero de processo em execução
Para evitar que o escalonamento se torne não escalável usamos a técnica de escalonamento multi-lista: agrupando os processos executáveis em conjuntos, promovendo os que estão mais perto do que está a ser analisado (primeiro nível e despromovendo para o nível mais baixo os que estão no primeiro nível.
coisas maybe importantes:
descrever o que é um quantum
o que é a preempção
conceito de justiça
o que é o CPU bound e i/o bound
o que é o tempo de espera, throughput, penalty ratio, conceito de justiça,
descrever o modo de funcionamento de cada um dos algoritmos estudados,
objectivos do escalonamento e duas principais dificuldades na obtenção de uma gestão óptima absoluta
explicar a influencia da preempção ou ausência dela num sistema
comparar dois algoritmos, para um cenário, e explicar qual o melhor e porquê
descrever a influencia da optimização de alguns indicadores de desempenho sobre os outros..
calcular tempos e indicadores..
Desenvolvimento na YoYo Games (GameMaker)..
Uma história interessante acerca de alguém que participou no desenvolvimento do GameMaker, desde a sua verão 1 até ao GMS2.
+infos(a fonte de informação): LINK
iGBL2019 (em Cork City)
“iGBL2019 will be held on 26th, 27th and 28th June 2019 in Cork City (Ireland), and we welcome abstracts from developers, doctoral students, instructors and researchers for game demos, presentations or workshops on the themes of games for learning, motivation and change.”
…and submit your abstract by 25th January 2018.
+infos(oficial): http://www.igbl-conference.com/
05_IntroducaoASP.NET MVC
Introdução ao MVC:
separação do UI de uma aplicação em três aspectos:
Controller (partilha eventos com a view e faz ligação ao model)
Model (partilha propriedades com a view)
View
(vista, modelo e controlador)
vista (nterface do utilizador para apresentação dos dados, isto é, representa o UI da aplicação)
modelo
controlador (Traduz as ações do utilizador em operações apropriadas; e é o cérebro da operação, responsável por tratar o pedido HTTP)
exemplo dos procedimentos:
endereço web, controlador, modelo e depois a view
existe um Router que selecciona o controlador correcto para tratar do request
os Actions Selectores são atributos que podem ser aplicados aos Actions Methods, e permitem o mecanismo de routing identificar o action correcto para manipular determinado pedido.
//exemplo do HttpGet
//no controlador
[HttpGet]
public ActionResult Edit(int id)
{
}
//na view
@Html.ActionLink("Editar", "Edit", new { id = item.Id })
As actions podem ter parâmetros de entrada (tipos de dados primitivos ou complexos)
e para isso é necessário que o controlador receba esses valores
public ActionResult Editar(int id)
{
return Content("id=" + id);
}
06_ASP.NET Passagem Dados, ViewsRazorLayouts
A passagem de dados:
A passagem de dados do Controlador à Vista, e ao próximo request, pode ser efetuada de outras formas para além da passagem de dados através de um argumento da View
Pode ser usado nas passagem de dados:
ViewData emque o Objeto é do tipo dicionário, acessível usando strings como chaves e necessita do type casting para tipos complexos
ou o ViewBag, objecto do tipo dinâmico, não necessita de type casting nem verificações de null e as propriedades são adicionadas em tempo de execução
//exemplo: ViewData
//no controlador
public ActionResult Vencedor()
{
var pescador = new Pescador() { Nome = "Pedro" };
ViewData["PescadorData"] = pescador;
return View();
}
//na View
@using MVC1.Models
@model MVC1.Models.Pescador
@{
ViewBag.Title = "Vencedor";
Layout = "~/Views/Shared/_Layout.cshtml";
}
<h2>@(((Pescador)ViewData["PescadorData"]).Nome)</h2>
ou
//exemplo: ViewBag
//no controlador
public ActionResult Vencedor()
{
var pescador = new Pescador() { Nome = "Pedro" };
ViewBag.PescadorProp = pescador;
return View();
}
//na View
@using MVC1.Models
@model MVC1.Models.Pescador
@{
ViewBag.Title = "Vencedor";
Layout = "~/Views/Shared/_Layout.cshtml";
}
<h2>@ViewBag.PescadorProp.Nome</h2>
As viewes:
A view não deve executar qualquer lógica de negócio, ou interagir com a base de dados directamente.
Deve trabalhar somente com os dados que lhe são fornecidos pelo controlador.
//exemplo para obter /pescadores/Index
public ActionResult Index()
{
return View();
}
//exemplo para obter /pescadores/OutraView
public ActionResult Index()
{
return View("OutraView");
}
A Sintaxe Razor:
Minimiza a quantidade de sintaxe e caracteres extra
Codifica automaticamente qualquer output enviado através do @ de forma a prevenir ataques cross site scripting
Blocos de código estão delimitados com @{ … }
Ficheiros C# tem extensão .cshtml
//exemplo razor view
@{ var mensagem = "Programação"; }
<p>O valor da Mensagem é: @mensagem</p>
@{
var boasVindas= "Bem vindo ao Razor!";
var diaSemana= DateTime.Now.DayOfWeek;
var mensagem = boasVindas + " Hoje é " + diaSemana;
}
Os Layouts:
_Layout.cshtml, Define o que se quer apresentar em todas as páginas da aplicação
A view _Layout deve ser especificada na pasta Shared existente na secção Views
E o RenderBody permite especificar onde será apresentado o conteúdo individual das views
07_Forms, HtmlHelpers, Validações – DataAnnotations
Os Html Helpers permitem:
Permitem a geração de elementos HTML
O Razor view engine já define um conjunto de helpers
Permite criar de forma simples pequenos blocos html tais como:
Criação de elementos de inputs;
Criação de ligações;
Criação de forms;
Existem três tipos de Html Helpers:
HTML Helpers Inline
Built-in HTML Helpers
e HTML Helpers personalizados
@Html.ActionLink(“Novo Aluno”, “Create”)
significa que:
Novo Aluno
Podemos fazer uso do @HTML.TextBox() usando o:
Método loosely typed e não apresenta erros de compilação quando se especifica o nome da propriedade errado,
ou
Método strongly typed que apresenta erro de compilação quando se especifica um nome de propriedade errado e gera o elemento TextBox para a propriedade especificada no modelo, recorrendo a uma expressão lambda
//exemplo:
@Html.TextBox("Nome", null, new { @class = "form-control" })
@Html.TextBoxFor(m => m.Nome, new { @class = "form-control" })
o uso do For permite verificar erros em tempo de compilação
//outros exemplos:
@Html.LabelFor(model => model.Numero, htmlAttributes: new { @class = "control-label col-md-2" })
@Html.EditorFor(model => model.Numero, new { htmlAttributes = new { @class = "form-control" } })
@Html.HiddenFor(model => model.Id)
@Html.DisplayNameFor(model => model.Numero)
@Html.DisplayFor(model => model.Numero)
As DataAnnotations é uma forma de adicionar informação contextual a classes ou membros da classe;
Existem três categorias principais:
Validation
Display
Modelling
//exemplo:
[StringLength(50,MinimumLength = 3)]
//exemplo:
[Required(ErrorMessage = "Especifique um nome.")]
//exemplo:
[StringLength(50,MinimumLength = 3,ErrorMessage ="O nome deve ter no mínimo 3 e maximo de 50 carateres.")]
//exemplo:
[Range(0, 18, ErrorMessage ="Idade deve estar entre 0 e 18")]
//exemplo:
[Display(Name = "Endereço Eletrónico")]
//exemplo:
[DisplayFormat(ApplyFormatInEditMode =true,DataFormatString ="{0:c}")]
//exemplo:
[ReadOnly(true)]
//exemplo:
[RegularExpression(@"\d{9}", ErrorMessage = "Nº de Telemovel invalido!")]
//exemplo:
[StringLength(10, MinimumLength = 5)]
e pelo uso das ValidationMessageFor surgem:
<div class="form-group">
@Html.LabelFor(model => model.Morada, htmlAttributes: new { @class = "control-label col-md-2" })
<div class="col-md-10">
@Html.EditorFor(model => model.Morada, new { htmlAttributes = new { @class = "form-control" } })
@Html.ValidationMessageFor(model => model.Morada, "", new { @class = "text-danger" })
</div>
</div>
A validação do lado do cliente pode ser feita recorrendo a expressões do jQuery
A validação dos dados:
o MVC executa a lógica de validação durante o model binding, através dos métodos métodos UpdateModel e TryUpdateModel de um controlador
//exemplo: Model Binding
public ActionResult Edit(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Aluno aluno = db.Alunos.Find(id);
if (aluno == null)
{
return HttpNotFound();
}
return View(aluno);
}
09_EntityFramework_CodeFirst
Os passos para trabalhar com o modo de 09_EntityFramework são:
_criar o contexto (classe que herda da DBcontext)
_especificar a connection string no ficheiro web.config
De seguida devemos:
criar os diferentes modelos de dados por exemplo:
aluno..
public class Aluno
{
public int AlunoID { get; set; }
public string AlunoNome { get; set; }
public DateTime? DataNascimento { get; set; }
public IList<Disciplina> Disciplinas { get; set; }
public Aluno()
{
}
}
Disciplina..
public class Disciplina
{
public int DisciplinaId { get; set; }
public string DisciplinaNome { get; set; }
public Curso Curso { get; set; }
public Docente Docente { get; set; }
public IList<Aluno> Alunos { get; set; }
}
Curso..
public enum Curso
{
INFORMATICA=1,
BIOMEDICA=2,
CIVIL=3,
MECANICA=4
}
Docente..
{
public class Docente
{
public int DocenteId { get; set; }
public string DocenteNome { get; set; }
}
Depois existe a necessidade de criar o contexto
public class EscolaContext : DbContext
{
public EscolaContext() : base("name=DefaultConnection")
{
}
public DbSet<Aluno> Alunos { get; set; }
public DbSet<Disciplina> Disciplinas { get; set; }
public DbSet<Docente> Docentes{ get; set; }
}
Especificar a conenection string no ficheiro web.config
Ir aos nugetpackage manager, e package manager manager console
Activar as Migrations: comando enable-migrations
Criar uma migration: comando add-migration “modeloInicialV0” (sempre que alterarmos os modelos)
E actualizar a base de dados: update-database
No ficheiro configuration.cs podemos realizar o seed das entidades e acrescentar dummy data nas tabelas
exemplo do seed (e a dummy data está noutro CS):
context.FixedStations.AddOrUpdate(
f => new { f.RecordDateFs, f.LocalizationFs, f.StartIndexDisponibilityFs, f.EndIndexDisponibilityFs },
DummyData.GetFixedStations().ToArray()
);
context.SaveChanges();
exemplo de dummy data:
context.Docentes.AddOrUpdate(a => a.DocenteNome, new Docente
{
DocenteNome = "Maria",
Disciplinas = new Collection<Disciplina>() {
new Disciplina() {DisciplinaNome="POO" }
}
});
}
É possivel alterar o que as convenções geram através de um processo de overriden:
usando DataAnnotaions ou FluentAPI
As DataAnnotaions:
simples de especificar, menos flexíveis, úteis para anotações simples: obrigações, tamanhos, máximos..
//exemplo de DataAnnotations
[Table("Alunos")]
public class Aluno
{}
//ou
[MaxLength(150), Required]
//ou
public DateTime? DataNascimento { get; set; }
//ou
[Column("Nome",TypeName="varchar")]
//ou
[ForeignKey("Docente")]
public int DocenteId { get; set; }
public virtual Docente Docente { get; set; }
//ou
[Key]
//ou
[NotMapped]
o FluentAPI:
permite configurar a configuração de relacionamentos entre classes mais complexas, separações de concerns
As fluentApi são escritas nos contextos
O código deve ser aplicado no método OnModelCreating(DbModelBuilder modelBuilder) da class que deriva do DbContext
Permite mais controlo na definição das relações usando HAS e o With
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
// Aplica as configurações recorrendo ao Fluent API
}
//exemplo de FluentAPI
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<Disciplina>()
.Property(t => t.DisciplinaNome)
.IsRequired();
//ou
modelBuilder.Entity<Aluno>().ToTable("Alunos");
//ou
modelBuilder.Entity<Aluno>().HasKey(t => t.NAluno);
Podemos usar ambas mas temos que ter em conta que as precedências são:
FluentAPI
DataAnnotaions
Convenções
Os relacionamentos com o fluentApi:
HasMany() – Se A tem muitos objetos to B
HasRequired – Se A tem apenas um objeto de B
HasOptional – Se A tem 0 ou 1 objeto de B
WithMany() – Se B tem muitos objetos to A
WithRequired – Se B tem apenas um objeto de A
WithOptional – Se B tem 0 ou 1 objeto de A
//relacionamento 1-N
modelBuilder.Entity<Professor>()
.HasMany(p => p.Disciplinas)
.WithRequired(d => d.Professor)
.HasForeignKey(d => d.ProfessorId);
//relacionamento N-M
modelBuilder.Entity<Professor>()
.HasMany(p => p.Disciplinas)
.WithMany(d => d.Professores)
.Map(m => m.ToTable("ProfessorDisciplinas“))
//relacionamento 1-0..1
modelBuilder.Entity<Professor>()
.HasOptional(p => p.Disciplina)
.WithRequired(d => d.Professor);
//relacionamento 1-1
modelBuilder.Entity<Professor>()
.HasRequired(p => p.Disciplina)
.WithRequiredPrincipal(d => d.Professor);
08_EntityFramework e DatabaseFirst
O objectivo da EntityFramework é o de aumentar a produtividade do programador, reduzindo tarefas redundantes para persistência de dados
Existem várias forma de especificar o modelo de dados:
Database First (Bd -> classes de domínio)
CodeFirst (classes de dominio -> Bd)
ModelFirst (UML e surgem as classes de dominio via EF e a base de dados)
O contexto (Model.Contex.cs):
Contem a classe que deriva da classe DbContext
Fornece a propriedade para cada classe do modelo que corresponde a tabela da BD (Fornecedor.cs Cliente.cs)
Os modelos:
os modelos representam as tabelas da base de dados
quando pretendemos usar o “maldito” scaffolding, recorremos à classe de contexto e ao modelo de classes
o Linq e a EntityFramework:
o Lazy Loading: o loading não é executado de forma imediata, é apenas quando se acede aos elementos (bom apenas para aplicações desktop)
Problema do n+1 do lazy loading:
fazer uso de inlcude
Alternativa ao lazy loading, é o explicit loading:
útil quando se pretende efectuar o load de muitos objectos e as queries ficam complexas (as queries são separadas), mas faz muitas queries na base de dados
ou o Eager loading:
quando se obtém os dados da BD em apenas um round-trip e faz uso de joins
Como adicionar objectos na BD:
//v1
var aluno = new Aluno { Nome = "Pedro",
UserName="pedro@residual.ptt",
Email ="pedro@residual.pt",
CursoId=1
};
db.Alunos.Add(aluno);
db.SaveChanges();
ou
//v2
var cursos = db.Cursos.ToList();
var curso = db.Cursos.Single(c => c.CursoId == 1);
var aluno = new Aluno { Nome = "Pedro",
UserName="pedro@residual.pt",
Email ="pedro@residual.pt",
Curso = curso
};
db.Alunos.Add(aluno);
db.SaveChanges();
Como alterar objectos na BD:
var curso = db.Cursos.Find(4); // ou var curso = db.Cursos.Single(c => c.CursoId == 4); curso.Objectivos = "Curso bla bla bla"; curso.Nome = "Novo Nome"; db.SaveChanges();
Como remover objectos na BD:
//Com CascadeDelete ativo var curso = db.Cursos.Find(4); db.Cursos.Remove(curso); db.SaveChanges();
Ou
//Sem CascadeDelete ativo var curso = db.Cursos.Include(c => c.Alunos) .Single(c => c.CursoId == 4); db.Alunos.RemoveRange(curso.Alunos); db.Cursos.Remove(curso); db.SaveChanges();
10_Security in web applications (pweb)
Segurança em aplicações Web
O que é uma vulnerabilidade? é uma fraqueza que permite aos atacantes ganharem acesso ao sistema ou a informações
Causas de vulnerabilidades:
complexidade
falhas no desenho da app
software bugs
falhas ao nível das passwords e privilégios
Uma vulnerabilidade é uma fault, que deixa espaço para a exploração maliciosa de um sistema.
Exemplo de ameaças ao software:
Denial of service (Oversize Payload, Coercive Parsing, Oversize Cryptography, Attack Obfuscation, Unvalidated Redirects and Forwards)
Brute force (Insecure Cryptographic Storage, Broken Authentication and Session Management)
Spoofing (Insufficient Transport Layer Protection, Metadata Spoofing, Security misconfiguration)
Injection (SQL Injection, Cross site Scripting (XSS), Cross Site Request Forgery, XPath Injection)
Flooding (Instantiation Flood, Indirect Flooding, BPEL State Deviation)
Exemplo de vulnerabilidades de aplicações web:
_estão expostas
_os hackers movem as suas atenções da rede para o código da aplicação web
_aplicação de vários níveis de ataques: (portas da network, tempered values, o código implementado nas aplicações)
Vulnerabilidades (injection vulnerabilities):
SQL injection (alterar a expressão de SQL que está a ser usada, alterar os dados da base de dados ou até mesmo executar comandos no sistema)
XPath injection (modificar o xpath que está previamente programado, ou ganhar acesso através do acesso a documentos XML)
Code execution (é possivel manipular os dados de entrada para enganar o ocidgo do servidor)
Cross-site request forgery (CSRF) (o utilizador pode manipular um utilizador para que este execute acções indesejadas assim que está autenticado. Faz isto enviado um link para o utilizador)
Soluções para segurança das aplicações web:
defense in depth: endurecendo todas as camadas da infraestrutura tecnológica através:
colocar restrições na capacidade do servidor de correr componentes autonomamente;
colocar ou elevar o nível dos filtros relacionados com os níveis de tráfico;
fazer uso de um IDS para identificar actividade anómala na infraestrutura;
Todas as entradas são consideradas maliciosas até prova em contrário.
Linhas de protecção:
Input validation (normalização dos dados de entrada, usar filtros para recusar valores fora do dominio)
Hotspot protection (garantir que está correctamente implementada)
Output validation (validar a saida de um determinado processo antes de este ser enviado)
Protect back-end resources (funcionalidades desnecessárias devem ser removidas, dedicar especial atenção quando se lida com informação)
Lidar com o SQL Injection:
impor validação do SQL;
Fazer uso de ferramentas online:
HP WebInspect
WSFuzzer
Acunetix
WatchFire
Rational APPScan
Foundstone
WEDigger
04_Introdução ao C# (pweb)
POO, princípios básicos:
abstração
herança
encapsulamento
polimorfismo
O mundo tem objectos que possuem características e comportamentos. Todos os objectos têm: estado (conjunto de propriedades de um objecto), comportamento (conjunto de acções sobre o objecto), unicidade (todo o objecto é único).
Objecto = Dados + Código
Dados -> comunica com -> atributos
Código -> comunica com -> métodos
nivel_acesso class nome_da_classe
{
// bloco de instruções
}
um classe tem:
nivel_acesso: nível de proteção da classe ( internal/public ou abstract ou sealed)
pode existir uma class @override -> permite substituir qualquer coisa (por exemplo um método)
pode existir numa class o virtual -> permite sobrescrever qualquer coisa (por exemplo um método)
e o new é usado para ocultar um determinado método
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PWEB_estudoCsharp
{
class Program
{
static void Main(string[] args)
{
@override x = new @override();
Console.WriteLine(x.Numero);
Console.ReadKey();
}
}
class @override
{
public int Numero { get; set; }
public @override()
{
Numero = 5;
}
}
}
o this serve para nos referirmos ao próprio (variável, campo, método..) do objecto e não a algo “local”
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PWEB_estudoCsharp
{
class Program
{
static void Main(string[] args)
{
Aviao a= new Aviao();
Aviao b = new Aviao("USA");
Console.WriteLine("Vem com o nome {0}", a.ONome);
Console.WriteLine("Vem com o nome {0}", b.ONome);
Console.ReadKey();
}
}
class Aviao
{
public string ONome="TAP";
public Aviao()
{
}
public Aviao(string nome)
{
this.ONome = nome;
}
}
}
assim uma classe tem os seguintes membros:
variáveis (campos ou atributos(members fields));
métodos
propriedades (gets e sets)
Os atributos têm sempre um nível de protecção:
private (por defeito),
public (acedido a partir de outras classes ou métodos),
protected (acedido a partir da classe onde foi declarado e/ou classes derivadas),
protected internal (acedido a partir de uma classe onde foi declarado ou de classes derivadas)
Podemos também dividir as classes, usando a terminologia partial
As classes também têm um nível de protecção:
internal (por defeito, a classe acedida apenas no projeto),
public (acedida de qualquer parte),
abstract ou internal abstract (acedida apenas no projeto e não pode ser instanciada, apenas derivada de)
public abstract (acessível de qualquer parte e não pode ser instanciada, apenas derivada de)
sealed (acessível apenas no projeto, não pode ser derivada, apenas instanciada)
public sealed
O encapsulamento tem como objectivo principal ocultar de pormenores internos da classe. Para fora vão apenas os métodos (se for o caso). Normalmente essa implementação é feita usando getters e setters
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PWEB_estudoCsharp
{
class Program
{
//exemplo do encapsulamento
static void Main(string[] args)
{
Aviao a= new Aviao();
Aviao b = new Aviao();
Console.WriteLine("Vem com o nome {0}", a.ONome);
Console.WriteLine("Vem com o nome {0}", b.ONome);
Console.ReadKey();
}
}
class Aviao
{
private string nome = "TAP";
public string ONome
{
get { return nome; }
set { nome = value; }
}
}
}
Os métodos (funções dentro das classes) podem ter parâmetros, sendo que estes podem ser passados por valor, ou então por referência, ou uso do out.
O uso da referência (ref) permite actualizar uma variável.
Existe tambem o formato de out
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PWEB_estudoCsharp
{
class Program
{
//exemplo do ref
static void Main(string[] args)
{
Contas a = new Contas();
int numero = -3;
Console.WriteLine("mostra resultados {0}", a.FazContas(ref numero));
Console.ReadKey();
}
}
class Contas
{
private int valor = 10;
public int FazContas (ref int recebe)
{
if (recebe < 0)
{
valor = this.valor;
}
else
{
valor = recebe * recebe;
}
return valor;
}
}
}
Podemos também utilizar arrays, nomeadamente parâmetros como argumentos
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PWEB_estudoCsharp
{
class Program
{
//exemplo do arrays
static void Main(string[] args)
{
Contas a = new Contas();
int[] numeros = {1,2,3};
Console.WriteLine("mostra resultados {0}", a.FazContas(numeros));
Console.ReadKey();
}
}
class Contas
{
public int FazContas (params int[] recebeArray)
{
int soma = 0;
foreach (var r in recebeArray)
{
soma += r;
}
return soma;
}
}
}
É possivel passar “invocar” um função ou método dependendo dos valores dos argumentos que recebe
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PWEB_estudoCsharp
{
class Program
{
//exemplo do argumentos
static void Main(string[] args)
{
Argumentos();
Argumentos(texto:"Peter");
Console.ReadKey();
}
static void Argumentos(int numero = 0, string texto = "Portugal")
{
Console.WriteLine("mostra resultados {0}, {1}", numero, texto);
}
}
}
O polimorfismo:
definição de métodos ou interfaces, que são genéricos e que podem ser implementados de diversas formas
Vantagens do polimorfismo:
reutilizar código;
tempo de desenvolvimento;
manutenção.
A herança:
permite reutilizar o código, permite a construção de classes baseadas noutras, sendo que a subclasse:
herda todas as propriedades e métodos da classe base;
pode incluir ou sobrepor novas propriedades e métodos.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PWEB_estudoCsharp
{
class Program
{
//exemplo de herança
static void Main(string[] args)
{
Filho f = new Filho();
Console.WriteLine("mostrar {0}", f.Metodo2());
Console.WriteLine("mostrar {0}", f.Metodo1());
Console.ReadKey();
}
class Mae
{
private int numero = 10;
public Mae() { }
public int Metodo1()
{
return numero;
}
}
class Filho:Mae
{
private int valor = 1;
public int Metodo2()
{
return valor;
}
}
}
}
Os membros da classe base, podem ser virtuais. A classe que herda uma classe com membros virtuais pode ser overridden pela classe que a herda, fazendo com que a classe derivada possa fornecer uma implementação alternativa para o membro.
O uso da palavra sealed evita que uma classe ou membros virtuais sejam herdados
uma classe base pode ser abstracta. É uma classe conceptual no qual se definem funcionalidades para as subclasses (que a herdam) e que possam implementá-las de forma não obrigatória.
se for estabelecido um método abstracto, então essa classe também o é. esse método não possui implementação na classe abstracta, apenas é e obrigatoriamente a sua definição e a implementação de ser feita na classe derivada.
Podem existir interfaces, usando a expressão interface
Todas as interfaces são publicas, os seus métodos não têm implementação, mas quem faz uso de uma interface tem que implementar as funcionalidades dos métodos.
Podem também tratar das excepções usando as expressões:
try
catch
finally
throw
Livro: A History of Videogames
Mais um livro que gostava de ter acesso:
A History of Videogames, de Iain Simons, James Newman, e Ian Livingstone
+infos(comprar): LINK
A história acerca da pirataria dos videojogos no Brasil
Uma história acerca da pirataria dos videojogos no Brasil. São três episódios:
Episódio 1 – Arcades Improvisados
“Com as máquinas de pinball da Taito, a indústria dos games no Brasil teve seu começo nas lojas sujas do centro de São Paulo e nas fábricas poluídas do Amazonas. Isso marcou o início de uma cultura gamer recheada de adaptações e clones nacionais muitas vezes criados às margens da lei.”
Episódio 2 – Consoles e jogos nacionais
“O Brasil passa a ter não só um mercado estável, mas também os primeiros jogadores. O lance é que grandes empresas, como a Nintendo, não estavam oficialmente no país. Então, alguns empreendedores começaram a criar os primeiros emuladores: produtos nacionais que eram adaptações de games e consoles populares. Como o Master System, da TecToy, e o Phantom System, da Gradiente.”
Episódio 3 – Modificações e o começo do eSports
“Na virada dos anos 2000, com os cartuchos dando lugar aos CDs e DVDs, a cultura de games no Brasil teve uma febre modder. Patchs de jogos mainstream como Winning Eleven (PlayStation 2) e Counter-Strike (PC) eram mais populares que os games originais, fazendo empresas como Microsoft e Sony finalmente chegarem oficialmente ao país. Também foi o começo da cultura de eSports no Brasil.”
+infos(fonte): LINK , pela RedBull