es/Hitman Tool ASM API
| 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
|
- 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.
- 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.
- En
ASM/HitmanDefines.asmde la distribución, asigna la primera dirección a!HitmanRAMBasey la primera dirección fuera de la reserva a!HitmanRAMLimit. Configura ambos valores juntos. En el código fuente, la plantilla está enHitmanBackend/ASM/HitmanDefines.asm. - 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
!HitmanSprite1Xy!HitmanSprite1Y. Prepara!HitmanSprite1Flipy los cuatro bordes de HB2 (!HitmanHB2Left,!HitmanHB2Top,!HitmanHB2Righty!HitmanHB2Bottom). - Suma
$0100a 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.
|