The wiki has been upgraded to MediaWiki 1.43. The wiki's theme is still being adapted to work with the new version, and may appear broken for the time being. --RanAS

es/Hitman Tool ASM API

From SnesLab
Jump to: navigation, search
English Português Español 日本語

Aquí puedes consultar las rutinas de Hitman Tool que se usan desde un sprite o desde UberASM. Si todavía estás creando las cajas de tu sprite, empieza por Archivos y Formatos.

Preparar el código

Instala Hitman Tool antes de ensamblar el código que lo usa. Las rutinas públicas aparecen como !Hitman_Base_* en HitmanDefines.asm. Utiliza las definiciones generadas para la ROM donde vas a insertar el recurso. Consulta el Quick Start para configurar PIXI y UberASMTool.

Las rutinas de esta página se llaman con JSL y regresan con RTL. Salvo donde se indique otro ancho, prepara A, X e Y en 8 bits. Varias rutinas usan las mismas variables temporales. Si necesitas leer los bordes de una caja o el resultado de un callback, hazlo antes de la siguiente comprobación.

Defines de Hitman

Usa el HitmanDefines.asm que generó Hitman Tool para tu ROM. Si cambias una propiedad, reubicas la RAM o vuelves a instalar el parche, vuelve a ensamblar el código que usa estos defines.

Nombre Qué representa
!Hitman_Base_ + nombre Dirección de una rutina base, por ejemplo !Hitman_Base_CheckNormalPair.
!Hitman_Callback_ + nombre Dirección de un callback incluido en la instalación, por ejemplo !Hitman_Callback_SetBit3.
!Hitman_Prop_ + Name del JSON Dirección de una tabla con un byte por slot de Normal sprite.
!MiSpriteHitboxContext Contexto que genera MiSprite.hitboxinfo. Suma el número de pose para elegir sus cajas.
!HitmanNormal*, !HitmanCluster*, !HitmanExtended* Tablas por slot. Incluyen ContextIDLow, ContextIDHigh, Flip y los bytes Low y High de XOff, YOff, Width y Height.
!HitmanSprite1X, !HitmanSprite1Y, !HitmanSprite1Flip Posición y orientación temporales del objeto 1. El objeto 2 tiene los defines equivalentes con Sprite2.
!HitmanHB1Left, !HitmanHB1Top, !HitmanHB1Right, !HitmanHB1Bottom Bordes de 16 bits de HB1. Usa los mismos sufijos con !HitmanHB2 para HB2.
!HitmanHBStatus y !HitmanDefault Relación entre las cajas y resultado acumulado de los callbacks, respectivamente.
!HitmanEventShell, !HitmanEventRegular, !HitmanEventExplosion, !HitmanEventFireball, !HitmanEventYoshiFireball, !HitmanEventQuake, !HitmanEventCapeDive, !HitmanEventShellHit Máscaras de eventos vanilla. Se usan para configurar los bits o comparar el evento que llega en A.
!HitmanRAMBase, !HitmanRAMLimit, !HitmanRAMEnd Inicio, límite reservado y fin del bloque ocupado. Consulta Reubicar la RAM de Hitman.

Leer o cambiar una propiedad

Si defines "Name": "IsLarge" en el JSON, Hitman genera !Hitman_Prop_IsLarge. Usa el slot del Normal sprite en X para consultar esa propiedad. Cada instancia tiene su propio valor.

; A e índices de 8 bits. X = slot del Normal sprite que quieres consultar.
LDA !Hitman_Prop_IsLarge,x
BEQ .Pequeno
; Aquí puedes aplicar la respuesta para un sprite grande.

También puedes cambiar el valor de esa instancia con STA !Hitman_Prop_IsLarge,x con A de 8 bits. El JSON proporciona el valor inicial al preparar el slot.

Publicar la hitbox de un Normal sprite

Cuando otro sprite quiere saber si te toca, Hitman lee !Hitman_Prop_HitboxSystem,x para saber qué cajas debe comprobar. X es el slot del Normal sprite.

