[SUPER NINTENDO] Hilo oficial.

1, 2, 3, 4, 528
Alucinado me hallo. 7 planos de scroll tiene el juego :O ... no tenía ni idea.

cuando llegó la super nintendo a españa, lo hizo con 4 juegos, ¿alguien los recuerda?, ¿pueden ser el super soccer, super castlevania IV, super Probotector, y super tennis?.

A mi el SCIV es un juego que me fascina, porque tiene su base en la sencillez, son solo 8 megabits, y cuando no te andas por las ramas con filigranas (y no me refiero a los graficos), salen títulos muy solidos, y muy bien aprovechados. No tiene el mejor apartado sonoro, y en este sentido, el cartucho necesitaba mas megas, se nota, pero es la dirección artistica la que rompe moldes aquí, no el hardware de la snes... y con los graficos lo mismo, la paleta elegida es AUTENTICA con mayusculas. el feeling, el desarrollo de las fases, lo variado de estas y la cantidad de situaciones diferentes... hasta el mapa previo a las fases, con zoom incluido, es entrañable. Quizás sea la nostalgia, pero ya en su día destacaban esos detallitos que lo convertían en un juego muy "cuco". Con 32 megas les hubiera salido una bestia parda, como pocos cartuchos con esa capacidad han sabido dar la sensación en todo el catalogo de super nes.

...este está en el top 5 de TODO el mundo.
La verdad que es muy sorprendente el SCIV hay escenas que a cualquiera lo deja con la boca abierta,la fase que mas me impacto que me dejo la mandibula en el suelo,fue la de la lampara balanceandose,increiblemente increible.
Con permiso analizo unos de mis juegos preferidos de Snes
Demon's Creast

Imagen


COMPAÑÍA - Capcom
DESARROLLADOR - Capcom
GÉNERO - acción/aventura
MEGAS - 16
AÑO - 1994
DISTRIBUCIÓN -Mundial

Imagen

comienza la lucha por el poder de las gemas


Juego de acción lateral desarrollado por Capcom que se basa en el universo Ghost and Goblins.
Controlando a Firebrand ( Red Arremer en Japón)Phalanx deberemos obtener todas las crestas de los elementos para derrotar al malvado Phalanx ,un demonio sediento de poder.


Imagen

Phalanx y las Crestas


El juego se desarrolla en un gran mapa en el cual gracias las capacidad de firebrand de volar no permitirá movernos de una zona a otra.
Las codiciadas crestas nos darán nuevas habilidades y transformaciones ,asi podremos acceder a todas las zonas , aparte podremos mejorar a personaje con otros items como nuevos disparos,hechizos ,pociones ect.

Gráficamente el juego es sobresaliente, la atmósfera esta muy lograda y recorreremos cada rincón del reino de los demonios,desde un cementerio hasta una bellisimo templo hundido, espectacular.
Y si visualmente es bonito ,en tema de sonido no se queda corto,las melodías son fantásticas y ambientan a la perfección logrando meternos aun mas en el juego.
Gracias al chip de sonido de la snes la calidad es bastante alta.

Un muestra de ello
http://www.youtube.com/watch?v=Y427A6PLIns

Imagen Imagen Imagen Imagen


Llegamos la parte mas importante ,la jugabilidad , el juego es bastante difícil (por lo menos mi me lo pareció) y puede que os cueste avanzar ,pero merece totalmente la pena intentarlo.

Es muy adictivo y siempre querrás ver mas y mas .
http://www.youtube.com/watch?v=g7GHP3B3-pU&feature=related


Mi valoración. 97/100 imprescindible

Pros:
    - excelente en el apartado técnico.
    - difícil pero muy jugable.
    - las diferentes transformaciones de firebrand.
    - su ambiente tétrico

Contras:
    - su dificultad puede suponer una traba.
    - adquirirlo en formato físico y en buen estado,prohibitivo .

Espero que os haya gustado, he copiado la plantilla que se ha utilizado en el analisis de contra 3 :p
Demon Crest es un juegazo,he jugado muy poco la verdad pero lo poco que he jugado es una maravilla.

PD Las review es mejor ponerlo cada 3 dias,ya se dijo.
Sin ánimo de menospreciar el trabajo de nadie, lo mas importante de una review, es el propio texto (no una colección de fotos, y un par comentarios). Todos los aportes son bienvenidos (y se agradecen, en serio), pero se corre el riesgo de que otra review mejor hecha acabe desplazando del índice a la anterior.

Evitemos que las reviews se conviertan en un album de fotos:
viewtopic.php?f=80&t=1413431&p=1719899989#p1719899989


...y otra cosa:

¿Que debo tener en cuenta a la hora de publicar Reviews?

Tan solo una serie de premisas para que el resto de usuarios que también trabajan para el hilo no vean pisado su trabajo:

    · Solo debe haber una review por página. Esto facilitará el debate, y no forzará el ritmo de publicación.
    · Al menos una diferencia de 3 días entre dos reviews. Si se amontonan, de poco servirá tener un índice en el primer post.
    · No mas de 4 imagenes por review (caratula + 3 imagenes). Es vital para centrar la redaccion en algo interesante que contar, y de paso no pecar de breve.
    · Las imágenes tendrán mas cohesión con la review si éstas exhiben todas un tamaño identico. Si entra por los ojos, interesará mas su lectura.
    · Es aconsejable no publicar imágenes que superen los 20/25 KBytes, por lo tanto se recomienda no usar fotos con una resolución mayor que 256x256 o similar, para que la calidad sea buena.
    · No incluir spoilers, ni siquiera usando su correspondiente comando para ocultarlos. Seguro que hay muchas cosas que contar, a parte de las que no se quiere que se cuenten.
O´Neill escribió:buen analisis, vaya inicio tubo la snes, super probotector+castlevania+mario world=viciada para muchos meses XD


Cierto, la snes ha sido la consola que mejores juegos ha sacado en el lanzamiento.

El hilo está quedando muy bien, ralph las fotos siempre vienen bien y hacen más ameno el análisis porque vas viendo parte de lo que se comenta.
racort escribió:El hilo está quedando muy bien, ralph las fotos siempre vienen bien y hacen más ameno el análisis porque vas viendo parte de lo que se comenta.


Si, y se agradece, como digo. Pero si mañana otro chaval analiza el mismo juego, sin escatimar palabras, obviamente tendremos un (bendito)problema.

No deseo que se me malinterprete, es un ratito de su tiempo que titorino nos ha dedicado a todos, y es muy de agradecer. Si todo el mundo se lavara las manos, el hilo se hundiría, y el esfuerzo de nadie serviría para nada. La historia es que no se muy bien como apañar dos veces la review del mismo juego en el índice... no quiero repetir el nombre dos veces, y tampoco poner dos links a su derecha. quizás la solución esté en crear yo otro post dentro del hilo, con un enlace a ambas reviews (en plan extendida, y un poco adornada), y enlazar ese (nuevo)post al índice.


...también quería comentar que la review anterior a la del demon's crest (SCIV), también le ha exigido un rato de su tiempo al autor, y no es plan de que nos pisemos las reviews. Dar un margen de tiempo entre review y review, aunque sea solo en señal de respeto al que (también)se molesta en colaborar, no está nada de más.


Yo, como me estoy dedicando a postear documentos tecnicos, voy un poco por libre(aunque aquellos que están muy cargados de imagenes, procuro dejarlos para las paginas vacías), pero en cuestión de reviews todos debemos pasar por ese aro, insisto. Está en el FAQ del post principal :)


...no es por tocar los webs, vaya.
La verdad que poco puedo opinar de los ultimos juegos comentados, porque salvo al contra,al resto no le he dedicado mucho tiempo.Los castlevanias nunca me han llamado la atencion y el demon crest me decepciono un pelin....pero bueno, sobre gustos.....

PD_me pido la review del Tales of phantasia [carcajad]
Para la siguiente pagina no pongais nada muy "cargado", que voy a meter un post MUY tocho, el que avisa no es traidor.

...y no, no es una review, estoy a otras cosas XD

EDIT: Añadida la demo del demon's crest.


Por cierto, quiero meter unos separadores en el post principal, ¿alguna sugerencia?.
Ese Demon's crest... juegazo, salió justo en la misma época del primer DKC, pero curiosamente no tuvo una gran distribución ni repercusión aún siendo una bestia parda de juego, no lo entiendo, tan pocas copias habían sacado para que sea uno de los más cotizados de SNES?

En cuanto al SCIV, totalmente de acuerdo, es un juegazo y creo que es un juego que a todos nos ha impactado.
Demon's Crest es uno de esos grandes desconocidos, sobretodo en la época, y que son títulos que todo el mundo debería probar. Juegazo sin duda
ImagenVolver a la página principal.



DOCUMENTACIÓN TÉCNICA: Ensamblador para 65816 (2ª parte)



Table of Contents:

    i Preface
    1.00 Introduction
    2.00 New 65816 Instructions
    3.00 65816 Native Mode Programming Model:
      3.01 · Native Mode Processor Status Register
    4.00 Native Mode Registers:
      4.01 · Accumulator
      4.02 · X,Y Index Registers
      4.03 · Direct Page Register (D)
      4.04 · Stack Pointer (S)
      4.05 · Program Bank Register (PBR)
      4.06 · Data Bank Register (DBR)
      4.07 · Status Register:
        4.07.1 · Emulation Bit E: Hidden Bit
        4.07.2 · Sixteen BIT User Registers
        4.07.3 · Index Register Select
        4.07.4 · Accumulator/Memory Select
      4.08 · Setting Status Register Bits
    5.00 65816 Emulation Mode Programming Model:
      5.01 · Emulation Mode Registers
    6.00 Relocating the Stack and Direct Page
    7.00 Addressing Modes:
      7.01 · New 65816 Specific Addressing Modes
      7.02 · Addressing Mode Descriptions

    8.00 Interrupts:
      8.01 · Hardware Vectors
    Appendix A: 65816 Instruction Set
    Appendix B: Composite Instruction List
    Appendix C: IC Pinouts

ImagenIr a la primera parte del artículo




===========
8.00 Interrupts
===========




There are some quirks to 65816 interrupts that you should consider. If you are going to be writing native 65816 code you should give some consideration to how your interrupt routine is going to be handled. If you have written custom a IRQ routine that assumes Native mode, then your considerations are minor. However, if you are writing Native mode 65816 code with 16 bit accumulator and/or 16 bit index registers, and you are using a stock kernal IRQ that assumes emulation mode, then you must do some coding to handle the discrepancies. In 6502 emulation mode, and IRQ pushes the program counter high, then pc low, and finally the status register on to the stack. When in Native mode an IRQ starts by stacking the following:

    Program Counter Bank (PBR)

    Program Counter High

    Program Counter Low

    Status Register

Next; the status register decimal mode bit (d) is cleared (setting binary mode), and the IRQ flag is set (non NMI only). Finally, the program bank (PBR) is set to zero and the 65816 jumps through the IRQ hardware vector.

The implications are that if the 65816 is running in emulation mode in a ram bank other than Bank zero, then the program bank is going to be lost (not good). There are two solutions to the problem. One is never to run in emulation mode outside of Ram Bank zero. Second; you could save off the current program bank value somewhere in Ram before running in emulation mode beyond Bank Zero.

