Criando serve de dofus !!

**mouraneto14** · 27 de Fevereiro 2010

Em primeiro lugar, devemos saber que o emulador está longe de estar completo ainda, e que o projeto continua, e os movimentos do dia-a-dia Smile

Além disso, este pacote é apenas uma demonstração dos antepassados emulador.

Assim, não haverá lotes de pouco uso e área de acesso não é grande.

Você vai precisar de:

O pack-Ancestrais envolvendo o emulador e banco de dados >>

É necessário se cadastrar para acessar o conteúdo.

<<<

Wamp --

-Navicat (para MySQL)

Versão mais recente do Java JRE

Primeiro passo: extrair os arquivos. :

\"Vá para o local onde pretende instalar o servidor (por exemplo C: \\ servtuto) então você vai criar um servtuto pasta (por exemplo) e arrastar os arquivos do rar para extraí-los.

Isso faz com que os arquivos que compõem o seu servidor (com ou sem fontes para criar um servidor, ele não é importante.).

Segundo passo: criar o banco de dados. :

-Agora abre Navicat. Clique em Arquivo -> New Connection.

Login name: O nome do seu servidor

Nome do host: localhost (por um lado, o princípio de que o servidor vai estar na máquina onde você está agora.)

Porto: 3306

Nome de usuário: seu nome de usuário (por padrão com Wamp: root)

password: a senha padrão (com Wamp: sem senha).

Assim você cria a conexão com o servidor SQL. Mas está vazio! Vamos consertá-lo.

Entrar para sua nova conexão (duplo clique sobre o nome), há uma espécie de raio verde e não vermelho com o nome do seu servidor.

Clique direito sobre essa conexão-> execute sql -> procurar. Vá para o local do seu servidor no create_databases.sql SQL SELECT

Ancestra_other duplo clique, em seguida, quando o ícone ao lado Ancestra_other é verde, botão direito do mouse ancestra_other fez executar o arquivo sql, Percorrer:

Vá para a pasta do seu servidor criado anteriormente arquivo SQL. Ancestra_other.sql você selecionar e pressione Start fechar prima, uma vez terminado, nós passamos o segundo banco de dados e final.

Em seguida, clique duas vezes ancestra_static, então, quando o ícone ao lado Ancestra_static é verde, botão direito do mouse ancestra_static fez executar o arquivo sql, Percorrer:

Vá para a pasta do seu servidor criado anteriormente arquivo SQL. Ancestra_static.sql você selecionar e pressione Start fechar prima, uma vez terminado, nós passamos o segundo banco de dados e final.

Isso faz com que seu DB está operacional.

Terceiro Passo: Configure. :

Vá para a pasta Core, abra o config.txt com o bloco de notas.

Em geral host_ip configuração alterar = (seu IP da Internet aqui, assim que se localmente: 127.0.0.1, se você usar o Hamachi, colocar o seu ip hamachi)

MOTD mudar se quiser, que é a mensagem pouco vermelho (ou outra cor, editável), que aparece na conexão.

Configurando o banco de dados

DB_HOST = 127.0.0.1 (ou localhost é o mesmo)

DB_USER = seu nome de usuário selecionado Navicat

DB_PASS = senha escolhida Navicat

STATIC_DB_NAME = ancestra_static

Outro_bd ancestra_other =

Na configuração GamePlay você pode mudar várias coisas no jogo, eu deixo você tentar.

(Não se esqueça de deixar um espaço depois do =)

Para jogar, você deve editar o config.xml localizado na pasta do dofus (geralmente C: \\ Program Files \\ Dofus). aberto com o botão direito -> Bloco de notas ou com o botão direito -> Editar.

Alterar como segue:

[esconder] <config>

name=\"En <conf ligne\">

name=\"Nom <connserver seu IP/No-IP/Ip-Hamachi/127.0.0.1 serveur\" ip=\"Votre testar em local\" port=\"444\" />

<dataserver url=\"

É necessário se cadastrar para acessar o conteúdo.

priority=\"3\" />

<dataserver url=\"

É necessário se cadastrar para acessar o conteúdo.

priority=\"0\" />

</ Conf>

</ CacheAsBitmap>

</ Config> [/ hide]

O IP é especificado na linha do config.txt host_ip.

A porta especificada é a linha do config.txt REALM_PORT.

Esta config.xml será o mesmo que você vai dar os seus jogadores para que eles se conectam.

Finalmente rumamos para o arquivo de núcleo, lança start.bat certificando wamp e serviço MySQL é iniciado.