Valor Geometría
$00 Deshabilitada en los recorridos vanilla de Hitman.
$01 Clipping del juego. Es el valor inicial.
$02 Una caja en RAM con desplazamientos con signo y dimensiones de 8 bits.
$03 Las cajas de la pose activa de un contexto.
$04 Una caja en RAM con desplazamientos con signo y dimensiones de 16 bits.

En modo $03, guarda el contexto más el número de pose en !HitmanNormalContextIDLow,x y !HitmanNormalContextIDHigh,x. Guarda el volteo en !HitmanNormalFlip,x (0 normal, 1 horizontal, 2 vertical y 3 ambos). Actualiza estos datos al cambiar la pose o la orientación. Así, otro sprite puede consultar las cajas del receptor.

Interacciones vanilla

Usa estas rutinas cuando quieras que el juego se encargue de la interacción. Por ejemplo, un proyectil custom puede comportarse como una bola de fuego de Mario.

Rutina Entrada en X Qué ejecuta
!Hitman_Base_RunVanillaSpriteInteraction Slot normal actual, también en !SpriteIndex. Interacción entre Normal sprites.
!Hitman_Base_RunVanillaFireballInteraction Slot del Extended sprite. Recorrido de bolas de fuego de Mario o Yoshi, según el evento configurado.
!Hitman_Base_RunVanillaQuakeInteraction Slot del Quake sprite, de 0 a 3. Avanza el temporizador y comprueba los receptores cuando corresponde.

Flags y callbacks de eventos

VanillaEventMask habilita la notificación de cada evento. ActionFlag acumula los bits y el código que los consume decide cuándo limpiarlos. VanillaResponseMask controla las respuestas del juego. Los valores iniciales de las máscaras son $00 y $7F, respectivamente.

Bit Evento Campo de VanillaCallbacks Y al entrar
$01 Impacto de caparazón o ítem SpriteSprite Slot normal de la contraparte
$02 Contacto regular entre sprites SpriteSprite Slot normal de la contraparte
$04 Explosión VanillaInteractionCallback (campo de respaldo del JSON) Slot de la explosión
$08 Bola de fuego de Mario Fireball Slot del Extended sprite
$10 Bola de fuego de Yoshi YoshiFireball Slot del Extended sprite
$20 Quake Quake Slot del Quake sprite
$40 Cape dive CapeDive $FF
$80 Aviso posterior para un ítem que sigue en estado $09 o $0A SpriteSprite Slot normal de la contraparte

El callback se ejecuta después de la respuesta del juego. Recibe en A el bit del evento actual, en X el slot del receptor y en Y el origen indicado en la tabla. A e índices entran en 8 bits y DBR apunta al banco del callback. Regresa con RTL, la pila balanceada y D y los anchos de registro preservados. El despachador restaura X, Y y DBR. Carry se ignora. El bit $80 solo genera una notificación.

Filtrar el contacto entre Normal sprites

SetSpritePairCollision

Permite o bloquea el contacto vanilla entre dos slots normales. Pasa los slots en X e Y y usa A en $00 para bloquear o $01 para permitir. Con una sola llamada bloqueas el contacto en ambos sentidos. La rutina preserva X, Y, DBR y D, usa $00–$01 como scratch e ignora slots inválidos y pares formados por el mismo slot.

Por ejemplo, un sprite que transporta a otro puede bloquear temporalmente el contacto entre ambos.

; X = sprite que carga, Y = pasajero.
LDA #$00
JSL !Hitman_Base_SetSpritePairCollision

Al soltar al pasajero, comprueba que Y siga siendo su slot y repite la llamada con A en $01. Hitman restablece los pares al inicializar un slot.

SetSpriteSlotCollision

Aplica el mismo cambio a todas las parejas del slot normal X. Usa A en $00 para bloquear o $01 para permitir. La rutina usa $00–$02 como memoria temporal.

Configurar Extended sprites

Edita ASM/ExtendedSpriteTablesConfig.asm en la carpeta de Hitman Tool. Las macros se evalúan al instalar el parche. En estas macros escribes el número del proyectil. Por ejemplo, $05 identifica las bolas de fuego de Mario. Cuando hagas una comprobación durante el juego, pasa el slot de la bola de fuego que quieres comprobar.

