• Please note that the developer team will be on leave until 26th of July. All technical support tickets will be handled when we're back in action. Thank you for understanding.

OSP Kit [WB] Naruto Hand Seals / Jutsu system

Currently viewing this thread:

This code is provided as is: I will try to assist with issues directly arising from the provided code, but I cannot promise support for anything you, the user, may do to it. I however will be trying to help you and your expansions of this code base. I just cannot promise any support past supporting the existing code base. I will not be answering questions about basic ModSys knowledge, for that visit: An Introduction to Module System Syntax and Usage by Caba`drin

handseals.png

(or how to enter complicated strings of characters to fire a script)

Skill level to implement: Intermediate ModSys Knowledge

Download Links:
Moddb, Nexus Mods, Google Drive
Abstract: Using twelve keys of the NumPad, allow the player to enter strings of seals to activate a "jutsu" as defined in a script.

Included: All required code and hand assets (lacking proper pose animations to line up hand models), a Native hand rig .blend file for adapting other hand models, a proof-of-concept demonstration Jutsu with documentation of making your own, and a demonstration module.

About: Based on my Magecraft system for my mod Fate/ Throne of Heroes, this adaptation allows the player to enter a custom string of 12 keys to activate a script, or in this case, a Jutsu. Written to be flexible, adaptable and easy to use for the scripter, this framework should be simple to plug into any mod using only a dozen slots, and very few scripts outside the mission templates. Performance was not tested during the formation of this framework, but can easily be improved by increasing the time of the ***_check mission template and adjusting the elapsed time val_add or should easily alleviate any bloat from high agent scenes.

YouTube video of Hand Seals

handseals.PNG
Hand Seal in OpenBRF. Of course this is what it would look like if I went through the effort of animating a pose per seal but. . .

Ideas for Alternative Uses and Expansions:
  • Magicka based elemental system, allow the user to make custom spells using 8 elemental keys with certain predefined strings making a predefined spell.
  • Using Numpad Enter to cast jutsu instead of the always-on passive check currently used by the system, this could allow jutsu strings with similar beginnings to be used.
  • Change hand seal replacement to wand movement animations for a Harry Potter spell system.
  • For AI I would assign them a ninja mastery level and they could access all the jutsu less than or equal to that level.
  • For the player, since it is actually difficult to pull off and requires knowledge of how to do it I would allow them to use any that they wish. With their mastery level allowing them to access a list that would put the jutsu of choice somewhere on the hud so they could see the combination

This OSP is provided for the Mount&Blade community and may only be used for modifications based on the M&B engine (Warband, VC, NW). Included art assets belong exclusively to Taleworlds. Credit is not required, but greatly appreciated. If you want to support me, follow my thread for my Warband mod Fate/ Throne of Heroes.

While I recommend downloading it to get the hand seal assets, here is the code, just in case.
Python:
from ID_items import *
from ID_quests import *
from ID_factions import *
# ########################################
# Constants
# ########################################

# hs_*** prefix is just so that we do not
# accidentally common words into constants

hs_rat = 1 
hs_ox = 2
hs_tiger = 3         
hs_hare = 4         
hs_dragon = 5         
hs_snake = 6
hs_horse = 7
hs_ram = 8
hs_monkey = 9
hs_bird = 10
hs_dog = 11
hs_boar = 12

# ########################################
# Agent Slots
# ########################################

# Feel free to change the numbering.
# This was just based off of Native's numbering.

# I use this to determine animation
slot_naruto_hand_seal_current         = 30

# Hand seal storage
slot_naruto_hand_seal_01             = 31
slot_naruto_hand_seal_02             = 32
slot_naruto_hand_seal_03             = 33
slot_naruto_hand_seal_04             = 34
slot_naruto_hand_seal_05             = 35
slot_naruto_hand_seal_06             = 36
slot_naruto_hand_seal_07             = 37
slot_naruto_hand_seal_08             = 38
slot_naruto_hand_seal_09             = 39
slot_naruto_hand_seal_10             = 40

# Obviously you could add more, or, alternatively,
# you could store them in a large, unused range with
# no other slots larger than it and have a named slot
# that counts how many are stored so you can store large
# amounts of slots without having to name each one.
# There is that one Jutsu that took 44 hand seals to execute. . .

# Used to see how long the agent has taken to enter a seal
slot_naruto_hand_seal_time_elapsed    = 41
# Not really necessary, but easier than running a for_range
# loop just to see if the storage slots were empty.
slot_naruto_reset_needed             = 42

Python:
# -*- coding: cp1254 -*-
from header_common import *
from header_operations import *
from module_constants import *
from module_constants import *
from header_parties import *
from header_skills import *
from header_mission_templates import *
from header_items import *
from header_triggers import *
from header_terrain_types import *
from header_music import *
from header_map_icons import *
from header_presentations import *
from ID_animations import *


####################################################################################################################
# scripts is a list of script records.
# Each script record contns the following two fields:
# 1) Script id: The prefix "script_" will be inserted when referencing scripts.
# 2) Operation block: This must be a valid operation block. See header_operations.py for reference.
####################################################################################################################

scripts += [
    # script_jutsu_check
    # Input:
    #        Parameter 1: agent_id
    # Output: none
    #
    # Usage: Take in an agent_id, use that agent_id to determine how long they've been using their current jutsu
    ("jutsu_check", [
        (set_fixed_point_multiplier, 100), # Always set this up. Just in case.
      
        (store_script_param, ":agent", 1),    # Take in the agent we are checking for jutsu usage
        (agent_is_human, ":agent"),            # Is this agent a human?
        (agent_is_alive, ":agent"),            # Is this agent currently alive?
      
        # Setting up local variables
        (agent_get_slot, ":time_elapsed", ":agent", slot_naruto_hand_seal_time_elapsed),    # Check time since last hand seal, remember this is done in CENTIseocnds, so 1 second is 100, etc.
        (agent_get_slot, ":reset_needed", ":agent", slot_naruto_reset_needed), # We check this to make sure that if 3 seconds pass without a jutsu we don't just reset for nothing.
      
      
        (agent_get_position, pos1, ":agent"),    # Stores agent position
      
        (try_begin),
            (lt, ":time_elapsed", 300),    # This is 300 centiseconds, or 3 seconds
          
            (assign, ":seal_01", 0),    # Sets up all of our local variables and insures they are zero
            (assign, ":seal_02", 0),
            (assign, ":seal_03", 0),
            (assign, ":seal_04", 0),
            (assign, ":seal_05", 0),
            (assign, ":seal_06", 0),
            (assign, ":seal_07", 0),
            (assign, ":seal_08", 0),
            (assign, ":seal_09", 0),
            (assign, ":seal_10", 0),
          
            (assign, ":jutsu_length", 1), # If we got this far, there's at least one hand seal in the tank, we'll then use this to store all the upcoming handseals in a way that we can check easily.
          
            (try_for_range, ":cur_slot", slot_naruto_hand_seal_01, slot_naruto_hand_seal_time_elapsed),
                (agent_slot_ge, ":agent", ":cur_slot", 0),    # Checks that the slot actually has a value, we can use that to find out how long the current jutsu string is
                (agent_get_slot, ":seal", ":agent", ":cur_slot"), # Now we store that value
              
                (try_begin),
                    (eq, ":jutsu_length", 1),
                    (assign, ":seal_01", ":seal"),
                (else_try),
                    (eq, ":jutsu_length", 2),
                    (assign, ":seal_02", ":seal"),
                (else_try),
                    (eq, ":jutsu_length", 3),
                    (assign, ":seal_03", ":seal"),
                (else_try),
                    (eq, ":jutsu_length", 4),
                    (assign, ":seal_04", ":seal"),
                (else_try),
                    (eq, ":jutsu_length", 5),
                    (assign, ":seal_05", ":seal"),
                (else_try),
                    (eq, ":jutsu_length", 6),
                    (assign, ":seal_06", ":seal"),
                (else_try),
                    (eq, ":jutsu_length", 7),
                    (assign, ":seal_07", ":seal"),
                (else_try),
                    (eq, ":jutsu_length", 8),
                    (assign, ":seal_08", ":seal"),
                (else_try),
                    (eq, ":jutsu_length", 9),
                    (assign, ":seal_09", ":seal"),
                (else_try),
                    (assign, ":seal_10", ":seal"),
                (try_end),
              
                (val_add, ":jutsu_length", 1), # Adds one to the length value, this has the effect of storing the current slot in a new local variable
            (try_end),
          
            # I do not use it, but you could potentially use the handseal count in ":jutsu_length" - 1 to determine the length of the handseal string. This could be useful for. . . something.
          
          
            # So, how to make your own jutsus Look at the example below and we'll go through it together
            (try_begin),
                # Example Jutsu, Substitution Jutsu!
              
                # First, go through the seals you need. For Substituation / Body Replacement Jutsu, we need to do Tiger > Boar > Ox > Dog > Snake.
              
                # My way of doing it here is a little strict and requires the player to enter it perfect, and to not have done any handseals before starting it. You could change this by running through the slots, and if that slot equalled tiger, then do that slot + 1 equals board, + 2 eq ox, etc, etc.
              
                # This way is just easier.
              
                (eq, ":seal_01", hs_tiger),    # Tiger is in slot 1, check
                (eq, ":seal_02", hs_boar),    # Boar in slot 2? Check!
                (eq, ":seal_03", hs_ox),    # Ox, in 3?
                (eq, ":seal_04", hs_dog),    # Dog, etc, etc.
                (eq, ":seal_05", hs_snake),    # Snake
              
                # If this is ALL true, the jutsu is correct and we can fire the effects!
              
                (copy_position, pos2, pos1),    # This duplicates the agent position for the next bit
              
                (store_random_in_range, ":rand_x", -180, 180),    # Randomizes the rotation values
                (store_random_in_range, ":rand_y", -180, 180),    # to make the log spawn at various
                (store_random_in_range, ":rand_z", -180, 180),    # angles in order to add variety.
              
                (position_rotate_x, pos2, ":rand_x"),
                (position_rotate_y, pos2, ":rand_y"),
                (position_rotate_z, pos2, ":rand_z"),
              
                (position_move_z, pos2, 150, 1),    # This places the log 150 cm higher than the agents feet
              
                (set_spawn_position, pos2),    # tell the game any spawning props, agents, etc will go here.
              
                (spawn_scene_prop, "spr_replacement_log"),    # This log is a a new scene prop, fyi. It's just the Native log model with physics.
                (particle_system_burst, "psys_dummy_smoke", pos2, 10),    # Obscurant smoke using native particle systems
              
                (position_move_y, pos1, -300),            # Moves pos1 of the agent 3m behind their current facing
                (position_set_z_to_ground_level, pos1),    # Makes sure they are still ground level
                (agent_set_position, ":agent", pos1),    # Teleports the agent
              
                # upon being successful reset all slots so we can immediately start on the next jutsu!
                (try_for_range, ":seal", slot_naruto_hand_seal_01, slot_naruto_hand_seal_time_elapsed),
                    (agent_set_slot, ":agent", ":seal", 0),  
                (try_end),  
            (try_end),
        (else_try),
            # This portion is only reached if 3 seconds have passed since the last hand seal used
          
            (eq, ":reset_needed", 1),    # makes sure there were queued seals and a reset is necessary
          
            # This next bit goes through each of the seal slots and resets them to zero
            (try_for_range, ":seal", slot_naruto_hand_seal_current, slot_naruto_hand_seal_time_elapsed),
                (agent_set_slot, ":agent", ":seal", 0),                              
            (try_end),
          
            (agent_set_slot, ":agent",  slot_naruto_reset_needed, 0), # Lets us know no seals are queued, and thus we do not need a reset
          
            #     This portion could be changed to check the currently equipped hand item, and unequip it,
            # but I do not feel like writing all that out. You might also want to store whatever an agent's
            # basic glove item is in a slot so you can equip that instead. You might acctually be able to
            # check what glove the agent's troop has and equip those. . .
          
            (agent_equip_item, ":agent", "itm_handseal_rat"),    # We do this to know what item is equipped
            (agent_unequip_item, ":agent", "itm_handseal_rat"),    # removes the hand seal model from the current agent to revert them back to bare fists.
        (try_end),
    ]),
]

Python:
from header_common import *
from header_animations import *


animations += [

# For hand seals, in my example it was placed over unused_human_anim_44

#    So, a quick explanation. "poses" is a native asset with frame 5 being extremely close to what we need. I am not an animatior so I didn't even attempt to make the hand seal body animations. The 69 is the animation priority, this sets it fairly high, but below equipping items. You could easily set it higher in order to make it so a player could do even fewer actions while firing the animation. 3.0 is just how long I wanted the animation to last, but I think shorter would be better in this case, and arf_cyclic is so it will loop until interrupted.

["pose_hand_seal", 0, 69,
   [3.0, "poses", 5, 5, arf_cyclic],
],

]

Python:
from module_constants import *
from ID_factions import *
from header_items import  *
from header_operations import *
from header_triggers import *

####################################################################################################################
# I actually do not know how to append new parts to a ModSys file, so this is to simplify implementation for you.
####################################################################################################################

items += [

["handseal_rat","Rat Hand Seal", [("handseal_rat_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_ox","ox Hand Seal", [("handseal_ox_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_tiger","tiger Hand Seal", [("handseal_tiger_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_hare","hare Hand Seal", [("handseal_hare_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_dragon","dragon Hand Seal", [("handseal_dragon_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_snake","snake Hand Seal", [("handseal_snake_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_horse","horse Hand Seal", [("handseal_horse_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_ram","ram Hand Seal", [("handseal_ram_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_monkey","monkey Hand Seal", [("handseal_monkey_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_bird","bird Hand Seal", [("handseal_bird_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_dog","dog Hand Seal", [("handseal_dog_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

["handseal_boar","boar Hand Seal", [("handseal_boar_l",0)], itp_type_hand_armor,0, 0, weight(0.0)|abundance(0)|body_armor(6)|difficulty(0),imodbits_armor],

]

Python:
from header_common import *
from header_operations import *
from header_mission_templates import *
from header_animations import *
from header_sounds import *
from header_music import *
from header_items import *
from module_constants import *


hand_seals_input = (
    0, 0, 0, [
  
    # Most numpad keys have a different function. This stops that.
    # Probably could be done in a much better way.
  
    (omit_key_once, key_numpad_1),
    (omit_key_once, key_numpad_2),
    (omit_key_once, key_numpad_3),
    (omit_key_once, key_numpad_4),
    (omit_key_once, key_numpad_5),
    (omit_key_once, key_numpad_6),
    (omit_key_once, key_numpad_7),
    (omit_key_once, key_numpad_8),
    (omit_key_once, key_numpad_9),
    (omit_key_once, key_num_lock),
    (omit_key_once, key_numpad_slash),
  
    (this_or_next|key_clicked, key_numpad_1),
    (this_or_next|key_clicked, key_numpad_2),
    (this_or_next|key_clicked, key_numpad_3),
    (this_or_next|key_clicked, key_numpad_4),
    (this_or_next|key_clicked, key_numpad_5),
    (this_or_next|key_clicked, key_numpad_6),
    (this_or_next|key_clicked, key_numpad_7),
    (this_or_next|key_clicked, key_numpad_8),
    (this_or_next|key_clicked, key_numpad_9),
    (this_or_next|key_clicked, key_num_lock),
    (this_or_next|key_clicked, key_numpad_slash),
    (this_or_next|key_clicked, key_numpad_multiply),
    (key_clicked, key_numpad_enter)
    ],
    [
        (set_fixed_point_multiplier, 100),    # We use this to keep math consistant
      
        (try_begin),
            (game_in_multiplayer_mode),
            (multiplayer_get_my_player, ":player"),
            (player_is_active, ":player"),
            (player_get_agent_id, ":agent", ":player"),
        (else_try),
            (get_player_agent_no, ":agent"),    # Since this can onl be called by the player, assume it was them
        (try_end),
        (agent_get_slot, ":time_elapsed", ":agent", slot_naruto_hand_seal_time_elapsed), # Store Time since last keypress
  
        (agent_set_wielded_item, ":agent", -1),    # Unequip all items, so as to not have anything in their hands
      
      
        (try_begin),
            (key_clicked, key_numpad_1),    # 1, Rat
            (assign, ":time_elapsed", 0),    # Set time since last key press to 0
            (assign, ":reset_needed", 1),    # Store the need to reset
            (assign, ":hand_seal", hs_rat),        # Store the current handseal as Rat
            # Quick reminder that in module_constants we defined hs_rat as 1, so you
            # could have used either, just hs_*** is more friendly to the reader.
        (else_try),
            (key_clicked, key_numpad_2),    # 2, Ox
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_ox),
        (else_try),
            (key_clicked, key_numpad_3),    # 3, Tiger
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_tiger),
        (else_try),
            (key_clicked, key_numpad_4),    # 4, Hare
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_hare),
        (else_try),
            (key_clicked, key_numpad_5),    # 5, Dragon
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_dragon),
        (else_try),
            (key_clicked, key_numpad_6),    # 6, Snake
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_snake),
        (else_try),
            (key_clicked, key_numpad_7),    # 7, Horse
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_horse),
        (else_try),
            (key_clicked, key_numpad_8),    # 8, Ram
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_ram),
        (else_try),
            (key_clicked, key_numpad_9),    # 9, Monkey
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_monkey),
        (else_try),
            (key_clicked, key_num_lock),    # 10, Bird
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_bird),
        (else_try),
            (key_clicked, key_numpad_slash),    # 11, Dog
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_dog),
        (else_try),
            (key_clicked, key_numpad_multiply),    # 12, Boar
            (assign, ":time_elapsed", 0),
            (assign, ":reset_needed", 1),
            (assign, ":hand_seal", hs_boar),
        (else_try),
            (key_clicked, key_numpad_enter), # Forced Reset Key.
            (try_for_range, ":seal", slot_naruto_hand_seal_current, slot_naruto_hand_seal_time_elapsed),
                (agent_set_slot, ":agent", ":seal", 0),    # Resets all storage slots to 0
            (try_end),
          
            #     This portion could be changed to check the currently equipped hand item, and unequip it,
            # but I do not feel like writing all that out. You might also want to store whatever an agent's
            # basic glove item is in a slot so you can equip that instead. You might acctually be able to
            # check what glove the agent's troop has and equip those. . .
          
            (agent_equip_item, ":agent", "itm_handseal_rat"),    # This allows us to ~know~ what item is equipped
            (agent_unequip_item, ":agent", "itm_handseal_rat"),    # so we can force the hands to return to normal
          
            (assign, ":reset_needed", 0),    # tell the game we no longer are waiting for a reset
        (try_end),
      
        (agent_set_slot, ":agent",  slot_naruto_reset_needed, ":reset_needed"),  
        # Store whether or not a reset is necessary based on the local var stored above
      
        (gt, ":hand_seal", 0),    # Makes sure nothing else is fired in case there isn't a seal ready
      
        (agent_set_slot, ":agent", slot_naruto_hand_seal_current, ":hand_seal"),  
        # Store the active seal for animation purposes
      
        (assign, ":iterator", 0),
        (try_for_range, ":cur_slot", slot_naruto_hand_seal_01, slot_naruto_hand_seal_time_elapsed),
            (eq, ":iterator", 0),    # Allows us to break the loop later
          
            (agent_slot_eq, ":agent", ":cur_slot", 0),    # If a slot is empty
            (agent_set_slot, ":agent", ":cur_slot", ":hand_seal"),    # Store the current hand seal in it
          
            (val_add, ":iterator", 100000),  
            # This breaks the loop so we don't accidentally store the same seal in every slot
        (try_end),
      
        (agent_set_slot, ":agent", slot_naruto_hand_seal_time_elapsed, ":time_elapsed"),    # Resets the timer
      
        (clear_omitted_keys), # Probably not necessary, but I like doing it.
  
    ]
)

hand_seals_check = (
    0, 0, 0, [],
    [
        (set_fixed_point_multiplier, 100),
        (try_for_agents, ":agent"),
            (agent_is_human, ":agent"),    # Makes sure it isn't checking slots for non-humans
          
            (agent_get_slot, ":reset_needed", ":agent", slot_naruto_reset_needed),    # This slot is set to 1 if a seal string is currently in progress, so
          
            (gt, ":reset_needed", 0), # We can halt the entire script in case the agent is not doing one
          
            (agent_get_slot, ":time_elapsed", ":agent", slot_naruto_hand_seal_time_elapsed),  
            # Check time since last hand seal
          
            (val_add, ":time_elapsed", 1),    # This adds 1 to the time since last hand seal, since this mission_template is set to 0 delay this is called 100 times a second!
          
            (agent_set_slot, ":agent", slot_naruto_hand_seal_time_elapsed, ":time_elapsed"),  
            # Store the new time (in centiseconds) since last seal
          
            (agent_get_slot, ":current_seal", ":agent", slot_naruto_hand_seal_current),  
            # This checks current stored seal, for hand animation purposes.
          
            # This next portion uses slot_naruto_hand_seal_current to determine what hands to equip.
            (try_begin),
                (eq, ":current_seal", 1),
                (agent_equip_item, ":agent", "itm_handseal_rat"),
            (else_try),
                (eq, ":current_seal", 2),
                (agent_equip_item, ":agent", "itm_handseal_ox"),
            (else_try),
                (eq, ":current_seal", 3),
                (agent_equip_item, ":agent", "itm_handseal_tiger"),
            (else_try),
                (eq, ":current_seal", 4),
                (agent_equip_item, ":agent", "itm_handseal_hare"),
            (else_try),
                (eq, ":current_seal", 5),
                (agent_equip_item, ":agent", "itm_handseal_dragon"),
            (else_try),
                (eq, ":current_seal", 6),
                (agent_equip_item, ":agent", "itm_handseal_snake"),
            (else_try),
                (eq, ":current_seal", 7),
                (agent_equip_item, ":agent", "itm_handseal_horse"),
            (else_try),
                (eq, ":current_seal", 8),
                (agent_equip_item, ":agent", "itm_handseal_ram"),
            (else_try),
                (eq, ":current_seal", 9),
                (agent_equip_item, ":agent", "itm_handseal_monkey"),
            (else_try),
                (eq, ":current_seal", 10),
                (agent_equip_item, ":agent", "itm_handseal_bird"),
            (else_try),
                (eq, ":current_seal", 11),
                (agent_equip_item, ":agent", "itm_handseal_dog"),
            (else_try),
                (eq, ":current_seal", 12),
                (agent_equip_item, ":agent", "itm_handseal_boar"),
            (try_end),
          
            (try_begin),
                (gt, ":current_seal", 0),
                (agent_set_animation, ":agent", "anim_pose_hand_seal", 1),
            (try_end),
          
            (call_script, "script_jutsu_check", ":agent"),
        (try_end),
    ]
)

Python:
from header_common import *
from header_scene_props import *
from header_operations import *
from header_triggers import *
from header_sounds import *
from module_constants import *
import string


scene_props += [
    # I have discovered this doesn't work in MP. Whoops!
    ("replacement_log", sokf_dynamic_physics,"wood_a","bo_wood_a", []),
]

Author Comments: It ain't clean. It ain't nice. But it is at least done!
Oh, also, for the demo module, the code for the substitution jutsu is 3>9>2>8>6. I think. It isn't an easy code.
Also, the base form obviously requires numpad. Sorry controllers and smaller laptops! I couldn't think of a better place than numpad.
 
Last edited:

poo

Regular
Oh wow very interesting.I think fate has made me stumble upon this thread.Coincidentally i am trying to remake the old warband naruto mod.I got the permission from sundiata a long time ago but nothing came of it.I stopped after making a whole map in blender and implemented it but had a giant hole that led underground and lords would get stuck in it.I was not very good at using blender.Anyways you mention that to implement this i need to be an intermediate coder which i am not.No matter.I will learn
 
Top Bottom