Pra quem quer criar uma emulador

Então você decidiu escrever um software de emulador? Muito bem,

pois este documento responde às perguntas técnicas comuns sobre

como escrever emuladores, podendo assim lhe ajudar em algo.

O que pode ser emulado?

O que é "emulação" e o que a difere de "simulação"?

É legal emular o hardware de um proprietário?

O que é "interpretar o emulador" e o que o difere de

"recompilar o emulador"?

Eu desejo escrever um emulador. Por onde devo começar?

Que linguagem de programação eu devo usar?

Onde eu obtenho informações do hardware a ser emulado?

Como eu emulo uma CPU?

Como eu optimizo meu código C?

O resto está por vir...

# O que pode ser emulado?

Basicamente qualquer coisa que tenha um microprocessador dentro.

Certamente, os dispositivos mais interessantes para se emular são

os que funcionam com mais ou menos flexibilidade. Incuindo:

Computadores

Calculadoras

Consoles de Videogames

Arcades de Videogames

etc.

É sempre bom lembrar que você pode emular qualquer sistema de

computador, mesmo os mais complexos ( como o computador Commodore

Amiga, por exemplo). Porém, nestes casos a performance da emulação

pode ser muito baixa.

# O que é "emulação" e o que a difere de "simulação"?

Emulação é a tentativa de imitar o desenho interior de um

dispositivo. Simulação é a tentativa de imitar as funções de um

dispositivo. Exemplos: um programa que imita o hardware do arcade

de Pacman para rodar a verdadeira ROM de Pacman é um emulador. O

jogo do Pacman escrito para um computador usar gráficos parecidos

com o real arcade é um simulador.

# É legal emular o hardware de um proprietário?

Embora muitos digam o contrário, ao que me parece é legal emular o

hardware de um proprietário, se as informações dele não forem

obtidas por meios ilegais. Você deve estar atento ao fato de que é

ilegal distribuir ROMs de sistema ( BIOS, etc. ) com emulador, se

este estiver em estado "copyrighted" (cópia registrada).

# O que é "interpretar o emulador" e o que o difere de "recompilar

o emulador"?

Há três esquemas básicos que podem ser utilizados por um emulador.

Eles podem ser combinados para se obter um melhor resultado.

Interpretação

O emulador lê o código emulado da memória byte-por-byte, o

decodifica e desempenha os comandos apropriados nos registros

emulados, memória, e I/O. O algoritimo geral de tal emulador é o

seguinte:

while(CPUIsRunning)

{

Fetch OpCode

Interpret OpCode

}

O melhor deste código é a facilidade do debug, portabilidade

e sincronização ( você pode simplesmente contar os ciclos que o

relógio faz e dar descanso à emulação por conta do ciclo ). O

simples, grande e óbvio problema é a performance. A interpretação

toma muito de tempo da CPU, e você pode precisar de um computador

rápido para rodar seu código numa velocidade decente.

Recompilação Estática

Nesta técnica, você pega o programa escrito no código emulado

e tenta traduzí-lo para o código de montagem (código assembly) de

seu computador. O resultado será um usual arquivo executável que

você poderá rodar no seu computador sem nenhuma outra ferramenta

especial.

Apesar de recompilação estática soar bem melhor, nem sempre

ela será possível. Por exemplo, você não pode recompilar

estaticamente um código auto-modificado (self-modifying), pois não

existe jeito de faze-lô rodar. Para evitar tais situações, você

pode tentar combinar a recompilação estática com a interpretação

ou recompilação dinâmica.

Recompilação Dinâmica

A recompilação dinâmica é essencialmente a mesma coisa que

a estática, a diferença é que ocorre durante execução do programa.

Ao invés de tentar recompilar todo o código em uma só vez, você

vai aonde quer com as instruções CALL ou JUMP.

Para aumentar a velocidade, esta técnica deve ser combinada com a

recompilação estática. Você pode ler mais sobre a recompilação

dinâmica no white paper (papel branco), por Ardi, criadores da

recompilação do emulador de Macintosh.

# Eu desejo escrever um emulador. Por onde devo começar?

Para escrever um emulador, você deve ter um bom conhecimento geral

de programação de computadores e de eletrônica digital. Alguma

experiência em programação em assembly lhe dará uma boa mão.

1.Escolha uma linguagem de programação para usar.

2.Ache toda informação disponível sobre o hardware a ser emulado.

3.Escreva a emulação da CPU ou obtenha o código real da emulação