Modo de %SetExtendedHitboxSystem Geometría
$00 Deshabilitada.
$01 Caja fija definida por %SetExtendedHitbox(id, xOffset, yOffset, width, height).
$02 Caja en RAM con offsets con signo y dimensiones de 8 bits. Publica X/Y en las tablas !HitmanExtendedXOffLow y !HitmanExtendedYOffLow, y el tamaño en !HitmanExtendedWidthLow y !HitmanExtendedHeightLow, indexadas por slot.
$03 Cajas por pose. Publica los dos bytes de contexto más pose en !HitmanExtendedContextIDLow y !HitmanExtendedContextIDHigh y la orientación en !HitmanExtendedFlip, indexados por slot.
$04 Caja en RAM de 16 bits. Publica las partes Low y High de cada offset y dimensión.

El contexto y algunos desplazamientos usan los mismos bytes. Si pasas de cajas por pose a una caja en RAM, vuelve a guardar sus desplazamientos y dimensiones antes de comprobarla.

%SetExtendedFireballEvent(id, event) configura la respuesta independientemente de la geometría. Usa !HitmanEventFireball para la respuesta de bola de fuego de Mario, !HitmanEventYoshiFireball para la de Yoshi o $00 si el proyectil decide su propia respuesta. Mario ($05) y Yoshi ($11) usan cajas fijas por defecto.

Por ejemplo, esta línea cambia la caja fija de la bola de fuego de Mario. La caja mide 12 × 19 píxeles y empieza 32 píxeles a la derecha y 4 por encima del origen.

%SetExtendedHitbox($05, $0020, $FFFC, $000C, $0013)

Para aplicar la respuesta vanilla desde un proyectil llama a RunVanillaFireballInteraction. Para consultar si un proyectil toca a un Normal sprite usa CheckExtendedNormalPair y lee Carry.

Callbacks incluidos

En un .hitboxinfo escribe el nombre de la rutina, por ejemplo .OnPlayerCollision CheckBounce. Hitman incorpora las rutinas seleccionadas desde Routines/ y exporta sus direcciones como !Hitman_Callback_*. Para la sintaxis de cada formato, consulta Archivos y Formatos.

Dentro de un callback puedes leer los bordes de las dos cajas en HB1 y HB2, o consultar su posición relativa en !HitmanHBStatus. A, X e Y están en 8 bits y Y contiene el ID histórico de la caja. Regresa con RTL y deja balanceada la pila. Los callbacks pueden acumular bits en !HitmanDefault, que el código llamador consume para decidir qué respuesta aplicar.

Callback Uso
Nothing Retorna sin cambiar el resultado.
SetBit3 Añade la máscara $04 a !HitmanDefault.
CheckBounce Selecciona una superficie de rebote para un Normal sprite, registra sus bordes y distingue la protección cuando Mario está dentro.
CheckBounceBit2, CheckBounceBit3 Ejecutan CheckBounce y añaden $02 o $04 si el bit alto de $65 está apagado.
CheckPlayerIsAbove Comprueba la posición de Mario para el sistema de rebote, respetando la protección interior.
ItemCheckBounce, ItemCheckPlayerIsAbove Adaptan esas comprobaciones al estado de un ítem.
CheckBounceCluster, CheckBounceClusterNoYSpeed Variantes de rebote para Cluster sprites.
CheckBounceSurface Registra una superficie para la respuesta de rebote.
PlayerFloor, PlayerLeftWall, PlayerRightWall Comprueban la caja como suelo, pared izquierda o pared derecha para Mario.
DefaultBottomFloorAndDirectionWall Prueba primero el suelo. Si la prueba falla, selecciona una pared según la dirección del sprite.
SolidForPlayer, SolidForPlayerWithSkip Variantes para tratar la caja como una superficie sólida para Mario.

Si tu sprite usa las rutinas de rebote de Dyzen, ejecuta %DyzenPrepareBounce() antes de recorrer las cajas. %DyzenBounce() usa el resultado para aplicar el rebote y %DyzenDetectPlayerIsAbove() actualiza el temporizador de protección interior. Conserva el scratch de ese recorrido entre las llamadas. El callback guarda los bordes en $6A (arriba), $6C (izquierda), $6E (derecha) y $1487|!addr (abajo).