One thing that is unclear at this point, is if the CMD Super CPU can even handle a Native Mode IRQ. Native Mode features a new hardware vector table:



8.01 Hardware Vectors:


Imagen



Notice that there is a separate BRK vector for Native mode, and no need to poll bit 5 for the brk flag. However when running in emulation mode, remember that bit 5 is still the BRK flag, and your IRQ will still need to check for the source of the IRQ.

While in Native mode, a BRK instruction is two bytes. The Zero BRK opcode followed by an optional "signature" byte. This way, you can detect what BRK caused the vector to be taken for multiple BRK's while debugging.

COP is for a coprocessor interrupt. (see the instruction COP)

Notice in Native mode where the IRQ vector destinations are...hmm

When an IRQ is triggered, the current instruction is completed before the interrupt is processed. This "interrupt latency" may be up to 7 clock cycles. If you are running a time critical IRQ you may want to examine the WAI:wait for interrupt instruction whereby you can stop the processor until and interrupt occurs.

The ABORT vector listed above is taken when the 65816's Abort pin is pulled low. This pin is only available on the 65816.




==========================
Appendix A: 65816 Instruction Set
==========================



Imagen

    n - negative.
    v - overflow.
    m - 8/16 memory/accumulator.
    x - 8/16 bit index registers.
    d - decimal mode.
    i - irq enable disable.
    z - zero result.
    c - carry.
    e - emulation.


ADC Add with carry.

When using 16 bit accumulator mode, as expected, a carry will be properly rolled over from bit 7 to bit 8 when generated by the operation. (ie: $FF+4 = $0103 with 1 in high byte an 3 in low byte of the accumulator.) Thus carry need only be cleared when the low order bytes are added. Manual checking for carry above bit 15 will still have to be done just as when in 8 bit accumulator mode.

When in 16 bit mode, the low-order bits are located in the effective address, and the high order bits are located in the effective address plus one.

Flags Altered nv----zc
    n Set if most-significant bit of result is set.
    v Set if signed overflow.
    z Set if result is zero.
    c Set if overflow.


Imagen



AND And Accumulator with Memory

Logically ANDs the data located at the effective address
specified by the operand and the accumulator.
If in 16 bit accumulator mode (m=0) Data ANDed from memory is
16 bits wide, the low byte is the effective address and the high
byte is the effective address+1.

Flags Altered n-----z-
    n Set if most significant bit of result is set.
    z Set if result of and is zero.


Imagen



ASL Arithmetic Shift Left

Shifts all bits left with most significant bit moving into the
carry flag. If in 16 bit accumulator mode (m=0), data shifted
is 16 bits.

Flags Altered n-----zc
    n Set if most significant bit of result is set.
    z Set if result is zero.
    c High bit (7 or 15) is moved into carry.


Imagen



Branching Instructions:


The following branch instructions work identically to a 6502 - therefore, no indepth discussion will be presented.
Branching commands do not affect any status register flags. The single byte operand range is +128 to -127.

    BCC Branch Carry Clear / alias BLT Branch Less Than.
    BCS Branch Carry Set / alias BGE Branch Greater Than or Equal.
    BEQ Branch Equal
    BNE Branch Not Equal
    BMI Branch Result Minus
    BPL Branch Result Positive
    BVC Branch Overflow Clear
    BVS Branch Overflow Set


Imagen


New Branch Instructions:


BRA Branch Always

Branch always takes the operand branch without regard for the current state of the status register. The single byte operand range is +128 to -127. This instruction and the following BRL instruction ease the task of writing relocatable code.

Imagen



BRL Branch Always Long

Same as BRA, but the operand is 2 bytes giving the instruction a 64k range. This instruction is similar to the JMP command, with the advantage being that JMP is and absolute address and BRL is a relative address.
No flags are affected.


Imagen



BIT Test Memory Bits against Accumulator

The 65816 provides 3 new addressing modes for the old standard BIT instruction. The only true difference is that when the processor is in 16 bit mode, the top two bits xfered to the status register will come from bits 14 and 15. When in 8 bit mode bits 6 and 7 are xfered to the status register.

Flags affected nv----z- (Other than immediate addressing).
    ------z- (Immediate addressing only).
    n Takes value of most significant bit of memory data.
    v Takes value from bit 6 or 14 of memory data.
    z Set if logical AND of mem and acc is zero.

Imagen



BRK Software Break

While in native 65816 mode, BRK is unaffected by the I interrupt disable flag. Additionally, you may now pass a one byte signature byte to indicate which BRK instruction caused the BRK to be preformed.
The new BRK handler includes a Hardware Vector- thus, it is no longer required to check for the BRK bit flag via the IRQ.

When a BRK is performed in 65816 Native mode:

    · the program counter bank register is pushed onto stack.
    · the program counter is incremented by two and pushed on the stack.
    · the status register is pushed onto the stack
    · the interrupt disable flag is set.
    · the decimal mode flag is cleared.
    · the program bank register is cleared to zero.
    · the program counter is loaded from the break vector at $FFE6-$FFE7.

While in 6502 emulation mode, (e=1) a BRK is preformed true to it's 6502 forerunner (b flag set, status pushed onto stack, SEI and IRQ performed.).

Imagen



Status Register Setting and Clearing:


The following status set and reset instructions operate the same in 65816 native mode and 6502 emulation mode.

    CLC Clear carry flag.
    CLD Clear decimal flag.
    CLI Clear interrupt flag.
    CLV Clear overflow flag.
    SEC Set carry flag.
    SED Set decimal flag.
    SEI Set interrupt flag.

Imagen



CMP Compare Accumulator with Memory

For the most part, this instruction works the same in 6502 emulation mode and 65816 mode.
While in 16 bit accumulator mode the low byte of the compare will come from the effective address and the high byte from the effective address plus one.

Flags Altered n-----zc
    n Set if most significant bit of result is set.
    z Set if result is zero.
    c Set if no borrow was required. Acc => memory.
    C=0 if borrow required Acc < memory.

Imagen


COP Coprocessor Empowerment

COP cause a software interrupt through a separate COP hardware vector. The vector is to be located at $FFF$-$FFF5. In 6502 emulation mode:

    · The program counter is incremented by 2 and pushed on stack.
    · The status register is pushed onto the stack.
    · The interrupt status bit is set.
    · The program counter is loaded with the hardware vector.
    · The decimal flag is cleared.

In Native mode:

    · The PC bank register is pushed onto stack.
    · The PC is incremented by two and pushed onto stack.
    · The status register is pushed onto stack.
    · The interrupt status flag is set.
    · The program bank register is cleared to zero.
    · The PC is loaded with the hardware vector.
    · The decimal flag is cleared after COP executed.

Flags Altered ----di--
    d decimal mode flag is reset to zero.
    i Interrupt disable is set.


Imagen



CPX Compare X Index register with Memory

CPX functions the same as a 6502. The only notable exception is to remember that when in 16 bit index register mode (x=0) that date/memory will be 16 bits wide. The low order byte will come from the the effect address and the high order byte from the effective address plus one.

Flags Altered n-----zc
    n Set if most significant bit of result is set.
    z Set if result is zero.
    c Set if no borrow was required ( X >= memory).
    Cleared if borrow required (X < memory).

Imagen



CPY Compare Y Index register with Memory

CPY functions the same as a 6502. The only notable exception is to remember that when in 16 bit index register mode (x=0) that date/memory will be 16 bits wide. The low order byte will come from the the effect address and the high order byte from the effective address plus one.

Flags Altered n-----zc
    n Set if most significant bit of result is set.
    z Set if result is zero.
    c Set if no borrow was required ( Y >= memory).
    Cleared if borrow required (Y < memory).


Imagen


DEC Decrement Memory

DEC also works nearly the same as a 6502 mode. When in 16 bit accumulator/memory mode (m=0) data altered will be 16 bits wide with automatic underflow from high byte to low byte. The low order byte will come from the the effect address and the high order byte from the effective address plus one.

Flags Altered n-----z-
    n Set if most significant bit of result is set.
    z Set if result is zero.


Imagen



DEX, DEY Decrement Index Registers

Both instructions operate just as a 6502. When in 16 bit index register mode, the register will be treated as 16 bits wide.

Flags Altered n-----z-
    n Set if most significant bit of result is set.
    z Set if result is zero.

Imagen



EOR Exclusive-OR Accumulator with Memory

Another instruction that operates just as a 6502, only new addressing modes. When in 16 bit memory/accumulator mode data is 16 bits wide - as usual the low byte will come from the effective address and the high byte from the effective address plus one.

Flags Altered n-----z-
    n Set if most significant bit of result is set.
    z Set if result is zero.

Imagen



INC Increment Data

Also operates just as the 6502 INC instruction. When in 16 bit memory/accumulator mode (m=0) data acted upon is 16 bits wide.
One new addressing mode is Accumulator addressing that will increment the Accumulator.

Flags Altered n-----z-
    n Set if most significant bit of result is set.
    z Set if result is zero.

Imagen


INX, INY Increment Index Registers

Both instructions operate just as a 6502. When in 16 bit index register mode, the register will be treated as 16 bits wide.

Flags Altered n-----z-
    n Set if most significant bit of result is set.
    z Set if result is zero.


Imagen



JMP Jump to New Location

JMP transfers control to the operand address. If a long jump is executed the program counter bank register is loaded with the third byte of the target address.

The 65816 Designers also specify that an assembler could possibly use JML in place of a JMP Long instruction, and also JML [adr] for Absolute indirect long.

    Flags Affected:--------



Imagen



JSR, JSL Jump to Subroutine (gosub)

JSR works just as a 6502 with the new addressing modes available. If an absolute address is coded by the assembler that is less than $FFFF then a standard JSR is used, else if it is greater than $FFFF then absolute long addressing is used. A standard JSR gosubs to the the routine in the current program bank.

JSR can also use Indexed Indirect addressing. (see section on addressing modes for an example.)

JML is a four byte instruction that will JSR to a subroutine located in any bank. When executed the current program counter bank is pushed onto the stack before the program counter high/low bytes.

    Flags Affected: --------

Imagen



LDA Load the Accumulator with Memory

LDA is nearly identical to the standard 6502 LDA instruction. New features are the implementation of the new addressing modes. While the status register is set for 16 bit memory/accumulator mode (m=0), data loaded is 16 bits wide with the load byte coming from the effective address and the high byte of the accumulator coming from the effective address plus one.

Flags affected n-----z-
    n Takes value of most significant bit of memory data.
    z Set if data loaded is zero.


Imagen




LDX Load X Register from Memory

LDX is identical to a stock 6502.
The only new feature to remember is that when in 16 bit index register mode (x=0) that data will be 16 bits wide. The X register low byte will come from the effective address and the high byte from the effective address plus one.

Flags affected n-----z-
    n Takes value of most significant bit of memory data.
    z Set if data loaded is zero.


Imagen



LDY Load Y Register from Memory

LDY is identical to a stock 6502.
The only new diversion is to remember that when in 16 bit index register mode (x=0) that data will be 16 bits wide. The Y register low byte will come from the effective address and the high byte from the effective address plus one.

Flags affected n-----z-
    n Takes value of most significant bit of memory data.
    z Set if data loaded is zero.


