API tools faq
paste
Advertisement
imbued

Bomber's Hideout Collision Angle Setup Script

imbued
Mar 19th, 2020
204
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 17.36 KB | None | 0 0
raw download clone embed print report
  1.  
  2.  
  3. # 53368
  4. # 1082
  5.  
  6. #goal_angle_list = [1824, 2802, 3818] #### 1824, 2802, and 3818 for sun's, this also works instead of the list of hex values
  7.  
  8. #-12168
  9.  
  10. initial_angle = 0xD554%65536 #### Input as hex or a signed or unsigned integer (python treats hex like a decimal integer; the mod 65536 allows for signed int input)
  11. goal_angle_list = [0x1134]#[0x9414, 0x9644]#[0x1134]#[0xFF4D, 0xFF5C, 0xFFBA]#[0x1134] #[0x73D6] # 1134, intro #[0x0720, 0x0AF2, 0x0EEA] #### These are the working angles for sun's song
  12. ##### 0xFF63 = razor sword, 0x1134 is itself, follow with deleting ocarina
  13.  
  14. def find_solutions(initial_angle, goal_angle_list, filename):
  15.    
  16.     if initial_angle > 65535 or initial_angle < 0 or isinstance(initial_angle, int) == False:
  17.         print('Error: The initial angle is not a valid input')
  18.    
  19.     with open(filename, "a") as file:
  20.    
  21.         Solution_Found = False
  22.         for i in range(8192):
  23.             for angle in goal_angle_list:
  24.                 if (initial_angle + i*1800)%65536 == angle:
  25.                     Solution_Found = True
  26.                     print("%d = %s is a working initial angle with %d Left ESS turns for goal angle %d = %s" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  27.                     file.write("%d = %s is a working initial angle with %d Left ESS turns for goal angle %d = %s\n" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  28.                    
  29.                 if (initial_angle - i*1800)%65536 == angle:
  30.                     Solution_Found = True
  31.                     print("%d = %s is a working initial angle with %d Right ESS turns for goal angle %d = %s" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  32.                     file.write("%d = %s is a working initial angle with %d Right ESS turns for goal angle %d = %s\n" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  33.                    
  34.         if Solution_Found == False:
  35.             print("No solutions were found for this initial angle.")
  36.  
  37.  
  38. def sortFirst(val):
  39.     return val[0]  
  40.  
  41. def find_ranked_solutions(initial_angle_list, goal_angle_list, filename):
  42.    
  43.     #solution_dict = {}
  44.     solution_list = []
  45.    
  46.     with open(filename, "a") as file:
  47.    
  48.         for initial_angle in initial_angle_list:
  49.            
  50.             print(hex(initial_angle))
  51.            
  52.             if initial_angle > 65535 or initial_angle < 0 or isinstance(initial_angle, int) == False:
  53.                 print('Error: The initial angle is not a valid input')
  54.            
  55.             Solution_Found = False
  56.             for i in range(8192):
  57.                 for angle in goal_angle_list:
  58.                    
  59.                     #if (initial_angle, angle) not in solution_dict:
  60.                      #   solution_dict[(initial_angle, angle, 'left')] = []
  61.                       #  solution_dict[(initial_angle, angle, 'right')] = []
  62.                    
  63.                     if (initial_angle + i*1800)%65536 == angle:
  64.                         Solution_Found = True
  65.                         #print("%d = %s is a working initial angle with %d Left ESS turns for goal angle %d = %s" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  66.                         #solution_dict[(initial_angle, angle, 'left')].append(i)
  67.                         solution_list.append((i, initial_angle, angle, 'Left'))
  68.                         #file.write("%d = %s is a working initial angle with %d Left ESS turns for goal angle %d = %s\n" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  69.                        
  70.                     if (initial_angle - i*1800)%65536 == angle:
  71.                         Solution_Found = True
  72.                         #print("%d = %s is a working initial angle with %d Right ESS turns for goal angle %d = %s" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  73.                         #solution_dict[(initial_angle, angle, 'right')].append(i)
  74.                         solution_list.append((i, initial_angle, angle, 'Right'))
  75.                         #file.write("%d = %s is a working initial angle with %d Right ESS turns for goal angle %d = %s\n" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  76.                        
  77.             #if Solution_Found == False:
  78.                 #print("No solutions were found for this initial angle.")
  79.        
  80.         ##### Now sort and then write to file
  81.        
  82.        
  83.         solution_list.sort(key=sortFirst)
  84.        
  85.         for entry in solution_list:
  86.            
  87.             file.write("%d = %s is a working initial angle with %d %s ESS turns for goal angle %d = %s\n" %(entry[1], hex(entry[1]), entry[0], entry[3], entry[2], hex(entry[2])))
  88.            
  89.         print("Done.")
  90.        
  91.            
  92.            
  93.  
  94. ###############
  95.  
  96. #initial_angle_list = [0xC001,0x8000,0xA54D,0xA54B,0xD8F8,0xD8F7,0x2708,0x270A,0x4000,0x59B4,0x59B6,0x0000,0x9078,0x9075,0xCF3E,0xCF35,0xA000,0xA009,0x720D,0x720C,0xADB8,0xADBD,0x5109,0x5104,0x8D87,0x8D85,0x6000,0x6008,0x313E,0x313C,0x6DB8,0x6DBD,0x1078,0x1074,0x4F3E,0x4F33,0x2000,0x2008,0xF20E,0xF20D,0x2DB8,0x2DBB,0xD109,0xD105,0x0D87,0x0D83,0xE000,0xE009,0xB13E,0xEDB8,0x254D,0x2549,0x59B4,0x59B6,0xA64C,0xA64B,0xDAB3,0xDAB8]
  97.  
  98. #oceanside
  99. #initial_angle_list = [0xC001,0x8000,0xA54D,0xA54B,0xD8F8,0xD8F7,0x2708,0x270A,0x4000,0x59B4,0x59B6,0x0000,0x9078,0x9075,0xCF3E,0xCF35,0xA000,0xA009,0x720D,0x720C,0xADB8,0xADBD,0x5109,0x5104,0x8D87,0x8D85,0x6000,0x6008,0x313E,0x313C,0x6DB8,0x6DBD,0x1078,0x1074,0x4F3E,0x4F33,0x2000,0x2008,0xF20E,0xF20D,0x2DB8,0x2DBB,0xD109,0xD105,0x0D87,0x0D83,0xE000,0xE009,0xB13E,0xEDB8,0x254D,0x2549,0x59B4,0x59B6,0xA64C,0xA64B,0xDAB3,0xDAB8]
  100.  
  101. #graveyard
  102. #initial_angle_list = [0x8000,0x92E4,0x92E6,0xB94C,0xB950,0xA325,0xA32A,0x85A7,0x85A3,0x882A,0x8823,0x7216,0x721C,0x891E,0x8914,0x76BC,0x76BD,0x6000,0x6008,0x46B4,0x46B1,0x32E7,0x32ED,0x1E53,0x1E57,0xEB20,0xEB2C,0x1DDE,0x1DD7,0xEF2A,0xEF30,0x14C1,0x14C5,0xFECF,0xFED1,0x0BCB,0x0BC3,0xF4F1,0xF4FE,0xEBCB,0xEBCC,0xDC4C,0xDC48,0xD078,0xD075,0xED1C,0x0000,0x76C5,0x76CD,0x729E,0x729C,0x4000,0x0D62,0x0D63,0x093B,0x0932,0xC000,0x40EA,0x40E0,0x0F1B,0x0F14,0x7124,0x712C]
  103. #initial_angle_list = [0xC001,0x0001,0x4001,0x8001,0xD2E6,0x12E6,0x52E6,0x12E5,0x52E5,0x52E4,0xF950,0x3950,0x7950,0xF960,0xF96F,0xE32A,0x232A,0x2329,0x632A,0x6329,0x6328,0xC5A3,0xC5A2,0xC5A1,0x05A3,0x05A1,0x45A3,0x45A2,0x45A1]
  104. #initial_angle_list = [0x4bc3,0x8bc3,0xcbc3,0x34fe,0x74f3,0xb4fe,0x2bcc,0x6bcc,0xabcc,0x1c48,0x5c48,0x9c48,0x1075,0x5075,0x9075]
  105.  
  106. #initial_angle_list = [0xC001,0x8000,0x4000,0x0000,0x9078,0x9075,0xCF3E,0xCF35,0xA000,0xA009,0x720D,0x720C,0xADB8,0xADBD,0x5109,0x5104,0x8D87,0x8D85,0x6000,0x6008,0x313E,0x313C,0x6DB8,0x6DBD,0x1078,0x1074,0x4F3E,0x4F33,0x2000,0x2008,0xF20E,0xF20D,0x2DB8,0x2DBB,0xD109,0xD105,0x0D87,0x0D83,0xE000,0xE009,0xB13E,0xEDB8]
  107.  
  108.  
  109. ###############################################################################
  110.  
  111. # Angles you get from targeting walls, walking forward to match angle with camera angle, then turning to get all 4 cardinal directions associated with that camera angle
  112. #initial_angle_list = [0x0000, 0x4000, 0x8000, 0xC000, 0xC001, 0x8001, 0x4001, 0x0001, 0xEDB8, 0xB13E, 0x713E, 0x313E, 0xF13E, 0xE000, 0xE009, 0xA009, 0x6009, 0x2009, 0xD87, 0xD83, 0xCD83, 0x8D83, 0x4D83, 0xD109, 0xD105, 0x9105, 0x5105, 0x1105, 0x2DB8, 0x2DBB, 0xEDBB, 0xADBB, 0x6DBB, 0xF20D, 0xF20E, 0xB20E, 0x720E, 0x320E, 0x2000, 0x2008, 0xE008, 0xA008, 0x6008, 0x4F3E, 0x4F33, 0xF33, 0xCF33, 0x8F33, 0x1078, 0x1074, 0xD074, 0x9074, 0x5074, 0x6DB8, 0x6DBB, 0x2DBB, 0xEDBB, 0xADBB, 0x313E, 0x313C, 0xF13C, 0xB13C, 0x713C, 0x8D87, 0x8D85, 0x4D85, 0xD85, 0xCD85, 0x5109, 0x5104, 0x1104, 0xD104, 0x9104, 0xADB8, 0xADBD, 0x6DBD, 0x2DBD, 0xEDBD, 0x720D, 0x720C, 0x320C, 0xF20C, 0xB20C, 0xA000, 0xCF3E, 0xCF35, 0x8F35, 0x4F35, 0xF35, 0x9078, 0x9075, 0x5075, 0x1075, 0xD075]
  113.  
  114. # Angles from camera manip things in oceanside:
  115. #initial_angle_list = [0x926E, 0x526E, 0x5285, 0x3FCD, 0x7FCD, 0x2008, 0x5FC9, 0x1FC2, 0x1F88, 0x5F88, 0x5F7C, 0x1FC9, 0x5FC9, 0x9FC9, 0xDFC9, 0x5FC2, 0x1FC2, 0x9FC2, 0xDFC2, 0x1F88, 0x5F88, 0x9F88, 0xDF88]
  116.  
  117. # Angles you get from walls in Room 4 of Oceanside (work in timestop) AND  4 cardinal direction 0xC001, 0x4001, 0x0001, 0x8001
  118. ######initial_angle_list = [0xC001, 0x4001, 0x0001, 0x8001, 0x0000, 0xC000, 0xEDB8, 0xB13E, 0xE000, 0x0D87, 0xD109, 0x2DB8, 0xF20D, 0x2000, 0x4F3E, 0x1078, 0x4000, 0x6DB8, 0x313E, 0x6000, 0x8D87, 0x5109, 0x8000, 0xADB8, 0x720D, 0xA000, 0xCF3E, 0x9078]
  119.  
  120. oceanside_room4_normal_vector_angle_list = [0x0000, 0xC000, 0xEDB8, 0xB13E, 0xE000, 0x0D87, 0xD109, 0x2DB8, 0xF20D, 0x2000, 0x4F3E, 0x1078, 0x4000, 0x6DB8, 0x313E, 0x6000, 0x8D87, 0x5109, 0x8000, 0xADB8, 0x720D, 0xA000, 0xCF3E, 0x9078]
  121.  
  122.  
  123. def find_goal_collision_angles(value_string):
  124.    
  125.     # if seahorse, then value_string = '0x24', for example
  126.    
  127.     """
  128.    
  129.    This function gives us the goal collision angles for a given item that needs
  130.    the 0x40 bit to be 0
  131.    
  132.    """
  133.    
  134.     if len(value_string) != 4 or value_string[0] != '0':
  135.         print('invalid input into find_goal_collision_angles() function')
  136.    
  137.     seahorse_list = []
  138.     for i in range(256):
  139.         string = hex(i)
  140.         if len(string) == 3:
  141.             new_string = '0x0' + string[2]
  142.         elif len(string) == 4:
  143.             new_string = string
  144.         else:
  145.             print("ERROR!!!!!!!!!!!!!!!!!!!!!!!!!!!???????????????????????????")
  146.        
  147.         collision_value = value_string + new_string[2:4]
  148.        
  149.         if len(collision_value) != 6:
  150.             print(collision_value)
  151.        
  152.         # If the 0x40 bit is 0, then add the value:
  153.         if collision_value[4] != '4' and collision_value[4] != '5' and collision_value[4] != '6' and collision_value[4] != '7' and collision_value[4] != 'c' and collision_value[4] != 'd' and collision_value[4] != 'e' and collision_value[4] != 'f':
  154.             seahorse_list.append(int(collision_value, 16))
  155.             #seahorse_list.append(collision_value)
  156.     if len(seahorse_list) != 128:
  157.         print("??????????????")
  158.    
  159.     return seahorse_list
  160.  
  161.  
  162. #################### NEW FOR 0x20 bit
  163.    
  164.  
  165. def find_goal_collision_angles_20_bit(value_string):
  166.    
  167.     # if seahorse, then value_string = '0x24', for example
  168.    
  169.     """
  170.    
  171.    This function gives us the goal collision angles for a given item that needs
  172.    the 0x40 bit to be 0
  173.    
  174.    """
  175.    
  176.     if len(value_string) != 4 or value_string[0] != '0':
  177.         print('invalid input into find_goal_collision_angles() function')
  178.    
  179.     seahorse_list = []
  180.     for i in range(256):
  181.         string = hex(i)
  182.         if len(string) == 3:
  183.             new_string = '0x0' + string[2]
  184.         elif len(string) == 4:
  185.             new_string = string
  186.         else:
  187.             print("ERROR!!!!!!!!!!!!!!!!!!!!!!!!!!!???????????????????????????")
  188.        
  189.         collision_value = value_string + new_string[2:4]
  190.        
  191.         if len(collision_value) != 6:
  192.             print(collision_value)
  193.        
  194.         # If the 0x20 bit is 0, then add the value:
  195.         if collision_value[4] != '2' and collision_value[4] != '3' and collision_value[4] != '6' and collision_value[4] != '7' and collision_value[4] != 'a' and collision_value[4] != 'b' and collision_value[4] != 'e' and collision_value[4] != 'f':
  196.             seahorse_list.append(int(collision_value, 16))
  197.             #seahorse_list.append(collision_value)
  198.     if len(seahorse_list) != 128:
  199.         print("??????????????")
  200.    
  201.     return seahorse_list
  202.  
  203.  
  204. #####################################
  205.  
  206.  
  207.  
  208.  
  209. def find_valid_goal_angles(goal_collision_angle_list, normal_vector_angle_list):
  210.    
  211.     """
  212.    
  213.    a normal vector angle is the angle you get by targeting a given wall
  214.    
  215.    
  216.    This function takes a list of normal vector angles and a list of goal collision
  217.    angles and returns a list of all in the form (goal_angle, normal_angle, goal_collision_angle)
  218.    where goal_angle is an angle that can be used to collide into a wall with a normal vector angle
  219.    of normal_angle to get a collision angle of goal_collision_angle
  220.    
  221.    """
  222.    
  223.     valid_goal_angle_list = []
  224.    
  225.     for normal_vector_angle in normal_vector_angle_list:
  226.         for i in range(65536):
  227.            
  228.             angle_diff = abs(normal_vector_angle - i)
  229.            
  230.             if angle_diff > 0x8000:
  231.            
  232.                 collision_angle = abs(0x10000 - angle_diff )
  233.            
  234.             elif angle_diff <= 0x8000 and angle_diff >= 0:
  235.                
  236.                 collision_angle = angle_diff
  237.                
  238.             else:
  239.                 print("UHHHHHHHH??????")
  240.            
  241.             if collision_angle in goal_collision_angle_list:
  242.                
  243.                 valid_goal_angle_list.append((i, normal_vector_angle, collision_angle))
  244.                
  245.    
  246.     return valid_goal_angle_list
  247.  
  248.  
  249.  
  250. def find_ranked_collision_solutions(initial_angle_list, goal_angle_list, filename):
  251.    
  252.     """
  253.    
  254.    The idea is to have goal_angle_list = find_valid_goal_angles(find_goal_collision_angles('0x24'), oceanside_room4_normal_vector_angle_list)
  255.    if doing seahorse (item 0x24)
  256.    
  257.    """
  258.    
  259.     #solution_dict = {}
  260.     solution_list = []
  261.    
  262.     with open(filename, "a") as file:
  263.    
  264.         for initial_angle in initial_angle_list:
  265.            
  266.             print(hex(initial_angle))
  267.            
  268.             if initial_angle > 65535 or initial_angle < 0 or isinstance(initial_angle, int) == False:
  269.                 print('Error: The initial angle is not a valid input')
  270.            
  271.             #Solution_Found = False
  272.             for i in range(8192):
  273.                 for entry in goal_angle_list:
  274.                    
  275.                     angle = entry[0]
  276.                     normal_vector_angle = entry[1]
  277.                     collision_angle = entry[2]
  278.                    
  279.                     #if (initial_angle, angle) not in solution_dict:
  280.                      #   solution_dict[(initial_angle, angle, 'left')] = []
  281.                       #  solution_dict[(initial_angle, angle, 'right')] = []
  282.                    
  283.                     if (initial_angle + i*1800)%65536 == angle:
  284.                         #Solution_Found = True
  285.                         #print("%d = %s is a working initial angle with %d Left ESS turns for goal angle %d = %s" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  286.                         #solution_dict[(initial_angle, angle, 'left')].append(i)
  287.                         solution_list.append((i, initial_angle, angle, 'Left', normal_vector_angle, collision_angle))
  288.                         #file.write("%d = %s is a working initial angle with %d Left ESS turns for goal angle %d = %s\n" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  289.                        
  290.                     if (initial_angle - i*1800)%65536 == angle:
  291.                         #Solution_Found = True
  292.                         #print("%d = %s is a working initial angle with %d Right ESS turns for goal angle %d = %s" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  293.                         #solution_dict[(initial_angle, angle, 'right')].append(i)
  294.                         solution_list.append((i, initial_angle, angle, 'Right', normal_vector_angle, collision_angle))
  295.                         #file.write("%d = %s is a working initial angle with %d Right ESS turns for goal angle %d = %s\n" %(initial_angle, hex(initial_angle), i, angle, hex(angle)))
  296.                        
  297.             #if Solution_Found == False:
  298.                 #print("No solutions were found for this initial angle.")
  299.        
  300.         ##### Now sort and then write to file
  301.        
  302.        
  303.         solution_list.sort(key=sortFirst)
  304.        
  305.         for entry in solution_list:
  306.            
  307.             #file.write("%d = %s is a working initial angle with %d %s ESS turns for goal angle %d = %s\n" %(entry[1], hex(entry[1]), entry[0], entry[3], entry[2], hex(entry[2])))
  308.             file.write("%s is a working initial angle with %d %s ESS turns for a goal angle of %s which can collide into a wall with normal vector angle %s to get collision angle %s\n" %(hex(entry[1]), entry[0], entry[3], hex(entry[2]), hex(entry[4]), hex(entry[5])))
  309.                        
  310.         print("Done.")
  311.  
  312.  
  313.  
  314. #goal_angle_list = find_goal_collision_angles('0x2E')
  315.  
  316. ################################ USE FOR OCEANSIDE
  317. ###################goal_angle_list = find_valid_goal_angles(find_goal_collision_angles('0x54'), oceanside_room4_normal_vector_angle_list)
  318.  
  319.  
  320. bomber_normal_vector_angle_list = [0x0000, 0x4000, 0x8000, 0xC000]
  321.  
  322. ########### USE FOR BOMBER'S
  323. goal_angle_list = find_valid_goal_angles(find_goal_collision_angles('0x66'), bomber_normal_vector_angle_list)
  324.  
  325. #goal_angle_list = find_valid_goal_angles(find_goal_collision_angles_20_bit('0x73'), bomber_normal_vector_angle_list)
  326.  
  327.  
  328.  
  329. save_path = "C:\\Users\\xyzabc\\Documents\\Bizhawk RAM Watch\\scripts\\"
  330. name_of_file = "angle output"
  331. complete_name = save_path + name_of_file + ".txt"  
  332.  
  333. #####initial_angle_list = [0xD6B4]
  334.  
  335. #####
  336. """
  337. for angle in initial_angle_list:
  338.    
  339.    find_solutions(angle, goal_angle_list, complete_name)
  340. """
  341. #####
  342.  
  343.  
  344. #find_ranked_solutions(initial_angle_list, goal_angle_list, complete_name)
  345.  
  346.  
  347. #initial_angle_list = [0x0AB4, 0x354F, 0x8AB3, 0xCAB2]
  348. initial_angle_list = [0x3880, 0x0000, 0x4000, 0x8000, 0xC000, 0x788E, 0xF88E, 0xB88E, 0x388E, 0x2DCD]
  349. #initial_angle_list = [0x7C4F]
  350.  
  351. find_ranked_collision_solutions(initial_angle_list, goal_angle_list, complete_name)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!