Llamar un callback desde ASM

Si Hitman incluyó el callback al instalar, llama a su define con JSL !Hitman_Callback_Nombre. El callback vuelve con RTL. Prepara los registros y las variables que espera esa rutina. Por ejemplo, un callback que comprueba una pared necesita que HB1 y HB2 ya contengan las cajas.

; A en 8 bits y !HitmanDefault ya inicializado para esta comprobación.
JSL !Hitman_Callback_SetBit3

SetBit3 añade $04 a !HitmanDefault. La llamada por sí sola no comprueba colisión. Para que Hitman incluya un callback, decláralo en la configuración que lo usa o en Dependencies: de un HitboxInfo legacy. Consulta Incluir rutinas auxiliares.

Crear un callback

Crea Routines/RegistrarContacto.asm dentro de la carpeta de Hitman Tool. El nombre de la etiqueta debe coincidir con el del archivo, sin .asm. En este ejemplo, el callback marca el bit $01 de !HitmanDefault para que el sprite sepa que tocó a Mario.

RegistrarContacto:
    LDA #$01
    TSB.b !HitmanDefault
    RTL

En el .hitboxinfo, añade esta línea dentro de la caja que debe activar el callback.

    .OnPlayerCollision RegistrarContacto

Vuelve a ejecutar Hitman Tool. Al leer el archivo de hitboxes, incluirá la rutina en el parche y generará !Hitman_Callback_RegistrarContacto. Después de insertar el sprite con PIXI, Hitman ejecutará el callback al comprobar el contacto con esa caja. Si necesitas llamarlo tú mismo desde ASM, usa JSL !Hitman_Callback_RegistrarContacto con A de 8 bits y el acumulador de resultados ya preparado.

Crear una rutina base

Usa una rutina base para compartir código entre sprites o recursos de UberASM. Por ejemplo, puedes crear una rutina que devuelva en Carry si el Normal sprite de X tiene activa la propiedad IsLarge.

Crea Patch/BaseRoutines/EsSpriteGrande.asm y ponle una etiqueta con el mismo nombre que el archivo. Este ejemplo requiere que hayas definido IsLarge en CustomProperties/.

; Entrada: A e índices de 8 bits. X = slot de un Normal sprite.
; Salida: C = 1 si IsLarge es distinto de cero. X e Y se conservan.
EsSpriteGrande:
    LDA !Hitman_Prop_IsLarge,x
    CMP #$01
    RTL

Hitman incluye automáticamente los archivos .asm que encuentra directamente en Patch/BaseRoutines/. Vuelve a ejecutar la instalación para que genere !Hitman_Base_EsSpriteGrande. Luego vuelve a ensamblar los recursos con PIXI o UberASMTool sobre la ROM de salida. Usa la nueva definición así:

    JSL !Hitman_Base_EsSpriteGrande
    BCC .Pequeno
    ; Aplica aquí la respuesta para un sprite grande.
.Pequeno

Usa nombres únicos para las etiquetas de entrada y documenta qué espera y qué modifica cada rutina. Los archivos Patch/Files/Includes.asm y HitmanDefines.asm se regeneran al instalar. Basta con añadir el archivo fuente en la carpeta correspondiente.

Reubicar la RAM de Hitman

Hitman guarda sus tablas de sprites, sus propiedades y los filtros de contacto en un bloque de RAM. Si otro parche usa esa zona, puedes mover el bloque entero. La última columna indica la primera dirección que queda fuera de la reserva.