Imagen



LSR Logical Shift Right.

Yet another instruction unchanged from the standard 6502 instruction set.
16 bit mode (m=0) data shifted will be 16 bits wide.

Flags Altered n-----zc
    n Cleared.
    z Set if result is zero.
    c Bit zero becomes new carry.


Imagen



Block Move Instructions


MVP Move Positive destination > source
MVN Move Negative destination < source

This instruction is new 65816 only. MVN and MVP move data from memory location to memory location without user intervention.

Two instructions are necessary so that as the data is being moved in a negative direction it will not overwrite itself.

The source address for the move is taken from the X register. The destination address for the move is taken for the Y register. The 16 bit length of the move is taken from the Accumulator regardless of the m flag setting. This value should be one less than the actual length of the move (ie a=$0000 and one byte will be moved).

The two operand bytes specify the source bank of 64k and the destination bank of 64k. The assembler order of the operand bytes is source, destination - however, the actual binary output code will be the MVN or MVP opcode followed byte the destination bank byte and the source bank byte.

MVN Move Negative is used when the source address is greater than the destination address, or conversely when the destination range is lower than the source range.

The MVN instruction uses the X and Y registers to denote the bottom (beginning) address of the two memory segments to be moved. With MVN the data is moved from the source in X to the destination in Y, then the X and Y registers are are incremented and the accumulator decremented until the accumulator underflows to $FFFF.

MVP Move Positive is used with the source address is less than the destination, or conversely when the destination range is higher in memory than the source range.

The MVP instruction uses the X and Y registers to denote the top address of the two blocks of memory. The data is moved from the source in X to the address in Y and then the XY and accumulator registers are decremented until the accumulator underflows to $FFFF.

If the index registers are set for 8 bit mode (x=1) or the processor is set for 6502 emulation mode, then the data moved will be in page zero only because the high bytes will default to zero.

To reduce code length it is very easy to setup the move instructions in a subroutine, then use dynamically modified code to exchange the MVN and MVP opcodes on-the-fly.

Status register flags are NOT affect by the move instructions.

Imagen



NOP No Operation.

Same as 6502. No flags are affected with NOP.

Imagen



ORA OR Accumulator with Memory.

Same function as 6502 ORA with new addressing modes.
When in 16 bit memory/accumulator mode (m=0) data acted upon is 16 bits wide. The low byte is the effective address and the high byte is the effective address plus one.

Flags Affected: n-----z-
    n Set if most significant bit of result is set.
    z Set if result is zero.


Imagen





PEA Push Effective Absolute Address

PEA pushes the sixteen-bit operand onto the stack. The stack pointer is decremented by two. No flags are affected. Unlike other instructions that use similar assembler notations, PEA pushes the value of the operands onto the stack, NOT the data located at an effective address. A more appropriate name should have been to push Immediate data onto the stack - it is unclear why this discrepancy exists.

For example:

    PEA $1234

Pushes a #$12 and then a #$34 onto the stack.

Imagen



PEI Push Effective Indirect Address

This 65816 instruction pushes the address of the effective address onto the stack. This instruction always pushes 16 bits of data onto the stack without regard for the settings of the x and m status bits.

The address of the effective address plus one is pushed on the stack first and then the address of the effective address is pushed on second.

For example: suppose $5678 is stored at location $21/$22 in standard low byte/high byte format, then a

    PEI ($21)

would get the $5678 from $21/$22 and push it onto the stack.

Imagen



PER Push effective PC Relative Indirect Address

This instruction takes the program counter and adds the 16 bit operand and pushes the resulting 16 bits onto the stack. The destination address must be located within the current bank of 64k memory. The value of the program counter used in the calculation is the address of the NEXT instruction following the PER and two operand bytes.

The result high byte is pushed first, followed by the low byte of the result.

Because this instruction uses a relative offset for the operand, it can aid in writing relocatable code. One could envision pushing an unknown run-time address onto the stack with PER and then pulling the address off to determine the programs run time origin.

Another use of this instruction could be to push a return address onto the stack for 6502 pha:pha:rts style coding

Imagen



Push, Pull APXY Instructions

PHA,PHP,PLA,PLP are unchanged from their 6502 forerunners. The only notable difference is that 16 bits will be pushed on when in accumulator/memory (m=0) mode and a PHA or PLA is executed (PHP/PLP only operate on 8 bits).

New push and pull stack instructions include PHY,PLY,PHX,PLX. These four new instructions push and pull the index registers on and off the stack. When the status register is set to 16 bit index register mode (x=0), the pull and push index registers will operate on 16 bits when the status register x is set to 0.

Imagen



Push, Pull Bank Registers

PHB Pushes the 8 bit contents of the data bank register on the stack.

PHD Pushes the 16 bit contents of the direct page register on stack.
The high byte is pushed first, followed by the low byte.

PHK Pushes the 8 bit contents of the program bank register on stack.

PLB Pulls a byte off the stack into the data bank register. This is the only instruction that can directly change the data bank register.

PLD Pulls a sixteen bit value off stack into the direct page register. The low byte is pulled first, followed by the high byte.

Pulled Flags Affected by pull instructions:

    n Set if most significant bit of value pulled is set.
    z Set if value pulled is zero.


Imagen



REP Reset Status Bits.

REP is a new 65816 instruction. When used, it will reset (clear) the bits specified by the 1 byte immediate value.

For Example to clear bit 5 of the status register:


REP #%00100000 ;clear bit 5.

or to clear multiple bits:


REP #%10110000 ;clear 7,5 and 4.

Any combination is acceptable.

To set a bit, see SEP.

Flags affected: nvmxdizc
    All flags that have an operand bit set are cleared.
    Other flags are not affected.

Imagen


ROL Rotate Memory or Accumulator Left

ROL works same as the 6502 ROL instruction.
When in 16 bit accumulator/memory mode (m=0) Data rotated is 16 bits wide with the former bit 15 becoming the new carry. - the low-order bits are located in the effective address, and the high order bits are located in the effective address plus one.

Flags affected: n-----zc
    n Set if most significant bit of result is set.
    z Set if result is zero.
    c The high bit (7 or 15) becomes the new carry.


Imagen



ROR Rotate Memory or Accumulator Right.

Works as 6502 ROR expected.
When in 16 bit memory/accumulator mode (m=0) data rotated will be 16 bits wide, plus the carry - the low-order bits are located in the effective address, and the high order bits are located in the effective address plus one.

Flags affected: n-----zc
    n Set if most significant bit of result is set.
    z Set if result is zero.
    c Low bit becomes the new carry.


Imagen



RTI Return from Interrupt

While in 6502 emulation mode (e=1) RTI is handled the same as a stock 6502.
While in native 65816 mode (e=0) RTI also pulls the program bank register byte off of the stack. Since this extra byte is present, it is essential that the RTI be executed in the same mode (e=?) that the processor was in when the interrupt was executed.

Flags Affected: The status register is pulled from the stack, therefore all flags are affected.


Imagen



RTL Return from Subroutine Long

RTL works similar to an RTS but it also pulls the program bank register off of the stack. This instruction should be used in conjunction with the JSR long instruction or by a setup routine that also pushes the program bank onto the stack. RTL pulls 24 bits off of the stack. First the two bytes of the program counter low/high are pulled and incremented, then the program bank register is pulled.

No Flags are affected by RTL.



Imagen



RTS Return from Subroutine

Same as the 6502 instruction. No flags are affected.

One interesting use of RTS is to push a return address on the stack and then execute it via RTS. In order to use this type of coding the address pushed onto the stack must be one less than the actual routine address because when pulled back off, the processor automatically inc's the program counter before continuing. While in Native mode with 16 bit accumulator/memory set, this can easily be accomplished by:

    DEC A ; dec 16 be accum. or DEA.
    PHA ; push 16 bit return adr on stack.
    RTS ; return to execute the instruction.


Imagen



SBC Subtract from Accumulator

SBC also works just a a 6502. Again the only difference is a few new addressing modes, and the fact that data maybe worked in a 16 bit accumulator or 16 bit memory location.
SBC and ADC when used in 16 bit memory/accumulator mode greatly enhance the overall utility of the 65816. A programmer can easily see how much faster addition and subtraction routines could be performed while operating on 16 bits instead of 8.

Flags Altered nv----zc
    n Set if most-significant bit of result is set.
    v Set if signed overflow.
    z Set if result is zero.
    c Set if unsigned borrow not required.

Imagen


SEP Set Status Bits

SEP is a new 65816 instruction. When used, it will set the bits specified by the 1 byte immediate value.
This is the only means of setting the M and X status register bits.

For Example to set bit 5 of the status register:

    SEP #%00100000 ;set bit 5.

    or to clear multiple bits:

    SEP #%10110000 ;set bits 7,5 and 4.

Any combination is acceptable.

To reset a bit, see REP.

Flags affected: nvmxdizc
    All flags that have an operand bit set are set.
    Other flags are not affected.


Imagen



Imagen


STP Stop the Processor

STP shuts the processor down until a hardware reset. It is used in some systems to put the processor to sleep and reduce power consumption. There is a RESet B pin on some 65816 processors that allow for the usage of this instruction.

Imagen



STX Store X Register to Memory

Another the same as 6502 mode.
Only exception is that when set for 16 bit index registers (x=0) data stored will be 16 bits wide. Low 8 bits of Y will be stored to the effective address and the high byte to the effective address plus one.
No flags are affected by STX.

Imagen


STY Store Y Register to Memory

Same as 6502 mode.
Only exception is that when set for 16 bit index registers (x=0) data stored will be 16 bits wide. Low 8 bits of Y will be stored to the effective address and the high byte to the effective address plus one.
No flags are affected by STY.

Imagen



STZ Store Zero byte to Memory

A new instruction of the 65816. STZ stores a zero byte to the destination address. When in 8 bit accumulator/memory mode (m=1) one byte is stored at the effective address. While in 16 bit memory/accumulator mode (m=0) a zero is stored to the effective address and to the effective address plus one. No flags are affected.

This instruction could be defined as a replacement for stock 6502 code as:

    lda #0
    sta $xxxx

The perky thing about STZ is that the accumulator is unchanged and the status register is also unchanged.

Imagen




Register Transfer Instructions:

TAX,TXA,TAY,TYA,TSX,TXS transfer instructions transfer bytes between the processor registers.

TAX: Transfer accumulator to X index register. TAY: Transfer accumulator to Y index register. TYA: Transfer Y index register to the accumulator. TXA: Transfer X index register to the accumulator. TSX: Transfer Stack pointer to the X index register. TXS: Transfer X index register to the Stack pointer.

Two new register transfer instructions are TXY to transfer directly from the X register into the Y register and TYX to transfer from Y register to X register.

Because the accumulator and index registers can be set for either 8 or 16 bits independently, the width of the transfer is determined by the destination register. The following table shows the possible combinations:

8 bit acc to 8 bit index regs. (m=1,x=1) 8 bits transferred.
8 bit acc,to 16 bit index regs (m=1, x=0), 16 bits are transferred.
    The hidden high order accumulator byte becomes the
    X or Y high byte.
16 bit index regs to 8 bit acc (m=1, x=0), 8 bits are transferred.
    The hidden high order accumulator byte is not
    affected and the previous values remain.
