|
Contest powered by:
Contest Burner
Músicas em Jogos (6) Fallout: New Vegas – Big Iron on His Hip
Jogo: Fallout: new Vegas
Período: de 1997 até hoje.
Plataforma: PC.
Ambiente: Offline.
Estilo: RPG.
Site oficial: Fallout: New Vegas
Wikipedia: http://en.wikipedia.org/wiki/Fallout_%28video_game%29
To the town of Agua Fria rode a stranger one fine day
Hardly spoke to folks around him didn’t have too much to say
No one dared to ask his business no one dared to make a slip
for the stranger there among them had a big iron on his hip
Big iron on his hip
It was early in the morning when he rode into the town
He came riding from the south side slowly lookin’ all around
He’s an outlaw loose and running came the whisper from each lip
And he’s here to do some business with the big iron on his hip
big iron on his hip
In this town there lived an outlaw by the name of Texas Red
Many men had tried to take him and that many men were dead
He was vicious and a killer though a youth of twenty four
And the notches on his pistol numbered one an nineteen more
One and nineteen more
Now the stranger started talking made it plain to folks around
Was an Arizona ranger wouldn’t be too long in town
He came here to take an outlaw back alive or maybe dead
And he said it didn’t matter he was after Texas Red
After Texas Red
Wasn’t long before the story was relayed to Texas Red
But the outlaw didn’t worry men that tried before were dead
Twenty men had tried to take him twenty men had made a slip
Twenty one would be the ranger with the big iron on his hip
Big iron on his hip
The morning passed so quickly it was time for them to meet
It was twenty past eleven when they walked out in the street
Folks were watching from the windows every-body held their breath
They knew this handsome ranger was about to meet his death
About to meet his death
There was forty feet between them when they stopped to make their play
And the swiftness of the ranger is still talked about today
Texas Red had not cleared leather fore a bullet fairly ripped
And the ranger’s aim was deadly with the big iron on his hip
Big iron on his hip
It was over in a moment and the folks had gathered round
There before them lay the body of the outlaw on the ground
Oh he might have went on living but he made one fatal slip
When he tried to match the ranger with the big iron on his hip
Big iron on his hip
Palestras (33 Berkeley) CS61B – Estrutura de Dados Usando Java – Aula 13 (Java Packages) | Programação
Por Daniel
Nesta aula, o professor Jonathan Shewchuck fala a respeito de:
- Java.lang;
- Comparable;
- Nukeable.java;
- SList.class;
- Nukeable.class;
- Classe Arrays em java.util;
- Uma interface pode ter múltiplas subinterfaces, com múltiplas subinterfaces;
- Java Packages: coleção de classes, java interfaces e subpacotes (subpackages) -> confiam uma na outra.
- Vantagens dos packages: 1 – contém classes escondidas, utilizadas por ele, mas invisíveis fora dele; 2 – Classes podem ter campos e métodos invisíveis fora do pacote; 3 – Pacotes diferentes podem ter classes om o mesmo nome.
- Duas classes com o mesmo nome no mesmo programa;
- java.awt.Frame;
- java.io;
- java.lang;
- Uso de packages;
- Fully qualified name, ex: java.lang.System.out.println(“blah”);
- Import;
- Todo programa java implicitamente importa java.lang;
- x.y.z.Class -> x/y/z/Class.class
- Em Unix -> classpath -> % printenv CLASSPATH -> . :/home/ff/csb1b/lib/ucb.jar(…);
- Construindo pacotes;
- Proteção de pacote – package protection: default;
- Package protection: mais protegido que protected e menos que private;
- A Classe ou Variável com proteção de pacote é visível em qualquer classe no mesmo pacote, mas não fora do pacote(arquivos fora do diretório);
- Classes de pacte podem aparecer em qualqur arquivo *.java.
- Compilando e rodando: devem ser feitos fora do pacote;
- Quatro níveis de proteção: public, protected, package e private;
| Visível | No mesmo pacote | Na subclasse | Em qualquer parte |
| Public | x | x | x |
| Protected | x | x | |
| Package | x | ||
| Private |
public interface Nukeable { //Nukeable.java public void nuke(); // São métodos abstratos se dentro de interfaces; } public interface Comparable { //em java.lang; public int compareTo(Object o); // São métodos abstratos se dentro de interfaces; } public class SList extendes List implements Nukeable, Comparable { } public void nuke() { head = null; size = 0; } public int compareTo(Object o) { } Nukeable n = new SList(); Comparable c = (Comparable) n; //Nem todo Nukeable é um Comparable; n.nuke(); if(c.compareTo(c2) > 0) { } public static void sort(Object[] a) // RUN-TIME ERROR se qualquer dos itens não for Comparable; public interface NukeAndCompare extendes Nukeable, Compare { } import java.io.File; //permite fazer referência a File import java.io.*; // refere-se a tudo dentro de java.io java.awt.Frame.add(photo.Frame.canvas); //dentro do diretório photo/Frame.class list/Slist.java package list; public class SList { sListNode head; int size; } list/SlistNode.java package list; class SlistNode //Proteção não especificada { Object item; SListNode next; } javac -g */*.java javac -g list/*.java heap/*.java *.java javac -g lis/SList.java java list.SList
Palestras (32 Berkeley) CS61B – Estrutura de Dados Usando Java – Aula 12 (Classes Abstratas) | Programação
Por Daniel
Nesta aula, o professor Jonathan Schewchuk fala sobre:
- Sutilezas das heranças;
- COMPILE-TIME ERROR;
- RUN-TIME ERROR;
- Nem toda SList tem um método eatList(): Java não pode utilizar dynamic method lookup em S.
- Casts: mudam o tipo static de uma expressão;
- Classes abstratas: único propósito é ser extendida -> sem implementação especificada;
- Métodos abstratos não possuem imlementação;
- Uma Classe não abstrata jamais deve conter um método abstrato, ou herdar um, sem prover uma implementação;
- ADT;
- Um list sorter pode funcionar em todo tipo de lista;
- Subclasses de List;
- TimedList: grava o tempo gasto fazendo operações na lista;
- TransactionList: loga toda as mudanças no disco em caso de queda de energia;
- Aplicação escolhe que tipo de lista deseja utilizar;
- instanceof: diz se Objeto é de uma classe específica
- Interfaces = protótipos e comportamentos de métodos públicos;
- Interfaces Java: palavra-chave em “interface”;
- Uma interface Java é como uma classe abstrata, mas com diferenças: 1 – uma classe pode herdar de apenas uma classe (Java não permite herança múltipla, mas apenas implementar(herdar de) múltiplas interfaces); 2 – Uma interface Java não pode: implementar métodos, incluir campos (excessão: constantes static final) -> apenas contém protótipos de métodos e constantes.
//Novo método em TailList chamado eatList() TailList t = new TailList(); t.eatList(); SList s new TailList(); S.eatList(); // Não funciona = COMPILE-TIME ERROR SList s; TailList t = new TailLiss(): s = t; t = s; //COMPILE-TIME ERROR t = (TailList) s; s = new SList(); int x = t.nth(1).intValue(); //COMPILE-TIME ERROR; int y = ((Integer)t.nth(1)).intValue(); // Faz o cast primeiro String z = t.nth(1).toString(); t = (TailList) s; // RUN-TIME ERROR if(s instanceof TailList) // Falso de s for null ou não referenciar um TailList ou subsclasse de TailList { t = (TailList) s; } public abstract class List { protected int size; public int length() { return size; } public abstract void insertFront(Object item); } List myList; myLyst = new List(); //COMPILE-TIME ERROR; public class SList extends List { //herda o campo size; protected SListNode head; //herda o método length(); //Sem "abstract", já que haverá implementação public void insertFront(Object item) { head = new SListNode(item, head); size++; } } List myList = new SList(); myList.insertFront(obj); public void listSort(list l) { ... }
Palestras (31 Berkeley) CS61B – Estrutura de Dados Usando Java – Aula 11 (Heranças) | Programação
Por Daniel
Nesta aula, o professor de Berkeley Jonathan Schewchuk fala a respeito de:
- Inheritance (herança): campos,
- “extends”;
- TailList é uma subclasse de SList;
- SList é a superclasse de TailList;
- Uma subclasse pode modificar uma superclasse de 3 maneiras: pode declarar novos campos; pode declarar novos métodos; e pode substituir velhos métodos por novas implementações.
- Heranças e construtores;
- Invocar métodos sobrescritos;
- “Protected” -> nível entre public e private: campos e métodos (visivel para a classe e subclasses);
- Private não é visível para subclasses;
- Hierarquia de classes;
- Dynamic method lookup: toda TailList é uma SList;
- Tipo static é apenas o tipo que você designou quando declarou, mas o tipo dynamic é classe do objeto que a classe referencia;
- Quando um método sobrescrito é invocado, o Java chama o método para o tipo dynamic, independentemente do tipo static.
public class tailList extends SList { /* head and size inherited from SList */ private SListNode tail; public void InsertEnd(object obj) { //Nova implementação que substitiu a antiga } } public TailList() { //Default: SList () sets size = 0, head = null; tail = null; } //Para sobrescrever public TailList(int x) { super(x); //Vira o primeiro dado recebido pelo construtor; tail = null; } public void insertFront(object obj) { super.insertFront(obj); if(size == 1) { tail = head; } } public class SList { protected SListNode head; protected int size; } SList s = new TailList(); TailList t = new SList(); //Não necessariamente, podem haver COMPILE TIME ERROS SList s = new TailList(); s.insertEnd(obj); // Chama o método TailList.insertEnd(); s = new SList(); s.insertEnd(obj); //Chama SList.insertEnd();
Palestras (30 Berkeley) CS61B – Estrutura de Dados Usando Java – Aula 10 (Teste de Códigos) | Programação
Por Daniel Cardoso Tavares
Neste vídeo, o professor Jonathan Schewchuk, da Universidade da Califórnia,. Berkeley, falará sobre:
- Método equals(): todo classe possui um; default: r1.equals(r2) -> testa se apontam para o mesmo objeto; comparam o conteúdo;
- 4 graus de igualdade: igualdade de referência (== na referência); igualdade estrutural superficial(verifica o conteúdo); igualdade estrutural profunda (campos são igual de acordo com equals()); igualdade lógica (ponto de vista matemático. Ex: 1/3 == 2/6).
- cada equals() é diferente em classes distintas;
- Teste de código: Teste modular, Teste de integração e verificação de resultado;
- Teste modular: test drivers, colocados em main() (verificam se seu código faz sentido pelos resultados) e stubs (bits de código chamados pelo código sendo testado -> preenche o espaço de um método ainda não implementado; determina se o bug está no método de chamada ou no chamado; produz informações de teste que subrotinas reais nunca/raramente trarão; permite repetir dados constantemente até verificar a fonte do bug);
- Teste de integração: objetivo -> Definir interfaces tão bem e sem ambiguidade quanto possível; Sem ambiguidades nas descrições dos comportamentos;
- Uso do debugger;
- Verificação do resultado: checagem da integridade da estrutura de dados (inspeciona a estrutura de dados e verifica se todos os invariants foram satisfeitos) e verificador de resultados do algoritmo(verificador se o resultado é o previsto);
- Assertion: código que testa uma invariant ou resultado;
- Ligando Assertions com: “java -ea” (java -ea SList);
- Desligando Assertions com: “java -da” (java -da SList);
- Teste de regressão: suite que pode ser rodado sucessivamente quando mudanças são feitas(ha maior quantidade de linhas de código para testes do que para o produto em si);
public class SList { public boolen equals(SList other) { if (size != other.size) { return false; } SListNode n1 = head; SListNode n2 = other.head; while(n1 != null) { if(!n1.item.equals(n2.item)) { return false; } n1 = n1.next; n2 = n2.next; } return true; } } public class MyProgram { public static void TestDriver() { //código de teste } } public class TestMyProgram { public static void main () { MyProgram.TestDriver(); } } assert (x == 3); //Imprime erro e dá crash quando falha. assert (list.size == list.countLength()): "Tamanho incorreto da SList: "+list.size;
Jogo Star Wars: Old Republic Chega a 1 Milhão de Jogadores em 3 Dias | Jogos
Por Daniel
Fonte: Gamasutra
O jogo Star Wars: Old Republic, MMORPG produzido pela BioWare e EA, conseguiu reunir mais de 1 milhão de usuários pagantes em apenas três dias. Este foi o jogo a mais rapidamente atingir tal marca.
De acordo com as informações oficiais, o tempo de jogo por usuário chega a 5 horas por dia, totalizando 28 milhões de horas de jogo no período (incluindo aqueles que, por conta de uma promoção, jogaram por 7 dias antes do lançamento).
Os produtores prometem que novos recursos serão lançados com frequência, a fim de manter constante o interesse dos jogadores.