ROM Base Límite exclusivo
LoROM $7FAC40 $7FAF00
LoROM con Free7E2000 reconocido $7E7000 $7E7D00
SA-1 $408000 $409400
  1. Consulta el rango ocupado y la cantidad de bytes en el log de instalación. Cada propiedad personalizada añade un byte por slot normal.
  2. Elige un rango disponible para tu ROM que tenga espacio para todas las tablas, que no cruce de banco y que puedas usar junto con Dynamic Xtreme y los demás parches.
  3. En ASM/HitmanDefines.asm de la distribución, asigna la primera dirección a !HitmanRAMBase y la primera dirección fuera de la reserva a !HitmanRAMLimit. Configura ambos valores juntos. En el código fuente, la plantilla está en HitmanBackend/ASM/HitmanDefines.asm.
  4. Reinstala Hitman y comprueba que !HitmanRAMEnd, el extremo exclusivo usado, no supere el límite elegido. Vuelve a ensamblar los recursos de PIXI y UberASM con los defines nuevos.

La reubicación cambia las tablas persistentes. HB1, HB2, !HitmanHBStatus y !HitmanDefault siguen siendo memoria temporal de colisión.

Rutinas de interacción manual

Si la rutina recibe una pose en A, calcula contexto base + pose actual antes de cada llamada. Lee la pose de la variable que usa tu sprite para animarse. Las tablas ContextIDLow y ContextIDHigh guardan el contexto publicado para que otros recursos puedan consultar esa hitbox.

CheckNormalPair

Usa JSL !Hitman_Base_CheckNormalPair si ya tienes los slots de los dos Normal sprites en X e Y. Si se tocan, Carry queda en 1. Puedes seguir usando X, Y, DBR y D después de la llamada. La comprobación reutiliza la memoria temporal de colisión. Si has bloqueado la pareja con SetSpritePairCollision, el bloqueo se aplica al recorrido vanilla.

CheckExtendedNormalPair

Si quieres saber si un proyectil toca a un Normal sprite, pon el slot del Normal sprite en X y el del proyectil en Y. Llama a JSL !Hitman_Base_CheckExtendedNormalPair y comprueba Carry. Con Carry en 1 puedes aplicar tu propia respuesta al impacto. La rutina conserva X, Y, DBR y D, y reutiliza la memoria temporal de colisión.

ProcessHitBoxesWithoutCallback

Compara las cajas de una pose contra un rectángulo preparado en HB2. Puedes llamar a esta rutina desde UberASM para comprobar una zona sin reservar un slot de sprite.

  • Con A en 16 bits, pasa el contexto más el número de pose. Entra con índices de 8 bits y la página directa del juego.
  • Guarda el origen de la pose en !HitmanSprite1X y !HitmanSprite1Y. Prepara !HitmanSprite1Flip y los cuatro bordes de HB2 (!HitmanHB2Left, !HitmanHB2Top, !HitmanHB2Right y !HitmanHB2Bottom).
  • Suma $0100 a cada coordenada del origen y a cada borde antes de guardarlos.
  • Carry queda en 1 al encontrar contacto y HB1 contiene la primera caja que tocó el rectángulo. Carry queda en 0 si ninguna caja toca la zona. A e índices regresan en 8 bits. Trata A, Y, HB1 y los punteros temporales de hitbox como scratch.

Con las coordenadas y el volteo ya preparados, esta llamada comprueba la pose 0 de Zone.hitboxinfo.

REP #$20
LDA.w #!ZoneHitboxContext
JSL !Hitman_Base_ProcessHitBoxesWithoutCallback
BCC .SinContacto
; HB1 contiene la caja que tocó la zona.
.SinContacto

PlayerNormalSpriteInteraction

Comprueba las cajas de una pose de un Normal sprite contra Mario y ejecuta los callbacks correspondientes. Pasa el slot en X, el volteo en !HitmanSprite1Flip y el contexto más la pose en A de 16 bits. Entra con índices de 8 bits. Según la distancia, el frame, el estado de Mario y el lado del escenario en que esté, Hitman puede saltarse la comprobación.

Carry indica si los callbacks dejaron un valor distinto de cero en !HitmanDefault. Un contacto puede dejar Carry en 0 si el callback no escribe un resultado. La llamada devuelve A a 8 bits.

PlayerSpriteInteraction

Llamada. Usa JSL !Hitman_Base_PlayerNormalSpriteInteraction, JSL !Hitman_Base_PlayerClusterSpriteInteraction o JSL !Hitman_Base_PlayerExtendedSpriteInteraction según la familia. Con X e Y de 8 bits, pasa el slot del sprite en X, el contexto más la pose en A de 16 bits y el volteo en !HitmanSprite1Flip.