8 bit index regs to 16 bit acc (m=0, x=1), Two bytes
    transferred with the high byte being zero.
16 bit acc to 8 bit index regs (m=0, x=1), Only the low byte of the
    accumulator is transferred to the index register.
16 bit acc to 16 bit index regs (m=0, x=0) 16 bits transferred.

16 bit stack pointer to 8 bit X register. Only the low byte
    address is transferred.
8 bit X reg to 16 bit stack pointer, sets stack high byte to zero.


Flags Affected: n-----z-
    n Set if most significant bit of transfer value is set.
    z Set if transferred value is zero.


Imagen



Direct Page Instructions:


Two new 65816 instructions are used to exchange data between the accumulator and the Direct Page Register.

TCD Transfer Accumulator to Direct Page Register.
TDC Transfer Direct Page Register to Accumulator.

TCD transfers a 16 bit value from the accumulator into the direct (zero page) pointer. A full 16 bits is transferred regardless of the 16/8 bit setting (m) of the accumulator.
The C in TCD is used to specify that the accumulator is referenced as C when it is 16 bits wide (low byte being A and high byte being B).
TDC transfers from the Direct Page register into the full 16 bit accumulator without regard for the setting of status bit m.

Some assemblers also allow TAD or TDA for the mnemonics.

Flags Affected: n-----z-
    n Set if most significant bit of transfer value is set.
    z Set if transferred value is zero.


Imagen



TCS Transfer Accumulator to Stack Pointer

TCS transfers a full 16 bits to the stack pointer without regard for the setting of status bit m.
As with TCD and TDC the C in TCS refers to the accumulator as a full 16 bits.
The mnemonic TAS, transfer a to stack pointer, is used by some assemblers.
While in 6502 emulation mode only the eight-bit A accumulator value is transferred because the stack is always located at page 1 on a 6502 TCS and TXS are the only two instructions that alter the stack pointer register.

No flags are affected by TCS.

Imagen


TSC Transfer Stack Pointer to Accumulator

TSC transfers a full 16 bits of the stack pointer to the 16 bit accumulator without regard for the setting of status bit m.
As with TCD and TDC the C in TSC refers to the accumulator as a full 16 bits.
The mnemonic TSA, transfer a to stack pointer, is used by some assemblers.

While in 6502 emulation mode a one will be transferred to the hidden B (upper 8 bits) accumulator because the stack is always located at page one in 6502 mode.

Flags Affected: n-----z-
    n Set if most significant bit of transfer value is set.
    z Set if transferred value is zero.



Imagen



TRB Test and Reset Memory Bits


TRB performs a logical AND of the accumulator's compliment and the effective address - data is then rewritten back to the specified address. This clears each memory bit that has a corresponding bit set in the accumulator, leaving all other memory bits unchanged.

To put it another way - TRB flips or inverts the accumulator value and then AND's that value with memory operand and stores the result back to the effective address.

While is 16 bit accumulator mode (m=0) data is operated on in the expected 16 bit fashion. The low byte of the operation is at the effective address and the high byte at the effective address plus one.

Flags Affected: ------z-
    z Set if memory value AND'ed with accumulator value is zero.

Imagen



TSB Test and Set Memory Bits


TSB logically OR's the accumulator and the data at the effective address. This effectively sets a bit at the memory location for each bit set in the accumulator.

While is 16 bit accumulator mode (m=0) data is operated on in the expected 16 bit fashion. The low byte of the operation is at the effective address and the high byte at the effective address plus one.

The status register zero flag is set after the accumulator is AND'd with the memory value. (same as the BIT instruction).

Flags Affected: ------z-
    z Set if memory value AND'ed with accumulator value is zero.


Imagen



WAI Wait for Interrupt


WAI suspends operations until and external hardware interrupt is generated. Power consumption by the processor is also reduced. If the disable interrupt flag (i=1) is set and an IRQ is pending before the execution of the WAI, then the WAIT is terminated and execution continues with the next instruction.

No flags are affected by WAI.

Imagen



WDM Reserved for Future Expansion


WDM is the first byte of a multi-byte instruction set to be used in future versions of the processor.
At current WDM is treated like a NOP no operation.
This instruction should NOT be used in current versions of the processor.
WDM: William D. Mensch, JR. (65816 designer).

Imagen



XBA Exchange B and A Accumulators


XBA exchanges the low eight bits of the accumulator (A) with the high order 8 bits of the accumulator (B). This operation has no regard for the setting of the status bit M.
This instruction will also work in 6502 emulation mode.

XBA can be used to save a temp copy of the low accumulator in the upper accumulator. It is also good when in 16 bit mode to invert a low and high byte value.

XBA is the only instruction that can access the upper 8 bits of the accumulator in emulation mode.

Some assemblers will also accept SWA (swap) for a mnemonic.

Flags Affected: n------z-
    n Set if the most significant bit of the new value in the low order 8 bits (A) of the accumulator is set. (former bit 15)
    z Set if new value of the lower order 8 bit accumulator (A) is zero.


Imagen



XCE Exchange Carry and Emulation Bits


XCE exchanges (swaps) the value in the E emulation bit and the C carry flag. This is the only means to access the E emulation bit.

To set emulation mode:
    sec ;set carry.
    xce ;exchange carry and emulation bits.

To set native mode:
    clc ;clear carry
    xce ;exchange carry and e bit.

    e
Flags Affected --mx/b---c
    e from previous carry flag.
    c from previous emulation flag.
    m native mode flag only. switching to native 65816 mode sets to one.
    x x is a native mode flag only.
    b brk is an emulation 6502 flag only. it is set to 1 to become the x flag in native mode

Imagen






============================
Appendix B:Composite Instruction List
============================




Imagen
Imagen
Imagen
Imagen
Imagen
Imagen


    * Add 1 if m=0 (16 bit memory/accumulator).
    ** Opcode is 1 byte, but program counter value pushed onto stack is incremented by 2 allowing for optional signature byte.
    + Add 1 byte if x=0 (16-bit index registers).
    1 Add 1 cycle if m=0 (16-bit memory/accumulator).
    2 Add 1 cycle if low bye of Direct Page (zero page) register is other than zero (DL<>0).
    3 Add 1 cycle if adding index crosses a page boundary.
    4 Add 1 cycle if CPU is 65C02 and d=1 (decimal mode. 65C02 only).
    5 Add 2 cycles if m=0 (16-bit memory/accumulator).
    6 Subtract 1 cycle if CPU is 65C02 and no page boundary crossed.
    7 Add 1 cycle if branch is taken.
    8 Add 1 more cycle if branch taken crosses page boundary on 6502, 65C02, or 65816/65082's emulation mode (e=1).
    9 Add 1 cycle for 65802/65816 native mode (e=0).
    10 Add 1 cycle if x=0 (16-bit index registers).
    11 Add 1 cycle if CPU is 65C02.
    12 6502: if low byte of operand is $FF (ie. operand is $xxFF): yields incorrect result.
    13 7 cycles per byte moved.
    14 Uses 3 cycles to shut the processor down; additional cycles are required by reset to restart CPU.
    15 Uses 3 cycles to shut the processor down; additional cycles are required by interrupt to restart it.
    16 Byte and cycle counts subject to change in future processors which expand WDM into 2-byte opcode portions of instructions of varying lengths.


These are the 255 opcodes of the 65816. (TODO: fix the mistakes in the list; explain the format of the list.)