da CPU.

4.Faça algum esboço do código para emular o descanso do hardware,

ao menos parcialmente.

5.Agora, será muito útil escrever um pequeno debugger embutido,

que permita parar a emulação e ver o que o programa está

fazendo. Talvez você precise de um disassembler da emulação da

linguagem do sistema assembly. Escreva o seu próprio se não

exitir um destes.

6.Tente rodar programas no seu emulador.

7.Use o disassembler e o debugger para ver que programas usam o

hardware e ajuste seu código apropriadamente.

# Que linguagem de programação eu devo usar?

As alternativas mais óbvias são C e Assembly. Aqui estão os prós e

contras de cada uma delas:

Assembly

+ Geralmente permite produzir um código rápido.

+ Os registros emulados da CPU podem ser utilizados para

armazenar diretamente os registros da CPU emulada.

+ Muitos opcodes podem ser emulados com os opcodes similares

à CPU emulada.

- O código não é portátil, ou seja, não será possível rodá-lo

num computador com arquitetura diferente.

- É difícil o debug e a manutenção do código.

C

+ O código pode se tornar portátil se trabalhar em sistemas

operacionais e computadores diferentes.

+ É relativelmente fácil o debug e a manutenção do código.

+ As diferentes hipóteses de como trabalha o hardware real

podem ser testadas rapidamente.

- C é, geralmente, mais lento que o código assembly puro.

Bom conhecimento da linguagem escolhida é absolutamente necessário

para se escrever um emulador que funcione, assim como, num projeto

complexo como este, o código deveria ser optimizado para poder

rodar o mais rápido possível.

Emulação de computadores definitivamente não é um dos projetos em

que você possa aprender uma linguagem de programação.

# Onde eu obtenho informações do hardware a ser emulado?

A seguir há uma lista de lugares onde você pode achar o que quer.

NEWSGROUPS (Grupos de Notícias)

comp.emulators.misc

Este é um grupo de notícias de discussão geral sobre emulação

de computadores. Muitos autores do emuladores lêem ele, embora o

nível de barulho seja muito alto.

comp.emulators.game-consoles

O mesmo que o comp.emulators.misc, só que mais especificado

na emulação de consoles de videogames.

comp.sys./emulated-system/

A hierarquia comp.sys.* contém grupos de notícias dedicados à

computadores específicos. Você pode obter muita informação técnica

útil na leitura desses grupos. Exemplos típicos:

comp.sys.msx Computadores MSX/MSX2/MSX2+/TurboR

comp.sys.sinclair Sinclair ZX80/ZX81/ZXSpectrum/QL