Resultado. Las tres llamadas comparan las cajas de la pose con Mario. Si algún callback deja un resultado en !HitmanDefault, Carry queda en 1. Si solo quieres saber si el sprite toca a Mario, usa InteractionWithoutCallback con los mismos datos. Carry queda en 1 en cuanto una caja toca a Mario. Las variantes OneHitboxInteraction y OneLongHitboxInteraction entran con A también de 8 bits, leen una caja de las tablas RAM del slot y devuelven Carry de contacto. La primera lee dimensiones y offsets de 8 bits y la segunda de 16. Las llamadas regresan con A de 8 bits.

El cálculo es igual para Normal sprites, Cluster sprites y Extended sprites. REP #$21 pone A en 16 bits y limpia Carry para la suma. AND.w #$00FF conserva solo el byte de la pose.

Ejemplo. En un Extended sprite sin volteo, usa la pose actual. !PoseIndex guarda el índice de la pose actual del sprite. Puedes definir tu propia tabla de un byte por slot y actualizarla al cambiar de pose. Si usas Dynamic Xtreme, puedes leer !LastPoseIndex,x en su lugar cuando tenga una pose válida y uses los mismos índices en el archivo de hitboxes.

; A e índices de 8 bits al comenzar. X = slot extended.
STZ.b !HitmanSprite1Flip
LDA !PoseIndex,x
REP #$21
AND.w #$00FF
ADC.w #!MiProyectilHitboxContext
JSL !Hitman_Base_PlayerExtendedSpriteInteractionWithoutCallback
BCC .SinContacto
; Aplica aquí la respuesta del proyectil.
.SinContacto

CapeSpriteInteraction

Llamada. Usa JSL con !Hitman_Base_CapeNormalSpriteInteraction, !Hitman_Base_CapeClusterSpriteInteraction o !Hitman_Base_CapeExtendedSpriteInteraction. X identifica el slot, A de 16 bits lleva el contexto más pose y !HitmanSprite1Flip contiene la orientación. Los índices entran en 8 bits.

Resultado. Comprueba la capa giratoria contra la pose y regresa con A de 8 bits. Carry indica un resultado en !HitmanDefault en las variantes con callbacks y contacto geométrico en las variantes WithoutCallback. Si la capa no está girando, devuelve Carry en 0. Puedes utilizar el ejemplo anterior cambiando la llamada por !Hitman_Base_CapeExtendedSpriteInteractionWithoutCallback.

FireballNormalSpriteInteraction y YoshiFireballNormalSpriteInteraction

Llamada. Usa JSL !Hitman_Base_FireballNormalSpriteInteraction para las bolas de fuego de Mario o JSL !Hitman_Base_YoshiFireballNormalSpriteInteraction para el recorrido manual histórico. X es el receptor normal y A de 16 bits contiene contexto más pose. Prepara !HitmanSprite1Flip e índices de 8 bits.

Resultado. Estas rutinas buscan proyectiles y comprueban si tocan las cajas del sprite. En la implementación actual, las cuatro variantes YoshiFireballNormalSprite* saltan los slots con ID $11. Para detectar un proyectil concreto de Yoshi, selecciona su slot y usa CheckExtendedNormalPair. Carry en 1 indica un resultado de esas acciones. InteractionWithoutCallback usa las mismas entradas y devuelve contacto geométrico. OneHitboxInteraction y OneLongHitboxInteraction toman X con A e índices de 8 bits y consultan una caja RAM de 8 o 16 bits. Para proyectiles custom configurados por número, usa CheckExtendedNormalPair desde una pareja conocida.

Recorrer Normal sprites

Llamada. Usa JSL con una de estas entradas y el prefijo !Hitman_Base_.

Entrada Origen y receptores
NormalNormalSpriteInteractionLoop Sprite normal contra otros Normal sprites.
NormalItemSpriteInteractionLoop Sprite normal contra ítems en los estados admitidos.
ClusterNormalSpriteInteractionLoop Sprite cluster contra Normal sprites.
ExtendedNormalSpriteInteractionLoop Sprite extendido contra Normal sprites.