MACHINE        ASSEMBLY           EFFECT                         FLAGS
00 00          brk                brk interrupt                  --------
00 nn          brk $nn            brk interrupt                  --------
01 nn          ora ($nn,x)        a | operand => a               n-----z-
02 00          cop                cop interrupt                  --------
02 nn          cop $nn            cop interrupt                  --------
03 nn          ora $nn,s          a | operand => a               n-----z-
04 nn          tsb $nn            operand | a => operand         ------&-
05 nn          ora $nn            a | operand => a               n-----z-
06 nn          asl $nn            operand << 1 => operand        n-----zc
07 nn          ora [$nn]          a | operand => a               n-----z-
08             php                push processor flags           --------
09 nn          ora #$nn           a | operand => a               n-----z-
09 nn mm       ora #$mmnn         a | operand => a               n-----z-
0a             asl a              a << 1 => a                    n-----zc
0b             phd                push direct page location      --------
0c nn mm       tsb $mmnn.w        operand | a => operand         ------&-
0d nn mm       ora $mmnn.w        a | operand => a               n-----z-
0e nn mm       asl $mmnn.w        operand << 1 => operand        n-----zc
0f nn mm kk    ora $kkmmnn.l      a | operand => a               n-----z-
10 nn          bpl label          branch if negative == 0        --------
11 nn          ora ($nn),y        a | operand => a               n-----z-
12 nn          ora ($nn)          a | operand => a               n-----z-
13 nn          ora ($nn,s),y      a | operand => a               n-----z-
14 nn          trb $nn            operand & ~a => operand        ------&-
15 nn          ora $nn,x          a | operand => a               n-----z-
16 nn          asl $nn,x          operand << 1 => operand        n-----zc
17 nn          ora [$nn],y        a | operand => a               n-----z-
18             clc                0 => carry                     -------c
19 nn mm       ora $mmnn.w,y      a | operand => a               n-----z-
1a             inc a              a + 1 => a                     n-----z-
1b             tcs                c => stack pointer             --------
1c nn mm       trb $mmnn.w        operand & ~a => operand        ------&-
1d nn mm       ora $mmnn.w,x      a | operand => a               n-----z-
1e nn mm       asl $mmnn.w,x      operand << 1 => operand        n-----zc
1f nn mm kk    ora $kkmmnn.l,x    a | operand => a               n-----z-
20 nn mm       jsr $mmnn          call 'jsr' subroutine          --------
21 nn          and ($nn,x)        a & operand => a               n-----z-
22 nn mm kk    jsl $kkmmnn        call 'jsl' subroutine          --------
23 nn          and $nn,s          a & operand => a               n-----z-
24 nn          bit $nn            test two highest bits          nv----&-
25 nn          and $nn            a & operand => a               n-----z-
26 nn          rol $nn            rotate left operand, carry     n-----zc
27 nn          and [$nn]          a & operand => a               n-----z-
28 nn          plp                pull processor flags           nvmxdizc
29 nn          and #$nn           a & operand => a               n-----z-
29 nn mm       and #$mmnn         a & operand => a               n-----z-
2a             rol a              rotate left a, carry           n-----zc
2b             pld                pull direct page location      n-----z-
2c nn mm       bit $mmnn.w        test two highest bits          nv----&-
2d nn mm       and $mmnn.w        a & operand => a               n-----z-
2e nn mm       rol $mmnn.w        rotate left operand, carry     n-----zc
2f nn mm kk    and $kkmmnn.l      a & operand => a               n-----z-
30 nn          bmi label          branch if negative == 1        --------
31 nn          and ($nn),y        a & operand => a               n-----z-
32 nn          and ($nn)          a & operand => a               n-----z-
33 nn          and ($nn,s),y      a & operand => a               n-----z-
34 nn          bit $nn,x          test two highest bits          nv----&-
35 nn          and $nn,x          a & operand => a               n-----z-
36 nn          rol $nn,x          rotate left operand, carry     n-----zc
37 nn          and [$nn],y        a & operand => a               n-----z-
38             sec                1 => carry                     -------c
39 nn mm       and $mmnn.w,y      a & operand => a               n-----z-
3a             dec a              a - 1 => a                     n-----z-
3b             tsc                stack pointer => c             n-----z-
3c nn mm       bit $mmnn.w,x      test two highest bits          nv----&-
3d nn mm       and $mmnn.w,x      a & operand => a               n-----z-
3e nn mm       rol $mmnn.w,x      rotate left operand, carry     n-----zc
3f nn mm kk    and $kkmmnn.l,x    a & operand => a               n-----z-
40             rti                return from interrupt          nvmxdizc
41 nn          eor ($nn,x)        a ^ operand => a               n-----z-
43 nn          eor $nn,s          a ^ operand => a               n-----z-
44 nn mm       mvp $mm,$nn        move block previous            --------
45 nn          eor $nn            a ^ operand => a               n-----z-
46 nn          lsr $nn            operand >> 1 => operand        n-----zc
47 nn          eor [$nn]          a ^ operand => a               n-----z-
48             pha                push a                         --------
49 nn          eor #$nn           a ^ operand => a               --------
4a             lsr a              a >> 1 => a                    n-----zc
4b             phk                push program bank              --------
4c nn mm       jmp $mmnn          jump within program bank       --------
4d nn mm       eor $mmnn.w        a ^ operand => a               n-----z-
4e nn mm       lsr $mmnn.w        operand >> 1 => operand        n-----zc
4f nn mm kk    eor $kkmmnn.l      a ^ operand => a               n-----z-
50 nn          bvc label          branch if overflow == 0        --------
51 nn          eor ($nn),y        a ^ operand => a               n-----z-
52 nn          eor ($nn)          a ^ operand => a               n-----z-
53 nn          eor ($nn,s),y      a ^ operand => a               n-----z-
54 nn mm       mvn $mm,nn         move block next                --------
55 nn          eor $nn,x          a ^ operand => a               n-----z-
56 nn          lsr $nn,x          operand >> 1 => operand        n-----zc
57 nn          eor [$nn],y        a ^ operand => a               n-----z-
58             cli                0 => IRQ disabled              -----i--
59 nn mm       eor $mmnn.w,y      a ^ operand => a               n-----z-
5a             phy                push y                         --------
5b             tcd                c => direct page location      --------
5c nn mm kk    jml $kkmmnn        jump to long address           --------
5d nn mm       eor $mmnn.w,x      a ^ operand => a               n-----z-
5e nn mm       lsr $mmnn.w,x      operand >> 1 => operand        n-----zc
5f nn mm kk    eor $kkmmnn.l,x    a ^ operand => a               n-----z-
60             rts                return from 'jsr' subroutine   --------
61 nn          adc ($nn,x)        a + operand + carry => a       nv----zc
62 nn mm       per label          push pc-relative address       --------
63 nn          adc $nn,s          a + operand + carry => a       nv----zc
64 nn          stz $nn            0 => operand                   --------
65 nn          adc $nn            a + operand + carry => a       nv----zc
66 nn          ror $nn            rotate right operand, carry    n-----zc
67 nn          adc [$nn]          a + operand + carry => a       nv----zc
68             pla                pull a                         n-----z-
69 nn          adc #$nn           a + operand + carry => a       nv----zc
69 nn mm       adc #$mmnn         a + operand + carry => a       nv----zc
6a             ror a              rotate right a, carry          n-----zc
6b             rtl                return from 'jsl' subroutine   --------
6c nn mm       jmp ($mmnn)        jump within program bank       --------
6d nn mm       adc $mmnn.w        a + operand + carry => a       nv----zc
6e nn mm       ror $mmnn.w        rotate right operand, carry    n-----zc
6f nn mm kk    adc $kkmmnn.l      a + operand + carry => a       nv----zc
70 nn          bvs label          branch if overflow == 1        --------
71 nn          adc ($nn),y        a + operand + carry => a       nv----zc
72 nn          adc ($nn)          a + operand + carry => a       nv----zc
73 nn          adc ($nn,s),y      a + operand + carry => a       nv----zc
74 nn          stz $nn,x          0 => operand                   --------
75 nn          adc $nn,x          a + operand + carry => a       nv----zc
76 nn          ror $nn,x          rotate right operand, carry    n-----zc
77 nn          adc [$nn],y        a + operand + carry => a       nv----zc
78             sei                1 => IRQ disabled              -----i--
79 nn mm       adc $mmnn.w,y      a + operand + carry => a       nv----zc
7a             ply                pull y                         n-----z-
7b             tdc                direct page location => c      n-----z-
7c nn mm       jmp ($mmnn,x)      jump within program bank       --------
7d nn mm       adc $mmnn.w,x      a + operand + carry => a       nv----zc
7e nn mm       ror $mmnn.w,x      rotate right operand, carry    n-----zc
7f nn mm kk    adc $kkmmnn.l,x    a + operand + carry => a       nv----zc
80 nn          bra label          branch                         --------
81 nn          sta ($nn,x)        a => operand                   --------
82 nn mm       brl label          long branch                    --------
83 nn          sta $nn,s          a => operand                   --------
84 nn          sty $nn            y => operand                   --------
85 nn          sta $nn            a => operand                   --------
86 nn          stx $nn            x => operand                   --------
87 nn          sta [$nn]          a => operand                   --------
88             dey                y - 1 => y                     n-----z-
89 nn          bit #$nn           test two highest bits          nv----&-
89 nn mm       bit #$mmnn         test two highest bits          nv----&-
8a             txa                x => a                         n-----z-
8b             phb                push data bank                 --------
8c nn mm       sty $mmnn.w        y => operand                   --------
8d nn mm       sta $mmnn.w        a => operand                   --------
8e nn mm       stx $mmnn.w        x => operand                   --------
8f nn mm kk    sta $kkmmnn.l      a => operand                   --------
90 nn          bcc label          branch if carry == 0           --------
91 nn          sta ($nn),y        a => operand                   --------
92 nn          sta ($nn)          a => operand                   --------
93 nn          sta ($nn,s),y      a => operand                   --------
94 nn          sty $nn,x          y => operand                   --------
95 nn          sta $nn,x          a => operand                   --------
96 nn          stx $nn,y          x => operand                   --------
97 nn          sta [$nn],y        a => operand                   --------
98             tya                y => a                         --------
99 nn mm       sta $mmnn.w,y      a => operand                   --------
9a             txs                x => stack pointer             --------
9b             txy                x => y                         n-----z-
9c nn mm       stz $mmnn.w        0 => operand                   --------
9d nn mm       sta $mmnn.w,x      a => operand                   --------
9e nn mm       stz $mmnn.w,x      0 => operand                   --------
9f nn mm kk    sta $kkmmnn.l,x    a => operand                   --------
a0 nn          ldy #$nn           operand => y                   n-----z-
a0 nn mm       ldy #$mmnn         operand => y                   n-----z-
a1 nn          lda ($nn,x)        operand => a                   n-----z-
a2 nn          ldx #$nn           operand => x                   n-----z-
a2 nn mm       ldx #$mmnn         operand => x                   n-----z-
a3 nn          lda $nn,s          operand => a                   n-----z-
a4 nn          ldy $nn            operand => y                   n-----z-
a5 nn          lda $nn            operand => a                   n-----z-
a6 nn          ldx $nn            operand => x                   n-----z-
a7 nn          lda [$nn]          operand => a                   n-----z-
a8             tay                a => y                         n-----z-
a9 nn          lda #$nn           operand => a                   n-----z-
a9 nn mm       lda #$mmnn         operand => a                   n-----z-
aa             tax                a => x                         n-----z-
ab             plb                pull data bank                 --------
ac nn mm       ldy $mmnn.w        operand => y                   n-----z-
ad nn mm       lda $mmnn.w        operand => a                   n-----z-
ae nn mm       ldx $mmnn.w        operand => x                   n-----z-
af nn mm kk    lda $kkmmnn.l      operand => a                   n-----z-
b0 nn          bcs label          branch if carry == 1           --------
b1 nn          lda ($nn),y        operand => a                   n-----z-
b2 nn          lda ($nn)          operand => a                   n-----z-
b3 nn          lda ($nn,s),y      operand => a                   n-----z-
b4 nn          ldy $nn,x          operand => y                   n-----z-
b5 nn          lda $nn,x          operand => a                   n-----z-
b6 nn          ldx $nn,y          operand => x                   n-----z-
b7 nn          lda [$nn],y        operand => a                   n-----z-
b8             clv                0 => overflow                  -v------
b9 nn mm       lda $mmnn.w,y      operand => a                   n-----z-
ba             tsx                stack pointer => x             n-----z-
bb             tyx                y => x                         n-----z-
bc nn mm       ldy $mmnn.w,x      operand => y                   n-----z-
bd nn mm       lda $mmnn.w,x      operand => a                   n-----z-
be nn mm       ldx $mmnn.w,y      operand => x                   n-----z-
bf nn mm kk    lda $kkmmnn.l,x    operand => a                   n-----z-
c0 nn          cpy #$nn           y - operand                    n-----zc
c0 nn mm       cpy #$mmnn         y - operand                    n-----zc
c1 nn          cmp ($nn,x)        a - operand                    n-----zc
c2 nn          rep #$nn           reset processor flags          nvmxdizc
c3 nn          cmp $nn,s          a - operand                    n-----zc
c4 nn          cmy $nn            y - operand                    n-----zc
c5 nn          cmp $nn            a - operand                    n-----zc
c6 nn          dec $nn            operand - 1 => operand         n-----z-
c7 nn          cmp [$nn]          a - operand                    n-----zc
c8             iny                y + 1 => y                     n-----z-
c9 nn          cmp #$nn           a - operand                    n-----zc
c9 nn mm       cmp #$mmnn         a - operand                    n-----zc
ca             dex                x - 1 => x                     n-----z-
cb             wai                wait for interrupt             --------
cc nn mm       cpy $mmnn.w        y - operand                    n-----zc
cd nn mm       cmp $mmnn.w        a - operand                    n-----zc
ce nn mm       dec $mmnn.w        operand - 1 => operand         n-----z-
cf nn mm kk    cmp $kkmmnn.l      a - operand                    n-----zc
d0 nn          bne label          branch if zero flag == 0       --------
d1 nn          cmp ($nn),y        a - operand                    n-----zc
d2 nn          cmp ($nn)          a - operand                    n-----zc
d3 nn          cmp ($nn,s),y      a - operand                    n-----zc
d4 nn          pei ($nn)          push address of operand        --------
d5 nn          cmp $nn,x          a - operand                    n-----zc
d6 nn          dec $nn,x          operand - 1 => operand         n-----z-
d7 nn          cmp [$nn],y        a - operand                    n-----zc
d8             cld                0 => decimal flag              ----d---
d9 nn mm       cmp $mmnn.w,y      a - operand                    n-----zc
da             phx                push x                         --------
db             stp                stop the processor             --------
dc nn mm       jml [$mmnn]        jump to long address           --------
dd nn mm       cmp $mmnn.w        a - operand                    n-----zc
de nn mm       dec $mmnn.w        operand - 1 => operand         n-----z-
df nn mm kk    cmp $kkmmnn.l,x    a - operand                    n-----zc
e0 nn          cpx #$nn           x - operand                    n-----zc
e0 nn mm       cpx #$mmnn         x - operand                    n-----zc
e1 nn          sbc ($nn,x)        a + ~operand + carry => a      nv----zc
e2 nn          sep #$nn           set processor flags            nvmxdizc
e3 nn          sbc $nn,s          a + ~operand + carry => a      nv----zc
e4 nn          cpx $nn            x - operand                    n-----zc
e5 nn          sbc $nn            a + ~operand + carry => a      nv----zc
e6 nn          inc $nn            operand + 1 => operand         n-----z-
e7 nn          sbc [$nn]          a + ~operand + carry => a      nv----zc
e8 nn          inx                x + 1 => x                     n-----z-
e9 nn          sbc #$nn           a + ~operand + carry => a      nv----zc
e9 nn mm       sbc #$mmnn         a + ~operand + carry => a      nv----zc
ea             nop                no operation                   --------
eb             xba                swap b with a                  --------
ec nn mm       cpx $mmnn.w        x - operand                    n-----zc
ed nn mm       sbc $mmnn.w        a + ~operand + carry => a      nv----zc
ee nn mm       inc $mmnn.w        operand + 1 => operand         n-----z-
ef nn mm kk    sbc $kkmmnn.l      a + ~operand + carry => a      nv----zc
f0 nn          beq label          branch if zero flag == 1       --------
f1 nn          sbc ($nn),y        a + ~operand + carry => a      nv----zc
f2 nn          sbc ($nn)          a + ~operand + carry => a      nv----zc
f3 nn          sbc ($nn,s),y      a + ~operand + carry => a      nv----zc
f4 nn mm       pea $mmnnn         push address of operand        --------
f5 nn          sbc $nn,x          a + ~operand + carry => a      nv----zc
f6 nn          inc $nn,x          operand + 1 => operand         n-----z-
f7 nn          sbc [$nn],y        a + ~operand + carry => a      nv----zc
f8             sed                1 => decimal flag              ----d---
f9 nn mm       sbc $mmnn.w,y      a + ~operand + carry => a      nv----zc
fa             plx                pull x                         n-----z-
fb             xce                swap carry, emulation flags    -------c
fc nn mm       jsr ($mmnn,x)      call 'jsr' subroutine          --------
fd nn mm       sbc $mmnn.w,x      a + ~operand + carry => a      nv----zc
fe nn mm       inc $mmnn.w,x      operand + 1 => operand         --------
ff nn mm kk    sbc $kkmmnn.l,x    a + ~operand + carry => a      nv----zc