comp.sys.apple2 Apple ][

etc.

Por favor, cheque sempre as FAQS apropriadas

antes de postar em qualquer grupo.

alt.folklore.computers

rec.games.video.classic

FTP

Oulu

É necessário se cadastrar para acessar o conteúdo.

WWW

Emulation Programmers Resource

É necessário se cadastrar para acessar o conteúdo.

Emulation (emulação de macintosh)

É necessário se cadastrar para acessar o conteúdo.

Programmer Heaven

É necessário se cadastrar para acessar o conteúdo.

Komkon

É necessário se cadastrar para acessar o conteúdo.

FAQ

Dê uma olhada nos sites (WWW) e nos grupos de notícias

# Como eu emulo uma CPU?

Antes de tudo, se você apenas necessitar emular o padrão Z80 ou a

CPU 6502, você deverá usar um dos emuladores de CPU que eu já

citei. Devem ser aplicadas certas condições para seu uso correto.

Para que deseja escrever seu próprio código de emulação de CPU ou

está interessado em saber como ele trabalha, eu forneço o código

básico de um emulador de CPU típico em linguagem C, logo abaixo.

Para o seu próprio emulador, você pode querer retirar algumas

partes ou adicionar outras para personalizá-lo.

Counter=InterruptPeriod;

PC=InitialPC;

for(;;)

{

OpCode=Memory[PC++];

Counter-=Cycles[OpCode];

switch(OpCode)

{

case OpCode1:

case OpCode2:

...

}

if(Counter<=0) {

/* checa por interrupções e faz outra emulação do hardware */

...

counter+="InterruptPeriod;"

if(exitrequired) break;

}

Primeiro, nós designamos os valores iniciais ao contador de ciclo

da CPU (Counter) e ao contador do programa (PC):

Counter=InterruptPeriod;

PC=InitialPC;

O contador contém o número de ciclos que a CPU deixa à próxima -

suspeitada - interrupção. Note que a interrupção não deve ocorrer

necessariamente quando o contador expirar: você pode usar isto

para muitos outros propósitos, tal como sincronizar timers, ou

atualizar os scanlines da tela. Mais deixe isto pra mais tarde. O

PC contém uma memória endereçada, que a nossa CPU emulada lerá no

seu próximo opcode.

Depois que os valores iniciais são designados, nós iniciamos o

loop principal:

for(;;)

{

Note que este loop também pode ser implementado com:

while(CPUIsRunning)

{

Aqui, CPUIsRunning é uma variável boolean. Ela tem suas vantagens,

como a de você poder terminar o loop a qualquer momento, setando

CPUIsRunning=0. Infelizmente, checando esta variável toda vez que

ela passar, tomará muito de tempo da CPU. Seria bom que você a

evita-se quando possível, porém, não implemente este loop com:

while(1)

{

Porque, neste caso, alguns compiladores gerarão um código checando

se 1 é verdadeiro ou não. Você certamente não deseja um compilador

fazendo um trabalho desnecessário em toda passagem de um loop.

Agora nós estamos no loop, e a primeira coisa será ler o próximo

opcode, que modifica o contador de programa:

OpCode=Memory[PC++];

Este é o caminho mais simples e rápido para ler a memória emulada,

porém, ela não será possível pelas seguintes razões:

× Memória pode ser fragmentada dentro das páginas de switch

(bancos aka)

× Lá podem ser mapeadas a memória dos dispositivos I/O do sistema

Nestes casos, nós podemos ler a memória emulada pela função

ReadMemory():

OpCode=ReadMemory(PC++);

Geralmente a função WriteMemory() serve para escrever na memória

emulada. Além disso, se tratando de memória I/O mapeada e páginas,

o WriteMemory() pode fazer também o seguinte:

Protejer a ROM contra modificações

Alguns softwares baseados em cartuchos (tais como os jogos de

MSX, por exemplo) tentam escrever na pópria ROM e se recusam a

trabalhar se são bem sucedidos. Isto é freqüentemente feito para

se protejer a cópia.

Manejar a memória espelhada (mirrored memory)

Uma área de memória pode ser acessível de vários endereços

diferentes. Por exemplo, os dados que você escreve dentro

localização $4000 também pode aparecer em $6000 e $8000. Esta

situação pode ser resolvida com o uso do ReadMemory(), mas,

usualmente, ela não é desejável, já que o ReadMemory() obtêm uma

chamada/call muito mais freqüente que com o WriteMemory().

Portanto, o caminho mais eficiente deve ser implementar a memória

espelhando na função WriteMemory().

As funções ReadMemory()/WriteMemory() dão muita sobrecarga na

emulação, sendo que seu dever é a deixar mais eficiente possível,

porque elas obterão chamadas/calls muito freqüentemente. Aqui vai

um exemplo destas funções:

leitura da memória (ReadMemory) do byte em inline estático

(registra o endereço da palavra):

{

return(MemoryPage[Address>>13][Address&0x1FFF]);

}

leitura da memória (ReadMemory) vazia em inline estático

(registra o endereço da palavra e o valor do byte):

{

MemoryPage[Address>>13][Address&0x1FFF]=Value;

}

Note a palavra-chave inline. Ela contará com um compilador para

embutir a função dentro do código, ao invés de fabricar uma

chamada/call para isto.

Se seu compilador não suportar inline ou _inline, tente fabricar

uma função estática: alguns compiladores (WatcomC, por exemplo)

optimizam funções estáticas curtas por inlining.

Também, lembre-se de que na maioria dos casos, o ReadMemory() será

chamado muitas vezes mais freqüentemente que o WriteMemory().

Portanto, isto estará valendo para implementar um código maior no

WriteMemory(), guardando ReadMemory() para os mais simples e curto

possíveis.

Depois que trouxer o opcode nós diminuímos o contador de ciclos da

CPU pelo número de ciclos requeridos por este opcode:

Counter-=Cycles[OpCode];

A tabela Cycles[] deverá conter o número de ciclos da CPU para

cada opcode. Tome cuidado, pois alguns opcodes (tal como jumps

condicionais ou chamadas/calls do subrotina) podem tomam um número

diferente de ciclos dependendo de seus argumentos. Isto pode ser

ajustado mais tarde, com outro código.

Agora está na hora de interpretar o opcode e executá-lo:

switch(OpCode)

{

É comum ter a concepção de que a construção de um switch() é

ineficiente para compilar numa cadeia de declarações if() ...

else if() ... Enquanto isso é verdadeiro para construções com um

pequeno número de casos, as grandes construções ( 100-200 ou mais

casos ) sempre parecem compilar dentro uma tabela de jumps,

deixando eles completamente eficientes.

Há dois caminhos alternativos para se interpretar os opcodes.

O primeiro vai fazer uma tabela de funções e chamar a mais

apropriada. Este método aparece ser menos eficiente que o switch()

pois você irá receber uma sobrecarga de funções de chamada/call.

O segundo método é fazer uma tabela de labels, e usar a declaração

do goto. Enquanto este método é ligeiramente mais rápido que o

switch(), ele trabalhará unicamente nos compiladores que suportam

"precomputed labels" (labels pré computadas). Outros compiladores

não permitirão que você crie um arranjo de endereços de labels.

Depois da bem sucedida interpretação e execução dum opcode, é

chegada a hora de checar se é necessária alguma interrupção. Neste

momento, você também pode desempenhar quaisquer tarefas que

necessitam ser sincronizadas com o relógio do sistema:

if(Counter<=0)

{

/* checa por interrupções e faz outra emulação de hardware */

...

counter+="InterruptPeriod;"

if(exitrequired) break;

}

A seguir, uma lista curta de coisas que você pode fazer com a

declaração if():

Checar se o fim da tela é alcançado e gerar uma interrupção

VBlank se assim

Checar se o fim do scanline é alcançado e gerar uma interrupção

HBlank se assim

Checar por uma colisão de sprites, e gerar uma interrução, se

necessário

Atualizar os timers da emulação de hardware, gerar uma

interrupção se os timers expirarem

Refrescar a amostra/display de scanline

Refrescar o modo tela inteira

Atualizar som

Ler o estado do teclado/joysticks

etc.

Cuidadosamente calcule o número de ciclos que a CPU necessita para

cada tarefa, então use o menor número no InterruptPeriod, e junte

todas as outras tarefas nele ( elas não devem necessariamente

executar em toda expiração do contador ).

Note que nós não apenas designamos Contador=InterruptPeriod, mas

fizemos um Counter+=InterruptPeriod: ele fará o contador de ciclos

mais preciso, mesmo usando números negativos.

Também dê uma olhada na linha

if(ExitRequired) break;

Como fica muito custoso checar a saída em toda passagem do loop,

nós fazemos isto unicamente quando o Contador expirar: ele apenas

sairá da emulação quando você atribuir ExitRequired=1, não tomando

muito tempo da CPU.

Isto é tudo que eu tenho a dizer sobre emulação de CPU em C.

Você deve ser capaz de imaginar quanto trabalho eu lhe

economizei.

GahFoeger · 28 de Fevereiro 2010

Niiiice

Bom Dia/Noite/Tarde/Madruga '-', tanto faz

pois e meu amigo, ja li esse topico em vaaarios lugares, porem naum consegui executa-lo, se voce conseguiu, por favor, add msn [email protected] e se for possivel, me ensina, se eu aprender, vc vai ter um sv de dofus para jogar 24 hrs, e como seu port foi as 2:50 parece q tu gosta de madrugar ;D, vlw ai brow, plz respostas

ﾠﾠMural de Coleçõesﾠﾠ · 27 de Março 2010

MOURA QUERO SER GM DO LINOS ME AVISA SE ACC MSN [email protected] email e igual

cheats0909 · 15 de Maio 2010

Editor de mapas do Dofus

[Wakfu = Dofus]

Eu estava vagando pela net:rolleyes: e encontrei imagens do que seria o Editor de mapas do Dofus chamado "wakfu map editor" no site:

É necessário se cadastrar para acessar o conteúdo.

possui divugação e comentarios sobre ele...

Cada vez começa a ser desenvolvido para muitos jogadores um dofus free...

:)

Bem eu nao encontrei para dowload entao resolvi postar esse comentario para a tuma que vem ler ajudar a procurar-lo.

Entrar

Criando serve de dofus !!

Posts Recomendados

mouraneto14 1

Link para o comentário

Compartilhar em outros sites

GahFoeger 0

Link para o comentário

Compartilhar em outros sites

190353 0

Link para o comentário

Compartilhar em outros sites

cheats0909 3

Link para o comentário

Compartilhar em outros sites

Fóruns

Todas Atividades

Lojinha WC

Informação Importante