Pasa el slot de origen en X y mantenlo también en !SpriteIndex. Pasa A de 16 bits con el contexto más pose, índices de 8 bits y el volteo en !HitmanSprite1Flip.

Resultado. Carry en 1 indica que se encontró un receptor y Y indica su slot. X vuelve al origen. Con callbacks, el recorrido se detiene cuando las acciones producen un resultado. Si solo quieres el primer sprite que toque al origen, usa la variante WithoutCallback. Cada recorrido aplica sus propios filtros.

Ejemplo. Busca el primer Normal sprite que toque las cajas de la pose actual del Extended sprite.

; X y !SpriteIndex identifican al extended. Flip ya preparado.
LDA !PoseIndex,x
REP #$21
AND.w #$00FF
ADC.w #!MiProyectilHitboxContext
JSL !Hitman_Base_ExtendedNormalSpriteInteractionLoopWithoutCallback
BCC .SinContacto
; Y identifica el receptor normal.
.SinContacto

AnyNormalSpriteInteraction

Llamada. JSL !Hitman_Base_AnyNormalSpriteInteraction toma X como slot normal receptor y !SpriteIndex como slot del origen. Prepara antes la posición, contexto y volteo del origen en las variables !HitmanSprite1*. Entra en 8 bits. La variante WithoutCallback usa los mismos datos del origen.

Resultado. Hitman lee las cajas que tenga configuradas el receptor. Con callbacks, Carry indica que las acciones produjeron un resultado. Con WithoutCallback, Carry indica que las cajas se tocan. JSL !Hitman_Base_AnyNormalSpriteInteractionOneHitbox recibe en cambio HB1 ya calculada y X como receptor, y devuelve contacto geométrico en Carry.

Preparar y comparar cajas

Rutina con prefijo !Hitman_Base_ Entradas Resultado
NormalSpritePositionSetup, ClusterPositionSetup, ExtendedPositionSetup X = slot de la familia correspondiente. Guarda X/Y de la posición en !HitmanSprite1X/Y en el convenio interno de Hitman.
NormalSpritePositionSetup2 X = slot normal. Prepara !HitmanSprite2X/Y.
NormalSpriteOneHitbox1, ClusterSpriteOneHitbox1, ExtendedSpriteOneHitbox1 X = slot con su caja RAM publicada. Calcula HB1 usando campos de 8 bits. Termina en 2 para escribir HB2.
NormalSpriteLongOneHitbox1, ClusterSpriteLongOneHitbox1, ExtendedSpriteLongOneHitbox1 X = slot con su caja RAM publicada. Calcula HB1 usando campos de 16 bits. Termina en 2 para escribir HB2.
PlayerClippingRoutine, NormalSpriteClippingRoutine Mario o Normal sprite en X, respectivamente. Prepara HB2 con el clipping del juego.
CapeClipping, CapeClippingHB1 Posición actual de la capa. Prepara HB2 o HB1, respectivamente.
FireballClipping, FireballClippingHB1, YoshiFireballClipping Y = slot extendido. Prepara HB2, HB1 y HB2, respectivamente, con la caja fija de la rutina.
FixClippingForInteraction Clipping vanilla ya cargado en scratch. Convierte ese clipping a los cuatro bordes de HB2.
CheckContact HB1 y HB2 preparadas. Carry en 1 si las cajas se tocan. Incluye bordes iguales. A regresa a 8 bits.
LoadNormalHitbox X = slot normal, Y = ordinal de la caja. Carry en 1 si HB1 contiene una caja válida. Una caja única usa ordinal 0. Preserva X, Y, DBR y D. Modifica A, $04–$07, HB1, posición temporal del objeto 2 y $98–$9B.
GetHitbox2 A de 16 bits = contexto más pose del objeto 2, índices de 8 bits y Y = ordinal. Prepara !HitmanSprite2X/Y y !HitmanSprite2Flip. Carry en 1 si cargó HB2 y en 0 al terminar la lista. Vuelve con A e índices de 8 bits.
ProcessHitBoxes Las mismas entradas que ProcessHitBoxesWithoutCallback. Recorre toda la pose y ejecuta las acciones por caja. Carry indica si !HitmanDefault quedó distinto de cero.