=================
Appendix C: IC Pinouts
=================


Imagen

Notes:
ML: Memory Lock line (pin 5) is asserted low during the execution of the read-modify-write (asl,dec,inc,lsr,rol,ror,trb, and tsb instructions to inform other ics that the bus may not be claimed yet.

VP: Vector Pull is asserted whenever any of the hardware vector address's are being accessed during an IRQ.

Abort: An input. When asserted caused the current instruction to be aborted.

VPA/VDA. Valid Program Address and Valid Data Address. These two signals extend on the 6502 SYNC line - to better handle DMA schemes.

    VPA VDA
    0 0 -Internal Operation
    0 1 -Valid program address
    1 0 -Valid data address
    1 1 -Opcode fetch


M/X: Memory and Index lines. These signals are multiplexed on pin
38. M is available during phase zero and X during Phase one.
These two signals reflect the contents of the status register m and x flags, allowing other devices to decode opcode fetches.

E: Emulation pin. This signal reflects the state of the processors emulation bit (E).



===================================================================
44 PIN PLCC Pinout.

Imagen



ImagenIr a la primera parte del artículo

ImagenVolver a la página principal.
Pagafantas está baneado por "clon para saltarse baneo"
¬_¬ que mierda es esa?
Pagafantas escribió:¬_¬ que mierda es esa?


Es la información del lenguaje ensamblador que entiende el micro de la SNES; algo imprescindible si quieres programar para ella sacándole el 100% de rendimiento.

Un gran aporte, sin duda...

Por cierto, estaría genial poner en el post principal lo que vendió cada juego en España; es un dato que a mi me encantaría saber... de los juegos de RPG yo tengo un par de artículos donde se dice, y éste era un dato que se veía mucho en las Nintendo Acción...
Pagafantas escribió:¬_¬ que mierda es esa?


Gracias, es reconfortante [jaja]


magno escribió:Es la información del lenguaje ensamblador que entiende el micro de la SNES; algo imprescindible si quieres programar para ella sacándole el 100% de rendimiento.

Un gran aporte, sin duda...


Tengo mas preparadas, y en alguna he leido agradecimientos a un tal "Magno". Me he acordado de ti (no se si tu tendrás algo que ver, ya me lo dirás) :)
La verdad que poco puedo opinar de los ultimos juegos comentados, porque salvo al contra,al resto no le he dedicado mucho tiempo.Los castlevanias nunca me han llamado la atencion y el demon crest me decepciono un pelin....pero bueno, sobre gustos.....

PD_me pido la review del Tales of phantasia [carcajad]


pero para el análsis que sea el de super nes y no el de gba [qmparto] [qmparto] [qmparto] [qmparto] [qmparto] [qmparto]
ChepoXX escribió:
La verdad que poco puedo opinar de los ultimos juegos comentados, porque salvo al contra,al resto no le he dedicado mucho tiempo.Los castlevanias nunca me han llamado la atencion y el demon crest me decepciono un pelin....pero bueno, sobre gustos.....

PD_me pido la review del Tales of phantasia [carcajad]


pero para el análsis que sea el de super nes y no el de gba [qmparto] [qmparto] [qmparto] [qmparto] [qmparto] [qmparto]


Que mas dara tio, si son practicamente el mismo juego [carcajad] Vale lo reconozco, solo me he pasado el de gba, pero aun no entiendo tan bien el japones como para hacerme el de SNES [risita]
Sobre el Demon's crest, la verdad es que esperaba un ritmo de juego mas clásico, pero su desarrollo es muy abierto, tirando hacia la aventura. su dificultad me ha frustrado un poco, porque me he sentado a meterle un par de partidas para catarlo, pero realmente se necesitan muchas mas. No he avanzado casi nada, y no le he dado tiempo para picarme con el. Caerá otra partida en algún momento, no puede ser que quiera que tenga de bueno, esté tan escondido ein?


Sobre el castlevania IV... nunca llegué a pasarmelo. Todas las fases hasta el castillo acabaron pasando "por la piedra", pero las siguientes, las del mapa del camino laberíntico... esas... la madre que las parió, que chungas me parecieron(en su día).
Lo genial de este juego, en mi caso, es que, salvo la mil veces rejugada primera fase, el resto están olvidadas, y esperando a que las re-descubra otra vez, como si nunca hubiera jugado. Es lo mejor del mundo, imaginarme otra vez con 15 años delante de la super nintendo.


ryo hazuki escribió:Que mas dara tio, si son practicamente el mismo juego [carcajad] Vale lo reconozco, solo me he pasado el de gba, pero aun no entiendo tan bien el japones como para hacerme el de SNES [risita]


¿No había alguna traducción por ahí?. voy a mirar a ver si tengo el mio traducido.
Pagafantas escribió:¬_¬ que mierda es esa?


Muestra un poco mas de respeto, considerate avisado.
ryo hazuki escribió:Que mas dara tio, si son practicamente el mismo juego [carcajad] Vale lo reconozco, solo me he pasado el de gba, pero aun no entiendo tan bien el japones como para hacerme el de SNES [risita]



No son el mismo juego, mucho más dinámico el de SNES con diferencia, a parte de que tiene 1 personaje jugable menos que el de GBA. Y el de SNES está traducido por un tal magno desde el 2006.................... mira que no haberlo jugado en castellano, con lo pedazo de juego que es!!! [+furioso]

Ralph escribió:Tengo mas preparadas, y en alguna he leido agradecimientos a un tal "Magno". Me he acordado de ti (no se si tu tendrás algo que ver, ya me lo dirás) :)


Pues estaría bien que las fueras poniendo, que son un gran aporte... Ésas que dices que son en agradecimiento a "Magno" sí deben de ser las clases que estuve dando hace unos años en los tiempos de TodoTradus... pero no aportan gran cosa, al menos eso creo yo, pero si a alguien les puede servir...
Pedazo de hilo completísimo. Vaya currazo que te estás pegando Ralph, muchas gracias.

Esto hilo mítico en dos días :)
interesante eso del lenguaje, quizas theelf le sirva para hacer algo en snes ;)

Demon crest, otro juegazo.

@calintz: se me olvidaba el f-zero y el super vicioso super tennis ;P y el zelda creo q tb salio al poco de salir...siempre he dixo q la snes tuvo el mejor inicio de juegos q ninguna otra consola.

Es que era cada mes varios titulos "must have".
magno escribió:Pues estaría bien que las fueras poniendo, que son un gran aporte... Ésas que dices que son en agradecimiento a "Magno" sí deben de ser las clases que estuve dando hace unos años en los tiempos de TodoTradus... pero no aportan gran cosa, al menos eso creo yo, pero si a alguien les puede servir...


En un principio servirá todo, porque no todo el mundo tendrá el mismo nivel. Lo que me preocupa ya un poquito mas es la manera de clasificar contenidos en el primer post. Ahora mismo tengo un caos bastante importante con todo lo que tengo encima pendiente (no es mucha cosa, pero me gusta entender que es loq eu estoy publicando, para saber donde estoy, y que me falta).

Se admiten sugerencias.

He empezado un poco con el tema de la carga de tiles(mientras tanto), pero no servirá de nada sin algún FAQ introductorio hacia el mundo de las traducciones. De esto me encargaré mas adelante, ahora mismo estoy liado con la documentación del 65816. Luego vendrá todo lo qeu pueda de los chips gráficos, y algo de lo que no se nada, es del chip de audio... mas o menos tengo leido como se comporta con la CPU de la super nintendo, pero imagino que ajeno a esto, tenga su chicha aparte.


EDIT: El FAQ también está un poco a medio hacer, si a alguien se le ocurren ideas para ello, pues algo que iremos ganando.
Yo creo que la SNES es la consola mas importante de todos los tiempos, la que revoluciono el mundo de los videojuegos llegando a todo tipo de publicos. Yo no la tengo, porque se que si me la compro va ser un derroche de pasta increible porque tiene demasiados juegos buenos.
En el antiguo hilo de snes medio oficial que habia antes, hice una review del Secret of Evermore, el caso es que no me acuerdo como se llamaba el antiguo hilo de SNES, creo que era "juegos de SNES" o algo asi, podeis decirmelo que pondré aquí la review?

gracias
YuPiKaIe escribió:En el antiguo hilo de snes medio oficial que habia antes, hice una review del Secret of Evermore, el caso es que no me acuerdo como se llamaba el antiguo hilo de SNES, creo que era "juegos de SNES" o algo asi, podeis decirmelo que pondré aquí la review?

gracias



Lo puse en este post,para que copiasen alguna review que habian puesto.

hilo_hilo-ofical-juegos-snes_1289551
vale, ralph, lo pongo mañana el análisis? mejor que hoy? por el tema de dejar unos días y tal?
ImagenVolver a la página principal.


Conectores(pinouts) y Protocolos del ratón, multiout, y controlpad





    Content:

    1. About the Author
    2. Introduction
    3. SNES Multi-out cable connector pins.
    4. SNES Controller cable connector pins.
    5. SNES Controller Communication Protocol
    6. SNES Controller Button-to-Clock Pulse Assignment
    7. SNES Mouse Protocol





1. About the Author

Author: Jim Christy
Version: 1.02
E-Mail: jchristy@hplred.HP.COM




2. Introduction

For all you game hardware enthusiasts out there, I took the opportunity this weekend to put a scope on my Super Nintendo connectors and find out what is going on. Because the standard Multi-out cable connector only has internal contacts for the audio and video signals, I had to find some more push-in gold contacts at a local store to fully break out all the signals. It appears easier to do this than make your own connector.

In short, I found that in addition to S-VHS, the multiout also supports RGB and sync. I also got the controller pinouts and protocol, which opens up some interesting possibilities. One could rather easily construct a "macro recorder" that records your exact button presses for a game sequence and allows you to play them back. They will be time-accurate by definition of the protocol, and depending on how random the game plays, you should be able to replay those sequences that get boring, and then take over control when you want.

If all of this is already well known, then sorry for the waste of net bandwidth...





3. SNES Multi-out cable connector pins.

These are numbered the way Nintendo did, and the view is looking back "into" the connector on the CABLE.

Imagen

Additional Notes:

As seen above, the SNES does have RGB capability. I was able to get a stable raster on my NEC MultiSync "classic" using the RGB and sync pins. However, the video levels are not RS-170 compatible. The DC offset needs to be filtered out with some large capacitors and the peak-to-peak video amplitude may need to be reduced to 0.7v by using a lower load impedance than 75 ohms. The Y/C (S-VHS) signals *appear* to be directly usable, but tests cannot be made until I find the pinouts for the S-VHS connector on my TV.





4. SNES Controller cable connector pins.

I could not find a Nintendo numbering scheme, so I made one up. The view is looking back "into" the connector on the CABLE.

Imagen

Additional notes:

Pins 5 and 6 show a DC voltage of 5v on a DMM. I forgot to look at them on a scope so there may pulses too. However, they don't connect to anything at present.

The controllers have a small circuit board with 2 surface mount 14-pin ICs, marked by Nintendo as IC-A and IC-B. Although rubber domes are used to provide the tactile response of the buttons, they are not capacitive technology as originally thought. Instead they use what appears to be carbon impregnated rubber on the underside which makes a resistive path (200 ohms) across 2 carbon coated PCB pads when depressed.

    · The red wire goes to pin 2 on IC-A.
    · The orange wire goes to pin 8 on both IC-A and IC-B.
    · The yellow wire goes to pin 9 on both IC-A and IC-B.

IC-A and IC-B appear to be identical, with a 91 date code and have another (possible part number) of 545. These are most likely 2 parallel load shift registers in series. Buttons on the controller pull the parallel load inputs to ground through the contact formed by pressing a button. IC-B serially feeds IC-A, which then drives the serial data line to the SNES CPU.





5. SNES Controller Communication Protocol

Every 16.67ms (or about 60Hz), the SNES CPU sends out a 12us wide, positive going data latch pulse on pin 3. This instructs the ICs in the controller to latch the state of all buttons internally. Six microsenconds after the fall of the data latch pulse, the CPU sends out 16 data clock pulses on pin 2. These are 50% duty cycle with 12us per full cycle. The controllers serially shift the latched button states out pin 4 on every rising edge of the clock, and the CPU samples the data on every falling edge.

Each button on the controller is assigned a specific id which corresponds to the clock cycle during which that button's state will be reported. The table in section 4.0 lists the ids for all buttons. Note that multiple buttons may be depressed at any given moment. Also note that a logic "high" on the serial data line means the button is NOT depressed.

At the end of the 16 cycle sequence, the serial data line is driven low until the next data latch pulse. The only slight deviation from this protocol is apparent in the first clock cycle. Because the clock is normally high, the first transition it makes after latch signal is a high-to-low transition. Since data for the first button (B in this case) will be latched on this transition, it's data must actually be driven earlier. The SNES controllers drive data for the first button at the falling edge of latch. Data for all other buttons is driven at the rising edge of clock. Hopefully the following timing diagram will serve to illustrate this. Only 4 of the 16 clock cycles are shown for brevity.

Imagen




6. SNES Controller Button-to-Clock Pulse Assignment

Imagen

Additional notes:

Clock cycles 13-16 are left high by controllers. On a mouse, cycle 16 is low.

The way the SNES responds if data is low during these cycles varies from game to game. Donkey Kong contry 1 acts as there is no controller in the port, Super Bases loaded 2 does not care.

NOTE: S-VHS is not means to mean Super-VHS. It stands for Super-Video (connector and output)

OK, the SNES uses the 65816 processor, which is basically a 16-bit version of the 6502. It runs at 3.579545 MHz (color-burst), and has an 8-bit data bus. It can address up to 16MB.

The carts are nothing more than ROM. To tell you how much data is one, take the number of 'MegaBits' and divide by 8 to get megabytes. That's how much data is really in the carts. So, an 8-mbit cart really is only 1 megabyte.





7. SNES Mouse Protocol

The snes mouse uses the same timing and protocol as a regular pad for it's buttons. The left button is reported at the 9th cycle, and the right button at the 10th cycle. The snes recognizes the mouse when the bit at the 16th clock cycle is low instead of high.

2.5ms after the 16 clock pulses, another series of clock pulses occurs. This is in fact cycles 17 to 32 since no new latch pulse had occured yet. The data is active low, just like the buttons. This time, the clock timing is different:

Imagen

Each time the SNES polls the mouse, the mouse reports how it moved since last poll. When no movement occured since last poll, all the motion bits stays high (which means binary 0). The direction bits keep their last state.
Mouse sensitivity:

The mouse has 3 configurable sensitivity levels. The currently active sensitivity level is reported by bits 11 and 12:

    · Bit 11 low, Bit 12 high: High sensitivity
    · Bit 11 high, Bit 12 low: Medium sensitivity
    · Bit 11 high, Bit 12 high: Low sensitivity


Selecting the sensitivity mode:

A special sequence is used to rotate between the 3 modes. First, a normal 12us latch pulse is applied. Next, the first 16 bits are read using normal button timings. Shortly after (about 1ms), 31 short latch pulses (3.4uS) are sent, with the clock going low for 700ns during each latch pulse. For selecting a specific sensitivity, simply execute the special sequence until bits 11 and 12 are as desired.


Fuente: repairfaq.org



ImagenVolver a la página principal.
Ahora que veo estos diagramas de los pinouts de los pad de SNES, no hay aun reviews de ningun periferico?? yo me ofrezco para hacer una del Capcom Power Stick Fighter.
Las reviews de los perifericos tienen la dificultad de que no valen los videos de youtube XD. Hay que probarlos primero, y la mayoría no tuvo ninguno.

...sobre el mando ese, pues no se mucho como hacer una review. Fijate en alguna review sobre mandos por internet, para saber como currarte tu la tuya, aunque apenas bastará con hablar de sus funciones (turbo, memoria, lo que sea), y sus caracteristicas (4 u 8 direcciones, peso, fijación a la mesa, materiales, si es de control sensible o duro, etc).

Será genial ver inaugurada esa sección de una vez :)
Las reviews de los perifericos tienen la dificultad de que no valen los videos de youtube XD. Hay que probarlos primero, y la mayoría no tuvo ninguno.

...sobre el mando ese, pues no se mucho como hacer una review. Fijate en alguna review sobre mandos por internet, para saber como currarte tu la tuya, aunque apenas bastará con hablar de sus funciones (turbo, memoria, lo que sea), y sus caracteristicas (4 u 8 direcciones, peso, fijación a la mesa, materiales, si es de control sensible o duro, etc).

Será genial ver inaugurada esa sección de una vez :)


jaja no te compliques tanto, que hga le review, seguro sabe como hacerla y va quedar genial [+risas] [+risas]
Ralph escribió:Las reviews de los perifericos tienen la dificultad de que no valen los videos de youtube XD. Hay que probarlos primero, y la mayoría no tuvo ninguno.

...sobre el mando ese, pues no se mucho como hacer una review. Fijate en alguna review sobre mandos por internet, para saber como currarte tu la tuya, aunque apenas bastará con hablar de sus funciones (turbo, memoria, lo que sea), y sus caracteristicas (4 u 8 direcciones, peso, fijación a la mesa, materiales, si es de control sensible o duro, etc).

Será genial ver inaugurada esa sección de una vez :)


Bien, te mando un mp entonces cuando tenga algo pronto, perifericos de Super Nintendo tengo el Capcom stick, un multitap y el game genie, tuve tambien el Super Scope con casi todos sus juegos, asi que mas o menos tengo una idea de como funcionan, y desde luego si hago el review incluiré mis propias fotos.
ok :)

...aprovecho para decir que he corregido algunas cosillas, como el listado de opcodes de la documentación técnica de ensamblador para ASM... algunas imagenes de algún artículo por ahí, etc.
La verdad es que te lo estas currando tio, esta quedando el hilo genial.Que no pare la cosa [oki]
Estoy intentando encontrar información sobre los juegos que usaron resoluciones superiores a la habitual de 256x224, pero google no me soluciona mucho la búsqueda, ¿alguien conoce algún link que ofrezca información al respecto?.
Mi análisis: Secret of Evermore

Imagen

Compañia: Square
Año lanzamiento: 1996 en PAL traducido al español
Players: 1 player
Megas: 24

Quiero compartir mi análisis personal de este juego, querido por muchos y odiados por otros tantos.

1996, SNES ya da sus últimos coletazos, pero vaya coletazos! SEGA ya tiene instaurado un sistema de 32 bits, Sega Saturn, y la megadrive dispone de 2 add-ons (Mega CD y 32X) que augmentan su potencial hasta los 32 bits. Y desde 1994 estamos inmersos en la dura batalla de los diferentes sistemas de 32 bits, con Sony y su PSX en cabeza.

Y... ¿Nintendo? Aún faltan un par de años para que la N64 salga en todo el mundo y instaure su nuevo sistema de 64 Bits así que de momento la política de Nintendo va a ser la de aguantar el chaparrón como fuere, obligando a exprimir a sus sistemas portátil de 8 Bits GameBoy y 16 Bits Super Nintendo hasta límites insospechados.

Doy fe de que no le salió mal la jugada, y pocos sistemas han sido tan exprimidos como la SNES.

Ya en 1996, Square, gigante de los RPG's, donde cuenta con un catálogo extraordinario en SNES, mas en japón y USA que en PAL, dudan entre sacar al mercado europeo el juego Chrono Trigger... o otro juego llamado Secret of Evermore.

Ya en esa época le Chrono Trigger destacaba y las revistas del sector se hacían eco, haciendo babas a los chavalines que ojeaban esas revistas soñando en no tener que recurrir al mercado de importación y gastarse 20.000 pesetas o mas por el juego + adaptador.