Llama a cada rutina de la tabla con JSL. Entra con A e índices de 8 bits salvo cuando la tabla especifique A de 16 bits.

; X = slot normal. A e índices en 8 bits.
LDY #$00
JSL !Hitman_Base_LoadNormalHitbox
BCC .SinCaja
JSL !Hitman_Base_PlayerClippingRoutine
JSL !Hitman_Base_CheckContact
BCC .SinContacto
; Mario toca la primera caja.
.SinContacto
.SinCaja

Estados, puntos y efectos

RunVanillaStatus

Llama con JSL !Hitman_Base_RunVanillaStatus seguido del sufijo de la tabla. Pasa el slot normal en X con A e índices de 8 bits. Cada entrada ejecuta el handler del estado indicado. Los cambios dependen del estado. Por ejemplo, la rutina puede mover el sprite, dibujarlo o cambiar su estado. El estado $08 se atiende en MAIN.

Estado Sufijo Estado Sufijo
$00 Erase $07 Unused
$01 Init $09 Stunned
$02 Killed $0A Kicked
$03 Smushed $0B Carried
$04 SpinJumped $0C GoalPowerup
$05 Sinking $06 LevelEndCoin

Por ejemplo, si el slot actual ya está en estado $0B, JSL !Hitman_Base_RunVanillaStatusCarried ejecuta su lógica vanilla de transporte.

Vectores de respuesta por estado

NormalSpriteExecuteCollissionResultVector usa el estado del otro sprite en Y. NormalSpriteExecuteFullCollissionResultVector usa también el estado del sprite actual en X. Ambas entradas se llaman con JSL, con A e índices de 8 bits. Coloca el retorno de tu rutina inmediatamente después del JSL y a continuación la tabla de direcciones de 16 bits del mismo banco. El handler seleccionado regresa con RTL al retorno que sigue al JSL. Si el estado no pasa la comprobación, el control vuelve directamente a la instrucción que sigue al JSL.

Usa este orden en cada grupo de la tabla: normal, estacionario, pateado y cargado. La variante completa tiene cuatro grupos en ese mismo orden según el estado del sprite actual.

Responder:
    JSL !Hitman_Base_NormalSpriteExecuteCollissionResultVector
    RTS
    dw .Normal, .Estacionario, .Pateado, .Cargado
.Normal
    RTL
.Estacionario
    RTL
.Pateado
    RTL
.Cargado
    RTL

Utilidades

Llama con JSL y el prefijo !Hitman_Base_, con A e índices de 8 bits.

Rutina Entrada Resultado o efecto
SubHorzPos X = slot normal. Y vale 0 si Mario queda a la derecha o en el mismo X, y 1 si queda a la izquierda. $0E–$0F guarda Mario X menos sprite X.
SubVertPos X = slot normal. Y vale 1 si Mario queda por encima y 0 en los demás casos. Deja el byte bajo de la diferencia vertical en $0F.
CapeStomping, YoshiStomping X = slot normal. Carry en 1 si pasan las comprobaciones auxiliares de pisotón para la capa o Yoshi.
GivePointsConsecutiveJump, GivePointsConsecutiveShell X = slot normal. Actualizan el contador de impactos consecutivos, el sonido y los puntos del recorrido correspondiente.
DisplayContactEffectAtSpritePosition X = slot normal. Reproduce el efecto de contacto en la posición del sprite y usa scratch a partir de $00.
StunKickedSprite X = slot normal, A = velocidad vertical inicial, por ejemplo $C0. Aturde al sprite y aplica la velocidad. Puedes mostrar el efecto visual con DisplayContactEffectAtSpritePosition.
DispatchVanillaCallback A = evento, X = receptor normal, Y = origen. Aplica los filtros de despacho y llama al callback configurado. Preserva X, Y, DBR, D y $0E. Consulta Flags y callbacks de eventos.