La decisión final de Square fue traer el Secret of Evermore, supongo que porque es un juego más occidentalizado, y el género de los RPG's en europa no estaba tan curtido ni instaurado (aunque por fans no sería, siendo francos) así que el hecho de traducir un juego de estas características les supuso una inversión que les hizo creer que Secret of Evermore sería una apuesta más segura entre los aficionados que Chrono Trigger, más "orientalizado"

Sea como fuere, aquí recibimos nuestro segundo RPG traducido al castellano para nuestra querida SNES, y debido a que no podía ser los 2 juegos, 1 se descartó, y este 1 no es ni mas ni menos que uno de los mejores RPG's de toda la historia.

¿Razón suficiente para cruzificar y maldecir para siempre al SoE?

En mi opinión, NO

El análisis

-Años 60. Un chaval con su perro va a ver una peli al cine. Al salir el perro se cruza con un gato y se pierde. El chico busca al perro y va a parara a unas instalaciones abandonadas, donde entra en una especie de laboratorio. Se encuentra con un artefacto que al tocarlo lo envia a otro lugar futurista donde un científico y su sirviente están trabajando en algo... el sirviente invita al chico a una sala, se marcha y unos robots te atacan. Cojes el bazooka, les das boleto, y te metes en una máquina. Sales disparado con una nave, y... aterrizas en la prehistoria!!!!!!! Y tu perro parece un lobo!!!!

¿Que ha pasado? Si de un paseo por las calles de podunk, acabas en la edad de piedra!

Y así empieza una de las mejores aventuras de SNES, a mi gusto por supuesto.

Tendrás que ir descifrando qué te ha pasado, ayudando a los diferentes líderes de los diferentes mundos que forman el juego, la prehistoria, edad clásica, media y futurista!

Y lo más importante, debes encontrar el camino a casa, a tu querida podunk! Pero... ¿Como? ¿Encontrarás más habitantes de podunk que te ayudarán en tu aventura? ¿Fuerzas superiores que conspirarán para que fracases?

¡Descúbrelo tu mismo, vale la pena!

Valoración personal

Juego muy ameno, divertido y directo, muy personalizable, com muchas fórmulas de alquimia (magias) a descubrir y usar, muchos secretos, armas que puedes subir de niveles, variedad de situaciones y paisajes... algunos desesperantes como el bosque ó los laberintos del castillo xd

Action RPG que copia el sistema del Secret of mana, de los anillos, atacas y la barra de energia baja al 0%, has de esperar a que se llene al 100% para que tus golpes sean lo máximo de efectivos posible.

Técnicamente a mi me gusta mucho, tiene excelentes gráficos, muy detallados y animados, con una estética no tan "oriental", mucho mas occidentalizado todo, como mas "en serio", el sonido, como de costumbre en Square, es excelente la banda sonora

Ya para acabar decir que este juego salió en castellano, en caja grande con la guía de pistas incluída, como el Illusion of Time, y que el precio de este juego completo, cuesta más de 60€ de media, siendo uno de los juegos más caros y valorados en PAL de SNES. Una lástima, de verdad, porque impide que muchos usuarios no se lo puedan permitir y gaudir de este juegazo.

Valoración total: 95
Juego muy ameno, divertido y directo, muy personalizable, com muchas fórmulas de alquimia (magias) a descubrir y usar, muchos secretos, armas que puedes subir de niveles, variedad de situaciones y paisajes... algunos desesperantes como el bosque ó los laberintos del castillo xd


+10

Excelente juego, en efecto. Se me ha quedado grabado en la memoria cuando llegas al Mercado ( mercadeando ademas para conseguir items e ingredientes ), cuando vuelas en el cohete y la lucha en la arena de gladiadores.

Si que es cierto que la SNES tuvo un final potente.
Creo que solo hubieron dos RPG's traducidos al castellano, aunque nunca los jugué. Yo era de los que leía en las revistas el revuelo que se montaba porque un juego "de esos"(nótese el desdén) salía traducido, y flipaba un poco con toda la cobertura que se le brindaba al juego.

En su día me acabé el zelda (enterandome de la mitad), y jugué "unos minutos" al secret of maná, aunque ya ni me acuerdo de si este estaba traducido al español (no se, no creo). No le vi nada especial, no solo al juego, si no al genero. Personalmente, incluso hoy en día soy muy reacio, además, prefiero un action RPG, que un JRPG... y si me obligan... antes prefiero perder un pié. Supongo, de todos modos, que como hoy en día uno ya es mas mayor, y por lo tanto mas capaz de demostrar un poco de paciencia, podría hacer el esfuerzo, y también apreciar mas los detalles que lo que una mente infantil puede llegar a hacer.

Algún día... antes tengo que escribir un libro, conocer las vegas, montarmelo con una famosa, construir una casa en el campo, conducir un ferrari, adoptar una china, y jubilarme... y luego ya veremos si me alcanzan los reflejos [sati]

...no se, algún día me pondré, seguro.
Ralph escribió:Creo que solo hubieron dos RPG's traducidos al castellano, aunque nunca los jugué. Yo era de los que leía en las revistas el revuelo que se montaba porque un juego "de esos"(nótese el desdén) salía traducido, y flipaba un poco con toda la cobertura que se le brindaba al juego.

En su día me acabé el zelda (enterandome de la mitad), y jugué "unos minutos" al secret of maná, aunque ya ni me acuerdo de si este estaba traducido al español (no se, no creo). No le vi nada especial, no solo al juego, si no al genero. Personalmente, incluso hoy en día soy muy reacio, además, prefiero un action RPG, que un JRPG... y si me obligan... antes prefiero perder un pié. Supongo, de todos modos, que como hoy en día uno ya es mas mayor, y por lo tanto mas capaz de demostrar un poco de paciencia, podría hacer el esfuerzo, y también apreciar mas los detalles que lo que una mente infantil puede llegar a hacer.

Algún día... antes tengo que escribir un libro, conocer las vegas, montarmelo con una famosa, construir una casa en el campo, conducir un ferrari, adoptar una china, y jubilarme... y luego ya veremos si me alcanzan los reflejos [sati]

...no se, algún día me pondré, seguro.


Salieron 4 rpg's en castellano: Illusion of time, Secret of evermore, Terranigma y Lufia II
YuPiKaIe escribió:Salieron 4 rpg's en castellano: Illusion of time, Secret of evermore, Terranigma y Lufia II


Exacto, los dos primeros con caja grande y libro de pistas, el tercero con libro de pistas opcional (lo tenías que pedir a Nintendo España) y el cuarto mondo y lirondo como cualquier juego de SNES.

Mirad, aquí tengo dos reportajes sobre la traducción de juegos de SNES al castellano que a mí, personalmente, me fascinaron:

http://magno.romhackhispano.org/Traduccion_IllusionOfTime.pdf
http://magno.romhackhispano.org/Traduccion_RPG.pdf

Recuerdo cómo leía esas noticias con avidez pensando en todo el revuelo que significaba traducir un juego... y es por eso que yo empecé a hacer traducciones al castellano, al ver que el Secret of Mana no llegó a salir traducido al castellano pero sí al alemán y al francés.

Ah, y otro reportaje que me encantó, el de los Dragon Quest para SNES:


http://magno.romhackhispano.org/Saga_DragonQuest.jpg
El Secret of evermore es un juegazo impresionante!
Me encantaría tener el de la caja grande.


Gracias magno por los pdfs :)
Se me acumula el trabajo, y esto es un caos ya. Iba a hacerlo directamente, pero quiero decirlo primero, mas que nada para que no os volvais locos. Puede ocurrir que postée algo de documentación sobre la super nes(o lo que competa) justo en la página siguiente de la publicación de una review (NUNCA en la misma página, recordemos que es mejor evitar que coincidan dos aportaciones en el mismo espacio), así que si esto sucede, que sepais que la intención no es distraeros de comentar la review pertinente (que tengo ya material de sobra, y aunque me da palo que quede todo tan de seguido, supongo que ya vendrá el momento en que todo adquiera un ritmo mas dinámico y coherente).


YuPiKaIe escribió:Salieron 4 rpg's en castellano: Illusion of time, Secret of evermore, Terranigma y Lufia II


Que se me pase el lufia, vale, pero el terranigma... [toctoc]


magno escribió:Mirad, aquí tengo dos reportajes sobre la traducción de juegos de SNES al castellano que a mí, personalmente, me fascinaron:

http://magno.romhackhispano.org/Traduccion_IllusionOfTime.pdf
http://magno.romhackhispano.org/Traduccion_RPG.pdf


Los recuerdo... o recuerdo al menos el primero. Eramos todos unos enanos con toda una vida por delante [buuuaaaa]


...¡¡¡qué nos ha pasado!!!.


[sonrisa]
Que recuerdos me trae esta review del Secret of Evermore. Fue mi primer RPG, género que no es de mis favoritos, pero este juego me marcó.


Saludos
Hola Ralph un post estupendo no he podido leerlo entero, solo la 1º parte de "Acontecimientos simultaneos" el cual me ha dejado todos los pelos erizados jaja que buena narracion, me lo apunto en favoritos para leerlo enterito.

Saludos.
Hola, queria aportar un pequeño granito de arena y aqui os dejo unos prototipos de lo que podria haber sido la super nintendo tanto en japon como en usa:

Imagen

Imagen

Un saludo.
Respecto al Secret of Evermore, es buen juego, pero pienso que está bastante sobrevalorado.

A mi me parece el peor con diferencia de los que nos llegaron traducidos y muy inferior a Secret of Mana por ejemplo. No sé, sólo pensar que aquí no llegaran juegos como Chronno trigger, Tales of Phantasia, Bahamut Lagoon, los Romancing Saga.....
Sin desmerecer a Secret of evermore la verdad, pero en mi opinión es un juego que no pasa del notable bajo, especialmente por el poco carisma de la historia y personajes. Es mi opinión repito, y respeto totalmente a quien le encantara el juego por supuesto.
skelton escribió:Respecto al Secret of Evermore, es buen juego, pero pienso que está bastante sobrevalorado.

A mi me parece el peor con diferencia de los que nos llegaron traducidos y muy inferior a Secret of Mana por ejemplo. No sé, sólo pensar que aquí no llegaran juegos como Chronno trigger, Tales of Phantasia, Bahamut Lagoon, los Romancing Saga.....
Sin desmerecer a Secret of evermore la verdad, pero en mi opinión es un juego que no pasa del notable bajo, especialmente por el poco carisma de la historia y personajes. Es mi opinión repito, y respeto totalmente a quien le encantara el juego por supuesto.


Yo pienso lo mismo que tu, pero igual que lo pienso con este, lo pienso con el illusion of time o terranigma (lufia 2 no lo he jugado porque intente jugar al lufia 1 y no pude...) y sobretodo el terranigma si que pienso que esta sobrevaloradisimo, aunque eso no significa que sea malo ni mucho menos...

salu2
Hablando de RPG ¿Que tal esta el Star ocean? es de los pocos RPG de SNES que aun no he jugado :(
ryo hazuki escribió:Hablando de RPG ¿Que tal esta el Star ocean? es de los pocos RPG de SNES que aun no he jugado :(


Muy, muy recomendable. Una pena que este también se lo quedaran los japos y no lo catáramos por aquí.
1397 respuestas
1, 2, 3, 4, 528