├── .gitattributes
├── .gitignore
├── PythonScripts
    ├── 7day-signin.py
    ├── _FileUpload.py
    ├── _SharecfgLookup.py
    ├── _UpdateAugmentConverter.py
    ├── _UpdateEquipConverter.py
    ├── _UpdateEquipWikidata.py
    ├── _UpdateShipsConverter.py
    ├── _UpdateSkinsWikidata.py
    ├── augment.py
    ├── data
    │   └── static
    │   │   ├── item_name_convert.json
    │   │   ├── settings_default.toml
    │   │   └── shipid_overrides.json
    ├── equip.py
    ├── equipskin.py
    ├── furniture.py
    ├── lib
    │   ├── Constants.py
    │   ├── Utility.py
    │   ├── WikiConstants.py
    │   ├── WikiHelper.py
    │   ├── __init__.py
    │   ├── api.py
    │   ├── apiclasses.py
    │   ├── apimodules.py
    │   ├── converter
    │   │   ├── __init__.py
    │   │   ├── augments.py
    │   │   ├── augments_updater.py
    │   │   ├── equips.py
    │   │   ├── equips_updater.py
    │   │   ├── ships.py
    │   │   ├── ships_updater.py
    │   │   ├── skins.py
    │   │   └── skins_updater.py
    │   ├── settings.py
    │   └── sharecfgmodules.py
    ├── map.py
    ├── milestone.py
    ├── quotes.py
    ├── ship.py
    ├── shop.py
    ├── skins.py
    ├── story.py
    └── templates
    │   ├── Equipment.json
    │   ├── EventShop.json
    │   ├── Juustagram.json
    │   ├── Map.json
    │   ├── Mission.json
    │   ├── MissionDouble.json
    │   ├── Ship.json
    │   ├── ShipQuote.json
    │   ├── ShipQuoteEN.json
    │   ├── ShipSkin.json
    │   ├── ShipSkin0.json
    │   ├── Story.json
    │   └── Template.json
├── README.md
├── lua_convert.py
├── lua_converter.py
├── lua_converter_v2.py
├── serializer.lua
└── serializer2.lua


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__
2 | .vscode
3 | Src*
4 | 


--------------------------------------------------------------------------------
/PythonScripts/7day-signin.py:
--------------------------------------------------------------------------------
 1 | from argparse import ArgumentParser
 2 | 
 3 | from lib import ALJsonAPI, Client, WikiHelper, Utility
 4 | from lib.apiclasses import Award, ShipReward
 5 | 
 6 | 
 7 | def award_to_display(award: Award, wikifier: WikiHelper.Wikifier, client: Client) -> str:
 8 | 	awardable = award.load_first(wikifier.api, client)
 9 | 	wiki_awardable = wikifier.wikify_awardable(awardable)
10 | 
11 | 	awardable_name = wiki_awardable.name
12 | 	# add link brackets for ship rewards
13 | 	if isinstance(awardable, ShipReward):
14 | 		awardable_name = f"[[{awardable_name}]]"
15 | 
16 | 	wiki_display = WikiHelper.simple_template("Display",
17 | 		[wiki_awardable.filelink, wiki_awardable.rarity.label, f"{award.amount}x "+awardable_name])
18 | 	return wiki_display
19 | 
20 | def seven_day_signin(loginid: int, wikifier: WikiHelper.Wikifier, client: Client = None):
21 | 	client = [client] or Client
22 | 
23 | 	activity_7_day_sign = wikifier.api.get_sharecfgmodule("activity_7_day_sign")
24 | 	signin_data = activity_7_day_sign.load_first(loginid, client)
25 | 	if not signin_data:
26 | 		client_names = ', '.join([c.name for c in client])
27 | 		raise ValueError(f"loginid {loginid} does not exist for clients '{client_names}'.")
28 | 
29 | 	award_displays = [award_to_display(award, wikifier, client) for award in signin_data.front_drops]
30 | 	return '\n'.join(award_displays)
31 | 
32 | def main():
33 | 	parser = ArgumentParser()
34 | 	parser.add_argument("-c", "--client", choices=Client.__members__, default = "EN",
35 | 						help="client to gather information from (default: EN)")
36 | 	parser.add_argument('loginid', metavar='INDEX', type=int, nargs=1,
37 | 						help='an index from sharecfg/activity_7_day_sign')
38 | 	args = parser.parse_args()
39 | 	
40 | 	client = Client[args.client]
41 | 	api = ALJsonAPI()
42 | 	wikifier = WikiHelper.Wikifier(api)
43 | 
44 | 	wikitext = seven_day_signin(args.loginid[0], wikifier, client)
45 | 	Utility.output(wikitext)
46 | 
47 | if __name__ == "__main__":
48 | 	main()
49 | 


--------------------------------------------------------------------------------
/PythonScripts/_FileUpload.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | from pathlib import Path
 3 | from enum import Enum, auto
 4 | from mwclient import APIError
 5 | 
 6 | from lib import WikiHelper
 7 | 
 8 | 
 9 | class UploadResult(Enum):
10 | 	SUCCESS = auto()
11 | 	FAILURE = auto()
12 | 	FAILURE_SAME = auto()
13 | 	WARNING_EXIST = auto()
14 | 	WARNING_DELETED = auto()
15 | 	WARNING_SIMILAR_NAME = auto()
16 | 
17 | 
18 | def do_upload(wikiclient: WikiHelper.WikiClient, *args, **kwargs) -> UploadResult:
19 | 	try:
20 | 		result = wikiclient.execute(wikiclient.mwclient.upload, *args, **kwargs)
21 | 	except APIError as error:
22 | 		# handle additional duplicate error otherwise raise the exception again
23 | 		if error.code == 'fileexists-no-change':
24 | 			print('Is duplicate, skipping.')
25 | 			return UploadResult.FAILURE_SAME
26 | 		raise error
27 | 
28 | 	# handle other return type
29 | 	if 'upload' in result:
30 | 		result = result['upload']
31 | 
32 | 	if result:
33 | 		if result['result'] == 'Success':
34 | 			print('Done.')
35 | 			return UploadResult.SUCCESS
36 | 
37 | 		if result['result'] == 'Warning':
38 | 			if 'exists' in result['warnings']:
39 | 				if not (('no-change' in result['warnings']) or ('duplicate-version' in result['warnings'])):
40 | 					return UploadResult.WARNING_EXIST
41 | 				print("Warning (exists):")
42 | 				print(result)
43 | 			elif 'was-deleted' in result['warnings']:
44 | 				print("Waning: File was previously deleted.")
45 | 				i = input("Retry uploading? (y/n): ")
46 | 				if i.lower() == 'y':
47 | 					return UploadResult.WARNING_DELETED
48 | 			elif 'page-exists' in result['warnings']:
49 | 				print("Waning: File page already exists, but has no file.")
50 | 				i = input("Retry uploading? (y/n): ")
51 | 				if i.lower() == 'y':
52 | 					return UploadResult.WARNING_EXIST
53 | 			elif 'exists-normalized' in result['warnings']:
54 | 				return UploadResult.WARNING_SIMILAR_NAME
55 | 			else:
56 | 				print("Warning:")
57 | 				print(result)
58 | 
59 | 		else:
60 | 			print('Failed with Unknown Error:')
61 | 			print(result)
62 | 
63 | 	else:
64 | 		print('Failed to upload.')
65 | 	return UploadResult.FAILURE
66 | 
67 | def upload_file(wikiclient: WikiHelper.WikiClient, filepath: Path):
68 | 	print(f'Uploading {filepath.name}... ', end='')
69 | 	result = do_upload(wikiclient, open(filepath, 'rb'), filename=filepath.name)
70 | 	while True:
71 | 		if result in (UploadResult.SUCCESS, UploadResult.FAILURE, UploadResult.FAILURE_SAME):
72 | 			break
73 | 		if result in (UploadResult.WARNING_EXIST, UploadResult.WARNING_DELETED, UploadResult.WARNING_SIMILAR_NAME):
74 | 			result = do_upload(wikiclient, open(filepath, 'rb'), filename=filepath.name, ignore=True)
75 | 
76 | 
77 | def main():
78 | 	wikiclient = WikiHelper.WikiClient().login()
79 | 	args = sys.argv[1:]
80 | 
81 | 	for arg in args:
82 | 		argpath = Path(arg)
83 | 		if not argpath.exists():
84 | 			print(f"Input File {arg} does not exist.")
85 | 			continue
86 | 
87 | 		if argpath.is_dir():
88 | 			for fp in argpath.rglob("*"):
89 | 				upload_file(wikiclient, fp)
90 | 		else:
91 | 			upload_file(wikiclient, argpath)
92 | 
93 | if __name__ == "__main__":
94 | 	main()
95 | 


--------------------------------------------------------------------------------
/PythonScripts/_SharecfgLookup.py:
--------------------------------------------------------------------------------
 1 | from lib import Client, ALJsonAPI
 2 | 
 3 | 
 4 | def main():
 5 | 	api = ALJsonAPI()
 6 | 
 7 | 	while True:
 8 | 		module = None
 9 | 		modulename = input("Module: ")
10 | 
11 | 		try:
12 | 			module = api.get_sharecfgmodule(modulename)
13 | 		except: pass
14 | 		if not module:
15 | 			try:
16 | 				module = api.get_apimodule(modulename)
17 | 			except: pass
18 | 
19 | 		if module: break
20 | 		else: print("FAILED: Module does not exist.")
21 | 
22 | 	while True:
23 | 		dataid = input("ID: ")
24 | 		client = input("Client: ")
25 | 
26 | 		try:
27 | 			if client:
28 | 				client = Client[client]
29 | 				print(module.load_client(dataid, client)._json)
30 | 			else:
31 | 				print(module.load_first(dataid, Client)._json)
32 | 		except:
33 | 			print("FAILED: Maybe the module does not have this id?")
34 | 
35 | if __name__ == "__main__":
36 | 	main()
37 | 


--------------------------------------------------------------------------------
/PythonScripts/_UpdateAugmentConverter.py:
--------------------------------------------------------------------------------
 1 | from lib import ALJsonAPI, Constants
 2 | from lib.converter import augments_updater
 3 | 
 4 | 
 5 | def main():
 6 | 	api = ALJsonAPI()
 7 | 	augmentcache_fp = Constants.AUGMENT_CONVERT_CACHE_PATH
 8 | 	augments_updater.update_converter(augmentcache_fp, api)
 9 | 
10 | if __name__ == "__main__":
11 | 	main()
12 | 


--------------------------------------------------------------------------------
/PythonScripts/_UpdateEquipConverter.py:
--------------------------------------------------------------------------------
 1 | from lib import ALJsonAPI, Constants
 2 | from lib.converter import equips_updater
 3 | 
 4 | 
 5 | def main():
 6 | 	api = ALJsonAPI()
 7 | 	equipcache_fp = Constants.EQUIP_CONVERT_CACHE_PATH
 8 | 	wikicache_fp = Constants.EQUIP_WIKIDATA_PATH
 9 | 	equips_updater.update_converter(equipcache_fp, wikicache_fp, api)
10 | 
11 | if __name__ == "__main__":
12 | 	main()
13 | 


--------------------------------------------------------------------------------
/PythonScripts/_UpdateEquipWikidata.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | 
 3 | from lib import Constants
 4 | from lib.WikiHelper import WikiClient
 5 | 
 6 | 
 7 | def request_equips(wikiclient: WikiClient, offset=0):
 8 | 	result = wikiclient.execute(wikiclient.mwclient.api,
 9 | 		action="cargoquery",
10 | 		format="json",
11 | 		limit=500,
12 | 		tables="equipment",
13 | 		fields="equipment.Name,equipment.BaseID",
14 | 		where="equipment.Type != 'Augment Module'",
15 | 		offset=offset)
16 | 	return result['cargoquery']
17 | 
18 | def download_equip_data():
19 | 	wikiclient = WikiClient().login()
20 | 	all_entires = []
21 | 	offset = 0
22 | 	while True:
23 | 		entries = request_equips(wikiclient, offset)
24 | 		all_entires += entries
25 | 		if len(entries) == 500:
26 | 			offset += 500
27 | 		else:
28 | 			return all_entires
29 | 
30 | 
31 | def main():
32 | 	cache_fp = Constants.EQUIP_WIKIDATA_PATH
33 | 	equipdata = download_equip_data()
34 | 	with open(cache_fp, "w", encoding="utf8") as file:
35 | 		json.dump(equipdata, file)
36 | 
37 | if __name__ == "__main__":
38 | 	main()
39 | 


--------------------------------------------------------------------------------
/PythonScripts/_UpdateShipsConverter.py:
--------------------------------------------------------------------------------
 1 | from lib import ALJsonAPI, Constants
 2 | from lib.converter import ships_updater
 3 | 
 4 | 
 5 | def main():
 6 | 	api = ALJsonAPI()
 7 | 	convert_fp = Constants.SHIPID_CONVERT_CACHE_PATH
 8 | 	override_fp = Constants.SHIPID_CONVERT_OVERRIDE_PATH
 9 | 	ships_updater.update_converter(convert_fp, override_fp, api)
10 | 
11 | if __name__ == "__main__":
12 | 	main()
13 | 


--------------------------------------------------------------------------------
/PythonScripts/_UpdateSkinsWikidata.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | 
 3 | from lib import Constants
 4 | from lib.WikiHelper import WikiClient
 5 | 
 6 | 
 7 | def request_skins(wikiclient: WikiClient, offset=0):
 8 | 	result = wikiclient.execute(wikiclient.mwclient.api,
 9 | 		action="cargoquery",
10 | 		format="json",
11 | 		limit=500,
12 | 		tables="ship_skins",
13 | 		fields="ship_skins.ShipName,ship_skins.SkinID,ship_skins.SkinCategory",
14 | 		order_by='"cargo__ship_skins"."ShipName","cargo__ship_skins"."SkinID"',
15 | 		offset=offset)
16 | 	return result['cargoquery']
17 | 
18 | def download_skin_data():
19 | 	wikiclient = WikiClient().login()
20 | 	all_entires = []
21 | 	offset = 0
22 | 	while True:
23 | 		entries = request_skins(wikiclient, offset)
24 | 		all_entires += entries
25 | 		if len(entries) == 500:
26 | 			offset += 500
27 | 		else:
28 | 			return all_entires
29 | 
30 | 
31 | def main():
32 | 	cache_fp = Constants.SKIN_WIKIDATA_PATH
33 | 	equipdata = download_skin_data()
34 | 	with open(cache_fp, "w", encoding="utf8") as file:
35 | 		json.dump(equipdata, file)
36 | 
37 | if __name__ == "__main__":
38 | 	main()
39 | 


--------------------------------------------------------------------------------
/PythonScripts/augment.py:
--------------------------------------------------------------------------------
  1 | from argparse import ArgumentParser
  2 | from difflib import get_close_matches
  3 | from collections.abc import Iterable
  4 | 
  5 | from lib import ALJsonAPI, Client, WikiHelper, Utility
  6 | from lib.Constants import ShipType as ship_types
  7 | 
  8 | 
  9 | attributes = {
 10 | 	'durability':		['Health',		'HealthMax',	'HealthOPS'],
 11 | 	'cannon':		['Firepower',		'FPMax',	'FPOPS'],
 12 | 	'torpedo':		['Torpedo',		'TorpMax',	'TorpOPS'],
 13 | 	'antiaircraft':		['AA',			'AAMax',	'AAOPS'],
 14 | 	'air':			['Aviation',		'AvMax',	'AvOPS'],
 15 | 	'reload':		['Reload',		'ReloadMax',	'ReloadOPS'],
 16 | 	'hit':			['Acc',			'AccMax',	'AccOPS'],
 17 | 	'dodge':		['Evasion',		'EvasionMax',	'EvasionOPS'],
 18 | 	'speed':		['Spd',			'SpdMax',	'SpdOPS'],
 19 | 	'luck':			['Luck',		'LuckMax',	'LuckOPS'],
 20 | 	'antisub':		['ASW',			'ASWMax',	'ASWOPS'],
 21 | 	'oxygen':		['Oxygen',		'OxygenMax',	'OxygenOPS']
 22 | }
 23 | 
 24 | 
 25 | 
 26 | def getGameData(augment, api: ALJsonAPI, clients: Iterable[Client]):
 27 | 	augment_data_statistics = api.get_sharecfgmodule("spweapon_data_statistics")
 28 | 	augment_data = {}
 29 | 	if type(augment) != int:
 30 | 		augment_id = augment.id
 31 | 		augment_data['Name'] = augment.wikiname
 32 | 		augment_data['Image'] = augment.icon
 33 | 	else:
 34 | 		augment_stats = augment_data_statistics.load_first(augment, clients)
 35 | 		augment_id = augment
 36 | 		augment_data['Name'] = augment_stats.name
 37 | 		augment_data['Image'] = "Augment " + augment_stats.icon
 38 | 	augment_data['BaseID'] = augment_id
 39 | 	
 40 | 	for client in [Client.CN, Client.JP]:
 41 | 		if augment0 := augment_data_statistics.load_client(f"{augment_id}", client):
 42 | 			augment_data[client.name+'Name'] = api.replace_namecode(augment0.name, client)
 43 | 	
 44 | 	augment_stats = augment_data_statistics.load_first(augment_id, clients)
 45 | 	augment_stats_up = augment_data_statistics.load_first(augment_id+10, clients)
 46 | 	if not augment_stats:
 47 | 		raise KeyError(f"Augment ID not found: {augment_id}")
 48 | 	augment_data['Type'] = "Augment Module"
 49 | 	augment_data['Stars'] = augment_stats.get('rarity') + 1
 50 | 	augment_data['Nationality'] = 'Universal'
 51 | 	augment_data['Tech'] = f"T{augment_stats.tech}"
 52 | 
 53 | 
 54 | 	i = 1
 55 | 	while stat := augment_stats.get(f"attribute_{i}"):
 56 | 		augment_data[attributes[stat][0]] = f"{augment_stats.get(f'value_{i}')} + {augment_stats.get(f'value_{i}_random')}"
 57 | 		if augment_stats_up.get(f'value_{i}'):
 58 | 			augment_data[attributes[stat][1]] = f"{augment_stats_up.get(f'value_{i}')} + {augment_stats.get(f'value_{i}_random')}"
 59 | 		i += 1
 60 | 
 61 | 
 62 | 	if not (usability := augment_stats.usability):
 63 | 		aug_type_data = api.get_sharecfgmodule('spweapon_type')
 64 | 		aug_type = aug_type_data.load_first(augment_stats.type,clients)
 65 | 		#usability = [1,2,3,4,5,6,7,8,10,12,13,17,18,19,22]
 66 | 		usability = aug_type.ship_type
 67 | 	for i in usability:
 68 | 		ship_type = ship_types.from_id(i)
 69 | 		if unique_ship := augment_stats.get('unique'):
 70 | 			augment_data[ship_type.templatename] = 2
 71 | 			augment_data[ship_type.templatename + 'Note'] = api.ship_converter.get_shipname(unique_ship) + ' only'
 72 | 		else:
 73 | 			augment_data[ship_type.templatename] = 1
 74 | 
 75 | 	augment_data['DropLocation'] = '[[Augmentation]]'
 76 | 
 77 | 
 78 | 
 79 | 	
 80 | 	skill_data_template = api.get_sharecfgmodule("skill_data_template")
 81 | 	skill_desc_template = api.get_sharecfgmodule("skill_world_display")
 82 | 
 83 | 
 84 | 	skill_id = augment_stats.effect_id
 85 | 	skill_data = skill_data_template.load_first(skill_id, clients)
 86 | 	skill_desc = skill_desc_template.load_first(skill_id, clients)
 87 | 	name = skill_data.name
 88 | 
 89 | 	desc_list = []
 90 | 	for j in [skill_data,skill_desc]:
 91 | 		if j:
 92 | 			desc = j['desc']
 93 | 			desc_add = j['desc_add']
 94 | 			for k, desc_add_item in enumerate(desc_add):
 95 | 				desc = desc.replace('$'+str(k+1), desc_add_item[0][0]+' ('+desc_add_item[skill_data['max_level']-1][0]+')')
 96 | 			desc_list.append(desc.replace('.0%','%'))
 97 | 	effect = "'''{}''': {}{}".format(name,desc_list[0] if desc_list else "","<br>[Operation Siren only] "+desc_list[1] if len(desc_list)>1 else "")
 98 | 
 99 | 	augment_data['Notes'] = effect
100 | 
101 | 
102 | 	if augment_stats.get('skill_upgrade'):
103 | 		skill_up = augment_stats_up.skill_upgrade[0]
104 | 		old_skill_data = skill_data_template.load_first(skill_up[0], clients)
105 | 		new_skill_data = skill_data_template.load_first(skill_up[1], clients)
106 | 		new_skill_desc = skill_desc_template.load_first(skill_up[1], clients)
107 | 		old_name = old_skill_data.name
108 | 		new_name = new_skill_data.name
109 | 
110 | 		desc_list = []
111 | 		for j in [new_skill_data,new_skill_desc]:
112 | 			if j:
113 | 				desc = j['desc']
114 | 				desc_add = j['desc_add']
115 | 				for k, desc_add_item in enumerate(desc_add):
116 | 					desc = desc.replace('$'+str(k+1), desc_add_item[0][0]+' ('+desc_add_item[new_skill_data['max_level']-1][0]+')')
117 | 				desc_list.append(desc.replace('.0%','%'))
118 | 		effect = "<br><br>''Replaces {} at +10 with {}''<br>{}{}".format(old_name,new_name,desc_list[0] if desc_list else "","<br>[Operation Siren only] "+desc_list[1] if len(desc_list)>1 else "")
119 | 
120 | 		augment_data['Notes'] += effect
121 | 
122 | 
123 | 	return augment_data
124 | 
125 | 
126 | 
127 | 
128 | 
129 | 
130 | def main():
131 | 	parser = ArgumentParser()
132 | 	parser.add_argument("-c", "--clients", choices=Client.__members__, default = ['EN'], nargs = '+',
133 | 						help="clients to gather information from (default: EN)")
134 | 	group = parser.add_mutually_exclusive_group()
135 | 	group.add_argument("-n", "--name", action="store_true",help="interprets arg as name/id of the Augment to get info for")
136 | 	group.add_argument("-s", "--ship", action="store_true",help="interprets arg as name/id of a ship")
137 | 	parser.add_argument("arg",help="argument to get info for")
138 | 	args = parser.parse_args()
139 | 
140 | 	clients = [ Client[c] for c in args.clients ]
141 | 	api = ALJsonAPI()
142 | 	if args.name:
143 | 		augment = api.augment_converter.from_wikiname(args.arg)
144 | 		if not augment:
145 | 			if args.arg.isdigit():
146 | 				augment_id = int(args.arg)
147 | 				augment = api.augment_converter.from_augmentid(augment_id)
148 | 				if not augment:
149 | 					print("Warning: ID not found in wiki data, attempting to get data from json!")
150 | 					augment = augment_id
151 | 			else:
152 | 				if m := get_close_matches(args.arg, api.augment_converter.wikiname_to_data.keys(), 1):
153 | 					print(f'"{args.arg}" is not a valid Augment name, assuming you meant "{m[0]}"!')
154 | 					augment = api.augment_converter.from_wikiname(m[0])
155 | 					if not augment:
156 | 						raise Exception('Augment cannot be found! (Something major must be wrong with the Augment Converter)')
157 | 				else:
158 | 					e = f'"{args.arg}" is not a valid Augment name.'
159 | 					raise ValueError(e)
160 | 	elif args.ship:
161 | 		if type(args.arg) != str:
162 | 			try:
163 | 				groupid = int(args.arg)
164 | 			except:
165 | 				raise TypeError(f'Expected string or int, got {type(args.arg)} at {args.arg}')
166 | 		else: groupid = api.ship_converter.get_groupid(args.arg)
167 | 		if not groupid:
168 | 			if args.arg.isdigit():
169 | 				groupid = int(args.arg)
170 | 			else:
171 | 				if m := get_close_matches(args.arg, api.ship_converter.ship_to_id.keys(), 1):
172 | 					e = f'"{args.arg}" is not a valid ship name, did you mean {m[0]}?'
173 | 				else:
174 | 					e = f'"{args.arg}" is not a valid ship name.'
175 | 				raise ValueError(e)
176 | 		augment = api.augment_converter.from_shipid(groupid)
177 | 		if not augment: print(f"Ship {args.arg} has no unique augment")
178 | 	template_data_game = getGameData(augment, api, clients)
179 | 	equip_template = WikiHelper.MultilineTemplate("Equipment")
180 | 	wikitext = equip_template.fill(template_data_game)
181 | 	Utility.output(wikitext)
182 | 	#print(equip.id)
183 | 
184 | if __name__ == "__main__":
185 | 	main()
186 | 


--------------------------------------------------------------------------------
/PythonScripts/data/static/item_name_convert.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"T1 Royal Tech Pack": "T1Box",
  3 | 	"T2 Royal Tech Pack": "T2Box",
  4 | 	"T3 Royal Tech Pack": "T3Box",
  5 | 	"T4 Royal Tech Pack": "T4Box",
  6 | 	"T5 Royal Tech Pack": "T5Box",
  7 | 	"T1 Eagle Tech Pack": "T1Box",
  8 | 	"T2 Eagle Tech Pack": "T2Box",
  9 | 	"T3 Eagle Tech Pack": "T3Box",
 10 | 	"T4 Eagle Tech Pack": "T4Box",
 11 | 	"T5 Eagle Tech Pack": "T5Box",
 12 | 	"T1 Sakura Tech Pack": "T1Box",
 13 | 	"T2 Sakura Tech Pack": "T2Box",
 14 | 	"T3 Sakura Tech Pack": "T3Box",
 15 | 	"T4 Sakura Tech Pack": "T4Box",
 16 | 	"T5 Sakura Tech Pack": "T5Box",
 17 | 	"T1 Ironblood Tech Pack": "T1Box",
 18 | 	"T2 Ironblood Tech Pack": "T2Box",
 19 | 	"T3 Ironblood Tech Pack": "T3Box",
 20 | 	"T4 Ironblood Tech Pack": "T4Box",
 21 | 	"T5 Ironblood Tech Pack": "T5Box",
 22 | 	"Random T1 Tech Pack": "T1Box",
 23 | 	"Random T2 Tech Pack": "T2Box",
 24 | 	"Random T3 Tech Pack": "T3Box",
 25 | 	"Random T4 Tech Pack": "T4Box",
 26 | 	"Random T5 Tech Pack": "T5Box",
 27 | 
 28 | 	"T1 Random Skill Book": "UnknownT1Book",
 29 | 	"T2 Random Skill Book": "UnknownT2Book",
 30 | 	"T3 Random Skill Book": "UnknownT3Book",
 31 | 	"T1 Offensive Skill Book": "OffenseT1TB",
 32 | 	"T2 Offensive Skill Book": "OffenseT2TB",
 33 | 	"T3 Offensive Skill Book": "OffenseT3TB",
 34 | 	"T1 Support Skill Book": "SupportT1TB",
 35 | 	"T2 Support Skill Book": "SupportT2TB",
 36 | 	"T3 Support Skill Book": "SupportT3TB",
 37 | 	"T1 Defensive Skill Book": "DefenseT1TB",
 38 | 	"T2 Defensive Skill Book": "DefenseT2TB",
 39 | 	"T3 Defensive Skill Book": "DefenseT3TB",
 40 | 
 41 | 	"T1 Random Retrofit Blueprint": "UnknownT1BP",
 42 | 	"T2 Random Retrofit Blueprint": "UnknownT2BP",
 43 | 	"T3 Random Retrofit Blueprint": "UnknownT3BP",
 44 | 	"T1 Destroyer Retrofit Blueprint": "DestroyerT1BP",
 45 | 	"T2 Destroyer Retrofit Blueprint": "DestroyerT2BP",
 46 | 	"T3 Destroyer Retrofit Blueprint": "DestroyerT3BP",
 47 | 	"T1 Cruiser Retrofit Blueprint": "CruiserT1BP",
 48 | 	"T2 Cruiser Retrofit Blueprint": "CruiserT2BP",
 49 | 	"T3 Cruiser Retrofit Blueprint": "CruiserT3BP",
 50 | 	"T1 Battleship Retrofit Blueprint": "BattleshipT1BP",
 51 | 	"T2 Battleship Retrofit Blueprint": "BattleshipT2BP",
 52 | 	"T3 Battleship Retrofit Blueprint": "BattleshipT3BP",
 53 | 	"T1 Carrier Retrofit Blueprint": "CarrierT1BP",
 54 | 	"T2 Carrier Retrofit Blueprint": "CarrierT2BP",
 55 | 	"T3 Carrier Retrofit Blueprint": "CarrierT3BP",
 56 | 
 57 | 	"T1 Random Gear Part": "UnknownT1Plate",
 58 | 	"T2 Random Gear Part": "UnknownT2Plate",
 59 | 	"T3 Random Gear Part": "UnknownT3Plate",
 60 | 	"T1 General Part": "AuxT1Plate",
 61 | 	"T2 General Part": "AuxT2Plate",
 62 | 	"T3 General Part": "AuxT3Plate",
 63 | 	"T1 Main Gun Part": "GunT1Plate",
 64 | 	"T2 Main Gun Part": "GunT2Plate",
 65 | 	"T3 Main Gun Part": "GunT3Plate",
 66 | 	"T1 Torpedo Part": "TorpT1Plate",
 67 | 	"T2 Torpedo Part": "TorpT2Plate",
 68 | 	"T3 Torpedo Part": "TorpT3Plate",
 69 | 	"T1 Anti-Air Gun Part": "AAT1Plate",
 70 | 	"T2 Anti-Air Gun Part": "AAT2Plate",
 71 | 	"T3 Anti-Air Gun Part": "AAT3Plate",
 72 | 	"T1 Aircraft Part": "PlaneT1Plate",
 73 | 	"T2 Aircraft Part": "PlaneT2Plate",
 74 | 	"T3 Aircraft Part": "PlaneT3Plate",
 75 | 
 76 | 	"Strengthening Unit S1": "AllSUnit",
 77 | 	"Strengthening Unit S2": "AllSUnit2",
 78 | 	"Special Strengthening Unit S2": "AllSUnit2",
 79 | 	"Strengthening Unit S3": "AllSUnit3",
 80 | 	"Special Strengthening Unit S3": "AllSUnit3",
 81 | 	"Strengthening Unit S4": "AllSUnit4",
 82 | 	"Special Strengthening Unit S4": "AllSUnit4",
 83 | 	"Random Blueprint": "UnknownSUnit",
 84 | 	
 85 | 	"Blueprint - Neptune": "HMS_NeptuneSUnit",
 86 | 	"Blueprint - Monarch": "MonarchSUnit",
 87 | 	"Blueprint - Ibuki": "IbukiSUnit",
 88 | 	"Blueprint - Izumo": "IzumoSUnit",
 89 | 	"Blueprint - Roon": "RoonSUnit",
 90 | 	"Blueprint - Saint Louis": "Saint LouisSUnit",
 91 | 	"Blueprint - Seattle": "SeattleSUnit",
 92 | 	"Blueprint - Georgia": "GeorgiaSUnit",
 93 | 	"Blueprint - Kitakaze": "KitakazeSUnit",
 94 | 	"Blueprint - Azuma": "AzumaSUnit",
 95 | 	"Blueprint - Friedrich der Große": "Friedrich der GroßeSUnit",
 96 | 	"Blueprint - Gascogne": "GascogneSUnit",
 97 | 	"Blueprint - Cheshire": "CheshireSUnit",
 98 | 	"Blueprint - Drake": "DrakeSUnit",
 99 | 	"Blueprint - Mainz": "MainzSUnit",
100 | 	"Blueprint - Odin": "OdinSUnit",
101 | 	"Blueprint - Champagne": "ChampagneSUnit",
102 | 	
103 | 	"Cognitive Chips": "Moduleicon",
104 | 	"Cognitive Datapack": "Cognitive Datapack",
105 | 	"Cognitive Array": "Cognitive Array",
106 | 	"Coins": "Coinicon",
107 | 	"Oil": "Oilicon",
108 | 	"Core Data": "Core Data",
109 | 	"Wisdom Cube": "cube",
110 | 	"Decor Tokens": "Furniture coin",
111 | 
112 | 	"Rare Cat Box": "Cat Box Rare",
113 | 	"Elite Cat Box": "Cat Box Elite",
114 | 	"Super Rare Cat Box": "Cat Box Super Rare",
115 | 
116 | 	"Oxy-cola": "Food1",
117 | 	"Candy Cane": "FoodChristmas",
118 | 	
119 | 	"Sakura Amulets": "SakuraPt",
120 | 	"Miniature Crowns": "CrownPt",
121 | 	"The Iron Blood Coat of Arms": "IronbloodPt",
122 | 	"Universe Badge": "UniverseBadgePt",
123 | 	"Gear Skin Box (Shining Stars)": "appearanceboxjichang",
124 | 	"Venus Points": "DOAPt",
125 | 	"Gear Skin Box (Venus Vacation)": "appearanceboxdoa",
126 | 	"Arcana Cube": "CubePt",
127 | 	"Symbol of Renaissance": "RenaissancePt",
128 | 	"Involuted Seal": "InvolutedSealPt",
129 | 	"Silver Wing Badge": "SilverWingPt",
130 | 	"Intel Pt": "IntelPt"
131 | }


--------------------------------------------------------------------------------
/PythonScripts/data/static/settings_default.toml:
--------------------------------------------------------------------------------
1 | # path to the json data folder
2 | source_json_path = "../SrcJson"
3 | 
4 | # which json data repository is used
5 | # "AzurLaneTools" for https://github.com/AzurLaneTools/AzurLaneData
6 | # "nobbyfix" for https://github.com/nobbyfix/AzurLaneSourceJson
7 | jsonloader_variant = "AzurLaneTools"
8 | 


--------------------------------------------------------------------------------
/PythonScripts/data/static/shipid_overrides.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"1010001": "Neptune (Neptunia)",
 3 | 	"1060003": "Kasumi (Venus Vacation)",
 4 | 	"30507": "Kaga (Battleship)",
 5 | 	"1050007": "Ookami Mio",
 6 | 	"70202": "Pamiat Merkuria",
 7 | 	"10224": "Cleveland µ",
 8 | 	"20225": "Sheffield µ",
 9 | 	"20232": "Enterprise (Royal Navy)",
10 | 	"30710": "Akagi µ",
11 | 	"40307": "Admiral Hipper µ",
12 | 	"90503": "Gascogne µ",
13 | 	"40308": "Roon µ",
14 | 	"10325": "Baltimore µ",
15 | 	"10805": "Albacore µ",
16 | 	"20228": "Dido µ",
17 | 	"20711": "Illustrious µ",
18 | 	"30711": "Taihou µ",
19 | 	"70105": "Tashkent µ",
20 | 	"90112": "Le Malin µ",
21 | 	"1020001": "22",
22 | 	"1020002": "33",
23 | 	"1030001": "Kuon",
24 | 	"1030002": "Nekone",
25 | 	"1030003": "Rurutie",
26 | 	"1030004": "Uruuru",
27 | 	"1030005": "Saraana",
28 | 	"1030006": "Fumiruiru",
29 | 	"1100005": "Fubuki (Senran Kagura)"
30 | }


--------------------------------------------------------------------------------
/PythonScripts/equipskin.py:
--------------------------------------------------------------------------------
 1 | from argparse import ArgumentParser
 2 | 
 3 | from lib import ALJsonAPI, Client, WikiHelper, Utility
 4 | from lib.apiclasses import BackyardTheme
 5 | 
 6 | 
 7 | EQUIPMENTTYPE_USAGE = {
 8 | 	1: '{{DD}} DD Main Gun',
 9 | 	2: '{{CL}} CL Main Gun',
10 | 	3: '{{CA}} CA Main Gun',
11 | 	4: '{{BB}} BB Main Gun',
12 | 	5: '{{Torpedo}} Torpedo',
13 | #	6: 'AA Gun',
14 | 	7: '{{CV}} Fighter',
15 | 	8: '{{CV}} Torpedo Bomber',
16 | 	9: '{{CV}} Dive Bomber',
17 | #	10: 'Auxiliary',
18 | #	11: None,
19 | 	12: '{{CV}} Seaplane',
20 | 	13: '{{Torpedo}} Sub Torpedo',
21 | #	14: 'Auxiliary',
22 | 	15: '{{CV}} ASW Plane',
23 | #	17: 'Helicopter'
24 | }
25 | 
26 | 
27 | api = ALJsonAPI()
28 | 
29 | def equipment_skin(client, eqid):
30 | 	equip_skin_template = api.get_sharecfgmodule('equip_skin_template')
31 | 	eqskin = equip_skin_template.load_client(eqid, client)
32 | 	if not eqskin: raise ValueError(f'Equipment skinid {eqid} does not exist.')
33 | 
34 | 	name = eqskin['name'].strip()
35 | 	icon = eqskin['icon']
36 | 	desc = eqskin['desc'].strip()
37 | 	usages = [EQUIPMENTTYPE_USAGE[eqtype] for eqtype in eqskin['equip_type'] if eqtype in EQUIPMENTTYPE_USAGE]
38 | 	return WikiHelper.simple_template('EquipSkinRow', [name, icon, desc, '<br>'.join(usages)])
39 | 
40 | def equipment_theme_skinlist(client, skinids: list):
41 | 	theme_skins = [equipment_skin(client, eqskinid) for eqskinid in skinids]
42 | 	return '\n'.join(theme_skins)
43 | 
44 | def equipment_theme(client, theme: BackyardTheme) -> str:
45 | 	skinlist = equipment_theme_skinlist(client, theme['ids'])
46 | 	return WikiHelper.simple_template('EquipSkinHeader', [theme.name])+'\n'+skinlist+'\n|}'
47 | 
48 | def get_theme_from_id(client: Client, themeid: str | int) -> BackyardTheme:
49 | 	equip_skin_theme_template = api.get_sharecfgmodule('equip_skin_theme_template')
50 | 	theme = equip_skin_theme_template.load_client(themeid, client)
51 | 	if not theme:
52 | 		raise ValueError(f'Equipment theme {themeid} does not exist.')
53 | 	return theme
54 | 
55 | def get_theme_from_name(client: Client, themename: str) -> BackyardTheme:
56 | 	equip_skin_theme_template = api.get_sharecfgmodule('equip_skin_theme_template')
57 | 	for theme in equip_skin_theme_template.all_client(client):
58 | 		if theme.name == themename:
59 | 			return theme
60 | 	raise ValueError(f"Equipment theme with name '{themename}' does not exist.")
61 | 
62 | def main():
63 | 	parser = ArgumentParser()
64 | 	parser.add_argument('-i', '--themeids', type=int, nargs='*', default=[],
65 | 		help='a list of indexes from sharecfg/equip_skin_theme_template')
66 | 	parser.add_argument('-n', '--themenames', type=str, nargs='*', default=[],
67 | 		help='a list of names of themes from sharecfg/equip_skin_theme_template')
68 | 	parser.add_argument('-c', '--client', required=True, help='client to gather information from')
69 | 	args = parser.parse_args()
70 | 
71 | 	client = Client[args.client]
72 | 
73 | 	themes = [get_theme_from_id(client, themeid) for themeid in args.themeids]
74 | 	themes.extend([get_theme_from_name(client, themename) for themename in args.themenames])
75 | 
76 | 	formatted_themes = [equipment_theme(client, theme) for theme in themes]
77 | 	Utility.output('\n'.join(formatted_themes))
78 | 
79 | if __name__ == "__main__":
80 | 	main()
81 | 


--------------------------------------------------------------------------------
/PythonScripts/furniture.py:
--------------------------------------------------------------------------------
  1 | from collections import Counter
  2 | from argparse import ArgumentParser
  3 | from collections.abc import Iterable
  4 | 
  5 | from lib import ALJsonAPI, Client, WikiHelper, Utility
  6 | from lib.apiclasses import Furniture
  7 | 
  8 | 
  9 | FURNITURE_TYPE = {
 10 | 	1: "Wallpaper", # TYPE_WALLPAPER
 11 | 	2: "Furniture", # TYPE_FURNITURE
 12 | 	3: "Decoration", # TYPE_DECORATE
 13 | 	4: "Floor", # TYPE_FLOORPAPER
 14 | 	5: "Floor Item", # TYPE_MAT
 15 | 	6: "Wall Decoration", # TYPE_WALL
 16 | 	7: "Special", # TYPE_COLLECTION
 17 | 	8: "Stage", # TYPE_STAGE
 18 | 	9: "Arch", # TYPE_ARCH
 19 | 	10: "Special", # TYPE_WALL_MAT
 20 | 	11: "Moving Object", # TYPE_MOVEABLE
 21 | 	12: "Transport", # TYPE_TRANSPORT
 22 | 	13: "Special" # TYPE_RANDOM_CONTROLLER
 23 | }
 24 | 
 25 | INTERACTION = {
 26 | 	"sit": "sit",
 27 | 	"wash": "bath",
 28 | 	"sleep": "sleep",
 29 | 	"dance": "dance",
 30 | 	"stand2": "stand",
 31 | 	"victory": "stand",
 32 | 	"yun": "stand",
 33 | 	"attack": "stand",
 34 | }
 35 | 
 36 | NUM_TEXT = ["One", "Two", "Three", "Four", "Five", "Six", "Seven"]
 37 | def convert_shipgirl_amount(num: int) -> str:
 38 | 	text = NUM_TEXT[num-1] + " shipgirl"
 39 | 	if num > 1: text += "s"
 40 | 	return text
 41 | 
 42 | 
 43 | def furniture_item_template(furn: Furniture):		
 44 | 		# optional shop data that needs to be checked if the field is there
 45 | 		price_coin = furn.dorm_icon_price if "dorm_icon_price" in furn else ""
 46 | 		price_gem = furn.gem_price if "dorm_icon_price" in furn else ""
 47 | 
 48 | 		if size := furn.size or "":
 49 | 			size = f"{size[0]}x{size[1]}"
 50 | 
 51 | 		interaction = ""
 52 | 		if "interAction" in furn:
 53 | 			interaction_counter = Counter()
 54 | 			for action_data in furn.interAction:
 55 | 				interaction_counter[action_data[0]] += 1
 56 | 			
 57 | 			interaction = []
 58 | 			for actionname, amount in interaction_counter.most_common():
 59 | 				interaction.append(f"{convert_shipgirl_amount(amount)} can {INTERACTION[actionname]} here.")
 60 | 			interaction = "<br>".join(interaction)
 61 | 
 62 | 		params = [furn.name, furn.icon, furn.describe, furn.rarity.label, FURNITURE_TYPE[furn.type], price_coin, price_gem,
 63 | 					furn.comfortable or "", size, furn.count, interaction]
 64 | 		return WikiHelper.simple_template("FurnitureRow", params)
 65 | 
 66 | class FurnitureQuery:
 67 | 	api: ALJsonAPI
 68 | 
 69 | 	def __init__(self, api: ALJsonAPI) -> None:
 70 | 		self.api = api
 71 | 
 72 | 	def get_theme(self, themeid: int, clients: Iterable[Client]):
 73 | 		# determine client list, because all api calls use load_first
 74 | 		backyard_theme_template = self.api.get_sharecfgmodule("backyard_theme_template")
 75 | 		theme = backyard_theme_template.load_first(themeid, clients)
 76 | 		if not theme:
 77 | 			raise ValueError(f"There is no theme with id {themeid}.")
 78 | 
 79 | 		wikitext = [
 80 | 			f"== {theme.name} ==",
 81 | 			f"*'''Description:''' ''{theme.desc}''",
 82 | 			WikiHelper.simple_template("FurnitureTableHeader", [f"FurnIcon_{theme.icon}.png"]),
 83 | 		]
 84 | 
 85 | 		# add all furniture directly referenced from the set
 86 | 		theme_items = {}
 87 | 		for furniture_ref in theme.furniture:
 88 | 			furnitem = furniture_ref.load_first(self.api, clients)
 89 | 			theme_items[furnitem] = None
 90 | 
 91 | 		# search for more furniture items that are not directly referenced
 92 | 		# these are usually gem-only items
 93 | 		furniture_module = self.api.get_apimodule("furniture")
 94 | 		for furnitem in furniture_module.load_all(clients):
 95 | 			if furnitem.themeId == theme.id:
 96 | 				theme_items[furnitem] = None
 97 | 
 98 | 		# convert all items to wikitext
 99 | 		for furnitem in theme_items:
100 | 			wikitext.append(furniture_item_template(furnitem))
101 | 
102 | 		wikitext.append("|}")
103 | 		return "\n".join(wikitext)
104 | 
105 | 	def get_themeid_from_name(self, name: str, clients: Iterable[Client]) -> int:
106 | 		backyard_theme_template = self.api.get_sharecfgmodule("backyard_theme_template")
107 | 		for theme in backyard_theme_template.load_all(clients):
108 | 			if theme.name == name:
109 | 				return theme.id
110 | 
111 | 
112 | def main():
113 | 	parser = ArgumentParser()
114 | 	parser.add_argument("-i", "--id", type=int,
115 | 						help="an index from sharecfg/backyard_theme_template")
116 | 	parser.add_argument("-n", "--name", type=str,
117 | 						help="a theme name from sharecfg/backyard_theme_template")
118 | 	parser.add_argument("-c", "--client", nargs='*', choices=Client.__members__,
119 | 						help="client to gather information from")
120 | 	args = parser.parse_args()
121 | 
122 | 	clients = Client
123 | 	if args.client:
124 | 		clients = [Client[c] for c in args.client]
125 | 	
126 | 	jsonapi = ALJsonAPI()
127 | 	fquery = FurnitureQuery(jsonapi)
128 | 	if themename := args.name:
129 | 		themeid = fquery.get_themeid_from_name(themename, clients)
130 | 	else:
131 | 		themeid = args.id
132 | 
133 | 	print(themeid)
134 | 
135 | 	result = fquery.get_theme(themeid, clients)
136 | 	Utility.output(result)
137 | 
138 | if __name__ == "__main__":
139 | 	main()
140 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/Constants.py:
--------------------------------------------------------------------------------
  1 | from pathlib import Path
  2 | from enum import Enum
  3 | 
  4 | 
  5 | ### Constant Filepaths ###
  6 | # static files (only manual changes)
  7 | ITEMNAME_OVERRIDES_PATH = Path("data", "static", "item_name_convert.json")
  8 | SHIPID_CONVERT_OVERRIDE_PATH = Path("data", "static", "shipid_overrides.json")
  9 | 
 10 | # dynamic files (generated files)
 11 | SHIPID_CONVERT_CACHE_PATH = Path("data", "dynamic", "shipid_convert.json")
 12 | EQUIP_CONVERT_CACHE_PATH = Path("data", "dynamic", "equip_convert.json")
 13 | EQUIP_WIKIDATA_PATH = Path("data", "dynamic", "equip_wikinames.json")
 14 | SKIN_WIKIDATA_PATH = Path("data", "dynamic", "skin_wikidata.json")
 15 | AUGMENT_CONVERT_CACHE_PATH = Path("data", "dynamic", "augment_convert.json")
 16 | 
 17 | 
 18 | class Rarity(Enum):
 19 | 	"""
 20 | 	Enum class that allows conversion of rarity values between the game data and wiki.
 21 | 	"""
 22 | 	__num2member_map__: dict[int, "Rarity"] = {}
 23 | 
 24 | 	rarity: int
 25 | 	"""Rarity id used in the game."""
 26 | 	label: str
 27 | 	"""Full rarity name used on the wiki."""
 28 | 	letter: str
 29 | 	"""Single letter used on the wiki in some templates."""
 30 | 
 31 | 	NORMAL0			= (0,	"Normal",		"E")
 32 | 	NORMAL			= (1,	"Normal",		"E")
 33 | 	RARE			= (2,	"Rare",			"B")
 34 | 	ELITE			= (3,	"Elite",		"P")
 35 | 	SUPER_RARE		= (4,	"Super Rare",	"G")
 36 | 	PRIORITY		= (4,	"Priority",		"G")
 37 | 	ULTRA_RARE		= (5,	"Ultra Rare",	"R")
 38 | 	LEGENDARY		= (5,	"Legendary",	"R")
 39 | 	DECISIVE		= (5,	"Decisive",		"R")
 40 | 	VALENTINE_GIFT	= (8,	"Normal",		"E")
 41 | 	GIFT_OTHER		= (9,	"Super Rare",	"G")
 42 | 	UNKNOWN18		= (17,	"???",			"?")
 43 | 
 44 | 	def __init__(self, rarity, label, letter) -> None:
 45 | 		# add attributes to enum objects
 46 | 		self.rarity = rarity
 47 | 		self.label = label
 48 | 		self.letter = letter
 49 | 		# add enum objects to member maps
 50 | 		if rarity not in self.__num2member_map__:
 51 | 			self.__num2member_map__[rarity] = self
 52 | 
 53 | 	def __str__(self) -> str:
 54 | 		return self.label
 55 | 
 56 | 	@classmethod
 57 | 	def from_id(cls, rarity_num: int, is_research: bool = False) -> "Rarity" | None:
 58 | 		"""
 59 | 		Returns a `Rarity` member with *rarity_num* matching it's `rarity` attribute.
 60 | 		Returns `None` if no match exists.
 61 | 
 62 | 		For `rarity_num=4`, `Rarity.SUPER_RARE` will be returned over `Rarity.PRIORITY`.
 63 | 		For `rarity_num=5`, `Rarity.ULTRA_RARE` will be returned over `Rarity.LEGENDARY` and `Rarity.DECISIVE`.
 64 | 		For `rarity_num=7`, `Rarity.SUPER_RARE` will be returned, as there is only a single item (likely in error).
 65 | 
 66 | 		If *is_research* is set True, `Rarity.PRIORITY` and `Rarity.DECISIVE` will be prioritised.
 67 | 		"""
 68 | 		if is_research:
 69 | 			if rarity := {4: Rarity.PRIORITY, 5: Rarity.DECISIVE}.get(rarity_num):
 70 | 				return rarity
 71 | 		if rarity_num == 7:
 72 | 			return Rarity.SUPER_RARE
 73 | 		return cls.__num2member_map__.get(rarity_num)
 74 | 
 75 | 
 76 | # from /model/const/nation.lua#Nation2Name
 77 | class Nation(Enum):
 78 | 	"""
 79 | 	Enum class that allows conversion of nation values between the game data and wiki.
 80 | 	"""
 81 | 	id: int
 82 | 	"""Nation id used in the game."""
 83 | 	label: str
 84 | 	"""Name of the nation used on the wiki."""
 85 | 
 86 | 	UNIVERSAL			= (0,	"Universal")
 87 | 	EAGLE_UNION			= (1,	"Eagle Union")
 88 | 	ROYAL_NAVY			= (2,	"Royal Navy")
 89 | 	SAKURA_EMPIRE		= (3,	"Sakura Empire")
 90 | 	IRON_BLOOD			= (4,	"Iron Blood")
 91 | 	DRAGON_EMPERY		= (5,	"Dragon Empery")
 92 | 	SARDEGNA_EMPIRE		= (6,	"Sardegna Empire")
 93 | 	NORTHERN_PARLIAMENT	= (7,	"Northern Parliament")
 94 | 	IRIS_LIBRE			= (8,	"Iris Libre")
 95 | 	VICHYA_DOMINION		= (9,	"Vichya Dominion")
 96 | 	IRIS_ORTHODOXY		= (10,	"Iris Orthodoxy")
 97 | 	TULIPA				= (11,	"Kingdom of Tulipa")
 98 | 	TEMPESTA			= (96,	"Tempesta")
 99 | 	META				= (97,	"META")
100 | 	UNIVERSAL2			= (98,	"Universal")
101 | 	SIREN				= (99,	"Siren")
102 | 	NEPTUNIA			= (101,	"Neptunia")
103 | 	BILIBILI			= (102,	"Bilibili")
104 | 	UTAWARERUMONO		= (103,	"Utawarerumono")
105 | 	KIZUNA_AI			= (104,	"Kizuna AI")
106 | 	HOLOLIVE			= (105,	"Hololive")
107 | 	VENUS_VACATION		= (106,	"Venus Vacation")
108 | 	IDOLMASTER			= (107,	"The Idolmaster")
109 | 	SSSS				= (108,	"SSSS")
110 | 	ATELIER_RYZA		= (109,	"Atelier Ryza")
111 | 	SENRAN_KAGURA		= (110,	"Senran Kagura")
112 | 	TO_LOVE_RU			= (111,	"To LOVE-Ru")
113 | 
114 | 	def __new__(cls, nation_id, label):
115 | 		obj = object.__new__(cls)
116 | 		obj._value_ = nation_id
117 | 		obj.label = label
118 | 		return obj
119 | 	
120 | 	def __str__(self) -> str:
121 | 		return self.label
122 | 
123 | 	@property
124 | 	def id(self) -> int:
125 | 		"""Nation id used in the game."""
126 | 		return self.value
127 | 
128 | 	@classmethod
129 | 	def from_id(cls, nation_id: int) -> "Nation" | None:
130 | 		"""
131 | 		Returns a `Nation` member with *nation_id* matching it's `id` attribute.
132 | 		Returns `None` if no match exists.
133 | 		"""
134 | 		return cls._value2member_map_.get(nation_id)
135 | 
136 | 
137 | class Attribute(Enum):
138 | 	"""
139 | 	Enum class that allows conversion of ship attributes between the game data and wiki.
140 | 	"""
141 | 	pos: int
142 | 	"""The position of the attribute in the ship statistics array."""
143 | 	wiki_param_name: str
144 | 	"""The name of the parameter on wiki templates used for the attribute."""
145 | 	wiki_template_name: str
146 | 	"""The name of the template displaying the attribute icon on the wiki."""
147 | 
148 | 	DURABILITY		= (0,	"Health",		"Health")
149 | 	CANNON			= (1,	"Fire",			"Firepower")
150 | 	TORPEDO			= (2,	"Torp",			"Torpedo")
151 | 	ANTIAIRCRAFT	= (3,	"AA",			"AA")
152 | 	AIR				= (4,	"Air",			"Aviation")
153 | 	RELOAD			= (5,	"Reload",		"Reload")
154 | 	ARMOR			= (6,	"Armor_Debug",		"Armor")
155 | 	HIT				= (7,	"Acc",			"Accuracy")
156 | 	DODGE			= (8,	"Evade",		"Evasion")
157 | 	SPEED			= (9,	"Speed",		"Speed")
158 | 	LUCK			= (10,	"Luck",			"Luck")
159 | 	ANTISUB			= (11,	"ASW",			"ASW")
160 | 
161 | 	def __init__(self, pos, param_name, template_name) -> None:
162 | 		# add attributes to enum objects
163 | 		self.pos = pos
164 | 		self.wiki_param_name = param_name
165 | 		self.wiki_template_name = template_name
166 | 
167 | 	def __str__(self) -> str:
168 | 		return self.name
169 | 
170 | 
171 | # from /model/const/shiptype.lua
172 | class ShipType(Enum):
173 | 	"""
174 | 	Enum class that allows conversion of shiptype values between the game data and wiki.
175 | 	"""
176 | 	__id2member_map__: dict[int, "ShipType"] = {}
177 | 	__name2member_map__: dict[str, "ShipType"] = {}
178 | 	__fullname2member_map__: dict[str, "ShipType"] = {}
179 | 
180 | 	id: int
181 | 	"""The ID of the shiptype as used in the game."""
182 | 	typename: str
183 | 	"""The full name of the shiptype as used on the wiki."""
184 | 	categoryname: str
185 | 	"""The full name of the shiptypes category as used on the wiki"""
186 | 	templatename: str
187 | 	"""The name of the template to display the shiptype icon on the wiki."""
188 | 	typetext: str
189 | 	"""The text displaying the abbreviation of the shiptype or multiple types for shiptype bundles."""
190 | 
191 | 	DD		= (1,	"Destroyer",					"Destroyers",					"DD",	"DD")
192 | 	CL		= (2,	"Light Cruiser",				"Light cruisers",				"CL",	"CL")
193 | 	CA		= (3,	"Heavy Cruiser",				"Heavy cruisers",				"CA",	"CA")
194 | 	BC		= (4,	"Battlecruiser",				"Battlecruisers",				"BC",	"BC")
195 | 	BB		= (5,	"Battleship",					"Battleships",					"BB",	"BB")
196 | 	CVL		= (6,	"Light Aircraft Carrier",		"Light aircraft carriers",		"CVL",	"CVL")
197 | 	CV		= (7,	"Aircraft Carrier",				"Aircraft carriers",			"CV",	"CV")
198 | 	SS		= (8,	"Submarine",					"Submarines",					"SS",	"SS")
199 | 	CAV		= (9,	"Aviation Cruiser",				"Aviation cruisers",			"CAV",	"CAV")
200 | 	BBV		= (10,	"Aviation Battleship",			"Aviation battleships",  		"BBV",	"BBV")
201 | 	CT		= (11,	"Torpedo Cruiser",				"Torpedo cruisers",				"CT",	"CT")
202 | 	AR		= (12,	"Repair Ship",					"Repair ships",					"AR",	"AR")
203 | 	BM		= (13,	"Monitor",						"Monitors",						"BM",	"BM")
204 | 	SSV		= (17,	"Submarine Carrier",			"Submarine carriers",			"SSV",	"SSV")
205 | 	CB		= (18,	"Large Cruiser",				"Large cruisers",				"CB",	"CB")
206 | 	AE		= (19,	"Munition Ship",				"Munition ships",				"AE",	"AE")
207 | 	DDG_V	= (20,	"DDG",							"Guided-missile destroyers",	"DDG",	"DDG")
208 | 	DDG_M	= (21,	"DDG",							"Guided-missile destroyers",	"DDG",	"DDG")
209 | 	IX_S	= (22,	"Sailing Frigate (Submarine)",	"Sailing Frigate",				"IXs",	"IX")
210 | 	IX_V	= (23,	"Sailing Frigate (Vanguard)",	"Sailing Frigate",				"IXv",	"IX")
211 | 	IX_M	= (24,	"Sailing Frigate (Main)",		"Sailing Frigate",				"IXm",	"IX")
212 | 	ZHAN	= (-1,	"",								"",								"BC",	"BC or BB")
213 | 	HANG	= (-1,	"",								"",								"CVL",	"CV or CVL")
214 | 	QIAN	= (-1,	"",								"",								"SS",	"SS or SSV or IX")
215 | 	ZHONG	= (-1,	"",								"",								"CB",	"CB or CA")
216 | 	FANQIAN	= (-1,	"",								"",								"DD",	"DD or DDG or CL")
217 | 	QUZHU	= (-1,	"",								"",								"DD",	"DD or DDG")
218 | 	FEGNFAN	= (-1,	"",								"",								"IXs",	"IX")
219 | 
220 | 	def __init__(self, typeid, typename, catname, templatename, typetext):
221 | 		# add attributes to enum objects
222 | 		self.id = typeid
223 | 		self.typename = typename
224 | 		self.categoryname = catname
225 | 		self.templatename = templatename
226 | 		self.typetext = typetext
227 | 
228 | 		# add enum objects to member maps
229 | 		self.__name2member_map__[self.name.lower()] = self
230 | 		if typeid != -1:
231 | 			self.__id2member_map__[typeid] = self
232 | 		if typename != "":
233 | 			self.__fullname2member_map__[typename.lower()] = self
234 | 
235 | 	@classmethod
236 | 	def from_id(cls, type_id: int) -> "ShipType" | None:
237 | 		"""
238 | 		Returns a `ShipType` member with *type_id* matching it's `id` attribute.
239 | 		Returns `None` if no match exists.
240 | 		"""
241 | 		return cls.__id2member_map__.get(type_id)
242 | 
243 | 	@classmethod
244 | 	def from_type(cls, type_name: str) -> "ShipType" | None:
245 | 		"""
246 | 		Returns a `ShipType` member with *type_name* matching it's `name` attribute, ignoring capitalization.
247 | 		Returns `None` if no match exists.
248 | 		"""
249 | 		return cls.__name2member_map__.get(type_name)
250 | 
251 | 	@classmethod
252 | 	def from_name(cls, type_name: str) -> "ShipType" | None:
253 | 		"""
254 | 		Returns a `ShipType` member with *type_name* matching it's `typename` attribute.
255 | 		Returns `None` if no match exists.
256 | 		"""
257 | 		return cls.__fullname2member_map__.get(type_name)
258 | 
259 | 
260 | class Armor(Enum):
261 | 	__label2member_map__: dict[str, "Armor"] = {}
262 | 	id: int
263 | 	"""ID of the armor type as used in the game."""
264 | 	label: str
265 | 	"""Name of the armor type."""
266 | 
267 | 	LIGHT	= (1,	"Light")
268 | 	MEDIUM	= (2,	"Medium")
269 | 	HEAVY	= (3,	"Heavy")
270 | 
271 | 	def __new__(cls, armor_id, label):
272 | 		obj = object.__new__(cls)
273 | 		obj._value_ = armor_id
274 | 		return obj
275 | 
276 | 	def __init__(self, armor_id, label) -> None:
277 | 		# add attributes to enum objects
278 | 		self.label = label
279 | 		# add enum objects to member maps
280 | 		self.__label2member_map__[label] = self
281 | 
282 | 	def __str__(self) -> str:
283 | 		return self.label
284 | 
285 | 	@property
286 | 	def id(self) -> int:
287 | 		"""
288 | 		ID of the armor type as used in the game.
289 | 		"""
290 | 		return self.value
291 | 
292 | 	@classmethod
293 | 	def from_id(cls, armor_id: int) -> "Armor" | None:
294 | 		"""
295 | 		Returns an Armor member with matching *armor_id* if match exists, otherwise None.
296 | 		"""
297 | 		return cls._value2member_map_.get(armor_id)
298 | 
299 | 	@classmethod
300 | 	def from_label(cls, armor_label: str) -> "Armor" | None:
301 | 		"""
302 | 		Returns an Armor member with matching *armor_label* if match exists, otherwise None.
303 | 		"""
304 | 		return cls.__label2member_map__.get(armor_label)
305 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/Utility.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | from os import PathLike
 3 | from typing import Any, MutableSequence
 4 | from pathlib import Path
 5 | 
 6 | 
 7 | def rreplace(s: str, old: str, new: str, occurrence: int) -> str:
 8 | 	"""
 9 | 	reverse replacement for strings
10 | 	"""
11 | 	li = s.rsplit(old, occurrence)
12 | 	return new.join(li)
13 | 
14 | def mkdir(directory: Path) -> None:
15 | 	"""
16 | 	faster than simply calling os.makedirs with exists_ok=True
17 | 	if the same directory gets checked even after its creation
18 | 	"""
19 | 	if not directory.exists():
20 | 		directory.mkdir(parents=True, exist_ok=True)
21 | 
22 | def mkdirf(file: Path) -> None:
23 | 	"""
24 | 	faster than simply calling os.makedirs with exists_ok=True
25 | 	if the same directory gets checked even after its creation
26 | 	"""
27 | 	mkdir(file.parent)
28 | 
29 | def output(text: str, filepath: PathLike | None = None) -> None:
30 | 	"""
31 | 	Tries to print the output to console, if it fails write it to the specified file in the output directory.
32 | 	"""
33 | 	try:
34 | 		print(text)
35 | 	except UnicodeEncodeError:
36 | 		if filepath:
37 | 			fpath = Path(filepath)
38 | 		else:
39 | 			fpath = Path("output", Path(sys.argv[0]).stem + ".wikitext")
40 | 
41 | 		mkdirf(fpath)
42 | 		with open(fpath, 'w', encoding='utf8') as f:
43 | 			f.write(text)
44 | 		print("Failed to print to console, output has been written into output directory.")
45 | 
46 | def dict_args_query(dict_input: dict, *args) -> Any:
47 | 	"""
48 | 	Recursively searches a dict for the given list of keys.
49 | 	"""
50 | 	for arg in args:
51 | 		if isinstance(dict_input, dict):
52 | 			dict_input = dict_input.get(arg)
53 | 			if not dict_input: return
54 | 	return dict_input
55 | 
56 | def pop_zeros(items: MutableSequence) -> MutableSequence:
57 | 	while items and items[-1] == 0:
58 | 		del items[-1]
59 | 	return items
60 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/WikiConstants.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | from pathlib import Path
 3 | 
 4 | from . import Constants
 5 | 
 6 | 
 7 | # filepath for wikiclient settings
 8 | WIKICLIENT_SETTINGS_PATH = Path("data", "static", "wiki_settings.json")
 9 | 
10 | # convert item names to wiki filenames
11 | itemname_convertpath = Constants.ITEMNAME_OVERRIDES_PATH
12 | with open(itemname_convertpath, 'r') as file:
13 | 	ITEMFILENAMES = json.load(file)
14 | 
15 | #TODO: rewrite to primarily use icon name instead of item name
16 | # enables to easier derive certain icons without knowing the award type
17 | def item_filename(name: str) -> str:
18 | 	return ITEMFILENAMES.get(name)
19 | 
20 | 
21 | # replaces certain phrases in item names for wiki purposes
22 | ITEMNAME_REPLACE = {
23 | 	'Mystery': 'Random',
24 | 	'Series ': 'S',
25 | 	'General Blueprint -': 'Strengthening Unit',
26 | }
27 | 
28 | def item_name(name: str) -> str:
29 | 	for match in ITEMNAME_REPLACE:
30 | 		if match in name: name = name.replace(match, ITEMNAME_REPLACE[match])
31 | 	return name
32 | 
33 | 
34 | # return page links for certain items
35 | def item_link(name: str) -> str | None:
36 | 	if not name: return ''
37 | 	if 'Strengthening Unit' in name: return 'Research'
38 | 	if name in ['Cognitive Chips', 'Cognitive Array']: return 'Dockyard#Cognitive_Awakening'
39 | 	if name == 'Oxy-cola': return 'Living_Area#Refilling_supplies'
40 | 	if name.endswith('Cat Box'): return 'Meowfficer#Cat_Lodge'
41 | 	if name.startswith('T'):
42 | 		if name.endswith('Tech Pack'): return 'Equipment#Equipment_Boxes'
43 | 		if name.endswith('Part'): return 'Equipment#Upgrade_(Enhance)'
44 | 
45 | 
46 | # return filled templates that will display the icon of the item
47 | def item_template(name: str) -> str:
48 | 	raise NotImplementedError()
49 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/WikiHelper.py:
--------------------------------------------------------------------------------
  1 | import re, json, time
  2 | from pathlib import Path
  3 | from typing import Any, Callable
  4 | from dataclasses import dataclass, field
  5 | import mwclient
  6 | from mwclient import APIError
  7 | 
  8 | from . import ALJsonAPI, WikiConstants
  9 | from .apiclasses import Awardable, EquipStat, Item, ShipReward, Furniture
 10 | 
 11 | 
 12 | class WikiClient():
 13 | 	def __init__(self, execution_delay: float = 1.5, settings_path: Path = WikiConstants.WIKICLIENT_SETTINGS_PATH):
 14 | 		self.settings_path = settings_path
 15 | 		self.execution_delay = execution_delay
 16 | 		self.last_execute_time = 0.0
 17 | 
 18 | 		### INIT MWCLIENT ###
 19 | 		print('reading wiki settings ...')
 20 | 		if settings_path.exists():
 21 | 			settings = self.load_settings()
 22 | 			print('Loaded settings.')
 23 | 		else:
 24 | 			print(f'{settings_path} not found. Creating new file...')
 25 | 			settings = {
 26 | 				"username": "",
 27 | 				"password": "",
 28 | 				"url": input("Wiki Url: "),
 29 | 				"useragent": input("Useragent: "),
 30 | 			}
 31 | 			self.save_settings(settings)
 32 | 			print('Settings file created.')
 33 | 		self.mwclient = mwclient.Site(settings['url'], clients_useragent=settings['useragent'])
 34 | 		self.settings = settings
 35 | 		self.logged_in = False
 36 | 
 37 | 	def load_settings(self) -> dict:
 38 | 		with open(self.settings_path, 'r', encoding='utf8') as settings_file:
 39 | 			return json.load(settings_file)
 40 | 
 41 | 	def save_settings(self, settings: dict) -> None:
 42 | 		with open(self.settings_path, 'w', encoding='utf8') as settings_file:
 43 | 			json.dump(settings, settings_file)	
 44 | 
 45 | 
 46 | 	def login(self) -> "WikiClient":
 47 | 		if self.logged_in: return self
 48 | 
 49 | 		if not self.settings['username']:
 50 | 			print("You can leave the username empty, but it will prompt to input one during the next run.")
 51 | 			if username := input("Username: "):
 52 | 				self.settings['username'] = username
 53 | 				self.settings['password'] = input("Password: ")
 54 | 				self.save_settings(self.settings)
 55 | 
 56 | 		# log into wiki
 57 | 		print('Logging into mediawiki...')
 58 | 		self.mwclient.login(self.settings['username'], self.settings['password'])
 59 | 		print('Logged in.')
 60 | 		return self
 61 | 
 62 | 	def execute(self, func: Callable, *args, **kwargs):
 63 | 		delta_last_execute = time.time() - self.last_execute_time
 64 | 		if delta_last_execute < self.execution_delay:
 65 | 			time.sleep(delta_last_execute)
 66 | 
 67 | 		try:
 68 | 			result = func(*args, **kwargs)
 69 | 		except APIError as error:
 70 | 			if error.code == "ratelimited":
 71 | 				exec_delay_saved = self.execution_delay
 72 | 				self.execution_delay = (self.execution_delay+5)*2
 73 | 				result = self.execute(func, *args, **kwargs)
 74 | 				self.execution_delay = exec_delay_saved
 75 | 			else:
 76 | 				raise error
 77 | 
 78 | 		self.last_execute_time = time.time()
 79 | 		return result
 80 | 
 81 | 
 82 | def simple_template(name: str, params: list) -> str:
 83 | 	params.insert(0, name)
 84 | 	wikitext = '|'.join([(str(param) if param is not None else '') for param in params])
 85 | 	return '{{'+wikitext.rstrip('|')+'}}'
 86 | 
 87 | 
 88 | class MultilineTemplate():
 89 | 	def __init__(self, template: str):
 90 | 		with open('templates/'+template+'.json', 'r') as jfile:
 91 | 			jsontemplate = json.load(jfile)
 92 | 		self.template_name = jsontemplate["template_name"]
 93 | 		self.sections = jsontemplate['template_sections']
 94 | 		self.behavior = jsontemplate['behavior']
 95 | 		self.default_behavior = self.behavior['default']
 96 | 		self.prefer_wiki_params = jsontemplate['prefer-wiki-data']
 97 | 
 98 | 	def _param(self, key, val) -> str:
 99 | 		if val is None: val = ''
100 | 		return f' | {key} = {str(val)}'
101 | 
102 | 	def _fill_section(self, section, content, wiki_content) -> str | None:
103 | 		# add all template parameter of current section
104 | 		section_params = []
105 | 		for param in section.get('params', []):
106 | 			value = content.get(param)
107 | 			if param in self.prefer_wiki_params:
108 | 				value = wiki_content.get(param)
109 | 
110 | 			p_behavior = self.behavior.get(param, self.default_behavior)
111 | 			p_behav_type = p_behavior['type']
112 | 			if p_behav_type == 'keep':
113 | 				section_params.append(self._param(param, value))
114 | 			elif p_behav_type == 'remove_empty':
115 | 				if not (value is None or value == ''):
116 | 					section_params.append(self._param(param, value))
117 | 			elif p_behav_type == 'dependency':
118 | 				dependency_type = p_behavior['dependency']['type']
119 | 				dependend_on = p_behavior['dependency']['dependent_params']
120 | 				if sum([param in content for param in dependend_on]) == 0: continue
121 | 				if dependency_type == 'keep_empty':
122 | 					if not value is None:
123 | 						section_params.append(self._param(param, value))
124 | 				elif dependency_type == 'remove_empty':
125 | 					if not (value is None or value == ''):
126 | 						section_params.append(self._param(param, value))
127 | 				elif dependency_type == 'keep_always':
128 | 					section_params.append(self._param(param, value))
129 | 				else: raise NotImplementedError(f'Unknown dependency behavior type {dependency_type}')
130 | 			else: raise NotImplementedError(f'Unknown behavior type {p_behav_type}')
131 | 
132 | 		# recursively fill all subsections
133 | 		sub_wikitexts = []
134 | 		for subsection in section.get('sections', []):
135 | 			sub_wikitext = self._fill_section(subsection, content, wiki_content)
136 | 			if sub_wikitext:
137 | 				sub_wikitexts.append(sub_wikitext)
138 | 
139 | 		# compile section_wikitext if any parameters were added from this section
140 | 		# section_wikitext consists of the comment before params, then the block of params, each on a new line
141 | 		if section_params:
142 | 			sub_wikitexts.insert(0, '\n'.join(section_params))
143 | 		if sub_wikitexts:
144 | 			comment = section['comment']
145 | 			comment = comment and comment+'\n'
146 | 			return comment+'\n\n'.join(sub_wikitexts).rstrip('\n')
147 | 
148 | 	def fill(self, content: dict[str, Any], wiki_content: dict[str, Any] | None = None) -> str:
149 | 		filled_sections = self._fill_section(self.sections, content, wiki_content or {})
150 | 
151 | 		# add all sections with one empty line spacing between them to result wikitext
152 | 		wikitext = "{{"+self.template_name+'\n'+filled_sections+'\n}}'
153 | 		return wikitext
154 | 
155 | COMMENT_REGEX = re.compile(r'<!--(.*?)-->')
156 | COMMENT_PART = re.compile(r'(.*?)-->|<!--(.*)')
157 | def remove_comments(wikitext: str) -> str:
158 | 	a, _ = COMMENT_REGEX.subn('', wikitext)
159 | 	b, _ = COMMENT_PART.subn('', a)
160 | 	return b
161 | 
162 | PARAMS_RE = re.compile(r'\n\ *\|')
163 | def parse_multiline_template(wikitext: str, do_remove_comments: bool = True) -> dict[str, str]:
164 | 	if do_remove_comments: wikitext = remove_comments(wikitext)
165 | 	template = {}
166 | 	params = PARAMS_RE.split(wikitext[2:-2])
167 | 	for param in params:
168 | 		if '=' in param:
169 | 			key, value = param.split('=', 1)
170 | 			template[key.strip()] = value.strip()
171 | 	return template
172 | 
173 | def put_icon(filename: str, itemname: str = '', size: str = 'x22px', nolink: bool = False) -> str:
174 | 	nolinkstr = 'link=' if nolink else ''
175 | 	args = [filename, size, itemname, nolinkstr]
176 | 	args = [arg for arg in args if arg != '']
177 | 	return '[[File:'+'|'.join(args).strip('|')+']]'
178 | 
179 | parttype = {
180 | 	'General': 'Aux',
181 | 	'Torpedo': 'Torp',
182 | 	'Aircraft': 'Plane',
183 | 	'Anti-Air Gun': 'AA',
184 | 	'Main Gun': 'Gun',
185 | 	'Random Gear': 'Unknown',
186 | }
187 | RE_BLUEPRINT_TEMPLATE = re.compile(r"^(T[0-9])\s(\w+)\sRetrofit\sBlueprint")
188 | RE_PACK_TEMPLATE = re.compile(r"^(\w+)\s(T[0-9])\sTech\sPack")
189 | def item_icontemplate(name: str | None) -> str | None:
190 | 	if not name: return ''
191 | 	if m := RE_BLUEPRINT_TEMPLATE.match(name):
192 | 		return "{{Blueprint|"+ m.group(1) + "|" + m.group(2) + "}}"
193 | 
194 | 	if ' Part' in name:
195 | 		pname = name.split(' ', 1)
196 | 		ptypename = pname[1].rsplit(' ', 1)[0]
197 | 		ptype = parttype.get(ptypename)
198 | 		return f'{{{{Plate|{pname[0]}|{ptype}}}}}'
199 | 	
200 | 	if m := RE_PACK_TEMPLATE.match(name):
201 | 		return "{{Box|"+ m.group(2) + "}}"
202 | 
203 | 	iconname = {
204 | 		'Oil': 'Oil',
205 | 		'Coins': 'Coin',
206 | 		'Wisdom Cube': 'Cube',
207 | 		'Cognitive Chips': 'Module',
208 | 		'Gems': 'Gem',
209 | 	}.get(name)
210 | 	if iconname: return '{{'+iconname+'}}'
211 | 
212 | 
213 | @dataclass
214 | class WikiAwardable(Awardable):
215 | 	link: str | None = field(default=None)
216 | 	filelink: str | None = field(default=None)
217 | 	icontemplate: str | None = field(default=None)
218 | 
219 | 
220 | @dataclass
221 | class Wikifier:
222 | 	api: ALJsonAPI = field(repr=False)
223 | 
224 | 	def wikify_awardable(self, awardable: Awardable) -> WikiAwardable:
225 | 		# overrides
226 | 		if isinstance(awardable, Item):
227 | 			awardable.icon = awardable.icon.replace("Props/", "").replace("Equips/", "")
228 | 
229 | 		# default conversion
230 | 		name = WikiConstants.item_name(awardable.name)
231 | 		link = WikiConstants.item_link(name)
232 | 		filelink = WikiConstants.item_filename(name) or WikiConstants.item_filename(awardable.icon) or awardable.icon
233 | 
234 | 		# type based switches
235 | 		if isinstance(awardable, EquipStat) or (isinstance(awardable, Item) and awardable.type == 9):
236 | 			try:
237 | 				awardable_icon_int = int(awardable.icon)
238 | 				equip_convert_data = self.api.equip_converter.from_equipid(awardable_icon_int)
239 | 				if not equip_convert_data: equip_convert_data = self.api.equip_converter.from_icon(awardable_icon_int)
240 | 				if not equip_convert_data: equip_convert_data = self.api.equip_converter.from_equipid(awardable.id)
241 | 				if not equip_convert_data: equip_convert_data = self.api.equip_converter.from_equipid(int(awardable.name))
242 | 			except ValueError: pass
243 | 
244 | 			name = ''
245 | 			if equip_convert_data:
246 | 				name = equip_convert_data.wikiname
247 | 			else:
248 | 				name = awardable.name
249 | 
250 | 			link = name or ''
251 | 			name = name or awardable.name
252 | 			filelink = awardable.icon
253 | 
254 | 		elif isinstance(awardable, ShipReward):
255 | 			name = self.api.ship_converter.get_shipname(awardable.shipid.groupid)
256 | 			link = name
257 | 			filelink = name+"Icon"
258 | 
259 | 		elif isinstance(awardable, Furniture):
260 | 			filelink = "FurnIcon_"+awardable.icon
261 | 
262 | 		icontemplate = item_icontemplate(name)
263 | 		return WikiAwardable(name=name, link=link, filelink=filelink, icontemplate=icontemplate,
264 | 			rarity=awardable.rarity, icon=awardable.icon)
265 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/__init__.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | from pathlib import Path
  3 | 
  4 | from .api import Client, JsonLoader, nobbyfix_JsonLoader, AzurLaneTools_JsonLoader, Module, ApiModule, SharecfgModule
  5 | from . import settings, apimodules, sharecfgmodules, Constants
  6 | from .converter import ships, equips, augments
  7 | 
  8 | 
  9 | ### USEFUL CONSTANTS
 10 | DEFAULT_CLIENTS = [Client.EN, Client.CN, Client.JP]
 11 | NAMECODE = re.compile(r'(\{namecode:(\d+)\})')
 12 | 
 13 | jsonloaders = {
 14 | 	"nobbyfix": nobbyfix_JsonLoader,
 15 | 	"AzurLaneTools": AzurLaneTools_JsonLoader,
 16 | }
 17 | 
 18 | 
 19 | class UnknownModuleError(Exception):
 20 | 	"""
 21 | 	Exception thrown when a modules is requested but does not exist.
 22 | 	"""
 23 | 
 24 | class ALJsonAPI:
 25 | 	"""
 26 | 	General purpose class to interact with json gamedata.
 27 | 	"""
 28 | 	_apimodules: dict[str, ApiModule]
 29 | 	_sharecfgmodules: dict[str, SharecfgModule]
 30 | 	loader: JsonLoader
 31 | 	apisettings: settings.APISettings
 32 | 	ship_converter: ships.ShipIDConverter
 33 | 	equip_converter: equips.EquipConverter
 34 | 	augment_converter: augments.AugmentConverter
 35 | 
 36 | 	def __init__(self, loader: JsonLoader | None = None, source_path: Path | None = None, settings_path: Path | None = None) -> None:
 37 | 		"""
 38 | 		Initializes the JsonAPI. Uses the JsonLoader as set in the settings file at "data/settings.toml".
 39 | 		Path of the settings file can be overridden using *settings_path*.
 40 | 		For usage of a different/custom JsonLoader, *loader* can be set, which will ignore the settings file.
 41 | 		"""
 42 | 		if source_path:
 43 | 			raise DeprecationWarning("Initialisation of ALJsonAPI using 'source_path' should be removed.")
 44 | 		
 45 | 		if loader:
 46 | 			self.loader = loader
 47 | 		else:
 48 | 			if settings_path:
 49 | 				self.apisettings = settings.read_and_parse_settings(settings_path)
 50 | 			else:
 51 | 				self.apisettings = settings.read_and_parse_settings()
 52 | 			self.loader = jsonloaders[self.apisettings.jsonloader_variant](self.apisettings.json_source_path)
 53 | 
 54 | 		self._apimodules = {}
 55 | 		self._sharecfgmodules = {}
 56 | 
 57 | 	# only initialize converter when they are actually used
 58 | 	def __getattr__(self, name):
 59 | 		if name == "ship_converter":
 60 | 			self.ship_converter = ships.load_converter(Constants.SHIPID_CONVERT_CACHE_PATH)
 61 | 			return self.ship_converter
 62 | 		if name == "equip_converter":
 63 | 			self.equip_converter = equips.load_converter(Constants.EQUIP_CONVERT_CACHE_PATH)
 64 | 			return self.equip_converter
 65 | 		if name == "augment_converter":
 66 | 			self.augment_converter = augments.load_converter(Constants.AUGMENT_CONVERT_CACHE_PATH)
 67 | 			return self.augment_converter
 68 | 		raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
 69 | 
 70 | 	### Module Loader Methods
 71 | 
 72 | 	def _load_apimodule(self, name: str) -> ApiModule:
 73 | 		"""
 74 | 		Loads an instance of the ApiModule called *name* and returns it.
 75 | 
 76 | 		Raises UnknownModuleError if that module does not exist.
 77 | 		"""
 78 | 		# get the class of the apimodule with *name*
 79 | 		moduleclass = apimodules.import_module(name)
 80 | 
 81 | 		# if no class is returned, that class does not exist, so an exception will be raised
 82 | 		if not moduleclass:
 83 | 			raise UnknownModuleError(f"The ApiModule {name} does not exist.")
 84 | 
 85 | 		# if the module exists, create and instance and return it
 86 | 		module = moduleclass(_api=self)
 87 | 		return module
 88 | 
 89 | 	def _load_sharecfgmodule(self, name: str) -> SharecfgModule:
 90 | 		"""
 91 | 		Loads an instance of the SharecfgModule called *name* and returns it.
 92 | 
 93 | 		If no client has json files under that name, an instance will still be returned
 94 | 		and all data requests to that module will just return None.
 95 | 		"""
 96 | 		# get the class of the apimodule with *name*
 97 | 		moduleclass = sharecfgmodules.import_module(name)
 98 | 
 99 | 		# if that module does not exists, the generic module class will be used
100 | 		if not moduleclass:
101 | 			moduleclass = SharecfgModule
102 | 		
103 | 		# create the instance and return it
104 | 		module = moduleclass(name=name, _loader=self.loader)
105 | 		return module
106 | 
107 | 	def _get_module(self, name: str, is_api: bool = False) -> SharecfgModule | ApiModule:
108 | 		"""
109 | 		Returns an instance of either a SharecfgModule or ApiModule called *name*.
110 | 		If *is_api* is set to true, an ApiModule will be returned, if False a SharecfgModule.
111 | 
112 | 		If the requested ApiModule does not exists, an UnknownModuleError will be raised.
113 | 
114 | 		For SharecfgModules, if no client has json files under that name, an instance will still be returned
115 | 		and all data requests to that module will just return None.
116 | 		"""
117 | 		# determine which instance cache to use depending on *is_api*
118 | 		used_cache = self._apimodules if is_api else self._sharecfgmodules
119 | 		
120 | 		# if there is an instance already in the cache, return it
121 | 		if name in used_cache:
122 | 			return used_cache[name]
123 | 
124 | 		# determine which loader function to use depending on *is_api* and try to load it
125 | 		module = self._load_apimodule(name) if is_api else self._load_sharecfgmodule(name)
126 | 
127 | 		# put the module instance into the cache and return it
128 | 		used_cache[name] = module
129 | 		return module
130 | 
131 | 	def get_apimodule(self, name: str) -> ApiModule:
132 | 		return self._get_module(name, True)
133 | 
134 | 	def get_sharecfgmodule(self, name: str) -> SharecfgModule:
135 | 		return self._get_module(name)
136 | 	
137 | 	def get_module(self, name: str) -> Module:
138 | 		return self.get_sharecfgmodule(name) or self.get_apimodule(name)
139 | 
140 | 	### Additional Api Methods
141 | 
142 | 	def replace_namecode(self, inputstring: str, client: Client) -> str:
143 | 		"""
144 | 		Replaces namecode references in a string with their respective codes for *client*.
145 | 		"""
146 | 		name_code = self.get_sharecfgmodule('name_code')
147 | 		results = NAMECODE.findall(inputstring)
148 | 		for namecode_string, namecode_num in results:
149 | 			# get the replacement string 'code' for the found namecode number for *client*
150 | 			code = name_code.load_client(namecode_num, client)
151 | 			# replace the namecode placeholder in the inputstring with the 'code'
152 | 			inputstring = inputstring.replace(namecode_string, code.name)
153 | 		return inputstring
154 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/apiclasses.py:
--------------------------------------------------------------------------------
  1 | from dataclasses import dataclass
  2 | from abc import ABCMeta, abstractmethod
  3 | from collections.abc import Iterable
  4 | from typing import Any
  5 | 
  6 | from .api import ApiModule, Client, APIdataclass, ApiData, SharecfgData, MergedSharecfgData, Module, SharecfgModule
  7 | from .Constants import Armor, Nation, Rarity, Attribute, ShipType
  8 | 
  9 | 
 10 | ### GENERAL DATA CLASSES ###
 11 | @dataclass
 12 | class DataRef(metaclass=ABCMeta):
 13 | 	"""
 14 | 	Abstract class for module apidata references.
 15 | 	"""
 16 | 	id: int
 17 | 	module: str
 18 | 
 19 | 	@abstractmethod
 20 | 	def _get_module(self, api: "ALJsonAPI") -> Module:
 21 | 		"""
 22 | 		Loads the Module referenced.
 23 | 		"""
 24 | 
 25 | 	def load(self, api: "ALJsonAPI", client: Client) -> ApiData | None:
 26 | 		"""
 27 | 		Loads the ApiData referenced from the module for *client*.
 28 | 		"""
 29 | 		module = self._get_module(api)
 30 | 		return module.load_client(self.id, client)
 31 | 
 32 | 	def load_first(self, api: "ALJsonAPI", clients: Iterable[Client]) -> ApiData | None:
 33 | 		"""
 34 | 		Loads the first ApiData referenced from the module for *clients*.
 35 | 		"""
 36 | 		module = self._get_module(api)
 37 | 		return module.load_first(self.id, clients)
 38 | 
 39 | @dataclass
 40 | class ApiDataRef(DataRef):
 41 | 	"""
 42 | 	A reference to ApiData of *module* with dataid *id*.
 43 | 	"""
 44 | 	def _get_module(self, api: "ALJsonAPI") -> ApiModule:
 45 | 		return api.get_apimodule(self.module)
 46 | 
 47 | @dataclass
 48 | class SharecfgDataRef(DataRef):
 49 | 	"""
 50 | 	A reference to SharecfgData of *module* with dataid *id*.
 51 | 	"""
 52 | 	def _get_module(self, api: "ALJsonAPI") -> SharecfgModule:
 53 | 		return api.get_sharecfgmodule(self.module)
 54 | 
 55 | 
 56 | @dataclass
 57 | class Awardable:
 58 | 	"""
 59 | 	Basic class to be implemented for ApiData that can be awarded.
 60 | 	"""
 61 | 	name: str
 62 | 	rarity: Rarity
 63 | 	icon: str
 64 | 
 65 | @dataclass
 66 | class AwardDisplay:
 67 | 	"""
 68 | 	Data class for award references.
 69 | 	Allows resolving that reference to the associated module using the award type.
 70 | 	"""
 71 | 	type: int
 72 | 	refid: int
 73 | 
 74 | 	"""
 75 | 	unimplemented:
 76 | 	10		DROP_TYPE_OPERATION
 77 | 	13		DROP_TYPE_WORLD_COLLECTION
 78 | 	19		DROP_TYPE_LOVE_LETTER
 79 | 	22		DROP_TYPE_META_PT
 80 | 	1000	DROP_TYPE_USE_ACTIVITY_DROP
 81 | 	1001	DROP_TYPE_RYZA_DROP
 82 | 	1002	DROP_TYPE_WORKBENCH_DROP
 83 | 	1003	DROP_TYPE_FEAST_DROP
 84 | 	"""
 85 | 	# see "const.lua" for all drop types and "model/vo/drop.lua" for which the data source is
 86 | 	def resolve(self) -> DataRef:
 87 | 		if self.type == 1: return ApiDataRef(id=self.refid, module="player_resource_reward")
 88 | 		if self.type in [2,8]: return ApiDataRef(id=self.refid, module="all_item_data_statistics")
 89 | 		if self.type == 3: return SharecfgDataRef(id=self.refid, module="equip_data_statistics")
 90 | 		if self.type == 4: return ApiDataRef(id=self.refid, module="ship_reward")
 91 | 		if self.type == 5: return ApiDataRef(id=self.refid, module="furniture")
 92 | 		if self.type == 6: return SharecfgDataRef(id=self.refid, module="strategy_data_template")
 93 | 		if self.type in [7,23]: return SharecfgDataRef(id=self.refid, module="ship_skin_template")
 94 | 		if self.type == 9: return SharecfgDataRef(id=self.refid, module="equip_skin_template")
 95 | 		if self.type == 12: return SharecfgDataRef(id=self.refid, module="world_item_data_template")
 96 | 		if self.type == 14: return SharecfgDataRef(id=self.refid, module="item_data_frame")
 97 | 		if self.type == 15: return SharecfgDataRef(id=self.refid, module="item_data_chat")
 98 | 		if self.type == 17: return SharecfgDataRef(id=self.refid, module="emoji_template")
 99 | 		if self.type == 21: return SharecfgDataRef(id=self.refid, module="spweapon_data_statistics")
100 | 		if self.type == 24: return SharecfgDataRef(id=self.refid, module="benefit_buff_template")
101 | 		if self.type == 25: return SharecfgDataRef(id=self.refid, module="commander_data_template")
102 | 		if self.type == 100: return SharecfgDataRef(id=self.refid, module="drop_data_restore")
103 | 		raise NotImplementedError(f"Cannot resolve award of type {self.type}: Unknown or unimplemented type.")
104 | 
105 | 	def load(self, api: "ALJsonAPI", client: Client) -> Awardable:
106 | 		dataref = self.resolve()
107 | 		awardable = dataref.load(api, client)
108 | 		return awardable
109 | 	
110 | 	def load_first(self, api: "ALJsonAPI", client: Iterable[Client]) -> Awardable:
111 | 		dataref = self.resolve()
112 | 		awardable = dataref.load_first(api, client)
113 | 		return awardable
114 | 
115 | @dataclass
116 | class AwardDisplayLabeled(AwardDisplay):
117 | 	label: str
118 | 
119 | @dataclass
120 | class Award(AwardDisplay):
121 | 	"""
122 | 	An AwardDisplay that also specifies that amount of the items awarded.
123 | 	"""
124 | 	amount: int
125 | 
126 | 
127 | ### GENERAL CLASSES ###
128 | class ShipID:
129 | 	"""
130 | 	Helper class that automatically converts shipids into the the three useful formats.
131 | 	"""
132 | 	fullid: int | None
133 | 	groupid: int
134 | 	singleid: int | None
135 | 
136 | 	def __init__(self, groupid: int = 0, fullid: int = 0):
137 | 		if groupid and fullid:
138 | 			self.fullid = fullid
139 | 			self.groupid = groupid
140 | 			self.singleid = fullid%10
141 | 		elif fullid:
142 | 			self.fullid = fullid
143 | 			self.groupid = fullid//10
144 | 			self.singleid = fullid%10
145 | 		elif groupid:
146 | 			self.fullid = None
147 | 			self.groupid = groupid
148 | 			self.singleid = None
149 | 		else:
150 | 			raise ValueError("ShipID needs either groupid or fullid to be set.")
151 | 
152 | 	def __str__(self):
153 | 		maxid = self.fullid if self.fullid else self.groupid
154 | 		diffgroupid = self.groupid if self.fullid and self.fullid//10 != self.groupid else None
155 | 		return self.__class__.__name__ + f"({maxid}{f', {diffgroupid}' if diffgroupid else ''})"
156 | 
157 | class CachedAPILoader():
158 | 	_cache: dict
159 | 	_api: "ALJsonAPI"
160 | 
161 | 	def __init__(self, api: "ALJsonAPI") -> None:
162 | 		self._cache = {}
163 | 		self._api = api
164 | 		self._generate_cache()
165 | 
166 | 	def _regenerate_cache(self) -> None:
167 | 		self._cache.clear()
168 | 		self._generate_cache()
169 | 
170 | 	@abstractmethod
171 | 	def _generate_cache(self) -> None: pass
172 | 
173 | 	def get(self, key) -> Any:
174 | 		return self._cache.get(key)
175 | 
176 | ### SHARECFG DATA CLASSES ###
177 | @APIdataclass
178 | class Milestone(SharecfgData):
179 | 	point: ApiDataRef
180 | 	rewards: list[Award]
181 | 
182 | @APIdataclass
183 | class ShopItem(SharecfgData, Award): pass
184 | 
185 | @APIdataclass
186 | class Chapter(SharecfgData):
187 | 	type: int
188 | 	previous_chapter: list[SharecfgDataRef]
189 | 	mob_list: list[SharecfgDataRef]
190 | 	mob_spawn_pattern: list[int]
191 | 	elite_list: list[SharecfgDataRef]
192 | 	elite_spawn_pattern: list[int]
193 | 	siren_list: list[SharecfgDataRef]
194 | 	siren_spawn_pattern: list[int]
195 | 	boss: SharecfgDataRef | None
196 | 	fleet_limitation: list[list[list[ShipType | int]]]
197 | 	awards: list[AwardDisplay]
198 | 
199 | @APIdataclass
200 | class EquipStat(SharecfgData, Awardable):
201 | 	nation: Nation
202 | 
203 | @APIdataclass
204 | class EquipStatUpgrade(SharecfgData):
205 | 	base: SharecfgDataRef
206 | 
207 | @APIdataclass
208 | class Expedition(SharecfgData):
209 | 	icons: list[str]
210 | 	award_display: list[AwardDisplay]
211 | 
212 | @APIdataclass
213 | class FurnitureData(SharecfgData, Awardable):
214 | 	theme: SharecfgDataRef | None
215 | 
216 | @APIdataclass
217 | class Item(SharecfgData, Awardable): pass
218 | 
219 | @APIdataclass
220 | class Code(SharecfgData): pass
221 | 
222 | @APIdataclass
223 | class Resource(SharecfgData):
224 | 	name: str
225 | 	item: ApiDataRef | None
226 | 
227 | @APIdataclass
228 | class ShipStat(SharecfgData):
229 | 	shipid: ShipID
230 | 	name: str
231 | 	rarity: Rarity
232 | 	nation: Nation
233 | 	type: ShipType
234 | 	armor: Armor
235 | 	attributes: dict[Attribute, int]
236 | 	attributes_growth: dict[Attribute, int]
237 | 	skin: SharecfgDataRef
238 | 
239 | @APIdataclass
240 | class ShipSkin(SharecfgData):
241 | 	shipid: ShipID
242 | 	background: int | None
243 | 	background_special: int | None
244 | 
245 | @APIdataclass
246 | class Task(SharecfgData):
247 | 	awards: list[Award]
248 | 	target_id: int | list[int] | list[tuple[int, int]]
249 | 
250 | @APIdataclass
251 | class Metatask(SharecfgData): pass
252 | 
253 | @dataclass
254 | class MetataskRef(SharecfgDataRef):
255 | 	repeat_limit: int
256 | 	xp_gain: int
257 | 
258 | @APIdataclass
259 | class MetashipSkill(SharecfgData):
260 | 	skill: SharecfgDataRef
261 | 	item_consume: list[Award]
262 | 	tasks: list[MetataskRef]
263 | 
264 | @APIdataclass
265 | class BackyardTheme(SharecfgData):
266 | 	name: str
267 | 	icon: str
268 | 	desc: str
269 | 	furniture: list[ApiDataRef]
270 | 
271 | @APIdataclass
272 | class LoginRewards(SharecfgData):
273 | 	front_drops: list[Award]
274 | 
275 | ### APIMODULE DATA CLASSES ###
276 | @dataclass
277 | class ShipReward(Awardable):
278 | 	shipid: ShipID
279 | 
280 | @APIdataclass
281 | class Furniture(MergedSharecfgData, Awardable):
282 | 	theme: SharecfgDataRef | None
283 | 
284 | @APIdataclass
285 | class ExtendedEquipStat(MergedSharecfgData): pass


--------------------------------------------------------------------------------
/PythonScripts/lib/apimodules.py:
--------------------------------------------------------------------------------
  1 | import itertools
  2 | from dataclasses import dataclass
  3 | from collections.abc import Iterable
  4 | 
  5 | from . import Client, ApiModule
  6 | from .apiclasses import Item, ShipReward, Furniture, ExtendedEquipStat, EquipStatUpgrade
  7 | 
  8 | 
  9 | @dataclass
 10 | class PlayerResourceReward(ApiModule):
 11 | 	def _load_client(self, dataid: str, client: Client) -> Item | None:
 12 | 		player_resource = self._getmodule("player_resource")
 13 | 		resource = player_resource._load_client(dataid, client)
 14 | 		if resource:
 15 | 			item = resource.item.load(self._api, client)
 16 | 			return item
 17 | 
 18 | 	def all_client_ids(self, client: Client) -> Iterable[int]:
 19 | 		player_resource = self._getmodule("player_resource")
 20 | 		client_ids = [resource.id for resource in player_resource.all_client(client) if resource.item]
 21 | 		return client_ids
 22 | 
 23 | @dataclass
 24 | class ShipRewardModule(ApiModule):
 25 | 	def _load_client(self, dataid: str, client: Client) -> ShipReward | None:
 26 | 		ship_data_statistics = self._getmodule("ship_data_statistics")
 27 | 		shipstat = ship_data_statistics._load_client(dataid, client)
 28 | 		if shipstat:
 29 | 			shipskin = shipstat.skin.load(self._api, client)
 30 | 			shipreward = ShipReward(
 31 | 				name=shipstat.name,
 32 | 				rarity=shipstat.rarity,
 33 | 				icon=shipskin.painting,
 34 | 				shipid=shipstat.shipid
 35 | 			)
 36 | 			return shipreward
 37 | 
 38 | 	def all_client_ids(self, client: Client) -> Iterable[int]:
 39 | 		ship_data_statistics = self._getmodule("ship_data_statistics")
 40 | 		client_ids = [sid for sid in ship_data_statistics.all_client_ids(client) if int(sid)%10 == 1]
 41 | 		return client_ids
 42 | 
 43 | @dataclass
 44 | class FurnitureModule(ApiModule):
 45 | 	def _load_client(self, dataid: str, client: Client) -> Furniture | None:
 46 | 		furniture_data_template = self._getmodule("furniture_data_template")
 47 | 		furniture_shop_template = self._getmodule("furniture_shop_template")
 48 | 
 49 | 		furniture_data = furniture_data_template.load_client(dataid, client)
 50 | 		furniture_shop = furniture_shop_template.load_client(dataid, client)
 51 | 		if furniture_data is not None and furniture_shop is not None:
 52 | 			return Furniture(furniture_data, furniture_shop)
 53 | 		elif furniture_data is not None:
 54 | 			return furniture_data
 55 | 		elif furniture_shop is not None:
 56 | 			return furniture_shop
 57 | 
 58 | 	def all_client_ids(self, client: Client) -> Iterable[int]:
 59 | 		furniture_data_template = self._getmodule("furniture_data_template")
 60 | 		return furniture_data_template.all_client_ids(client)
 61 | 
 62 | @dataclass
 63 | class ExtendedEquipDataStatistics(ApiModule):
 64 | 	def _load_client(self, dataid: str, client: Client) -> ExtendedEquipStat | None:
 65 | 		equip_data_statistics = self._getmodule("equip_data_statistics")
 66 | 
 67 | 		def_data = equip_data_statistics.load_client(dataid, client)
 68 | 		if def_data is not None:
 69 | 			if isinstance(def_data, EquipStatUpgrade):
 70 | 				base_data = def_data.base.load(self._api, client)
 71 | 				return ExtendedEquipStat(def_data, base_data)
 72 | 			else:
 73 | 				return ExtendedEquipStat(def_data)
 74 | 
 75 | 	def all_client_ids(self, client: Client) -> Iterable[int]:
 76 | 		equip_data_statistics = self._getmodule("equip_data_statistics")
 77 | 		return equip_data_statistics.all_client_ids(client)
 78 | 
 79 | @dataclass
 80 | class AllItemDataStatistics(ApiModule):
 81 | 	def _load_client(self, dataid: str, client: Client) -> Item | None:
 82 | 		item_data_statistics = self._getmodule("item_data_statistics")
 83 | 		item_virtual_data_statistics = self._getmodule("item_virtual_data_statistics")
 84 | 
 85 | 		item_data = item_data_statistics.load_client(dataid, client)
 86 | 		item_virtual_data = item_virtual_data_statistics.load_client(dataid, client)
 87 | 		if item_data:
 88 | 			return item_data
 89 | 		else:
 90 | 			return item_virtual_data
 91 | 
 92 | 	def all_client_ids(self, client: Client) -> Iterable[int]:
 93 | 		item_data_statistics = self._getmodule("item_data_statistics")
 94 | 		item_virtual_data_statistics = self._getmodule("item_virtual_data_statistics")
 95 | 		return itertools.chain(item_data_statistics.all_client_ids(client), item_virtual_data_statistics.all_client_ids(client))
 96 | 
 97 | 
 98 | __all__ = {
 99 | 	"player_resource_reward": PlayerResourceReward,
100 | 	"ship_reward": ShipRewardModule,
101 | 	"furniture": FurnitureModule,
102 | 	"extended_equip_data_statistics": ExtendedEquipDataStatistics,
103 | 	"all_item_data_statistics": AllItemDataStatistics,
104 | }
105 | 
106 | def import_module(modulename: str) -> ApiModule:
107 | 	return __all__.get(modulename)
108 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nobbyfix/AzurLaneTools/498d20c350c9e7aa0280aafcba1947f8dc770489/PythonScripts/lib/converter/__init__.py


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/augments.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | from os import PathLike
 3 | from dataclasses import dataclass
 4 | 
 5 | 
 6 | @dataclass
 7 | class AugmentConvertResult:
 8 | 	id: int
 9 | 	icon: str
10 | 	shipid: int
11 | 	wikiname: str
12 | 
13 | @dataclass
14 | class AugmentConverter:
15 | 	id_to_data: dict[int, AugmentConvertResult]
16 | 	icon_to_data: dict[str, AugmentConvertResult]
17 | 	shipid_to_data: dict[int, AugmentConvertResult]
18 | 	wikiname_to_data: dict[str, AugmentConvertResult]
19 | 
20 | 	def from_augmentid(self, augmentid: int) -> AugmentConvertResult | None:
21 | 		return self.id_to_data.get(augmentid)
22 | 
23 | 	def from_icon(self, icon: str) -> AugmentConvertResult | None:
24 | 		return self.icon_to_data.get(icon)
25 | 
26 | 	def from_shipid(self, shipid: int) -> AugmentConvertResult | None:
27 | 		return self.shipid_to_data.get(shipid)
28 | 
29 | 	def from_wikiname(self, wikiname: str) -> AugmentConvertResult | None:
30 | 		return self.wikiname_to_data.get(wikiname)
31 | 
32 | 	def convert(self, key: int | str) -> AugmentConvertResult | None:
33 | 		"""Returns either an AugmentConvertResult from the key.
34 | 		from_augmentid, from_shipid or from_wikiname should be prefered.
35 | 
36 | 		:param key: an augmentid, shipid or wikiname"""
37 | 		return self.from_augmentid(key) or self.from_icon(key) or self.from_shipid(key) or self.from_wikiname(key)
38 | 
39 | 
40 | def load_converter(filepath: PathLike) -> AugmentConverter:
41 | 	"""Returns the converter using the cached converter data.
42 | 
43 | 	:param filepath: path to the converter data cache file"""
44 | 	with open(filepath, 'r', encoding="utf8") as file:
45 | 		augment_data = json.load(file)
46 | 
47 | 	id_to_data = {int(augid): AugmentConvertResult(*data.values()) for augid, data in augment_data['gameid'].items()}
48 | 	icon_to_data = {icon: AugmentConvertResult(*data.values()) for icon, data in augment_data['icon'].items()}
49 | 	shipid_to_data = {int(shipid): AugmentConvertResult(*data.values()) for shipid, data in augment_data['shipid'].items()}
50 | 	wikiname_to_data = {wikiname: AugmentConvertResult(*data.values()) for wikiname, data in augment_data['wikiname'].items()}
51 | 	return AugmentConverter(id_to_data, icon_to_data, shipid_to_data, wikiname_to_data)
52 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/augments_updater.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | from os import PathLike
 3 | 
 4 | from .. import ALJsonAPI, Client
 5 | 
 6 | 
 7 | def update_converter(convert_fp: PathLike, api: ALJsonAPI):
 8 | 	"""Updates the cached version of the converter data."""
 9 | 	augment_data_statistics = api.get_sharecfgmodule("spweapon_data_statistics")
10 | 
11 | 	# retrieve converter data
12 | 	conversions = {'icon': dict(), 'gameid': dict(), 'shipid': dict(), 'wikiname': dict()}
13 | 
14 | 	def idfilter(dataid: int) -> bool:
15 | 		if type(dataid) == str:
16 | 			if not dataid.isdigit(): return True
17 | 			else: dataid = int(dataid)
18 | 		if dataid%20 != 0: return True
19 | 	for augmentstat in augment_data_statistics.load_all(Client, idfilter):
20 | 		gameid = int(augmentstat.id)
21 | 		wikiname = augmentstat.name
22 | 		icon = 'Augment_'+str(augmentstat.icon)
23 | 		shipid = augmentstat.unique or 0
24 | 
25 | 		# add data onto conversions dict
26 | 		json_res_data = { "gameid": gameid, "icon": icon, "shipid": shipid, "wikiname": wikiname }
27 | 		for k1, k2 in (("icon", icon), ("gameid", str(gameid)), ("shipid", str(shipid)), ("wikiname", wikiname)):
28 | 			if k2:
29 | 				conversions[k1][k2] = json_res_data
30 | 
31 | 	# save data to file
32 | 	with open(convert_fp, 'w', encoding = "utf8") as f:
33 | 		json.dump(conversions, f, ensure_ascii=False)
34 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/equips.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | from os import PathLike
 3 | from dataclasses import dataclass
 4 | 
 5 | 
 6 | @dataclass
 7 | class EquipConvertResult:
 8 | 	id: int
 9 | 	icon: int
10 | 	gamename: str
11 | 	wikiname: str
12 | 
13 | @dataclass
14 | class EquipConverter:
15 | 	id_to_data: dict[int, EquipConvertResult]
16 | 	icon_to_data: dict[int, EquipConvertResult]
17 | 	gamename_to_data: dict[str, EquipConvertResult]
18 | 	wikiname_to_data: dict[str, EquipConvertResult]
19 | 
20 | 	def from_equipid(self, equipid: int) -> EquipConvertResult | None:
21 | 		return self.id_to_data.get(equipid)
22 | 
23 | 	def from_icon(self, icon: int) -> EquipConvertResult | None:
24 | 		return self.icon_to_data.get(icon)
25 | 
26 | 	def from_gamename(self, gamename: str) -> EquipConvertResult | None:
27 | 		return self.gamename_to_data.get(gamename)
28 | 
29 | 	def from_wikiname(self, wikiname: str) -> EquipConvertResult | None:
30 | 		return self.wikiname_to_data.get(wikiname)
31 | 
32 | 	def convert(self, key: int | str) -> EquipConvertResult | None:
33 | 		"""Returns either an EquipConvertResult from the key.
34 | 		from_equipid, from_gamename or from_wikiname should be prefered.
35 | 
36 | 		:param key: an equipid, gamename or wikiname"""
37 | 		return self.from_equipid(key) or self.from_icon(key) or self.from_gamename(key) or self.from_wikiname(key)
38 | 
39 | 
40 | def load_converter(filepath: PathLike) -> EquipConverter:
41 | 	"""Returns the converter using the cached converter data.
42 | 
43 | 	:param filepath: path to the converter data cache file"""
44 | 	with open(filepath, 'r', encoding="utf8") as file:
45 | 		equip_data = json.load(file)
46 | 
47 | 	id_to_data = {int(eqid): EquipConvertResult(*data.values()) for eqid, data in equip_data['gameid'].items()}
48 | 	icon_to_data = {int(icon): EquipConvertResult(*data.values()) for icon, data in equip_data['icon'].items()}
49 | 	gamename_to_data = {gamename: EquipConvertResult(*data.values()) for gamename, data in equip_data['gamename'].items()}
50 | 	wikiname_to_data = {wikiname: EquipConvertResult(*data.values()) for wikiname, data in equip_data['wikiname'].items()}
51 | 	return EquipConverter(id_to_data, icon_to_data, gamename_to_data, wikiname_to_data)
52 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/equips_updater.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import html
 3 | from os import PathLike
 4 | 
 5 | from .. import ALJsonAPI, Client
 6 | from ..apiclasses import EquipStat
 7 | 
 8 | 
 9 | def load_wikinames(filepath: PathLike) -> dict[int, str]:
10 | 	with open(filepath, 'r') as file:
11 | 		wikidata = json.load(file)
12 | 
13 | 	conversions = {}
14 | 	for entry in wikidata:
15 | 		data = entry['title']
16 | 		baseid = int(data['BaseID'].strip(".png"))
17 | 		if baseid in conversions: continue
18 | 		name = html.unescape(data['Name'])
19 | 		conversions[baseid] = name
20 | 	return conversions
21 | 
22 | 
23 | def update_converter(convert_fp: PathLike, wiki_namecache_fp: PathLike, api: ALJsonAPI):
24 | 	"""Updates the cached version of the converter data."""
25 | 	equip_data_statistics = api.get_sharecfgmodule("equip_data_statistics")
26 | 
27 | 	# retrieve converter data
28 | 	overrides = load_wikinames(wiki_namecache_fp)
29 | 	conversions = {'icon': dict(), 'gameid': dict(), 'gamename': dict(), 'wikiname': dict()}
30 | 
31 | 	for equipstat in equip_data_statistics.load_all(Client):
32 | 		if not isinstance(equipstat, EquipStat): continue
33 | 		gameid = equipstat.id
34 | 		gamename = equipstat.name
35 | 		icon = int(equipstat.icon)
36 | 		wikiname = overrides.get(gameid) or ''
37 | 
38 | 		json_res_data = { "gameid": gameid, "icon": icon, "gamename": gamename, "wikiname": wikiname }
39 | 		for k1, k2 in (("icon", str(icon)), ("gameid", str(gameid)), ("gamename", gamename), ("wikiname", wikiname)):
40 | 			if k2:
41 | 				conversions[k1][k2] = json_res_data
42 | 
43 | 	# save data to file
44 | 	with open(convert_fp, 'w', encoding="utf8") as f:
45 | 		json.dump(conversions, f, ensure_ascii=False)
46 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/ships.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | from os import PathLike
 3 | from dataclasses import dataclass
 4 | 
 5 | 
 6 | @dataclass
 7 | class ShipIDConverter:
 8 | 	ship_to_id: dict[str, int]
 9 | 	id_to_ship: dict[int, str]
10 | 
11 | 	def get_groupid(self, shipname: str) -> int | None:
12 | 		return self.ship_to_id.get(shipname)
13 | 
14 | 	def get_shipname(self, groupid: int) -> str | None:
15 | 		return self.id_to_ship.get(groupid)
16 | 
17 | 	def convert(self, key: int | str) -> int | str | None:
18 | 		"""Returns either a groupid or shipname depending on the key.
19 | 		get_groupid and get_shipname should be prefered.
20 | 
21 | 		:param key: a groupid or shipname"""
22 | 		groupid = self.get_groupid(key)
23 | 		shipname = self.get_shipname(key)
24 | 		return groupid or shipname
25 | 
26 | def load_converter(filepath: PathLike) -> ShipIDConverter:
27 | 	"""Returns the converter using the cached converter data.
28 | 
29 | 	:param filepath: path to the converter data cache file"""
30 | 	with open(filepath, 'r') as file:
31 | 		ship_data = json.load(file)
32 | 	groupid_convert = {int(groupid): name for groupid, name in ship_data['groupid'].items()}
33 | 	return ShipIDConverter(ship_data['ship'], groupid_convert)
34 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/ships_updater.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | from os import PathLike
 3 | 
 4 | from .. import ALJsonAPI, Client
 5 | 
 6 | 
 7 | def load_overrides(filepath: PathLike) -> dict[int, str]:
 8 | 	"""Loads all all shipname overrides from the given file.
 9 | 
10 | 	:param filepath: path to the overrides file"""
11 | 	with open(filepath, 'r', encoding='utf8') as file:
12 | 		json_data = json.load(file)
13 | 	return {int(groupid): name for groupid, name in json_data.items()}
14 | 
15 | 
16 | def update_converter(convert_fp: PathLike, override_fp: PathLike, api: ALJsonAPI):
17 | 	"""Updates the cached version of the converter data."""
18 | 	ship_data_statistics = api.get_sharecfgmodule("ship_data_statistics")
19 | 
20 | 	# retrieve converter data
21 | 	overrides = load_overrides(override_fp)
22 | 	conversions = {'ship': dict(), 'groupid': dict()}
23 | 
24 | 	def idfilter(dataid: int | str) -> bool:
25 | 		try:
26 | 			dataid = int(dataid)
27 | 		except: return True
28 | 		if dataid%10 != 1: return True
29 | 		if dataid//1000 == 900: return True
30 | 		if dataid == 901001: return True
31 | 		return False
32 | 
33 | 	for shipstat in ship_data_statistics.load_all(Client, idfilter):
34 | 		groupid = shipstat.shipid.groupid
35 | 
36 | 		# if groupid is overridden, just add the ship names from there
37 | 		if groupid in overrides:
38 | 			shipname = overrides[groupid]
39 | 		else:
40 | 			shipname = shipstat.name
41 | 
42 | 		# add data onto conversions dict
43 | 		conversions['ship'][shipname] = groupid
44 | 		conversions['groupid'][groupid] = shipname
45 | 
46 | 	# save data to file
47 | 	with open(convert_fp, 'w') as f:
48 | 		json.dump(conversions, f)
49 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/skins.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | from dataclasses import dataclass
 3 | from os import PathLike
 4 | 
 5 | 
 6 | @dataclass
 7 | class SkinConvertResult:
 8 | 	id: int
 9 | 	shipname: str
10 | 	category: str
11 | 	painting: str
12 | 	prefab: str
13 | 
14 | @dataclass
15 | class SkinsConverter:
16 | 	painting_to_data: dict[str, SkinConvertResult]
17 | 
18 | 	def from_painting(self, paintingname: str) -> SkinConvertResult | None:
19 | 		return self.painting_to_data.get(paintingname)
20 | 
21 | 	def convert(self, key: int | str) -> SkinConvertResult | None:
22 | 		"""Returns either an SkinConvertResult from the key.
23 | 		from_painting should be prefered.
24 | 
25 | 		:param key: an paintingname"""
26 | 		return self.from_painting(key)
27 | 
28 | def load_converter(filepath: PathLike) -> SkinsConverter:
29 | 	"""Returns the converter using the cached converter data.
30 | 
31 | 	:param filepath: path to the converter data cache file"""
32 | 	with open(filepath, 'r', encoding="utf8") as file:
33 | 		skin_data = json.load(file)
34 | 
35 | 	painting_to_data = {p: SkinConvertResult(data['gameid'], data['shipname'], data['category'], p, data['prefab']) for p, data in skin_data['painting'].items()}
36 | 	return SkinsConverter(painting_to_data)
37 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/converter/skins_updater.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import html
 3 | from os import PathLike
 4 | 
 5 | from .. import ALJsonAPI, Client
 6 | from ..apiclasses import EquipStat
 7 | 
 8 | 
 9 | def load_wikinames(filepath: PathLike) -> dict[int, str]:
10 | 	with open(filepath, 'r') as file:
11 | 		wikidata = json.load(file)
12 | 
13 | 	conversions = {}
14 | 	for entry in wikidata:
15 | 		data = entry['title']
16 | 		image = int(data['Image'].strip(".png"))
17 | 		if image in conversions: continue
18 | 		name = html.unescape(data['Name'])
19 | 		conversions[image] = name
20 | 	return conversions
21 | 
22 | 
23 | def update_converter(convert_fp: PathLike, wiki_namecache_fp: PathLike, api: ALJsonAPI):
24 | 	"""Updates the cached version of the converter data."""
25 | 	equip_data_statistics = api.get_module("equip_data_statistics")
26 | 
27 | 	# retrieve converter data
28 | 	overrides = load_wikinames(wiki_namecache_fp)
29 | 	conversions = {'gameid': dict(), 'gamename': dict(), 'wikiname': dict()}
30 | 
31 | 	for equipstat in equip_data_statistics.load_all(Client):
32 | 		if not isinstance(equipstat, EquipStat): continue
33 | 		gameid = equipstat.id
34 | 		gamename = equipstat.name
35 | 		wikiname = overrides.get(gameid) or ''
36 | 
37 | 		conversions['gameid'][str(gameid)] = { "gamename": gamename, "wikiname": wikiname }
38 | 		conversions['gamename'][gamename] = { "gameid": gameid, "wikiname": wikiname }
39 | 		conversions['wikiname'][wikiname] = { "gameid": gameid, "gamename": gamename }
40 | 
41 | 	# save data to file
42 | 	with open(convert_fp, 'w', encoding="utf8") as f:
43 | 		json.dump(conversions, f, ensure_ascii=False)


--------------------------------------------------------------------------------
/PythonScripts/lib/settings.py:
--------------------------------------------------------------------------------
 1 | import tomllib
 2 | import shutil
 3 | from pathlib import Path
 4 | from dataclasses import dataclass
 5 | 
 6 | 
 7 | SETTINGS_FILEPATH = Path("data", "settings.toml")
 8 | SETTINGS_FILEPATH_DEFAULT = Path("data", "static", "settings_default.toml")
 9 | 
10 | @dataclass
11 | class APISettings:
12 |     json_source_path: Path
13 |     jsonloader_variant: str
14 | 
15 | 
16 | def read_settings(path: Path = SETTINGS_FILEPATH):
17 |     if not path.exists():
18 |         if SETTINGS_FILEPATH_DEFAULT.exists():
19 |             shutil.copyfile(SETTINGS_FILEPATH_DEFAULT, path)
20 |         else:
21 |             raise RuntimeError(f"Default settings backup file at '{SETTINGS_FILEPATH_DEFAULT}' does not exist!")
22 |     
23 |     with open(path, "rb") as f:
24 |         return tomllib.load(f)
25 | 
26 | def read_and_parse_settings(path: Path | None = None) -> APISettings:
27 |     settings_data = read_settings(path) if path else read_settings()
28 | 
29 |     return APISettings(
30 |         json_source_path = Path(settings_data["source_json_path"]).resolve(),
31 |         jsonloader_variant = settings_data["jsonloader_variant"]
32 |     )
33 | 


--------------------------------------------------------------------------------
/PythonScripts/lib/sharecfgmodules.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | from dataclasses import dataclass
  3 | from collections.abc import Iterable
  4 | 
  5 | from . import Client, SharecfgModule, Utility
  6 | from .apiclasses import (ApiDataRef, LoginRewards, SharecfgDataRef, AwardDisplay, AwardDisplayLabeled, Award, BackyardTheme,
  7 | 	Chapter, Code, EquipStat, EquipStatUpgrade, Expedition, FurnitureData, Item, MetashipSkill,
  8 | 	MetataskRef, Metatask, Milestone, Resource, ShipID, ShipSkin, ShipStat, ShopItem, Task)
  9 | from .Constants import Armor, Rarity, Nation, Attribute, ShipType
 10 | 
 11 | 
 12 | @dataclass
 13 | class Activity7DaySign(SharecfgModule):
 14 | 	def _instantiate_client(self, dataid: str, data: dict) -> LoginRewards:
 15 | 		return LoginRewards(
 16 | 			json=data,
 17 | 			front_drops=[Award(*awarddata) for awarddata in data["front_drops"]]
 18 | 		)
 19 | 
 20 | @dataclass
 21 | class ActivityEventPt(SharecfgModule):
 22 | 	def _instantiate_client(self, dataid: str, data: dict) -> Milestone:
 23 | 		return Milestone(
 24 | 			json=data,
 25 | 			point=ApiDataRef(data["pt"], "player_resource_reward"),
 26 | 			rewards=[Award(*awarddata) for awarddata in data["drop_client"]],
 27 | 		)
 28 | 
 29 | @dataclass
 30 | class ActivityShopTemplate(SharecfgModule):
 31 | 	def _instantiate_client(self, dataid: str, data: dict) -> ShopItem:
 32 | 		return ShopItem(
 33 | 			json=data,
 34 | 			type=data["commodity_type"],
 35 | 			refid=data["commodity_id"],
 36 | 			amount=data["num"],
 37 | 		)
 38 | 
 39 | @dataclass
 40 | class BackyardThemeTemplate(SharecfgModule):
 41 | 	def _instantiate_client(self, dataid: str, data: dict) -> BackyardTheme:
 42 | 		return BackyardTheme(
 43 | 			json=data,
 44 | 			furniture=[ApiDataRef(fid, "furniture") for fid in data["ids"]]
 45 | 		)
 46 | 
 47 | 
 48 | def convert_shiptype(typeid: int | str) -> ShipType | int:
 49 | 	if typeid == 0:
 50 | 		return 0
 51 | 	if isinstance(typeid, str):
 52 | 		return ShipType.from_type(typeid)
 53 | 	if typeid != 0:
 54 | 		return ShipType.from_id(typeid)
 55 | 
 56 | @dataclass
 57 | class ChapterTemplate(SharecfgModule):
 58 | 	def _instantiate_client(self, dataid: str, data: dict) -> Chapter:
 59 | 		previous_chapter = []
 60 | 		for pre_chapter_id_list in data["pre_chapter"]:
 61 | 			for pre_chapter_id in pre_chapter_id_list:
 62 | 				if pre_chapter_id != 0:
 63 | 					previous_chapter.append(SharecfgDataRef(pre_chapter_id, "chapter_template"))
 64 | 
 65 | 		enemies = [SharecfgDataRef(enemydata[0], "expedition_data_template") for enemydata in data["expedition_id_weight_list"]]
 66 | 		elites = [SharecfgDataRef(enemyid, "expedition_data_template") for enemyid in data["elite_expedition_list"]]
 67 | 		sirens = [SharecfgDataRef(enemyid, "expedition_data_template") for enemyid in data["ai_expedition_list"]]
 68 | 
 69 | 		boss = None
 70 | 		if boss_id_data := data["boss_expedition_id"]:
 71 | 			if len(boss_id_data) > 0:
 72 | 				boss = SharecfgDataRef(boss_id_data[0], "expedition_data_template")
 73 | 
 74 | 		chapter = Chapter(
 75 | 			json=data,
 76 | 			previous_chapter=previous_chapter,
 77 | 			mob_list=enemies,
 78 | 			mob_spawn_pattern=Utility.pop_zeros(data["enemy_refresh"]),
 79 | 			elite_list=elites,
 80 | 			elite_spawn_pattern=Utility.pop_zeros(data["elite_refresh"]),
 81 | 			siren_list=sirens,
 82 | 			siren_spawn_pattern=Utility.pop_zeros(data["ai_refresh"]),
 83 | 			boss=boss,
 84 | 			fleet_limitation=[[[convert_shiptype(tid) for tid in subfleet] for subfleet in fleet] for fleet in data["limitation"]],
 85 | 			awards=[AwardDisplay(*award) for award in data["awards"]]
 86 | 		)
 87 | 		return chapter
 88 | 
 89 | @dataclass
 90 | class EquipDataStatistics(SharecfgModule):
 91 | 	def _instantiate_client(self, dataid: str, data: dict) -> EquipStat | EquipStatUpgrade:
 92 | 		if "base" in data:
 93 | 			return EquipStatUpgrade(
 94 | 				json=data,
 95 | 				base=SharecfgDataRef(data["base"], "equip_data_statistics")
 96 | 			)
 97 | 
 98 | 		return EquipStat(
 99 | 			json=data,
100 | 			rarity=Rarity.from_id(data["rarity"]-1),
101 | 			nation=Nation.from_id(data["nationality"]),
102 | 		)
103 | 
104 | @dataclass
105 | class ExpeditionDataTemplate(SharecfgModule):
106 | 	def parse_awarddata(self, awarddata, dataid: str) -> AwardDisplay:
107 | 		if len(awarddata) == 2:
108 | 			return AwardDisplay(*awarddata)
109 | 		elif len(awarddata) == 3:
110 | 			return AwardDisplayLabeled(*awarddata)
111 | 		else:
112 | 			print(f"WARNING: Found AwardDisplay with more/less than 2 arguments (dataid: {dataid})")
113 | 			print(f"WARNING: AwardDisplay raw data <{awarddata}>")
114 | 
115 | 	def _instantiate_client(self, dataid: str, data: dict) -> Expedition:
116 | 		return Expedition(
117 | 			json=data,
118 | 			icons=[icon for icon in (data["icon"].strip(), data["add_icon"].strip()) if icon],
119 | 			award_display=[self.parse_awarddata(awarddata, dataid) for awarddata in data["award_display"]],
120 | 		)
121 | 
122 | @dataclass
123 | class FurnitureDataTemplate(SharecfgModule):
124 | 	def _instantiate_client(self, dataid: str, data: dict) -> FurnitureData:
125 | 		theme = None
126 | 		if (themeid := data["themeId"]) != 0:
127 | 			theme = SharecfgDataRef(themeid, "backyard_theme_template")
128 | 
129 | 		return FurnitureData(
130 | 			json=data,
131 | 			rarity=Rarity.from_id(data["rarity"]),
132 | 			theme=theme,
133 | 		)
134 | 
135 | @dataclass
136 | class ItemDataStatistics(SharecfgModule):
137 | 	def _instantiate_client(self, dataid: str, data: dict) -> Item:
138 | 		return Item(
139 | 			json=data,
140 | 			rarity=Rarity.from_id(data["rarity"]),
141 | 		)
142 | 
143 | @dataclass
144 | class ItemVirtualDataStatistics(ItemDataStatistics): pass
145 | 
146 | @dataclass
147 | class NameCode(SharecfgModule):
148 | 	# cjson converts the lua table into a json array, not a dict
149 | 	# SharecfgModule expects a dict (to use the get function)
150 | 	# so the array needs to be converted into a dict
151 | 	def _process_data(self, client: Client, jsondata) -> None:
152 | 		# start enumeration at one, since lua tables start keys at one
153 | 		# the key also needs to be converted into a string to comply with SharecfgModule behaviour
154 | 		#jsondata = {str(i): data for i, data in enumerate(jsondata, 1)}
155 | 		if isinstance(jsondata, dict):
156 | 			jsondata = jsondata.values()
157 | 		jsondata = {str(data['id']): data for data in jsondata}
158 | 		super()._process_data(client, jsondata)
159 | 
160 | 	def _instantiate_client(self, dataid: str, data: dict) -> Code:
161 | 			return Code(json=data)
162 | 
163 | 	# needs custom implementation, because name_code has no "all" field
164 | 	def all_client_ids(self, client: Client) -> Iterable[int]:
165 | 		self._load_data(client)
166 | 		return self._data[client].keys()
167 | 
168 | @dataclass
169 | class PlayerResource(SharecfgModule):
170 | 	def _instantiate_client(self, dataid: str, data: dict) -> Resource:
171 | 			item = None
172 | 			if (itemid := data["itemid"]) != 0:
173 | 				item = ApiDataRef(itemid, "all_item_data_statistics")
174 | 
175 | 			return Resource(
176 | 				json=data,
177 | 				item=item,
178 | 			)
179 | 
180 | @dataclass
181 | class ShipDataStatistics(SharecfgModule):
182 | 	def _instantiate_client(self, dataid: str, data: dict) -> ShipStat:
183 | 		attributes = {}
184 | 		attributes_growth = {}
185 | 		for attr in Attribute:
186 | 			attributes[attr] = data["attrs"][attr.pos]
187 | 			attributes_growth[attr] = data["attrs_growth"][attr.pos]
188 | 
189 | 		return ShipStat(
190 | 			json=data,
191 | 			shipid=ShipID(fullid=data["id"]),
192 | 			rarity=Rarity.from_id(data["rarity"]-1),
193 | 			nation=Nation.from_id(data["nationality"]),
194 | 			type=ShipType.from_id(data["type"]),
195 | 			armor=Armor.from_id(data["armor_type"]),
196 | 			attributes=attributes,
197 | 			attributes_growth=attributes_growth,
198 | 			skin=SharecfgDataRef(data["skin_id"], "ship_skin_template"),
199 | 		)
200 | 
201 | @dataclass
202 | class ShipMetaSkilltask(SharecfgModule):
203 | 	def _instantiate_client(self, dataid: str, data: dict) -> MetashipSkill:
204 | 		tasks = []
205 | 		for taskdata in data["skill_levelup_task"]:
206 | 			taskref = MetataskRef(id=taskdata[0], module="task_meta_data_template",
207 | 				repeat_limit=taskdata[1], xp_gain=taskdata[2])
208 | 			tasks.append(taskref)
209 | 
210 | 		return MetashipSkill(
211 | 			json=data,
212 | 			skill=SharecfgDataRef(data["skill_ID"], "skill_data_template"),
213 | 			item_consume=[Award(*awarddata) for awarddata in data["skill_unlock"]],
214 | 			tasks=tasks,
215 | 		)
216 | 
217 | @dataclass
218 | class ShipSkinExpression(SharecfgModule):
219 | 	def all_client_ids(self, client: Client) -> Iterable[int | str]:
220 | 		if clientdata := self._load_data(client):
221 | 			return clientdata.keys()
222 | 
223 | @dataclass
224 | class ShipSkinTemplate(SharecfgModule):
225 | 	def _instantiate_client(self, dataid: str, data: dict) -> ShipSkin:
226 | 		shipid = ShipID(fullid=data["id"])
227 | 		if data["ship_group"] != shipid.groupid:
228 | 			shipid = ShipID(fullid=data["id"], groupid=data["ship_group"])
229 | 
230 | 		background = int(data["bg"]) if data["bg"] else None
231 | 		background_special = int(data["bg_sp"]) if data["bg_sp"] else None
232 | 
233 | 		return ShipSkin(
234 | 			json=data,
235 | 			shipid=shipid,
236 | 			background=background,
237 | 			background_special=background_special,
238 | 		)
239 | 
240 | @dataclass
241 | class TaskDataTemplate(SharecfgModule):
242 | 	def _instantiate_client(self, dataid: str, data: dict) -> Task:
243 | 		award_display = data["award_display"]
244 | 		# alert when a badly converted award_display property is found
245 | 		# (this is true for only one task across all clients except TW)
246 | 		if isinstance(award_display, str):
247 | 			logging.debug(f"Malformatted awarddisplay {award_display} for task {dataid}. (ignoring task)")
248 | 			return
249 | 
250 | 		targetid_data = data["target_id"]
251 | 		targetid = int(targetid_data) if isinstance(targetid_data, str) else targetid_data
252 | 
253 | 		return Task(
254 | 			json=data,
255 | 			awards=[Award(*awarddata) for awarddata in award_display],
256 | 			target_id=targetid,
257 | 		)
258 | 
259 | @dataclass
260 | class TaskMetaDataTemplate(SharecfgModule):
261 | 	def _instantiate_client(self, dataid: str, data: dict) -> Metatask:
262 | 		return Metatask(json=data)
263 | 
264 | 
265 | __all__ = {
266 | 	"activity_7_day_sign": Activity7DaySign,
267 | 	"activity_event_pt": ActivityEventPt,
268 | 	"activity_shop_template": ActivityShopTemplate,
269 | 	"backyard_theme_template": BackyardThemeTemplate,
270 | 	"chapter_template": ChapterTemplate,
271 | 	"equip_data_statistics": EquipDataStatistics,
272 | 	"expedition_data_template": ExpeditionDataTemplate,
273 | 	"furniture_data_template": FurnitureDataTemplate,
274 | 	"item_data_statistics": ItemDataStatistics,
275 | 	"item_virtual_data_statistics": ItemVirtualDataStatistics,
276 | 	"name_code": NameCode,
277 | 	"player_resource": PlayerResource,
278 | 	"ship_data_statistics": ShipDataStatistics,
279 | 	"ship_meta_skilltask": ShipMetaSkilltask,
280 | 	"ship_skin_expression": ShipSkinExpression,
281 | 	"ship_skin_template": ShipSkinTemplate,
282 | 	"task_data_template": TaskDataTemplate,
283 | 	"task_meta_data_template": TaskMetaDataTemplate,
284 | }
285 | 
286 | def import_module(modulename: str) -> SharecfgModule:
287 | 	return __all__.get(modulename)
288 | 


--------------------------------------------------------------------------------
/PythonScripts/map.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | import math
  3 | from collections import Counter
  4 | from collections.abc import Iterable
  5 | from argparse import ArgumentParser
  6 | from itertools import chain
  7 | 
  8 | from lib import ALJsonAPI, Client, Utility, WikiHelper, Constants
  9 | from lib.apiclasses import Award, CachedAPILoader, ShipReward, Task
 10 | 
 11 | 
 12 | TIER_EQUIP_NAME = re.compile(r"^(T[0-9]\s).*")
 13 | DESIGN_EQUIP_NAME = re.compile(r".*(\s(T[0-9]\s)Design)")
 14 | 
 15 | property_limit_text = {
 16 | 	"level" : "Average Level",
 17 | 	"durability": "{{Health}} Total HP",
 18 | 	"cannon": "{{Firepower}} Total Firepower",
 19 | 	"torpedo": "{{Torpedo}} Total Torpedo",
 20 | 	"antiaircraft": "{{AA}} Total Anti-Air",
 21 | 	"air": "{{Aviation}} Total Aviation",
 22 | 	"antisub": "{{ASW}} Total ASW",
 23 | 	"dodge": "{{Evasion}} Total Evasion",
 24 | 	"reload": "{{Reload}} Total Reload",
 25 | }
 26 | 
 27 | property_limit_sign = {
 28 | 	-1: "<",
 29 | 	0: "=",
 30 | 	1: ">",
 31 | }
 32 | 
 33 | # "model/const/chapterconst.lua" with slot0.AttachX
 34 | node_type_letter = {
 35 | 	-1: "x", # land
 36 | 	0: " ", # water
 37 | 	1: "s", # start
 38 | 	2: "q", # question
 39 | 	3: "a", # ammo
 40 | 	4: "c", # combat
 41 | 	5: "ambush", # ambush
 42 | 	6: "e", # enemy
 43 | 	7: "m", # matime_escort: mine
 44 | 	8: "b", # boss
 45 | 	9: "story", # story
 46 | 	11: "areaboss", # areaboss
 47 | 	12: "p", # siren (champion)
 48 | 	14: "torpedofleet", # torpedo-fleet
 49 | 	15: "sirenpatrol", # siren (champion)-patrol
 50 | 	16: "u", # submarine
 51 | 	17: "f", # matime_escort: transport
 52 | 	18: "d", # matime_escort: transport_target
 53 | 	19: "siren-submarine", # siren (champion)-submarine
 54 | 	20: "oni", # oni
 55 | 	21: "oni-target", # oni-target
 56 | 	24: "bomb-enemy", # bomb-enemy
 57 | 	25: "barrier", # barrier
 58 | 	26: "huge supply", # huge supply
 59 | 	100: "h", # harbour
 60 | }
 61 | 
 62 | drop_const = {
 63 | 	"bp": {
 64 | 		54041: "{{Blueprint|T2|Destroyer}} T1-T2 Destroyer Retrofit Blueprint",
 65 | 		54042: "{{Blueprint|T2|Cruiser}} T1-T2 Cruiser Retrofit Blueprint",
 66 | 		54043: "{{Blueprint|T2|Battleship}} T1-T2 Battleship Retrofit Blueprint",
 67 | 		54044: "{{Blueprint|T2|Carrier}} T1-T2 Carrier Retrofit Blueprint",
 68 | 		54045: "{{Blueprint|T3|Destroyer}} T1-T3 Destroyer Retrofit Blueprint",
 69 | 		54046: "{{Blueprint|T3|Cruiser}} T1-T3 Cruiser Retrofit Blueprint",
 70 | 		54047: "{{Blueprint|T3|Battleship}} T1-T3 Battleship Retrofit Blueprint",
 71 | 		54048: "{{Blueprint|T3|Carrier}} T1-T3 Carrier Retrofit Blueprint",
 72 | 	},
 73 | 	"coredata": { 59900: "{{Core data}} Core Data", },
 74 | 	"part": {
 75 | 		54011: "{{Plate|T1}} T1 Upgrade Parts",
 76 | 		54012: "{{Plate|T2}} T1-T2 Upgrade Parts",
 77 | 		54013: "{{Plate|T3}} T1-T3 Upgrade Parts",
 78 | 		54017: "{{Plate|T3}} T2-T3 Upgrade Parts",
 79 | 	},
 80 | 	"box": {
 81 | 		54021: "{{Box|T1}} T1 Tech Boxes",
 82 | 		54022: "{{Box|T2}} T1-T2 Tech Boxes",
 83 | 		54023: "{{Box|T3}} T1-T3 Tech Boxes",
 84 | 		54024: "{{Box|T4}} T1-T4 Tech Boxes",
 85 | 	},
 86 | 	"coins": { 59001: "{{Coin}} Coins", },
 87 | }
 88 | 
 89 | # for star strings, see "model/const/chapterconst.lua#GetAchieveDesc"
 90 | star_strings = {
 91 | 	1: "Defeat flagship",
 92 | 	2: "Defeat {} escort fleets",
 93 | 	3: "Defeat all enemies",
 94 | 	4: "Deployed ships ≤ {}",
 95 | 	#5: "%s not deployed",
 96 | 	6: "Clear with a Full Combo",
 97 | }
 98 | 
 99 | 
100 | def flatten(*args) -> Iterable:
101 | 	iterables = []
102 | 	for arg in args:
103 | 		if isinstance(arg, Iterable):
104 | 			iterables.extend(arg)
105 | 		else:
106 | 			iterables.append(arg)
107 | 	return iterables
108 | 
109 | 
110 | def find_chapter_tasks(chapterid: int, api: ALJsonAPI, client: Client) -> tuple[Task, Task]:
111 | 	"""
112 | 	:return: Returns a tuple of format (<cleartask>, <threestartask>)
113 | 	"""
114 | 	clear_task = None
115 | 	threestar_task = None
116 | 
117 | 	task_data_template = api.get_sharecfgmodule("task_data_template")
118 | 	for task in task_data_template.all_client(client):
119 | 		taskid_it = flatten(task.target_id)
120 | 		if chapterid in taskid_it:
121 | 			if task.sub_type == 1020: clear_task = task
122 | 			elif task.sub_type == 1021: threestar_task = task
123 | 			# break loop if both tasks are already found
124 | 			if clear_task and threestar_task:
125 | 				break
126 | 	return clear_task, threestar_task
127 | 
128 | 
129 | def get_task_awards(task: Task, api: ALJsonAPI, client: Client, wikifier: WikiHelper.Wikifier) -> str:
130 | 	award_output = []
131 | 	for award in task.awards:
132 | 		awardable = award.load(api, client)
133 | 
134 | 		wiki_awardable = wikifier.wikify_awardable(awardable)
135 | 		outicon = wiki_awardable.icontemplate or WikiHelper.put_icon(filename=wiki_awardable.filelink+".png",
136 | 			itemname=wiki_awardable.name, nolink=True)
137 | 		outname = wiki_awardable.name
138 | 		if isinstance(awardable, ShipReward):
139 | 			outname = f"[[{outname}]]"
140 | 		award_output.append(f"{award.amount}x {outname} {outicon}")
141 | 	return ", ".join(award_output)
142 | 
143 | 
144 | class EnemyNameLoader(CachedAPILoader):
145 | 	def _generate_cache(self) -> None:
146 | 		enemy_data_statistics = self._api.get_sharecfgmodule("enemy_data_statistics")
147 | 		for entry in enemy_data_statistics.all_client(Client.EN):
148 | 			if "icon" in entry:
149 | 				priority = False
150 | 				if entry_prev := self._cache.get(entry.icon):
151 | 					entry_prev, priority = entry_prev
152 | 				
153 | 				if not priority:
154 | 					if "name" in entry:
155 | 						self._cache[entry.icon] = (entry, entry.name in self._api.ship_converter.ship_to_id)
156 | 					else:
157 | 						if entry_prev:
158 | 							self._cache[entry.icon] = (entry_prev, False)
159 | 						else:
160 | 							self._cache[entry.icon] = (entry, False)
161 | 	
162 | 	def name_from_icon(self, icon: str) -> str:
163 | 		if entry := self._cache.get(icon):
164 | 			entry, priority = entry
165 | 			name = entry.get("name") or entry.prefab
166 | 			if priority:
167 | 				name = "[["+ name + "]]"
168 | 
169 | 			if "type" in entry:
170 | 				return name + " {{" + Constants.ShipType.from_id(entry.type).templatename + "}}"
171 | 
172 | 			return name
173 | 		return icon	
174 | 
175 | 
176 | def star_requirement(num: int, value: int | None = None) -> str:
177 | 	if num == 0:
178 | 		return
179 | 
180 | 	star_text = star_strings[num]
181 | 	if num in [2, 4]:
182 | 		return star_text.format(value)
183 | 	return star_text
184 | 
185 | def fleet_retriction(fleet_limit: list[list[Constants.ShipType | int]]) -> str:
186 | 	countedtypes = Counter(chain(*fleet_limit))
187 | 	types_str = []
188 | 	for shiptype, amount in countedtypes.items():
189 | 		if shiptype == 0: continue
190 | 		types_str.append(f"{amount} {{{{{shiptype.templatename}}}}} {shiptype.typetext}")
191 | 	return ", ".join(types_str)
192 | 
193 | 
194 | def get_chapter(chapterid: int, api: ALJsonAPI, client: Client) -> str:
195 | 	wikifier = WikiHelper.Wikifier(api)
196 | 	chapter_template = api.get_sharecfgmodule("chapter_template")
197 | 	chapter = chapter_template.load_client(chapterid, client)
198 | 
199 | 	### set default chapter info
200 | 	chapter_wiki_template = {}
201 | 	chapter_wiki_template["ctID"] = chapter.id
202 | 	chapter_wiki_template["ID"] = chapter.chapter_name
203 | 	chapter_wiki_template["Title"] = chapter.name
204 | 	chapter_wiki_template["Introduction"] = api.replace_namecode(chapter.profiles, client)
205 | 
206 | 	### unlock condition
207 | 	unlock_require = []
208 | 	map_require = []
209 | 	if unlocklevel := chapter.unlocklevel:
210 | 		unlock_require.append("Commander Lv. " + str(unlocklevel))
211 | 	for previous_chapter_entry in chapter.previous_chapter:
212 | 		pre_chapter = previous_chapter_entry.load(api, client)
213 | 		pre_chapter_name = pre_chapter.chapter_name
214 | 		map_require.append(f"[[#{pre_chapter_name}|{pre_chapter_name}]]")
215 | 	if len(map_require) == 1:
216 | 		unlock_require.append(f"Clear {map_require[0]}")
217 | 	elif len(map_require) > 1:
218 | 		unlock_require.append("Clear either " + " or ".join(map_require))
219 | 	chapter_wiki_template["Requirements"] = " and ".join(unlock_require)
220 | 
221 | 	### associated tasks
222 | 	clear_task, threestar_task = find_chapter_tasks(chapterid, api, client)
223 | 	if clear_task: chapter_wiki_template["ClearReward"] = get_task_awards(clear_task, api, client, wikifier)
224 | 	if threestar_task: chapter_wiki_template["3StarReward"] = get_task_awards(threestar_task, api, client, wikifier)
225 | 
226 | 	### normal and elite mob info
227 | 	exp = [ -1, -1, -1 ]
228 | 	level = [ 9999, -1 ]
229 | 	for enemyref in chain(chapter.mob_list, chapter.elite_list):
230 | 		enemy = enemyref.load(api, client)
231 | 		# small fleets are type 1, 4, 7
232 | 		# medium fleets are type 2, 5, 8
233 | 		# large fleets are type 3, 6, 9
234 | 		# cargo fleets are type 10
235 | 		# skip all other types for now
236 | 		if not 1 <= enemy.type <= 10: continue
237 | 		exp[(enemy.type-1)%3] = enemy.exp
238 | 		if enemy.level < level[0]: level[0] = enemy.level
239 | 		if enemy.level > level[1]: level[1] = enemy.level
240 | 
241 | 	# set template params for normal mob fleet xp and level
242 | 	if level[0] == level[1]:
243 | 		chapter_wiki_template["MobLevel"] = level[0]
244 | 	elif level[0] != 9999 and level[1] != -1:
245 | 		chapter_wiki_template["MobLevel"] = f"{level[0]}-{level[1]}"
246 | 	for i, xpval in enumerate(exp):
247 | 		if xpval != -1:
248 | 			chapter_wiki_template[f"MobExp{i+1}"] = exp[i]
249 | 
250 | 	# add mob spawn order
251 | 	if chapter.mob_list:
252 | 		chapter_wiki_template["MobSpawnOrder"] = ",".join([str(el) for el in chapter.mob_spawn_pattern])
253 | 	if chapter.elite_list:
254 | 		chapter_wiki_template["EliteSpawnOrder"] = ",".join([str(el) for el in chapter.elite_spawn_pattern])
255 | 
256 | 	### siren mob info
257 | 	if chapter.siren_list:
258 | 		# get siren xp and level values
259 | 		exp = -1
260 | 		level = [ 9999, -1 ]
261 | 		for enemyref in chapter.siren_list:
262 | 			if enemyref.id in [0, 1]: continue
263 | 			# if enemyref.id == 1: continue # possibly needed, from legacy code
264 | 			enemy = enemyref.load(api, client)
265 | 			if enemy.exp > exp: exp = enemy.exp
266 | 			if enemy.level < level[0]: level[0] = enemy.level
267 | 			if enemy.level > level[1]: level[1] = enemy.level
268 | 
269 | 		# add xp and level values and spawn order to template data
270 | 		if level[0] == level[1]:
271 | 			chapter_wiki_template["SirenLevel"] = level[0]
272 | 		elif level[0] != 9999 and level[1] != -1:
273 | 			chapter_wiki_template["SirenLevel"] = f"{level[0]}-{level[1]}"
274 | 		if exp != -1:
275 | 			chapter_wiki_template["MobExpSiren"] = exp
276 | 		chapter_wiki_template["SirenSpawnOrder"] = ",".join([str(el) for el in chapter.siren_spawn_pattern])
277 | 
278 | 	### boss info
279 | 	enemynameloader = EnemyNameLoader(api)
280 | 	if chapter.boss and chapter.boss.id != 0:
281 | 		boss_enemy = chapter.boss.load(api, client)
282 | 		#bossicons = set(chapter.icon).union(set(boss_enemy.icons))
283 | 		chapter_wiki_template["Boss"] = " and ".join([enemynameloader.name_from_icon(icon) for icon in chapter.icon])
284 | 		chapter_wiki_template["BossLevel"] = boss_enemy.level
285 | 		chapter_wiki_template["BossExp"] = boss_enemy.exp
286 | 	chapter_wiki_template["BossBattleReq"] = chapter.boss_refresh or "0"
287 | 	chapter_wiki_template["BossBattleClear"] = math.ceil(100/(chapter.progress_boss or 1))
288 | 
289 | 	# other general chapter info
290 | 	chapter_wiki_template["AvoidRequire"] = chapter.avoid_require
291 | 	chapter_wiki_template["Star1"] = star_requirement(chapter.star_require_1, chapter.num_1)
292 | 	chapter_wiki_template["Star2"] = star_requirement(chapter.star_require_2, chapter.num_2)
293 | 	chapter_wiki_template["Star3"] = star_requirement(chapter.star_require_3, chapter.num_3)
294 | 	chapter_wiki_template["SuggestedAirSupremacy"] = chapter.best_air_dominance
295 | 	chapter_wiki_template["ActualAirSupremacy"] = chapter.air_dominance
296 | 
297 | 	if chapter.use_oil_limit:
298 | 		chapter_wiki_template["OilCapMob"] = chapter.use_oil_limit[0]
299 | 		chapter_wiki_template["OilCapBoss"] = chapter.use_oil_limit[1]
300 | 		chapter_wiki_template["OilCapSub"] = chapter.use_oil_limit[2]
301 | 
302 | 	### hard mode info
303 | 	if chapter.type == 2:
304 | 		# fleet type limitations
305 | 		for i in range(max(2, len(chapter.fleet_limitation))):
306 | 			if len(chapter.fleet_limitation) > i:
307 | 				chapter_wiki_template[f"Fleet{i+1}"] = fleet_retriction(chapter.fleet_limitation[i])
308 | 			else:
309 | 				chapter_wiki_template[f"Fleet{i+1}"] = "Not available"
310 | 
311 | 		# stat restrictions
312 | 		stat_strs = []
313 | 		for ltype, lsign, lamount in chapter.property_limitation:
314 | 			stat_strs.append(f"{property_limit_text[ltype]} {property_limit_sign[lsign]} {lamount}")
315 | 		chapter_wiki_template["StatRestrictions"] = ", ".join(stat_strs)
316 | 
317 | 	### Nodemap
318 | 	nodemap = ""
319 | 	current_row = -1
320 | 	for row, _, access, nodetype in chapter.get("grids"):
321 | 		if row == current_row:
322 | 			nodemap = "|"+nodemap
323 | 		else:
324 | 			if nodemap: nodemap = "\n	|" + nodemap
325 | 			current_row = row
326 | 		if not access: nodetype = -1
327 | 		nodemap = node_type_letter[nodetype] + nodemap
328 | 	chapter_wiki_template["NodeMap"] = "{{MapTable\n	|"+nodemap+"\n  }}"
329 | 
330 | 	### drops
331 | 	shipdrops = [""]
332 | 	equipdrops = [""]
333 | 	map_drop_output_list = {"other": []}
334 | 
335 | 	for award in chapter.awards:
336 | 		award = award.load(api, client)
337 | 
338 | 		# ship drops
339 | 		if award.icon == "Props/54000":
340 | 			shipdrop_awards = award["display_icon"]
341 | 			for shipdrop_award in shipdrop_awards:
342 | 				shipdrop = Award(*shipdrop_award).load(api, client)
343 | 				shipdrop_wiki = wikifier.wikify_awardable(shipdrop)
344 | 				dropicon = WikiHelper.simple_template("IconHover", [shipdrop_wiki.name, shipdrop_wiki.rarity.rarity+1])
345 | 				shipdrops.append(dropicon)
346 | 
347 | 		# equipment drops
348 | 		elif award.icon == "Props/55000":
349 | 			equipdrop_awards = award["display_icon"]
350 | 			for equipdrop_award in equipdrop_awards:
351 | 				equipdrop = Award(*equipdrop_award).load(api, client)
352 | 				equipdrop_wiki = wikifier.wikify_awardable(equipdrop)
353 | 
354 | 				if m := TIER_EQUIP_NAME.match(equipdrop.name):
355 | 					equipdrop_name = m.group(1) + equipdrop_wiki.name
356 | 				elif m := DESIGN_EQUIP_NAME.match(equipdrop.name):
357 | 					equipdrop_name = m.group(2) + equipdrop_wiki.name.replace(m.group(1), "")
358 | 				else:
359 | 					equipdrop_name = equipdrop_wiki.name
360 | 
361 | 				dropicon = WikiHelper.simple_template("EquipmentBox", [equipdrop_wiki.rarity.rarity+1,
362 | 					equipdrop_name, equipdrop_wiki.link, equipdrop_wiki.icon])
363 | 				equipdrops.append(dropicon)
364 | 
365 | 		# other map drops
366 | 		else:
367 | 			isSpecialDrop = False
368 | 			for drop_key, key_dict in drop_const.items():
369 | 				if award.id in key_dict:
370 | 					isSpecialDrop = True
371 | 					map_drop_output_list[drop_key] = key_dict[award.id]
372 | 					break
373 | 			if not isSpecialDrop:
374 | 				map_drop_output_list["other"].append(award.name)
375 | 
376 | 	map_drop_output = ""
377 | 	for drop_key in drop_const:
378 | 		if drop_key in map_drop_output_list:
379 | 			if map_drop_output: map_drop_output += ", "
380 | 			map_drop_output += map_drop_output_list[drop_key]
381 | 
382 | 	chapter_wiki_template["ShipDrops"] = "\n".join(shipdrops)
383 | 	chapter_wiki_template["EquipmentDrops"] = "\n".join(equipdrops)
384 | 	chapter_wiki_template["MapDrops"] = map_drop_output
385 | 	return chapter_wiki_template
386 | 
387 | 
388 | def main():
389 | 	parser = ArgumentParser()
390 | 	parser.add_argument("-c", "--client", required=True, choices=Client.__members__,
391 | 						help="client to gather information from")
392 | 	mapgroup = parser.add_mutually_exclusive_group(required=True)
393 | 	mapgroup.add_argument("-m", "--mapids", metavar="MAPID", type=int, nargs='+',
394 | 						help="indexes from sharecfg/chapter_template")
395 | 	mapgroup.add_argument("-e", "--eventid", type=int, nargs=1,
396 | 						help="index prefix from sharecfg/chapter_template for events")
397 | 	parser.add_argument("--mult", "--multiplier", type=int, nargs='?', default=10000,
398 | 						help="multiplier of the event id index prefix")
399 | 	args = parser.parse_args()
400 | 
401 | 	client = Client[args.client]
402 | 	api = ALJsonAPI()
403 | 
404 | 	if args.mapids:
405 | 		mapids = args.mapids
406 | 	elif args.eventid:
407 | 		eventid = args.eventid[0] * args.mult
408 | 		chapter_template = api.get_sharecfgmodule("chapter_template")
409 | 		ids = chapter_template.all_client_ids(client)
410 | 		mapids = filter(lambda mapid: 0 < (int(mapid) - eventid) < 100, ids)
411 | 
412 | 	template_map = WikiHelper.MultilineTemplate("Map")
413 | 	mapstrings = []
414 | 	for mapid in sorted(mapids):
415 | 		mapdata = get_chapter(mapid, api, client)
416 | 		mapstrings.append( mapdata["ID"] + "=" + template_map.fill(mapdata) )
417 | 
418 | 	wikitext = "<tabber>\n" + "\n|-|\n".join(mapstrings) + "\n</tabber>"
419 | 	Utility.output(wikitext)
420 | 
421 | if __name__ == "__main__":
422 | 	main()
423 | 


--------------------------------------------------------------------------------
/PythonScripts/milestone.py:
--------------------------------------------------------------------------------
 1 | from argparse import ArgumentParser
 2 | 
 3 | from lib import ALJsonAPI, Client, Utility
 4 | from lib.apiclasses import ShipReward
 5 | from lib.WikiHelper import Wikifier, put_icon, simple_template
 6 | 
 7 | 
 8 | class MilestoneQuery:
 9 | 	api: ALJsonAPI
10 | 	wikifier: Wikifier
11 | 
12 | 	def __init__(self, api: ALJsonAPI = None, wikifier: Wikifier = None) -> None:
13 | 		if not api:
14 | 			api = ALJsonAPI()
15 | 		if not wikifier:
16 | 			wikifier = Wikifier(api)
17 | 		self.api = api
18 | 		self.wikifier = wikifier
19 | 
20 | 	def get(self, client: Client, event_id: int, pt_filename: str, columns: int = 3) -> str:
21 | 		activity_event_pt = self.api.get_sharecfgmodule("activity_event_pt")
22 | 		event_milestone = activity_event_pt.load_client(event_id, client)
23 | 		if not event_milestone:
24 | 			raise ValueError(f"A milestone with id {event_id} does not exist.")
25 | 
26 | 		pt_name = event_milestone.point.load(self.api, client).name
27 | 		wikitext = '{| class="wikitable" style="text-align:center"\n'
28 | 		for _ in range(columns):
29 | 			wikitext += "!"+put_icon(pt_filename, pt_name, nolink=True)+"\n!Reward\n"
30 | 
31 | 		for targetid, targetnum in enumerate(event_milestone.target):
32 | 			# go to next row every x columns
33 | 			if (targetid % columns) == 0: wikitext += "|-\n"
34 | 			award = event_milestone.rewards[targetid]
35 | 			awardable = award.load(self.api, client)
36 | 			wiki_awardable = self.wikifier.wikify_awardable(awardable)
37 | 
38 | 			awardable_name = wiki_awardable.name
39 | 			# add link brackets for ship rewards
40 | 			if isinstance(awardable, ShipReward):
41 | 				awardable_name = f"[[{awardable_name}]]"
42 | 
43 | 			wiki_display = simple_template("Display",
44 | 				[wiki_awardable.filelink, wiki_awardable.rarity.label, f"{award.amount}x "+awardable_name])
45 | 
46 | 			wikitext += "|"+str(targetnum)+"\n|"+wiki_display+"\n"
47 | 		wikitext += "|}\n"
48 | 		return wikitext
49 | 
50 | def main():
51 | 	parser = ArgumentParser()
52 | 	parser.add_argument("eventid", metavar="INDEX", type=int, nargs=1,
53 | 						help="an index from sharecfg/activity_event_pt")
54 | 	parser.add_argument("-c", "--client", required=True, choices=Client.__members__,
55 | 						help="client to gather information from")
56 | 	parser.add_argument("-pt", "--pointfile", default="Pt.png", type=str,
57 | 						help="filename of the point icon on the wiki")
58 | 	parser.add_argument("-col", "--columns", default=3, type=int,
59 | 						help="amount of rows to spread the data on the result wikitable")
60 | 	args = parser.parse_args()
61 | 
62 | 	result = MilestoneQuery().get(Client[args.client], args.eventid[0], args.pointfile, args.columns)
63 | 	Utility.output(result)
64 | 
65 | if __name__ == "__main__":
66 | 	main()
67 | 


--------------------------------------------------------------------------------
/PythonScripts/quotes.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | import enum
  3 | import mwparserfromhell
  4 | from dataclasses import dataclass
  5 | from collections import Counter
  6 | 
  7 | from lib import DEFAULT_CLIENTS, Client, ALJsonAPI, WikiHelper, Constants, Utility
  8 | from lib.Utility import rreplace
  9 | 
 10 | 
 11 | VOICE_TYPE_CONVERT = {
 12 | 	'skill': 'SkillActivation',
 13 | 	#'main': 'SecretaryIdle', // needs custom implementation
 14 | 	'feeling1': 'AffinityDisappointed',
 15 | 	'feeling2': 'AffinityStranger',
 16 | 	'feeling3': 'AffinityFriendly',
 17 | 	'feeling4': 'AffinityLike',
 18 | 	'feeling5': 'AffinityLove',
 19 | 	'touch': 'SecretaryTouch',
 20 | 	'battle': 'MissionStart',
 21 | 	'drop_descrip': 'ShipDescription',
 22 | 	'mail': 'Mail',
 23 | 	'propose': 'Pledge',
 24 | 	'lose': 'Defeat',
 25 | 	'hp_warning': 'LowHP',
 26 | 	'detail': 'Details',
 27 | 	'win_mvp': 'MVP',
 28 | 	'touch2': 'SpecialTouch',
 29 | 	'headtouch': 'Headpat',
 30 | 	'mission': 'Task',
 31 | 	'mission_complete': 'TaskComplete',
 32 | 	'home': 'MissionFinished',
 33 | 	'login': 'Login',
 34 | 	'unlock': 'Acquisition',
 35 | 	'upgrade': 'Strengthening',
 36 | 	'profile': 'SelfIntro',
 37 | 	#'vote': '', //Doesn't seen to be used
 38 | 	'expedition': 'Commission',
 39 | 	#'couple_encourage': 'Additional' // needs custom implementation
 40 | }
 41 | 
 42 | # tabber tab names
 43 | TAB_NAMES = {
 44 | 	Client.CN: 'Chinese Server',
 45 | 	Client.JP: 'Japanese Server',
 46 | 	Client.EN: 'English Server'
 47 | }
 48 | 
 49 | 
 50 | class QuoteType(enum.Enum):
 51 | 	BASE = enum.auto()
 52 | 	POST_OATH = enum.auto()
 53 | 	MAX_AFFECTION = enum.auto()
 54 | 
 55 | 	@property
 56 | 	def skinname_suffix(self):
 57 | 		if self == QuoteType.POST_OATH:
 58 | 			return "(EXTRA: Post-Oath)"
 59 | 		if self == QuoteType.MAX_AFFECTION:
 60 | 			return "(EXTRA: 100+ Affection)"
 61 | 		return ""
 62 | 
 63 | 	def skin_type(self, skinid: int):
 64 | 		if self == QuoteType.BASE:
 65 | 			if skinid == 0:
 66 | 				return ""
 67 | 			return f"Skin{skinid}"
 68 | 		if self in [QuoteType.POST_OATH, QuoteType.MAX_AFFECTION]:
 69 | 			if skinid == 0: return "BasePostPledge"
 70 | 			return f"Skin{skinid}PostPledge"
 71 | 		raise NotImplementedError(f'Unknown combination of QuoteType ({self.name}) and SkinID ({skinid}).')
 72 | 
 73 | @dataclass
 74 | class SkinQuotes:
 75 | 	lines: dict
 76 | 	display_name: str
 77 | 	quote_type: QuoteType
 78 | 
 79 | 
 80 | COLORTAG_START = re.compile(r'<color=#(\w+)>')
 81 | def clean_value(v: str) -> str:
 82 | 	v = v.strip()
 83 | 	if v.startswith('*'): v = v.replace('*', '<nowiki/>*', 1)
 84 | 	elif v.startswith('#'): v = v.replace('#', '<nowiki/>*', 1)
 85 | 	if '\n' in v: v = v.replace('\n', '<br>')
 86 | 	if v.endswith(',0'): v = v.replace(',0', '')
 87 | 
 88 | 	# remove color tags
 89 | 	if '</color>' in v: v = v.replace('</color>', '')
 90 | 	v = COLORTAG_START.sub('', v)
 91 | 	return v
 92 | 
 93 | 
 94 | # initialize API, sharecfg data, wiki interface and templates
 95 | api = ALJsonAPI()
 96 | ship_skin_words = api.get_sharecfgmodule("ship_skin_words")
 97 | ship_skin_words_extra = api.get_sharecfgmodule("ship_skin_words_extra")
 98 | ship_skin_template = api.get_sharecfgmodule("ship_skin_template")
 99 | ShipConverter = api.ship_converter
100 | wikiclient = WikiHelper.WikiClient().login()
101 | template_general = WikiHelper.MultilineTemplate('ShipQuote')
102 | template_en = WikiHelper.MultilineTemplate('ShipQuoteEN')
103 | 
104 | # get all skinids from all versions
105 | skinids = dict()
106 | for client in Client:
107 | 	for groupid, shipskinids in ship_skin_template._load("get_id_list_by_ship_group", client).items():
108 | 		if groupid in skinids:
109 | 			skinids[groupid].update(shipskinids)
110 | 		else:
111 | 			skinids[groupid] = set(shipskinids)
112 | 
113 | 
114 | def full_clean_value(client: Client, value: str) -> str:
115 | 	value = clean_value(value)
116 | 	return api.replace_namecode(value, client)
117 | 
118 | def format_or_list(values: list) -> str:
119 | 	s = ", ".join(values)
120 | 	return rreplace(s, ",", " or", 1)
121 | 
122 | 
123 | 
124 | def getGameQuoteSingleBase(client: Client, fullid: int | str) -> SkinQuotes:
125 | 	"""Returns a dict containing ALL quotes of a single skin.
126 | 	The keys are named after parameters complying with Template:ShipQuote for easy convertability.
127 | 	"""
128 | 	skinquotes = dict()
129 | 	quotes_data = ship_skin_words.load_client(fullid, client)
130 | 	if not quotes_data: return
131 | 
132 | 	# fetch skinname from single_id or ship_skin_template
133 | 	if fullid % 10 == 0: skinname = 'Default Skin'
134 | 	elif fullid % 10 == 9: skinname = 'Retrofit Skin'
135 | 	else:
136 | 		skin_data = ship_skin_template.load_client(fullid, client)
137 | 		if skin_data:
138 | 			skinname = api.replace_namecode(skin_data.name, client)
139 | 		if not client == Client.EN:
140 | 			if skin_data_en := ship_skin_template.load_client(fullid, Client.EN):
141 | 				skinname_en = api.replace_namecode(skin_data_en.name, Client.EN)
142 | 				skinname += ' / '+skinname_en
143 | 
144 | 	# get normal voice lines
145 | 	for voice_key in VOICE_TYPE_CONVERT:
146 | 		line = quotes_data.get(voice_key)
147 | 		if not line: continue
148 | 		template_param = VOICE_TYPE_CONVERT[voice_key]
149 | 		skinquotes[template_param] = full_clean_value(client, line)
150 | 
151 | 	# get secretary idle lines
152 | 	secidles = quotes_data.main.split('|')
153 | 	for i, line in enumerate(secidles):
154 | 		if (not line) or (line == 'nil'): continue
155 | 		skinquotes[f'SecretaryIdle{i+1}'] = full_clean_value(client, line)
156 | 
157 | 	# get additional lines
158 | 	additionals = quotes_data.couple_encourage
159 | 	if additionals != '0' and not isinstance(additionals, str):
160 | 		for i, additional in enumerate(additionals):
161 | 			if len(additional) != 4:
162 | 				print(f"Add {i}, {fullid}, {client.name}: Wrong formatting.")
163 | 				continue
164 | 			sortie_with, min_amount, line, quote_type = additional
165 | 			line = full_clean_value(client, line)
166 | 
167 | 			sortie_with_str = ''
168 | 			if quote_type == 0: # shiplist
169 | 				shipnames = []
170 | 				for groupid in sortie_with:
171 | 					shipname = ShipConverter.convert(groupid)
172 | 					if shipname:
173 | 						shipnames.append(shipname)
174 | 					else:
175 | 						print(f"Add {i}, {fullid}, {client.name}: Wrong groupid {groupid}.")
176 | 				if min_amount < len(shipnames): sortie_with_str = f'at least {min_amount} of: '
177 | 				sortie_with_str += ', '.join([shipname for shipname in shipnames if shipname is not None])
178 | 			
179 | 			elif quote_type == 1: # shiptype
180 | 				shiptypes = []
181 | 				for shiptypeid in sortie_with:
182 | 					if shiptype := Constants.ShipType.from_id(shiptypeid):
183 | 						shiptypes.append(shiptype.typename+('s' if min_amount > 1 else ''))
184 | 					else:
185 | 						print(f"Add {i}, {fullid}, {client.name}: Wrong shiptypeid {shiptypeid}.")
186 | 				sortie_with_str = f'at least {min_amount} other '+format_or_list(shiptypes)
187 | 
188 | 			elif quote_type == 2: # rarity
189 | 				shiprarities = []
190 | 				for rarityid in sortie_with:
191 | 					if rarity := Constants.Rarity.from_id(rarityid):
192 | 						shiprarities.append(rarity.label)
193 | 					else:
194 | 						print(f"Add {i}, {fullid}, {client.name}: Wrong rarityid {rarityid}.")
195 | 				sortie_with_str = f'at least {min_amount} ' + format_or_list(shiprarities) + ' ships'
196 | 
197 | 			elif quote_type == 3: # nation
198 | 				shipnations = []
199 | 				for nationid in sortie_with:
200 | 					if nation := Constants.Nation.from_id(nationid):
201 | 						shipnations.append(nation.label)
202 | 					else:
203 | 						print(f"Add {i}, {fullid}, {client.name}: Wrong nationid {nationid}.")
204 | 				sortie_with_str = f'at least {min_amount} ' + format_or_list(shipnations) + ' ships'
205 | 
206 | 			elif quote_type == 4: # artist
207 | 				sortie_with_str = f'at least {min_amount} other ships designed by the same [[Artists|artist]]'
208 | 
209 | 			else:
210 | 				raise ValueError(f"Add {i}, {fullid}, {client.name}: Unknown additional type {quote_type}.")
211 | 
212 | 			skinquotes[f'Additional{i+1}'] = f'(Sortie with {sortie_with_str}) {line}'
213 | 
214 | 	return SkinQuotes(skinquotes, skinname, QuoteType.BASE)
215 | 
216 | def getGameQuoteSingleEX(client: Client, fullid: int | str) -> SkinQuotes:
217 | 	"""Returns a dict containing ALL quotes of a single EXTRA skin.
218 | 	The keys are named after parameters complying with Template:ShipQuote for easy convertability.
219 | 	"""
220 | 	skinquotes = dict()
221 | 	quotes_data = ship_skin_words_extra.load_client(fullid, client)
222 | 	if not quotes_data: return
223 | 
224 | 	# get normal voice lines
225 | 	for voice_key in VOICE_TYPE_CONVERT:
226 | 		linedata = quotes_data.get(voice_key)
227 | 		if not linedata: continue
228 | 		line = linedata[0][1]
229 | 		template_param = VOICE_TYPE_CONVERT[voice_key]
230 | 		skinquotes[template_param] = full_clean_value(client, line)
231 | 
232 | 	# get secretary idle lines
233 | 	if secidledata := quotes_data.main:
234 | 		secidles = secidledata[0][1].split('|')
235 | 		for i, line in enumerate(secidles):
236 | 			if (not line) or (line == 'nil'): continue
237 | 			skinquotes['SecretaryIdle'+str(i+1)] = full_clean_value(client, line)
238 | 	
239 | 	affection_counter = []
240 | 	for linedata in quotes_data._json.values():
241 | 		if not linedata: continue
242 | 		if isinstance(linedata, (str, int)): continue
243 | 		affection_counter.append(linedata[0][0])
244 | 
245 | 	counter_result = Counter(affection_counter).most_common()
246 | 	if counter_result[0][0] == 100:
247 | 		quote_type = QuoteType.MAX_AFFECTION
248 | 	elif counter_result[0][0] == 1100:
249 | 		quote_type = QuoteType.POST_OATH
250 | 	else: raise NotImplementedError(f'Unknown affection value {counter_result[0][0]}.')
251 | 	return SkinQuotes(skinquotes, '', quote_type)
252 | 
253 | def getGameQuoteSingle(client: Client, fullid: int | str) -> dict[QuoteType, SkinQuotes]:
254 | 	result = {}
255 | 	if basequotes := getGameQuoteSingleBase(client, fullid):
256 | 		result[basequotes.quote_type] = basequotes
257 | 	if ex_quotes := getGameQuoteSingleEX(client, fullid):
258 | 		if basequotes:
259 | 			ex_quotes.display_name = " ".join([basequotes.display_name, ex_quotes.quote_type.skinname_suffix])
260 | 		result[ex_quotes.quote_type] = ex_quotes
261 | 	return result
262 | 
263 | def getGameQuoteData(client: Client, groupid: int) -> dict:
264 | 	"""Returns a dict containing ALL quotes of all skins of a given ship.
265 | 	The keys are named after parameters complying with Template:ShipQuote for easy convertability.
266 | 	"""
267 | 	total_add_ids = 0
268 | 	quotes = dict()
269 | 	for skinid in skinids[str(groupid)]: # iterate through all skinids of current ship
270 | 		if groupid == skinid//10:
271 | 			singleid = skinid % 10
272 | 		else: # if groupid does not match, the skin must have a singleid >= 10
273 | 			singleid = 10+total_add_ids
274 | 			total_add_ids += 1
275 | 		quotedata = getGameQuoteSingle(client, skinid) 
276 | 		if quotedata: quotes[singleid] = quotedata
277 | 	return quotes
278 | 
279 | 
280 | def getWikiQuoteData(shipname=None, quotepage=None) -> dict:
281 | 	"""Returns a dict containing ALL quotes of all skins of a given ship from the WIKI.
282 | 	The keys are named after parameters complying with Template:ShipQuote for easy convertability.
283 | 
284 | 	Either shipname or quotepage has to be given, otherwise None is returned.
285 | 	"""
286 | 	quote_wikidata = dict()
287 | 	if not quotepage:
288 | 		if not shipname: return None
289 | 		quotepage = wikiclient.execute(wikiclient.mwclient.pages.get, shipname+'/Quotes')
290 | 	if quotepage.exists:
291 | 		mwparser = mwparserfromhell.parse(quotepage.text())
292 | 		templates = mwparser.filter_templates()
293 | 		for template in templates:
294 | 			if not 'ShipQuote' in template.name: continue
295 | 			parsed_template_data = WikiHelper.parse_multiline_template(str(template))
296 | 			client = parsed_template_data.get('Region')
297 | 			skinname = parsed_template_data.get('Skin').replace('Skin', '').replace('Base', '') or '0'
298 | 			singleid = int(skinname.replace('PostPledge', '') or 0)
299 | 
300 | 			# create client sub-dict and skinid sub-dict if not existing
301 | 			if not quote_wikidata.get(client): quote_wikidata[client] = dict()
302 | 			if not quote_wikidata[client].get(singleid): quote_wikidata[client][singleid] = dict()
303 | 
304 | 			if 'PostPledge' in skinname:
305 | 				quote_wikidata[client][singleid][QuoteType.POST_OATH] = parsed_template_data
306 | 			else:
307 | 				quote_wikidata[client][singleid][QuoteType.BASE] = parsed_template_data
308 | 	return quote_wikidata
309 | 
310 | def updateQuotePage(shipname, saveToFile=False) -> bool:
311 | 	"""Updates the quote page of a given ship.
312 | 
313 | 	:return:
314 | 	 true if gallery page update was successful, otherwise false.
315 | 	"""
316 | 	# retrieve data from wiki and gamefiles
317 | 	groupid = ShipConverter.convert(shipname)
318 | 	quotes_gamedata = {client: getGameQuoteData(client, groupid) for client in DEFAULT_CLIENTS}
319 | 	quotepage = wikiclient.execute(wikiclient.mwclient.pages.get, shipname+'/Quotes')
320 | 	quotes_wikidata = dict()#getWikiQuoteData(quotepage=quotepage)
321 | 
322 | 	# merge game and wiki data
323 | 	wikitext = []
324 | 
325 | 	for client in DEFAULT_CLIENTS:
326 | 		if client not in quotes_gamedata: continue
327 | 		client_game_quotes = quotes_gamedata[client]
328 | 		if not client_game_quotes: continue
329 | 		if wikitext:
330 | 			wikitext.append("|-|")
331 | 		wikitext.append(TAB_NAMES[client]+"=")
332 | 
333 | 		for skinid in [0,-1,9,8,1,2,3,4,5,6,7]+list(range(10,max(client_game_quotes or [0])+1)):
334 | 			if skinid not in client_game_quotes: continue
335 | 
336 | 			client_skin_game_quotes = client_game_quotes[skinid]
337 | 			for quotetype, skin_game_quotes in client_skin_game_quotes.items():
338 | 				if not skin_game_quotes: continue
339 | 
340 | 				skin_wiki_quotes = Utility.dict_args_query(quotes_wikidata, client.name, skinid, quotetype) or Utility.dict_args_query(quotes_wikidata, client.name, skinid, QuoteType.POST_OATH) or {}
341 | 				skin_wiki_quotes = {k: clean_value(v) for k,v in skin_wiki_quotes.items()}
342 | 				skin_result_template = {**skin_wiki_quotes, **skin_game_quotes.lines}
343 | 
344 | 				# add further values to template
345 | 				skin_result_template['Region'] = client.name
346 | 				skin_result_template['Skin'] = skin_game_quotes.quote_type.skin_type(skinid)
347 | 
348 | 				# generate wikitext and add to wikitext list
349 | 				wikitext.append('==='+skin_game_quotes.display_name+'===')
350 | 				if client == Client.EN:
351 | 					wikitext.append(template_en.fill(skin_result_template))
352 | 				else:
353 | 					wikitext.append(template_general.fill(skin_result_template))
354 | 
355 | 
356 | 	wikitext = ["{{ShipTabber}}", "<tabber>"]+wikitext+["</tabber>"]
357 | 	wikitext = "\n".join(wikitext)
358 | 
359 | 	if saveToFile:
360 | 		Utility.output('ship-quotes', wikitext)
361 | 	else:
362 | 		wikiclient.execute(quotepage.save, wikitext, summary='Added missing lines/updated changed information')
363 | 
364 | def main():
365 | 	#updateQuotePage("Hatakaze", True)
366 | 	for ship in sorted(ShipConverter.ship_to_id.keys()):
367 | 		updateQuotePage(ship)
368 | 
369 | 
370 | if __name__ == "__main__":
371 | 	main()
372 | 


--------------------------------------------------------------------------------
/PythonScripts/shop.py:
--------------------------------------------------------------------------------
 1 | from argparse import ArgumentParser
 2 | 
 3 | from lib import ALJsonAPI, Client, Utility
 4 | from lib.WikiHelper import MultilineTemplate, Wikifier, simple_template
 5 | 
 6 | 
 7 | template_shop = MultilineTemplate("EventShop")
 8 | 
 9 | def shop(api: ALJsonAPI, wikifier: Wikifier, client: Client, eventid: int, pt_filename: str) -> str:
10 | 	activity_template = api.get_sharecfgmodule("activity_template")
11 | 	activity_shop_template = api.get_sharecfgmodule("activity_shop_template")
12 | 
13 | 	# get shopitem_id's from activity_template
14 | 	activity = activity_template.load_client(eventid, client)
15 | 	total_pt = 0
16 | 
17 | 	shopitem_wikitexts = [""]
18 | 	for shopitemid in activity["config_data"]:
19 | 		shopitem = activity_shop_template.load_client(shopitemid, client)
20 | 		award = shopitem.load(api, client)
21 | 		wikiaward = wikifier.wikify_awardable(award)
22 | 		rarity = wikiaward.rarity.label
23 | 		name = wikiaward.name
24 | 		link = wikiaward.link
25 | 		filelink = wikiaward.filelink
26 | 
27 | 		total_pt += shopitem.resource_num * shopitem.num_limit
28 | 		item_template_data = [ rarity, name, link, filelink, shopitem.num_limit, shopitem.resource_num, pt_filename, shopitem.amount ]
29 | 		shopitem_wikitexts.append(simple_template('EventShopItem', item_template_data))
30 | 
31 | 	eventshop_template_data = {
32 | 		'TotalPt': total_pt,
33 | 		'PtImage': pt_filename,
34 | 		'Items': '\n'.join(shopitem_wikitexts)
35 | 	}
36 | 	return template_shop.fill(eventshop_template_data)
37 | 
38 | def main():
39 | 	parser = ArgumentParser()
40 | 	parser.add_argument("shopid", metavar="INDEX", type=int, nargs=1,
41 | 						help="an index from sharecfg/activity_template that links to sharecfg/activity_shop_template")
42 | 	parser.add_argument("-c", "--client", required=True, choices=Client.__members__,
43 | 						help="client to gather information from")
44 | 	parser.add_argument("-pt", "--pointfile", default="Pt.png", type=str,
45 | 						help="filename of the point icon on the wiki")
46 | 	args = parser.parse_args()
47 | 
48 | 	api = ALJsonAPI()
49 | 	result = shop(api, Wikifier(api), Client[args.client], args.shopid[0], args.pointfile)
50 | 	Utility.output(result)
51 | 
52 | if __name__ == "__main__":
53 | 	main()
54 | 


--------------------------------------------------------------------------------
/PythonScripts/skins.py:
--------------------------------------------------------------------------------
  1 | from collections import Counter
  2 | from itertools import chain
  3 | from pathlib import Path
  4 | from time import sleep
  5 | from typing import Any, Callable
  6 | 
  7 | import mwparserfromhell
  8 | 
  9 | from lib import ALJsonAPI, Client, WikiHelper, Constants, Utility, DEFAULT_CLIENTS
 10 | from lib.converter import ships
 11 | 
 12 | 
 13 | api = ALJsonAPI()
 14 | ship_skin_template = api.get_sharecfgmodule("ship_skin_template")
 15 | shop_template = api.get_sharecfgmodule("shop_template")
 16 | ship_converter = ships.load_converter(Constants.SHIPID_CONVERT_CACHE_PATH)
 17 | 
 18 | wikiclient = WikiHelper.WikiClient().login()
 19 | t_shipskin = WikiHelper.MultilineTemplate('ShipSkin')
 20 | t_shipskin0 = WikiHelper.MultilineTemplate('ShipSkin0')
 21 | 
 22 | 
 23 | # get all skinids from all versions
 24 | skinids = dict()
 25 | for client in Client:
 26 | 	idlist = ship_skin_template._load("get_id_list_by_ship_group", client)
 27 | 	if idlist:
 28 | 		for groupid, shipskinids in idlist.items():
 29 | 			if groupid in skinids:
 30 | 				skinids[groupid].update(shipskinids)
 31 | 			else:
 32 | 				skinids[groupid] = set(shipskinids)
 33 | 
 34 | if not skinids:
 35 | 	for shipskindata in ship_skin_template.load_all(Client):
 36 | 		groupid = str(shipskindata.ship_group)
 37 | 		if groupid in skinids:
 38 | 			skinids[groupid].add(shipskindata.id)
 39 | 		else:
 40 | 			skinids[groupid] = {shipskindata.id}
 41 | 
 42 | 
 43 | def eval_counter(count_values: dict, val_check: Callable, error_msg: str) -> Any | None:
 44 | 	if count_values:
 45 | 		mc = Counter(count_values.values()).most_common()
 46 | 		if len(mc) > 1:
 47 | 			print(error_msg.format(count_values))
 48 | 
 49 | 		val = mc[0][0]
 50 | 		if val_check(val):
 51 | 			return val
 52 | 
 53 | 
 54 | def game_single_skin(fullid: int) -> dict:
 55 | 	"""
 56 | 	Returns a dict containing ONLY the important information of a single skin.
 57 | 	The keys are named after parameters complying with Template:ShipSkin for easy convertability.
 58 | 
 59 | 	:param fullid: A skinid from sharecfg/ship_skin_template
 60 | 	"""
 61 | 	skin_ret = dict()
 62 | 	
 63 | 	# additional objects to check if all clients actutally have the same values
 64 | 	background_counter = dict()
 65 | 	sp_background_counter = dict()
 66 | 	live2d_counter = dict()
 67 | 	cost_counter = dict()
 68 | 
 69 | 	for client in DEFAULT_CLIENTS:
 70 | 		gameskindata = ship_skin_template.load_client(fullid, client)
 71 | 		if not gameskindata: continue # continue with next client if this one does not have the skin
 72 | 
 73 | 		skin_ret['SkinID'] = gameskindata['group_index']
 74 | 
 75 | 		live2d_counter[client.name] = '1' if 1 in gameskindata['tag'] else None
 76 | 
 77 | 		# the following values are always not set for retrofit and default skins
 78 | 		if fullid % 10 in {0, 9}: continue
 79 | 
 80 | 		skin_ret['SkinName'+client.name] = api.replace_namecode(gameskindata['name'], client)
 81 | 		background_counter[client.name] = gameskindata['bg']
 82 | 		sp_background_counter[client.name] = gameskindata['bg_sp']
 83 | 		
 84 | 		# get shop data
 85 | 		shopid = gameskindata['shop_id']
 86 | 		if shopid != 0:
 87 | 			shopitem = shop_template.load_client(shopid, client)
 88 | 			if shopitem is not None:
 89 | 				cost_counter[client.name] = shopitem['resource_num']
 90 | 				if not shopitem['time'] == 'always':
 91 | 					skin_ret['Limited'+client.name] = '1'
 92 | 			else:
 93 | 				# if the skin has an invalid shopid, its very likely an error and that skin actually does not exist in that client
 94 | 				skin_ret.pop('SkinName'+client.name)
 95 | 
 96 | 	# check if all clients have the same info, if not use most common one
 97 | 	# background has empty string as its empty value
 98 | 	if bg := eval_counter(background_counter, (lambda v: v != ''), f'{fullid} has differing backgrounds: %s'):
 99 | 		skin_ret['Background'] = bg
100 | 
101 | 	# special background has empty string as its empty value
102 | 	if spbg := eval_counter(sp_background_counter, (lambda v: v != ''), f'{fullid} has differing special backgrounds: %s'):
103 | 		skin_ret['SpecialBackground'] = spbg
104 | 
105 | 	# live2d has empty string as its empty value
106 | 	if live2d := eval_counter(live2d_counter, (lambda v: v is not None), f'{fullid} has differing live2d info: %s'):
107 | 		skin_ret['Live2D'] = live2d
108 | 
109 | 	# cost has 0 as its empty value
110 | 	if cost := eval_counter(cost_counter, (lambda v: v != 0), f'{fullid} has differing shop cost: %s'):
111 | 		skin_ret['Cost'] = cost
112 | 
113 | 	return skin_ret
114 | 
115 | def game_skins(groupid: int) -> dict:
116 | 	"""
117 | 	Returns a dict containing ONLY the important information of all skins of a given ship.
118 | 	The keys are named after parameters complying with Template:ShipSkin for easy convertability.
119 | 
120 | 	:param groupid: the groupid identifying the ship
121 | 	"""
122 | 	skins = dict()
123 | 	for fullid in skinids[str(groupid)]:
124 | 		skindata = game_single_skin(fullid)
125 | 		skins[skindata['SkinID']] = skindata
126 | 	return skins
127 | 
128 | def wiki_skins(shipname: str, gallerypage = None) -> dict:
129 | 	"""
130 | 	Returns a dict containing all the parameters of all skins from a gallery page of a given ship
131 | 	and the additional art on the page.
132 | 
133 | 	:param shipname: name of the ship
134 | 	:param gallerypage: if the gallerypage is already loaded, it can be passed over
135 | 	"""
136 | 	if gallerypage is None: gallerypage = wikiclient.execute(wikiclient.mwclient.pages.get, shipname+'/Gallery')
137 | 	if not gallerypage.exists: return
138 | 
139 | 	skins = dict()
140 | 	mwparser = mwparserfromhell.parse(gallerypage.text())
141 | 	templates = mwparser.filter_templates()
142 | 	for template in templates:
143 | 		if not 'ShipSkin' in template.name: continue
144 | 		parsed_template = WikiHelper.parse_multiline_template(str(template))
145 | 		skinid_num = int(parsed_template.get('SkinID'))
146 | 		skins[skinid_num] = parsed_template
147 | 	
148 | 	# search for additional art/artwork
149 | 	additional_art = '' 
150 | 	found_addart = False
151 | 	for node in mwparser.nodes:
152 | 		nodename = str(node.lower())
153 | 		if 'additional art' in nodename or 'artwork' in nodename:
154 | 			found_addart = True
155 | 		if found_addart:
156 | 			additional_art += str(node)
157 | 	return skins, additional_art
158 | 
159 | 
160 | def update_gallery_page(shipname: str, save_to_file: bool = False, default_skincategory: str = '') -> bool:
161 | 	"""Updates the gallery page of a given ship.
162 | 
163 | 	:param shipname: the name of a ship used on the wiki
164 | 	:param save_to_file: outputs into a file in the /output directory instead of updating the wikipage
165 | 	:param default_skincategory: the default skincategory if new skins are found in the game files
166 | 	:return: true if update was successful, otherwise false
167 | 	"""
168 | 	groupid = ship_converter.get_groupid(shipname)
169 | 	if not groupid: raise ValueError(f'Shipname {shipname} does not lead to a valid groupid.')
170 | 
171 | 	# retrieve skins from wiki and game
172 | 	gallerypage = wikiclient.execute(wikiclient.mwclient.pages.get, shipname+'/Gallery')
173 | 	skins_game = game_skins(groupid)
174 | 	skins_wiki, additionalArt = wiki_skins(shipname, gallerypage) or ({}, '')
175 | 
176 | 	# merge game and wiki skin information with game overwriting wiki
177 | 	skins = dict()
178 | 	for skinid in set(skins_game.keys()) | set(skins_wiki.keys()):
179 | 		skin = skins_wiki.get(skinid, {})
180 | 		skin.update(skins_game.get(skinid, {}))
181 | 		skins[skinid] = skin
182 | 
183 | 	# generate wikitext
184 | 	wikitext = '{{ShipTabber}}\n{{#tag:tabber|'
185 | 	for skinid in chain([0,-1,9,8], range(1, 7+1), range(10,max(skins)+1)):
186 | 		if skinid not in skins: continue
187 | 		skin = skins[skinid]
188 | 
189 | 		# use default skincategory if skin has none or the value for it is already set empty
190 | 		if 'SkinCategory' not in skin or skin['SkinCategory'] == '':
191 | 			skin['SkinCategory'] = default_skincategory
192 | 		# only retrofit skin need a static skin category set
193 | 		if skinid == 9: skin['SkinCategory'] = 'Kai'
194 | 
195 | 		# append filled template to result wikitext (used template depends on skinid)
196 | 		if skinid == 0: wikitext += '\n'+t_shipskin0.fill(skin)
197 | 		else: wikitext += '\n'+t_shipskin.fill(skin)
198 | 	
199 | 	wikitext += '\n}}' # close tabber
200 | 	if additionalArt: wikitext += f'\n\n{additionalArt}' # also add additional art at the end
201 | 
202 | 	if save_to_file:
203 | 		#save wikitext to file
204 | 		Utility.output(wikitext, Path("output", "skins", shipname + ".wikitext"))
205 | 		sleep(1)
206 | 	else:
207 | 		# update gallerypage on the wiki
208 | 		summary = 'Added missing skins/updated changed information' if gallerypage.exists else 'Created gallery page'
209 | 		gallerypage.save(wikitext, summary=summary)
210 | 		sleep(2)
211 | 	return True
212 | 
213 | 
214 | def main():
215 | 	update_gallery_page("Ayanami", save_to_file=True)
216 | 	"""
217 | 	_MANUAL_OVERRIDES = {
218 | 		"fuxu": ("Foch", ""),
219 | 		"fuxu_2": ("Foch", "Casual"),
220 | 		"ougen_5": ("Prinz Eugen", "RaceQueen"),
221 | 		"qiye_7": ("Enterprise", "RaceQueen"),
222 | 	}
223 | 
224 | 	ships = {}
225 | 	for name, cat in _MANUAL_OVERRIDES.values():
226 | 		if not name in ships or cat:
227 | 			ships[name] = cat
228 | 
229 | 	for shipname, defcat in ships.items():
230 | 		print(f'Updating {shipname}...')
231 | 		success = update_gallery_page(shipname, default_skincategory=defcat, save_to_file=True)
232 | 		if not success: print('An error occured.')
233 | 	"""
234 | 
235 | if __name__ == "__main__":
236 | 	main()
237 | 


--------------------------------------------------------------------------------
/PythonScripts/story.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | import json
  3 | from pathlib import Path
  4 | from argparse import ArgumentParser
  5 | 
  6 | from lib import Client, ALJsonAPI, WikiHelper, Utility, DEFAULT_CLIENTS
  7 | 
  8 | 
  9 | api = ALJsonAPI()
 10 | memory_group = api.get_sharecfgmodule("memory_group")
 11 | memory_template = api.get_sharecfgmodule("memory_template")
 12 | ship_skin_template = api.get_sharecfgmodule("ship_skin_template")
 13 | STORY_TEMPLATE = WikiHelper.MultilineTemplate('Story')
 14 | 
 15 | with open(Path('data', 'ship_painting_convert.json'), 'r', encoding='utf8') as f:
 16 | 	SHIP_PAINTING_NAMES = json.load(f)
 17 | 
 18 | tabber_name = {
 19 | 	Client.EN: "English",
 20 | 	Client.CN: "Chinese",
 21 | 	Client.JP: "Japanese",
 22 | }
 23 | 
 24 | 
 25 | HTML_TAG = re.compile(r"<[^>]*>")
 26 | def sanitize(v: str) -> str:
 27 | 	return HTML_TAG.sub("", v).strip()
 28 | 
 29 | def sanitize_w_namecode(v: str, client: Client) -> str:
 30 | 	return api.replace_namecode(sanitize(v), client)
 31 | 
 32 | def actor(atype, name, skincat, nameoverride, skinname):
 33 | 	res = f"{atype}:{name}/{skincat}:{nameoverride}"
 34 | 	return res.strip(":").strip("/").strip(":")
 35 | 
 36 | def story(storyname: str, client: Client):
 37 | 	lines_result = []
 38 | 
 39 | 	storydata = api.loader.load_story(storyname.lower(), client)
 40 | 	for story_segment in storydata['scripts']:
 41 | 		if 'say' in story_segment:
 42 | 			actorstr = ''
 43 | 			if 'actor' in story_segment:
 44 | 				actorid = story_segment['actor']
 45 | 				if actorid > 0:
 46 | 					actor_skindata = ship_skin_template.load_client(actorid, client)
 47 | 					actor_painting = actor_skindata['painting']
 48 | 					skinname = actor_skindata['name'].strip().replace('μ', 'µ')
 49 | 					if actor_painting in SHIP_PAINTING_NAMES:
 50 | 						pcn = SHIP_PAINTING_NAMES[actor_painting]
 51 | 						shipname = pcn['shipname']
 52 | 						category = pcn['category']
 53 | 						if shipname == skinname: skinname = ""
 54 | 						actorstr = actor("S", shipname, category, "", skinname)
 55 | 					else:
 56 | 						actorstr = "O:"+actor_skindata['name'].strip()
 57 | 				else: raise NotImplementedError('Unsupported ActorID')
 58 | 
 59 | 			optionstr = ''
 60 | 			if 'optionFlag' in story_segment:
 61 | 				optionstr = f"'''If Option {story_segment['optionFlag']}:''' "
 62 | 
 63 | 			lines_result.append(f"[{actorstr}] {optionstr}"+sanitize_w_namecode(story_segment['say'], client))
 64 | 		if 'sequence' in story_segment:
 65 | 			sequence_sanitized = [sanitize_w_namecode(line[0], client) for line in story_segment['sequence']]
 66 | 			sequence_text = "<br>".join(sequence_sanitized)
 67 | 			lines_result.append("[] "+sequence_text)
 68 | 
 69 | 		if 'options' in story_segment:
 70 | 			option_sanitized = [f"'''Option {line['flag']}:''' "+sanitize_w_namecode(line['content'], client) for line in story_segment['options']]
 71 | 			option_text = "<br>".join(option_sanitized)
 72 | 			lines_result.append("[O:Commander] "+option_text)
 73 | 
 74 | 	return lines_result
 75 | 
 76 | def memory(memoryid: int | str, client: Client):
 77 | 	memory_data = memory_template.load_client(memoryid, client)
 78 | 	story_lines = story(memory_data['story'], client)
 79 | 
 80 | 	template_params = {
 81 | 		"Title": memory_data['title'],
 82 | 		"Unlock": memory_data['condition'],
 83 | 		"Language": client.name,
 84 | 	}
 85 | 	story_lines = "\n | ".join(story_lines)
 86 | 	template_params['Language'] += "\n | "+story_lines
 87 | 	return STORY_TEMPLATE.fill(template_params)
 88 | 
 89 | def memorygroup(memorygroup_id: int | str, client: Client):
 90 | 	memorygroup_data = memory_group.load_client(memorygroup_id, client)
 91 | 	memory_collection = [f'Chapter {i}=\n'+memory(memoryid, client) for i, memoryid in enumerate(memorygroup_data['memories'], 1)]
 92 | 	return tabber_name[client] + " Story=\n<tabber>\n" + "\n|-|\n".join(memory_collection) + "\n</tabber>"
 93 | 
 94 | 
 95 | def main():
 96 | 	parser = ArgumentParser()
 97 | 	parser.add_argument('memoryid', metavar='INDEX', type=int,
 98 | 						help='an index from sharecfg/memory_template')
 99 | 	args = parser.parse_args()
100 | 
101 | 	TITLE = "Tower of Transcendence"
102 | 	clients_result = [memorygroup(args.memoryid, client) for client in DEFAULT_CLIENTS]
103 | 
104 | 	wikitext = [
105 | 		"{{#tag:tabber|",
106 | 		"\n{{!}}-{{!}}\n".join(clients_result),
107 | 		"}}",
108 | 		"{{StoryList}}",
109 | 		f"[[Category:Memories|{TITLE}]]",
110 | 		f"[[Category:Major Event Memories|{TITLE}]]",
111 | 	]
112 | 	Utility.output("\n".join(wikitext))
113 | 
114 | if __name__ == "__main__":
115 | 	main()
116 | 


--------------------------------------------------------------------------------
/PythonScripts/templates/Equipment.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"template_name": "Equipment",
  3 | 	"template_sections": {
  4 | 		"comment": "",
  5 | 		"sections": [
  6 | 			{
  7 | 				"comment": "<!-- General Data -->",
  8 | 				"params": ["Name", "AltNames", "CNName", "JPName", "KRName", "ENName", "Image", "BaseID", "Type", "Stars", "Nationality", "Tech"]
  9 | 			},
 10 | 			{
 11 | 				"comment": "<!-- Ship Stats Modifier -->",
 12 | 				"params": ["Health", "HealthMax", "HealthOPS", "Torpedo", "TorpMax", "TorpOPS", "Firepower", "FPMax", "FPOPS", "Aviation", "AvMax", "AvOPS", "Evasion", "EvasionMax", "EvasionOPS", "ASW", "ASWMax", "ASWOPS", "Oxygen", "OxygenMax", "OxygenOPS", "AA", "AAMax", "AAOPS", "Acc", "AccMax", "AccOPS", "Spd", "SpdMax", "SpdOPS", "Luck", "LuckMax", "LuckOPS", "Reload", "ReloadMax", "ReloadOPS"]
 13 | 			},
 14 | 			{
 15 | 				"comment": "<!-- Equipment Stats -->",
 16 | 				"sections": [
 17 | 					{
 18 | 						"comment": "",
 19 | 						"params": ["Damage", "DamageMax", "DamageOPS", "RoF", "RoFMax", "RoFOPS", "Int", "IntMax", "IntOPS", "Number", "Angle", "WepRangeMin", "WepRange", "ProjRange", "ProjSpeed", "Spread", "FiringSpread", "PatternSpread", "Coef", "CoefMax", "ArmorModL", "ArmorModM", "ArmorModH", "PlaneHP", "PlaneHPMax", "PlaneHPOPS", "OpSiren", "Shells", "Salvoes", "VolleyTime", "Characteristic", "PlaneSpeed", "CrashDamage", "DodgeLimit", "PlaneDodge"]
 20 | 					},
 21 | 					{
 22 | 						"comment": "",
 23 | 						"params": ["Ammo", "AoE", "Weapons"]
 24 | 					}
 25 | 				]
 26 | 			},
 27 | 			{
 28 | 				"comment": "<!-- Usability -->",
 29 | 				"sections": [
 30 | 					{
 31 | 						"comment": "",
 32 | 						"params": ["UseOverride", "DD", "DDNote", "CL", "CLNote", "CA", "CANote", "CB", "CBNote", "BB", "BBNote", "BC", "BCNote", "BM", "BMNote", "BBV", "BBVNote", "CV", "CVNote", "CVL", "CVLNote", "AR", "ARNote", "AE", "AENote", "SS", "SSNote", "SSV", "SSVNote", "IX", "IXNote", "IXs", "IXsNote", "IXv", "IXvNote", "IXm", "IXmNote"]
 33 | 					}
 34 | 				]
 35 | 			},
 36 | 			{
 37 | 				"comment": "<!-- Notes -->",
 38 | 				"sections": [
 39 | 					{
 40 | 						"comment": "",
 41 | 						"params": ["DropLocation", "BulletPattern", "Notes", "Research", "LabFrom", "LabTo"]
 42 | 					}
 43 | 				]
 44 | 			}
 45 | 		]
 46 | 	},
 47 | 	"behavior": {
 48 | 		"default": {
 49 | 			"type": "remove_empty"
 50 | 		},
 51 | 		"Name": {
 52 | 			"type": "keep"
 53 | 		},
 54 | 		"CNName": {
 55 | 			"type": "keep"
 56 | 		},
 57 | 		"JPName": {
 58 | 			"type": "keep"
 59 | 		},
 60 | 		"Image": {
 61 | 			"type": "keep"
 62 | 		},
 63 | 		"BaseID": {
 64 | 			"type": "keep"
 65 | 		},
 66 | 		"Type": {
 67 | 			"type": "keep"
 68 | 		},
 69 | 		"Stars": {
 70 | 			"type": "keep"
 71 | 		},
 72 | 		"Nationality": {
 73 | 			"type": "keep"
 74 | 		},
 75 | 		"Tech": {
 76 | 			"type": "keep"
 77 | 		},
 78 | 		"DamageMax": {
 79 | 			"type": "dependency",
 80 | 			"dependency": {
 81 | 				"type": "keep_empty",
 82 | 				"dependent_params": ["Damage"]
 83 | 			}
 84 | 		},
 85 | 		"RoF": {
 86 | 			"type": "remove_empty"
 87 | 		},
 88 | 		"RoFMax": {
 89 | 			"type": "remove_empty"
 90 | 		},
 91 | 		"Spread": {
 92 | 			"type": "remove_empty"
 93 | 		},
 94 | 		"Angle": {
 95 | 			"type": "remove_empty"
 96 | 		},
 97 | 		"WepRange": {
 98 | 			"type": "remove_empty"
 99 | 		},
100 | 		"ProjRange": {
101 | 			"type": "remove_empty"
102 | 		},
103 | 		"Shells": {
104 | 			"type": "remove_empty"
105 | 		},
106 | 		"Salvoes": {
107 | 			"type": "remove_empty"
108 | 		},
109 | 		"Characteristic": {
110 | 			"type": "remove_empty"
111 | 		},
112 | 		"VolleyTime": {
113 | 			"type": "remove_empty"
114 | 		},
115 | 		"Coef": {
116 | 			"type": "remove_empty"
117 | 		},
118 | 		"CoefMax": {
119 | 			"type": "remove_empty"
120 | 		},
121 | 		"ArmorModL": {
122 | 			"type": "remove_empty"
123 | 		},
124 | 		"ArmorModM": {
125 | 			"type": "remove_empty"
126 | 		},
127 | 		"ArmorModH": {
128 | 			"type": "remove_empty"
129 | 		},
130 | 		"Ammo": {
131 | 			"type": "remove_empty"
132 | 		},
133 | 		"DropLocation": {
134 | 			"type": "keep"
135 | 		},
136 | 		"Notes": {
137 | 			"type": "keep"
138 |    	 	}
139 | 	},
140 | 	"prefer-wiki-data": []
141 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/EventShop.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "EventShop",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "",
 8 | 				"params": ["ShopName", "TotalPt", "PtImage"]
 9 | 			},
10 | 			{
11 | 				"comment": "",
12 | 				"params": ["ColorScheme", "Image", "Size", "Top", "Left"]
13 | 			},
14 | 			{
15 | 				"comment": "",
16 | 				"params": ["Items"]
17 | 			}
18 | 		]
19 | 	},
20 | 	"behavior": {
21 | 		"default": {
22 | 			"type": "keep"
23 | 		}
24 | 	},
25 | 	"prefer-wiki-data": []
26 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/Juustagram.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "Juustagram",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "",
 8 | 				"params": ["pict", "post"]
 9 | 			}
10 | 		]
11 | 	},
12 | 	"behavior": {
13 | 		"default": {
14 | 			"type": "keep"
15 | 		}
16 | 	},
17 | 	"prefer-wiki-data": []
18 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/Map.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "Map",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "<!-- General Information -->",
 8 | 				"params": ["ctID", "Title", "Introduction", "Requirements", "ClearReward", "3StarReward"]
 9 | 			},
10 | 			{
11 | 				"comment": "<!-- Enemy Fleet Information -->",
12 | 				"params": ["MobLevel", "SirenLevel", "MobExp1", "MobExp2", "MobExp3", "MobExpSiren", "MobSpawnOrder", "EliteSpawnOrder", "SirenSpawnOrder", "Boss", "BossLevel", "BossExp"]
13 | 			},
14 | 			{
15 | 				"comment": "<!-- Stage Information -->",
16 | 				"params": ["BossBattleReq", "BossBattleClear", "Star1", "Star2", "Star3", "AvoidRequire", "SuggestedAirSupremacy", "ActualAirSupremacy", "OilCapMob", "OilCapBoss", "OilCapSub"]
17 | 			},
18 | 			{
19 | 				"comment": "<!-- Hardmode Restrictions -->",
20 | 				"params": ["Fleet1", "Fleet2", "StatRestrictions"]
21 | 			},
22 | 			{
23 | 				"comment": "<!-- Stage Drop Information, Node Map and Notes -->",
24 | 				"params": ["MapDrops", "EquipmentDrops", "ShipDrops", "PreviewFile", "NodeMap", "Notes"]
25 | 			}
26 | 		]
27 | 	},
28 | 	"behavior": {
29 | 		"default": {
30 | 			"type": "remove_empty"
31 | 		}
32 | 	},
33 | 	"prefer-wiki-data": []
34 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/Mission.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "Mission",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "",
 8 | 				"params": ["descen", "reward", "notes"]
 9 | 			}
10 | 		]
11 | 	},
12 | 	"behavior": {
13 | 		"default": {
14 | 			"type": "remove_empty"
15 | 		}
16 | 	},
17 | 	"prefer-wiki-data": []
18 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/MissionDouble.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "MissionDouble",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "",
 8 | 				"params": ["descen1", "descen2", "reward1", "reward2", "notes"]
 9 | 			}
10 | 		]
11 | 	},
12 | 	"behavior": {
13 | 		"default": {
14 | 			"type": "remove_empty"
15 | 		}
16 | 	},
17 | 	"prefer-wiki-data": []
18 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/ShipQuote.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"template_name": "ShipQuote",
  3 | 	"template_sections": {
  4 | 		"comment": "",
  5 | 		"sections": [
  6 | 			{
  7 | 				"comment": "",
  8 | 				"params": ["Region", "Voice", "Skin"]
  9 | 			},
 10 | 			{
 11 | 				"comment": "",
 12 | 				"params": ["ShipDescription", "ShipDescriptionTL", "ShipDescriptionNote"]
 13 | 			},
 14 | 			{
 15 | 				"comment": "",
 16 | 				"params": ["SelfIntro", "SelfIntroTL", "SelfIntroNote"]
 17 | 			},
 18 | 			{
 19 | 				"comment": "",
 20 | 				"params": ["Acquisition", "AcquisitionTL", "AcquisitionNote"]
 21 | 			},
 22 | 			{
 23 | 				"comment": "",
 24 | 				"params": ["Login", "LoginTL", "LoginNote"]
 25 | 			},
 26 | 			{
 27 | 				"comment": "",
 28 | 				"params": ["Details", "DetailsTL", "DetailsNote"]
 29 | 			},
 30 | 			{
 31 | 				"comment": "",
 32 | 				"params": ["SecretaryIdle1", "SecretaryIdle1TL", "SecretaryIdle1Note"]
 33 | 			},
 34 | 			{
 35 | 				"comment": "",
 36 | 				"params": ["SecretaryIdle2", "SecretaryIdle2TL", "SecretaryIdle2Note"]
 37 | 			},
 38 | 			{
 39 | 				"comment": "",
 40 | 				"params": ["SecretaryIdle3", "SecretaryIdle3TL", "SecretaryIdle3Note"]
 41 | 			},
 42 | 			{
 43 | 				"comment": "",
 44 | 				"params": ["SecretaryIdle4", "SecretaryIdle4TL", "SecretaryIdle4Note"]
 45 | 			},
 46 | 			{
 47 | 				"comment": "",
 48 | 				"params": ["SecretaryIdle5", "SecretaryIdle5TL", "SecretaryIdle5Note"]
 49 | 			},
 50 | 			{
 51 | 				"comment": "",
 52 | 				"params": ["SecretaryIdle6", "SecretaryIdle6TL", "SecretaryIdle6Note"]
 53 | 			},
 54 | 			{
 55 | 				"comment": "",
 56 | 				"params": ["SecretaryIdle7", "SecretaryIdle7TL", "SecretaryIdle7Note"]
 57 | 			},
 58 | 			{
 59 | 				"comment": "",
 60 | 				"params": ["SecretaryIdle8", "SecretaryIdle8TL", "SecretaryIdle8Note"]
 61 | 			},
 62 | 			{
 63 | 				"comment": "",
 64 | 				"params": ["SecretaryTouch", "SecretaryTouchTL", "SecretaryTouchNote"]
 65 | 			},
 66 | 			{
 67 | 				"comment": "",
 68 | 				"params": ["SpecialTouch", "SpecialTouchTL", "SpecialTouchNote"]
 69 | 			},
 70 | 			{
 71 | 				"comment": "",
 72 | 				"params": ["Headpat", "HeadpatTL", "HeadpatNote"]
 73 | 			},
 74 | 			{
 75 | 				"comment": "",
 76 | 				"params": ["Task", "TaskTL", "TaskNote"]
 77 | 			},
 78 | 			{
 79 | 				"comment": "",
 80 | 				"params": ["TaskComplete", "TaskCompleteTL", "TaskCompleteNote"]
 81 | 			},
 82 | 			{
 83 | 				"comment": "",
 84 | 				"params": ["Mail", "MailTL", "MailNote"]
 85 | 			},
 86 | 			{
 87 | 				"comment": "",
 88 | 				"params": ["MissionFinished", "MissionFinishedTL", "MissionFinishedNote"]
 89 | 			},
 90 | 			{
 91 | 				"comment": "",
 92 | 				"params": ["Commission", "CommissionTL", "CommissionNote"]
 93 | 			},
 94 | 			{
 95 | 				"comment": "",
 96 | 				"params": ["Strengthening", "StrengtheningTL", "StrengtheningNote"]
 97 | 			},
 98 | 			{
 99 | 				"comment": "",
100 | 				"params": ["MissionStart", "MissionStartTL", "MissionStartNote"]
101 | 			},
102 | 			{
103 | 				"comment": "",
104 | 				"params": ["MVP", "MVPTL", "MVPNote"]
105 | 			},
106 | 			{
107 | 				"comment": "",
108 | 				"params": ["Defeat", "DefeatTL", "DefeatNote"]
109 | 			},
110 | 			{
111 | 				"comment": "",
112 | 				"params": ["SkillActivation", "SkillActivationTL", "SkillActivationNote"]
113 | 			},
114 | 			{
115 | 				"comment": "",
116 | 				"params": ["LowHP", "LowHPTL", "LowHPNote"]
117 | 			},
118 | 			{
119 | 				"comment": "",
120 | 				"params": ["AffinityDisappointed", "AffinityDisappointedTL", "AffinityDisappointedNote"]
121 | 			},
122 | 			{
123 | 				"comment": "",
124 | 				"params": ["AffinityStranger", "AffinityStrangerTL", "AffinityStrangerNote"]
125 | 			},
126 | 			{
127 | 				"comment": "",
128 | 				"params": ["AffinityFriendly", "AffinityFriendlyTL", "AffinityFriendlyNote"]
129 | 			},
130 | 			{
131 | 				"comment": "",
132 | 				"params": ["AffinityLike", "AffinityLikeTL", "AffinityLikeNote"]
133 | 			},
134 | 			{
135 | 				"comment": "",
136 | 				"params": ["AffinityLove", "AffinityLoveTL", "AffinityLoveNote"]
137 | 			},
138 | 			{
139 | 				"comment": "",
140 | 				"params": ["Pledge", "PledgeTL", "PledgeNote"]
141 | 			},
142 | 			{
143 | 				"comment": "",
144 | 				"params": ["Additional1", "Additional1TL", "Additional1Note"]
145 | 			},
146 | 			{
147 | 				"comment": "",
148 | 				"params": ["Additional2", "Additional2TL", "Additional2Note"]
149 | 			},
150 | 			{
151 | 				"comment": "",
152 | 				"params": ["Additional3", "Additional3TL", "Additional3Note"]
153 | 			},
154 | 			{
155 | 				"comment": "",
156 | 				"params": ["Additional4", "Additional4TL", "Additional4Note"]
157 | 			},
158 | 			{
159 | 				"comment": "",
160 | 				"params": ["Additional5", "Additional5TL", "Additional5Note"]
161 | 			},
162 | 			{
163 | 				"comment": "",
164 | 				"params": ["Additional6", "Additional6TL", "Additional6Note"]
165 | 			},
166 | 			{
167 | 				"comment": "",
168 | 				"params": ["Additional7", "Additional7TL", "Additional7Note"]
169 | 			},
170 | 			{
171 | 				"comment": "",
172 | 				"params": ["Additional8", "Additional8TL", "Additional8Note"]
173 | 			},
174 | 			{
175 | 				"comment": "",
176 | 				"params": ["Additional9", "Additional9TL", "Additional9Note"]
177 | 			},
178 | 			{
179 | 				"comment": "",
180 | 				"params": ["Additional10", "Additional10TL", "Additional10Note"]
181 | 			},
182 | 			{
183 | 				"comment": "",
184 | 				"params": ["Additional11", "Additional11TL", "Additional11Note"]
185 | 			},
186 | 			{
187 | 				"comment": "",
188 | 				"params": ["Additional12", "Additional12TL", "Additional12Note"]
189 | 			},
190 | 			{
191 | 				"comment": "",
192 | 				"params": ["Valentine18", "Valentine18TL", "Valentine18Note"]
193 | 			},
194 | 			{
195 | 				"comment": "",
196 | 				"params": ["Valentine19", "Valentine19TL", "Valentine19Note"]
197 | 			},
198 | 			{
199 | 				"comment": "",
200 | 				"params": ["Valentine20", "Valentine20TL", "Valentine20Note"]
201 | 			}
202 | 		]
203 | 	},
204 | 	"behavior": {
205 | 		"default": {
206 | 			"type": "remove_empty"
207 | 		},
208 | 		"Region": {
209 | 			"type": "keep"
210 | 		},
211 | 		"Skin": {
212 | 			"type": "keep"
213 | 		},
214 | 		"ShipDescriptionTL": {
215 | 			"type": "dependency",
216 | 			"dependency": {
217 | 				"type": "keep_always",
218 | 				"dependent_params": ["ShipDescription"]
219 | 			}
220 | 		},
221 | 		"ShipDescriptionNote": {
222 | 			"type": "dependency",
223 | 			"dependency": {
224 | 				"type": "keep_always",
225 | 				"dependent_params": ["ShipDescription"]
226 | 			}
227 | 		},
228 | 		"SelfIntroTL": {
229 | 			"type": "dependency",
230 | 			"dependency": {
231 | 				"type": "keep_always",
232 | 				"dependent_params": ["SelfIntro"]
233 | 			}
234 | 		},
235 | 		"SelfIntroNote": {
236 | 			"type": "dependency",
237 | 			"dependency": {
238 | 				"type": "keep_always",
239 | 				"dependent_params": ["SelfIntro"]
240 | 			}
241 | 		},
242 | 		"AcquisitionTL": {
243 | 			"type": "dependency",
244 | 			"dependency": {
245 | 				"type": "keep_always",
246 | 				"dependent_params": ["Acquisition"]
247 | 			}
248 | 		},
249 | 		"AcquisitionNote": {
250 | 			"type": "dependency",
251 | 			"dependency": {
252 | 				"type": "keep_always",
253 | 				"dependent_params": ["Acquisition"]
254 | 			}
255 | 		},
256 | 		"LoginTL": {
257 | 			"type": "dependency",
258 | 			"dependency": {
259 | 				"type": "keep_always",
260 | 				"dependent_params": ["Login"]
261 | 			}
262 | 		},
263 | 		"LoginNote": {
264 | 			"type": "dependency",
265 | 			"dependency": {
266 | 				"type": "keep_always",
267 | 				"dependent_params": ["Login"]
268 | 			}
269 | 		},
270 | 		"DetailsTL": {
271 | 			"type": "dependency",
272 | 			"dependency": {
273 | 				"type": "keep_always",
274 | 				"dependent_params": ["Details"]
275 | 			}
276 | 		},
277 | 		"DetailsNote": {
278 | 			"type": "dependency",
279 | 			"dependency": {
280 | 				"type": "keep_always",
281 | 				"dependent_params": ["Details"]
282 | 			}
283 | 		},
284 | 		"SecretaryIdle1TL": {
285 | 			"type": "dependency",
286 | 			"dependency": {
287 | 				"type": "keep_always",
288 | 				"dependent_params": ["SecretaryIdle1"]
289 | 			}
290 | 		},
291 | 		"SecretaryIdle1Note": {
292 | 			"type": "dependency",
293 | 			"dependency": {
294 | 				"type": "keep_always",
295 | 				"dependent_params": ["SecretaryIdle1"]
296 | 			}
297 | 		},
298 | 		"SecretaryIdle2TL": {
299 | 			"type": "dependency",
300 | 			"dependency": {
301 | 				"type": "keep_always",
302 | 				"dependent_params": ["SecretaryIdle2"]
303 | 			}
304 | 		},
305 | 		"SecretaryIdle2Note": {
306 | 			"type": "dependency",
307 | 			"dependency": {
308 | 				"type": "keep_always",
309 | 				"dependent_params": ["SecretaryIdle2"]
310 | 			}
311 | 		},
312 | 		"SecretaryIdle3TL": {
313 | 			"type": "dependency",
314 | 			"dependency": {
315 | 				"type": "keep_always",
316 | 				"dependent_params": ["SecretaryIdle3"]
317 | 			}
318 | 		},
319 | 		"SecretaryIdle3Note": {
320 | 			"type": "dependency",
321 | 			"dependency": {
322 | 				"type": "keep_always",
323 | 				"dependent_params": ["SecretaryIdle3"]
324 | 			}
325 | 		},
326 | 		"SecretaryIdle4TL": {
327 | 			"type": "dependency",
328 | 			"dependency": {
329 | 				"type": "keep_always",
330 | 				"dependent_params": ["SecretaryIdle4"]
331 | 			}
332 | 		},
333 | 		"SecretaryIdle4Note": {
334 | 			"type": "dependency",
335 | 			"dependency": {
336 | 				"type": "keep_always",
337 | 				"dependent_params": ["SecretaryIdle4"]
338 | 			}
339 | 		},
340 | 		"SecretaryIdle5TL": {
341 | 			"type": "dependency",
342 | 			"dependency": {
343 | 				"type": "keep_always",
344 | 				"dependent_params": ["SecretaryIdle5"]
345 | 			}
346 | 		},
347 | 		"SecretaryIdle5Note": {
348 | 			"type": "dependency",
349 | 			"dependency": {
350 | 				"type": "keep_always",
351 | 				"dependent_params": ["SecretaryIdle5"]
352 | 			}
353 | 		},
354 | 		"SecretaryIdle6TL": {
355 | 			"type": "dependency",
356 | 			"dependency": {
357 | 				"type": "keep_always",
358 | 				"dependent_params": ["SecretaryIdle6"]
359 | 			}
360 | 		},
361 | 		"SecretaryIdle6Note": {
362 | 			"type": "dependency",
363 | 			"dependency": {
364 | 				"type": "keep_always",
365 | 				"dependent_params": ["SecretaryIdle6"]
366 | 			}
367 | 		},
368 | 		"SecretaryIdle7TL": {
369 | 			"type": "dependency",
370 | 			"dependency": {
371 | 				"type": "keep_always",
372 | 				"dependent_params": ["SecretaryIdle7"]
373 | 			}
374 | 		},
375 | 		"SecretaryIdle7Note": {
376 | 			"type": "dependency",
377 | 			"dependency": {
378 | 				"type": "keep_always",
379 | 				"dependent_params": ["SecretaryIdle7"]
380 | 			}
381 | 		},
382 | 		"SecretaryIdle8TL": {
383 | 			"type": "dependency",
384 | 			"dependency": {
385 | 				"type": "keep_always",
386 | 				"dependent_params": ["SecretaryIdle8"]
387 | 			}
388 | 		},
389 | 		"SecretaryIdle8Note": {
390 | 			"type": "dependency",
391 | 			"dependency": {
392 | 				"type": "keep_always",
393 | 				"dependent_params": ["SecretaryIdle8"]
394 | 			}
395 | 		},
396 | 		"SecretaryTouchTL": {
397 | 			"type": "dependency",
398 | 			"dependency": {
399 | 				"type": "keep_always",
400 | 				"dependent_params": ["SecretaryTouch"]
401 | 			}
402 | 		},
403 | 		"SecretaryTouchNote": {
404 | 			"type": "dependency",
405 | 			"dependency": {
406 | 				"type": "keep_always",
407 | 				"dependent_params": ["SecretaryTouch"]
408 | 			}
409 | 		},
410 | 		"SpecialTouchTL": {
411 | 			"type": "dependency",
412 | 			"dependency": {
413 | 				"type": "keep_always",
414 | 				"dependent_params": ["SpecialTouch"]
415 | 			}
416 | 		},
417 | 		"SpecialTouchNote": {
418 | 			"type": "dependency",
419 | 			"dependency": {
420 | 				"type": "keep_always",
421 | 				"dependent_params": ["SpecialTouch"]
422 | 			}
423 | 		},
424 | 		"HeadpatTL": {
425 | 			"type": "dependency",
426 | 			"dependency": {
427 | 				"type": "keep_always",
428 | 				"dependent_params": ["Headpat"]
429 | 			}
430 | 		},
431 | 		"HeadpatNote": {
432 | 			"type": "dependency",
433 | 			"dependency": {
434 | 				"type": "keep_always",
435 | 				"dependent_params": ["Headpat"]
436 | 			}
437 | 		},
438 | 		"TaskTL": {
439 | 			"type": "dependency",
440 | 			"dependency": {
441 | 				"type": "keep_always",
442 | 				"dependent_params": ["Task"]
443 | 			}
444 | 		},
445 | 		"TaskNote": {
446 | 			"type": "dependency",
447 | 			"dependency": {
448 | 				"type": "keep_always",
449 | 				"dependent_params": ["Task"]
450 | 			}
451 | 		},
452 | 		"TaskCompleteTL": {
453 | 			"type": "dependency",
454 | 			"dependency": {
455 | 				"type": "keep_always",
456 | 				"dependent_params": ["TaskComplete"]
457 | 			}
458 | 		},
459 | 		"TaskCompleteNote": {
460 | 			"type": "dependency",
461 | 			"dependency": {
462 | 				"type": "keep_always",
463 | 				"dependent_params": ["TaskComplete"]
464 | 			}
465 | 		},
466 | 		"MailTL": {
467 | 			"type": "dependency",
468 | 			"dependency": {
469 | 				"type": "keep_always",
470 | 				"dependent_params": ["Mail"]
471 | 			}
472 | 		},
473 | 		"MailNote": {
474 | 			"type": "dependency",
475 | 			"dependency": {
476 | 				"type": "keep_always",
477 | 				"dependent_params": ["Mail"]
478 | 			}
479 | 		},
480 | 		"MissionFinishedTL": {
481 | 			"type": "dependency",
482 | 			"dependency": {
483 | 				"type": "keep_always",
484 | 				"dependent_params": ["MissionFinished"]
485 | 			}
486 | 		},
487 | 		"MissionFinishedNote": {
488 | 			"type": "dependency",
489 | 			"dependency": {
490 | 				"type": "keep_always",
491 | 				"dependent_params": ["MissionFinished"]
492 | 			}
493 | 		},
494 | 		"CommissionTL": {
495 | 			"type": "dependency",
496 | 			"dependency": {
497 | 				"type": "keep_always",
498 | 				"dependent_params": ["Commission"]
499 | 			}
500 | 		},
501 | 		"CommissionNote": {
502 | 			"type": "dependency",
503 | 			"dependency": {
504 | 				"type": "keep_always",
505 | 				"dependent_params": ["Commission"]
506 | 			}
507 | 		},
508 | 		"StrengtheningTL": {
509 | 			"type": "dependency",
510 | 			"dependency": {
511 | 				"type": "keep_always",
512 | 				"dependent_params": ["Strengthening"]
513 | 			}
514 | 		},
515 | 		"StrengtheningNote": {
516 | 			"type": "dependency",
517 | 			"dependency": {
518 | 				"type": "keep_always",
519 | 				"dependent_params": ["Strengthening"]
520 | 			}
521 | 		},
522 | 		"MissionStartTL": {
523 | 			"type": "dependency",
524 | 			"dependency": {
525 | 				"type": "keep_always",
526 | 				"dependent_params": ["MissionStart"]
527 | 			}
528 | 		},
529 | 		"MissionStartNote": {
530 | 			"type": "dependency",
531 | 			"dependency": {
532 | 				"type": "keep_always",
533 | 				"dependent_params": ["MissionStart"]
534 | 			}
535 | 		},
536 | 		"MVPTL": {
537 | 			"type": "dependency",
538 | 			"dependency": {
539 | 				"type": "keep_always",
540 | 				"dependent_params": ["MVP"]
541 | 			}
542 | 		},
543 | 		"MVPNote": {
544 | 			"type": "dependency",
545 | 			"dependency": {
546 | 				"type": "keep_always",
547 | 				"dependent_params": ["MVP"]
548 | 			}
549 | 		},
550 | 		"DefeatTL": {
551 | 			"type": "dependency",
552 | 			"dependency": {
553 | 				"type": "keep_always",
554 | 				"dependent_params": ["Defeat"]
555 | 			}
556 | 		},
557 | 		"DefeatNote": {
558 | 			"type": "dependency",
559 | 			"dependency": {
560 | 				"type": "keep_always",
561 | 				"dependent_params": ["Defeat"]
562 | 			}
563 | 		},
564 | 		"SkillActivationTL": {
565 | 			"type": "dependency",
566 | 			"dependency": {
567 | 				"type": "keep_always",
568 | 				"dependent_params": ["SkillActivation"]
569 | 			}
570 | 		},
571 | 		"SkillActivationNote": {
572 | 			"type": "dependency",
573 | 			"dependency": {
574 | 				"type": "keep_always",
575 | 				"dependent_params": ["SkillActivation"]
576 | 			}
577 | 		},
578 | 		"LowHPTL": {
579 | 			"type": "dependency",
580 | 			"dependency": {
581 | 				"type": "keep_always",
582 | 				"dependent_params": ["LowHP"]
583 | 			}
584 | 		},
585 | 		"LowHPNote": {
586 | 			"type": "dependency",
587 | 			"dependency": {
588 | 				"type": "keep_always",
589 | 				"dependent_params": ["LowHP"]
590 | 			}
591 | 		},
592 | 		"AffinityDisappointedTL": {
593 | 			"type": "dependency",
594 | 			"dependency": {
595 | 				"type": "keep_always",
596 | 				"dependent_params": ["AffinityDisappointed"]
597 | 			}
598 | 		},
599 | 		"AffinityDisappointedNote": {
600 | 			"type": "dependency",
601 | 			"dependency": {
602 | 				"type": "keep_always",
603 | 				"dependent_params": ["AffinityDisappointed"]
604 | 			}
605 | 		},
606 | 		"AffinityStrangerTL": {
607 | 			"type": "dependency",
608 | 			"dependency": {
609 | 				"type": "keep_always",
610 | 				"dependent_params": ["AffinityStranger"]
611 | 			}
612 | 		},
613 | 		"AffinityStrangerNote": {
614 | 			"type": "dependency",
615 | 			"dependency": {
616 | 				"type": "keep_always",
617 | 				"dependent_params": ["AffinityStranger"]
618 | 			}
619 | 		},
620 | 		"AffinityFriendlyTL": {
621 | 			"type": "dependency",
622 | 			"dependency": {
623 | 				"type": "keep_always",
624 | 				"dependent_params": ["AffinityFriendly"]
625 | 			}
626 | 		},
627 | 		"AffinityFriendlyNote": {
628 | 			"type": "dependency",
629 | 			"dependency": {
630 | 				"type": "keep_always",
631 | 				"dependent_params": ["AffinityFriendly"]
632 | 			}
633 | 		},
634 | 		"AffinityLikeTL": {
635 | 			"type": "dependency",
636 | 			"dependency": {
637 | 				"type": "keep_always",
638 | 				"dependent_params": ["AffinityLike"]
639 | 			}
640 | 		},
641 | 		"AffinityLikeNote": {
642 | 			"type": "dependency",
643 | 			"dependency": {
644 | 				"type": "keep_always",
645 | 				"dependent_params": ["AffinityLike"]
646 | 			}
647 | 		},
648 | 		"AffinityLoveTL": {
649 | 			"type": "dependency",
650 | 			"dependency": {
651 | 				"type": "keep_always",
652 | 				"dependent_params": ["AffinityLove"]
653 | 			}
654 | 		},
655 | 		"AffinityLoveNote": {
656 | 			"type": "dependency",
657 | 			"dependency": {
658 | 				"type": "keep_always",
659 | 				"dependent_params": ["AffinityLove"]
660 | 			}
661 | 		},
662 | 		"PledgeTL": {
663 | 			"type": "dependency",
664 | 			"dependency": {
665 | 				"type": "keep_always",
666 | 				"dependent_params": ["Pledge"]
667 | 			}
668 | 		},
669 | 		"PledgeNote": {
670 | 			"type": "dependency",
671 | 			"dependency": {
672 | 				"type": "keep_always",
673 | 				"dependent_params": ["Pledge"]
674 | 			}
675 | 		},
676 | 		"Additional1TL": {
677 | 			"type": "dependency",
678 | 			"dependency": {
679 | 				"type": "keep_always",
680 | 				"dependent_params": ["Additional1"]
681 | 			}
682 | 		},
683 | 		"Additional1Note": {
684 | 			"type": "dependency",
685 | 			"dependency": {
686 | 				"type": "keep_always",
687 | 				"dependent_params": ["Additional1"]
688 | 			}
689 | 		},
690 | 		"Additional2TL": {
691 | 			"type": "dependency",
692 | 			"dependency": {
693 | 				"type": "keep_always",
694 | 				"dependent_params": ["Additional2"]
695 | 			}
696 | 		},
697 | 		"Additional2Note": {
698 | 			"type": "dependency",
699 | 			"dependency": {
700 | 				"type": "keep_always",
701 | 				"dependent_params": ["Additional2"]
702 | 			}
703 | 		},
704 | 		"Additional3TL": {
705 | 			"type": "dependency",
706 | 			"dependency": {
707 | 				"type": "keep_always",
708 | 				"dependent_params": ["Additional3"]
709 | 			}
710 | 		},
711 | 		"Additional3Note": {
712 | 			"type": "dependency",
713 | 			"dependency": {
714 | 				"type": "keep_always",
715 | 				"dependent_params": ["Additional3"]
716 | 			}
717 | 		},
718 | 		"Additional4TL": {
719 | 			"type": "dependency",
720 | 			"dependency": {
721 | 				"type": "keep_always",
722 | 				"dependent_params": ["Additional4"]
723 | 			}
724 | 		},
725 | 		"Additional4Note": {
726 | 			"type": "dependency",
727 | 			"dependency": {
728 | 				"type": "keep_always",
729 | 				"dependent_params": ["Additional4"]
730 | 			}
731 | 		},
732 | 		"Additional5TL": {
733 | 			"type": "dependency",
734 | 			"dependency": {
735 | 				"type": "keep_always",
736 | 				"dependent_params": ["Additional5"]
737 | 			}
738 | 		},
739 | 		"Additional5Note": {
740 | 			"type": "dependency",
741 | 			"dependency": {
742 | 				"type": "keep_always",
743 | 				"dependent_params": ["Additional5"]
744 | 			}
745 | 		},
746 | 		"Additional6TL": {
747 | 			"type": "dependency",
748 | 			"dependency": {
749 | 				"type": "keep_always",
750 | 				"dependent_params": ["Additional6"]
751 | 			}
752 | 		},
753 | 		"Additional6Note": {
754 | 			"type": "dependency",
755 | 			"dependency": {
756 | 				"type": "keep_always",
757 | 				"dependent_params": ["Additional6"]
758 | 			}
759 | 		},
760 | 		"Additional7TL": {
761 | 			"type": "dependency",
762 | 			"dependency": {
763 | 				"type": "keep_always",
764 | 				"dependent_params": ["Additional7"]
765 | 			}
766 | 		},
767 | 		"Additional7Note": {
768 | 			"type": "dependency",
769 | 			"dependency": {
770 | 				"type": "keep_always",
771 | 				"dependent_params": ["Additional7"]
772 | 			}
773 | 		},
774 | 		"Additional8TL": {
775 | 			"type": "dependency",
776 | 			"dependency": {
777 | 				"type": "keep_always",
778 | 				"dependent_params": ["Additional8"]
779 | 			}
780 | 		},
781 | 		"Additional8Note": {
782 | 			"type": "dependency",
783 | 			"dependency": {
784 | 				"type": "keep_always",
785 | 				"dependent_params": ["Additional8"]
786 | 			}
787 | 		},
788 | 		"Additional9TL": {
789 | 			"type": "dependency",
790 | 			"dependency": {
791 | 				"type": "keep_always",
792 | 				"dependent_params": ["Additional9"]
793 | 			}
794 | 		},
795 | 		"Additional9Note": {
796 | 			"type": "dependency",
797 | 			"dependency": {
798 | 				"type": "keep_always",
799 | 				"dependent_params": ["Additional9"]
800 | 			}
801 | 		},
802 | 		"Additional10TL": {
803 | 			"type": "dependency",
804 | 			"dependency": {
805 | 				"type": "keep_always",
806 | 				"dependent_params": ["Additional10"]
807 | 			}
808 | 		},
809 | 		"Additional10Note": {
810 | 			"type": "dependency",
811 | 			"dependency": {
812 | 				"type": "keep_always",
813 | 				"dependent_params": ["Additional10"]
814 | 			}
815 | 		},
816 | 		"Additional11TL": {
817 | 			"type": "dependency",
818 | 			"dependency": {
819 | 				"type": "keep_always",
820 | 				"dependent_params": ["Additional11"]
821 | 			}
822 | 		},
823 | 		"Additional11Note": {
824 | 			"type": "dependency",
825 | 			"dependency": {
826 | 				"type": "keep_always",
827 | 				"dependent_params": ["Additional11"]
828 | 			}
829 | 		},
830 | 		"Additional12TL": {
831 | 			"type": "dependency",
832 | 			"dependency": {
833 | 				"type": "keep_always",
834 | 				"dependent_params": ["Additional12"]
835 | 			}
836 | 		},
837 | 		"Additional12Note": {
838 | 			"type": "dependency",
839 | 			"dependency": {
840 | 				"type": "keep_always",
841 | 				"dependent_params": ["Additional12"]
842 | 			}
843 | 		},
844 | 		"Valentine18TL": {
845 | 			"type": "dependency",
846 | 			"dependency": {
847 | 				"type": "keep_always",
848 | 				"dependent_params": ["Valentine18"]
849 | 			}
850 | 		},
851 | 		"Valentine18Note": {
852 | 			"type": "dependency",
853 | 			"dependency": {
854 | 				"type": "keep_always",
855 | 				"dependent_params": ["Valentine18"]
856 | 			}
857 | 		},
858 | 		"Valentine19TL": {
859 | 			"type": "dependency",
860 | 			"dependency": {
861 | 				"type": "keep_always",
862 | 				"dependent_params": ["Valentine19"]
863 | 			}
864 | 		},
865 | 		"Valentine19Note": {
866 | 			"type": "dependency",
867 | 			"dependency": {
868 | 				"type": "keep_always",
869 | 				"dependent_params": ["Valentine19"]
870 | 			}
871 | 		},
872 | 		"Valentine20TL": {
873 | 			"type": "dependency",
874 | 			"dependency": {
875 | 				"type": "keep_always",
876 | 				"dependent_params": ["Valentine20"]
877 | 			}
878 | 		},
879 | 		"Valentine20Note": {
880 | 			"type": "dependency",
881 | 			"dependency": {
882 | 				"type": "keep_always",
883 | 				"dependent_params": ["Valentine20"]
884 | 			}
885 | 		}
886 | 	},
887 | 	"prefer-wiki-data": []
888 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/ShipQuoteEN.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"template_name": "ShipQuote",
  3 | 	"template_sections": {
  4 | 		"comment": "",
  5 | 		"sections": [
  6 | 			{
  7 | 				"comment": "",
  8 | 				"params": ["Region", "Voice", "Skin"]
  9 | 			},
 10 | 			{
 11 | 				"comment": "",
 12 | 				"params": ["ShipDescription", "ShipDescriptionNote"]
 13 | 			},
 14 | 			{
 15 | 				"comment": "",
 16 | 				"params": ["SelfIntro", "SelfIntroNote"]
 17 | 			},
 18 | 			{
 19 | 				"comment": "",
 20 | 				"params": ["Acquisition", "AcquisitionNote"]
 21 | 			},
 22 | 			{
 23 | 				"comment": "",
 24 | 				"params": ["Login", "LoginNote"]
 25 | 			},
 26 | 			{
 27 | 				"comment": "",
 28 | 				"params": ["Details", "DetailsNote"]
 29 | 			},
 30 | 			{
 31 | 				"comment": "",
 32 | 				"params": ["SecretaryIdle1", "SecretaryIdle1Note"]
 33 | 			},
 34 | 			{
 35 | 				"comment": "",
 36 | 				"params": ["SecretaryIdle2", "SecretaryIdle2Note"]
 37 | 			},
 38 | 			{
 39 | 				"comment": "",
 40 | 				"params": ["SecretaryIdle3", "SecretaryIdle3Note"]
 41 | 			},
 42 | 			{
 43 | 				"comment": "",
 44 | 				"params": ["SecretaryIdle4", "SecretaryIdle4Note"]
 45 | 			},
 46 | 			{
 47 | 				"comment": "",
 48 | 				"params": ["SecretaryIdle5", "SecretaryIdle5Note"]
 49 | 			},
 50 | 			{
 51 | 				"comment": "",
 52 | 				"params": ["SecretaryIdle6", "SecretaryIdle6Note"]
 53 | 			},
 54 | 			{
 55 | 				"comment": "",
 56 | 				"params": ["SecretaryIdle7", "SecretaryIdle7Note"]
 57 | 			},
 58 | 			{
 59 | 				"comment": "",
 60 | 				"params": ["SecretaryIdle8", "SecretaryIdle8Note"]
 61 | 			},
 62 | 			{
 63 | 				"comment": "",
 64 | 				"params": ["SecretaryTouch", "SecretaryTouchNote"]
 65 | 			},
 66 | 			{
 67 | 				"comment": "",
 68 | 				"params": ["SpecialTouch", "SpecialTouchNote"]
 69 | 			},
 70 | 			{
 71 | 				"comment": "",
 72 | 				"params": ["Headpat", "HeadpatNote"]
 73 | 			},
 74 | 			{
 75 | 				"comment": "",
 76 | 				"params": ["Task", "TaskNote"]
 77 | 			},
 78 | 			{
 79 | 				"comment": "",
 80 | 				"params": ["TaskComplete", "TaskCompleteNote"]
 81 | 			},
 82 | 			{
 83 | 				"comment": "",
 84 | 				"params": ["Mail", "MailNote"]
 85 | 			},
 86 | 			{
 87 | 				"comment": "",
 88 | 				"params": ["MissionFinished", "MissionFinishedNote"]
 89 | 			},
 90 | 			{
 91 | 				"comment": "",
 92 | 				"params": ["Commission", "CommissionNote"]
 93 | 			},
 94 | 			{
 95 | 				"comment": "",
 96 | 				"params": ["Strengthening", "StrengtheningNote"]
 97 | 			},
 98 | 			{
 99 | 				"comment": "",
100 | 				"params": ["MissionStart", "MissionStartNote"]
101 | 			},
102 | 			{
103 | 				"comment": "",
104 | 				"params": ["MVP", "MVPNote"]
105 | 			},
106 | 			{
107 | 				"comment": "",
108 | 				"params": ["Defeat", "DefeatNote"]
109 | 			},
110 | 			{
111 | 				"comment": "",
112 | 				"params": ["SkillActivation", "SkillActivationNote"]
113 | 			},
114 | 			{
115 | 				"comment": "",
116 | 				"params": ["LowHP", "LowHPNote"]
117 | 			},
118 | 			{
119 | 				"comment": "",
120 | 				"params": ["AffinityDisappointed", "AffinityDisappointedNote"]
121 | 			},
122 | 			{
123 | 				"comment": "",
124 | 				"params": ["AffinityStranger", "AffinityStrangerNote"]
125 | 			},
126 | 			{
127 | 				"comment": "",
128 | 				"params": ["AffinityFriendly", "AffinityFriendlyNote"]
129 | 			},
130 | 			{
131 | 				"comment": "",
132 | 				"params": ["AffinityLike", "AffinityLikeNote"]
133 | 			},
134 | 			{
135 | 				"comment": "",
136 | 				"params": ["AffinityLove", "AffinityLoveNote"]
137 | 			},
138 | 			{
139 | 				"comment": "",
140 | 				"params": ["Pledge", "PledgeNote"]
141 | 			},
142 | 			{
143 | 				"comment": "",
144 | 				"params": ["Additional1", "Additional1Note"]
145 | 			},
146 | 			{
147 | 				"comment": "",
148 | 				"params": ["Additional2", "Additional2Note"]
149 | 			},
150 | 			{
151 | 				"comment": "",
152 | 				"params": ["Additional3", "Additional3Note"]
153 | 			},
154 | 			{
155 | 				"comment": "",
156 | 				"params": ["Additional4", "Additional4Note"]
157 | 			},
158 | 			{
159 | 				"comment": "",
160 | 				"params": ["Additional5", "Additional5Note"]
161 | 			},
162 | 			{
163 | 				"comment": "",
164 | 				"params": ["Additional6", "Additional6Note"]
165 | 			},
166 | 			{
167 | 				"comment": "",
168 | 				"params": ["Additional7", "Additional7Note"]
169 | 			},
170 | 			{
171 | 				"comment": "",
172 | 				"params": ["Additional8", "Additional8Note"]
173 | 			},
174 | 			{
175 | 				"comment": "",
176 | 				"params": ["Additional9", "Additional9Note"]
177 | 			},
178 | 			{
179 | 				"comment": "",
180 | 				"params": ["Additional10", "Additional10Note"]
181 | 			},
182 | 			{
183 | 				"comment": "",
184 | 				"params": ["Additional11", "Additional11Note"]
185 | 			},
186 | 			{
187 | 				"comment": "",
188 | 				"params": ["Additional12", "Additional12Note"]
189 | 			},
190 | 			{
191 | 				"comment": "",
192 | 				"params": ["Valentine18", "Valentine18Note"]
193 | 			},
194 | 			{
195 | 				"comment": "",
196 | 				"params": ["Valentine19", "Valentine19Note"]
197 | 			},
198 | 			{
199 | 				"comment": "",
200 | 				"params": ["Valentine20", "Valentine20Note"]
201 | 			}
202 | 		]
203 | 	},
204 | 	"behavior": {
205 | 		"default": {
206 | 			"type": "remove_empty"
207 | 		},
208 | 		"Region": {
209 | 			"type": "keep"
210 | 		},
211 | 		"Skin": {
212 | 			"type": "keep"
213 | 		},
214 | 		"ShipDescriptionNote": {
215 | 			"type": "dependency",
216 | 			"dependency": {
217 | 				"type": "keep_always",
218 | 				"dependent_params": ["ShipDescription"]
219 | 			}
220 | 		},
221 | 		"SelfIntroNote": {
222 | 			"type": "dependency",
223 | 			"dependency": {
224 | 				"type": "keep_always",
225 | 				"dependent_params": ["SelfIntro"]
226 | 			}
227 | 		},
228 | 		"AcquisitionNote": {
229 | 			"type": "dependency",
230 | 			"dependency": {
231 | 				"type": "keep_always",
232 | 				"dependent_params": ["Acquisition"]
233 | 			}
234 | 		},
235 | 		"LoginNote": {
236 | 			"type": "dependency",
237 | 			"dependency": {
238 | 				"type": "keep_always",
239 | 				"dependent_params": ["Login"]
240 | 			}
241 | 		},
242 | 		"DetailsNote": {
243 | 			"type": "dependency",
244 | 			"dependency": {
245 | 				"type": "keep_always",
246 | 				"dependent_params": ["Details"]
247 | 			}
248 | 		},
249 | 		"SecretaryIdle1Note": {
250 | 			"type": "dependency",
251 | 			"dependency": {
252 | 				"type": "keep_always",
253 | 				"dependent_params": ["SecretaryIdle1"]
254 | 			}
255 | 		},
256 | 		"SecretaryIdle2Note": {
257 | 			"type": "dependency",
258 | 			"dependency": {
259 | 				"type": "keep_always",
260 | 				"dependent_params": ["SecretaryIdle2"]
261 | 			}
262 | 		},
263 | 		"SecretaryIdle3Note": {
264 | 			"type": "dependency",
265 | 			"dependency": {
266 | 				"type": "keep_always",
267 | 				"dependent_params": ["SecretaryIdle3"]
268 | 			}
269 | 		},
270 | 		"SecretaryIdle4Note": {
271 | 			"type": "dependency",
272 | 			"dependency": {
273 | 				"type": "keep_always",
274 | 				"dependent_params": ["SecretaryIdle4"]
275 | 			}
276 | 		},
277 | 		"SecretaryIdle5Note": {
278 | 			"type": "dependency",
279 | 			"dependency": {
280 | 				"type": "keep_always",
281 | 				"dependent_params": ["SecretaryIdle5"]
282 | 			}
283 | 		},
284 | 		"SecretaryIdle6Note": {
285 | 			"type": "dependency",
286 | 			"dependency": {
287 | 				"type": "keep_always",
288 | 				"dependent_params": ["SecretaryIdle6"]
289 | 			}
290 | 		},
291 | 		"SecretaryIdle7Note": {
292 | 			"type": "dependency",
293 | 			"dependency": {
294 | 				"type": "keep_always",
295 | 				"dependent_params": ["SecretaryIdle7"]
296 | 			}
297 | 		},
298 | 		"SecretaryIdle8Note": {
299 | 			"type": "dependency",
300 | 			"dependency": {
301 | 				"type": "keep_always",
302 | 				"dependent_params": ["SecretaryIdle8"]
303 | 			}
304 | 		},
305 | 		"SecretaryTouchNote": {
306 | 			"type": "dependency",
307 | 			"dependency": {
308 | 				"type": "keep_always",
309 | 				"dependent_params": ["SecretaryTouch"]
310 | 			}
311 | 		},
312 | 		"SpecialTouchNote": {
313 | 			"type": "dependency",
314 | 			"dependency": {
315 | 				"type": "keep_always",
316 | 				"dependent_params": ["SpecialTouch"]
317 | 			}
318 | 		},
319 | 		"HeadpatNote": {
320 | 			"type": "dependency",
321 | 			"dependency": {
322 | 				"type": "keep_always",
323 | 				"dependent_params": ["Headpat"]
324 | 			}
325 | 		},
326 | 		"TaskNote": {
327 | 			"type": "dependency",
328 | 			"dependency": {
329 | 				"type": "keep_always",
330 | 				"dependent_params": ["Task"]
331 | 			}
332 | 		},
333 | 		"TaskCompleteNote": {
334 | 			"type": "dependency",
335 | 			"dependency": {
336 | 				"type": "keep_always",
337 | 				"dependent_params": ["TaskComplete"]
338 | 			}
339 | 		},
340 | 		"MailNote": {
341 | 			"type": "dependency",
342 | 			"dependency": {
343 | 				"type": "keep_always",
344 | 				"dependent_params": ["Mail"]
345 | 			}
346 | 		},
347 | 		"MissionFinishedNote": {
348 | 			"type": "dependency",
349 | 			"dependency": {
350 | 				"type": "keep_always",
351 | 				"dependent_params": ["MissionFinished"]
352 | 			}
353 | 		},
354 | 		"CommissionNote": {
355 | 			"type": "dependency",
356 | 			"dependency": {
357 | 				"type": "keep_always",
358 | 				"dependent_params": ["Commission"]
359 | 			}
360 | 		},
361 | 		"StrengtheningNote": {
362 | 			"type": "dependency",
363 | 			"dependency": {
364 | 				"type": "keep_always",
365 | 				"dependent_params": ["Strengthening"]
366 | 			}
367 | 		},
368 | 		"MissionStartNote": {
369 | 			"type": "dependency",
370 | 			"dependency": {
371 | 				"type": "keep_always",
372 | 				"dependent_params": ["MissionStart"]
373 | 			}
374 | 		},
375 | 		"MVPNote": {
376 | 			"type": "dependency",
377 | 			"dependency": {
378 | 				"type": "keep_always",
379 | 				"dependent_params": ["MVP"]
380 | 			}
381 | 		},
382 | 		"DefeatNote": {
383 | 			"type": "dependency",
384 | 			"dependency": {
385 | 				"type": "keep_always",
386 | 				"dependent_params": ["Defeat"]
387 | 			}
388 | 		},
389 | 		"SkillActivationNote": {
390 | 			"type": "dependency",
391 | 			"dependency": {
392 | 				"type": "keep_always",
393 | 				"dependent_params": ["SkillActivation"]
394 | 			}
395 | 		},
396 | 		"LowHPNote": {
397 | 			"type": "dependency",
398 | 			"dependency": {
399 | 				"type": "keep_always",
400 | 				"dependent_params": ["LowHP"]
401 | 			}
402 | 		},
403 | 		"AffinityDisappointedNote": {
404 | 			"type": "dependency",
405 | 			"dependency": {
406 | 				"type": "keep_always",
407 | 				"dependent_params": ["AffinityDisappointed"]
408 | 			}
409 | 		},
410 | 		"AffinityStrangerNote": {
411 | 			"type": "dependency",
412 | 			"dependency": {
413 | 				"type": "keep_always",
414 | 				"dependent_params": ["AffinityStranger"]
415 | 			}
416 | 		},
417 | 		"AffinityFriendlyNote": {
418 | 			"type": "dependency",
419 | 			"dependency": {
420 | 				"type": "keep_always",
421 | 				"dependent_params": ["AffinityFriendly"]
422 | 			}
423 | 		},
424 | 		"AffinityLikeNote": {
425 | 			"type": "dependency",
426 | 			"dependency": {
427 | 				"type": "keep_always",
428 | 				"dependent_params": ["AffinityLike"]
429 | 			}
430 | 		},
431 | 		"AffinityLoveNote": {
432 | 			"type": "dependency",
433 | 			"dependency": {
434 | 				"type": "keep_always",
435 | 				"dependent_params": ["AffinityLove"]
436 | 			}
437 | 		},
438 | 		"PledgeNote": {
439 | 			"type": "dependency",
440 | 			"dependency": {
441 | 				"type": "keep_always",
442 | 				"dependent_params": ["Pledge"]
443 | 			}
444 | 		},
445 | 		"Additional1Note": {
446 | 			"type": "dependency",
447 | 			"dependency": {
448 | 				"type": "keep_always",
449 | 				"dependent_params": ["Additional1"]
450 | 			}
451 | 		},
452 | 		"Additional2Note": {
453 | 			"type": "dependency",
454 | 			"dependency": {
455 | 				"type": "keep_always",
456 | 				"dependent_params": ["Additional2"]
457 | 			}
458 | 		},
459 | 		"Additional3Note": {
460 | 			"type": "dependency",
461 | 			"dependency": {
462 | 				"type": "keep_always",
463 | 				"dependent_params": ["Additional3"]
464 | 			}
465 | 		},
466 | 		"Additional4Note": {
467 | 			"type": "dependency",
468 | 			"dependency": {
469 | 				"type": "keep_always",
470 | 				"dependent_params": ["Additional4"]
471 | 			}
472 | 		},
473 | 		"Additional5Note": {
474 | 			"type": "dependency",
475 | 			"dependency": {
476 | 				"type": "keep_always",
477 | 				"dependent_params": ["Additional5"]
478 | 			}
479 | 		},
480 | 		"Additional6Note": {
481 | 			"type": "dependency",
482 | 			"dependency": {
483 | 				"type": "keep_always",
484 | 				"dependent_params": ["Additional6"]
485 | 			}
486 | 		},
487 | 		"Additional7Note": {
488 | 			"type": "dependency",
489 | 			"dependency": {
490 | 				"type": "keep_always",
491 | 				"dependent_params": ["Additional7"]
492 | 			}
493 | 		},
494 | 		"Additional8Note": {
495 | 			"type": "dependency",
496 | 			"dependency": {
497 | 				"type": "keep_always",
498 | 				"dependent_params": ["Additional8"]
499 | 			}
500 | 		},
501 | 		"Additional9Note": {
502 | 			"type": "dependency",
503 | 			"dependency": {
504 | 				"type": "keep_always",
505 | 				"dependent_params": ["Additional9"]
506 | 			}
507 | 		},
508 | 		"Additional10Note": {
509 | 			"type": "dependency",
510 | 			"dependency": {
511 | 				"type": "keep_always",
512 | 				"dependent_params": ["Additional10"]
513 | 			}
514 | 		},
515 | 		"Additional11Note": {
516 | 			"type": "dependency",
517 | 			"dependency": {
518 | 				"type": "keep_always",
519 | 				"dependent_params": ["Additional11"]
520 | 			}
521 | 		},
522 | 		"Additional12Note": {
523 | 			"type": "dependency",
524 | 			"dependency": {
525 | 				"type": "keep_always",
526 | 				"dependent_params": ["Additional12"]
527 | 			}
528 | 		},
529 | 		"Valentine18Note": {
530 | 			"type": "dependency",
531 | 			"dependency": {
532 | 				"type": "keep_always",
533 | 				"dependent_params": ["Valentine18"]
534 | 			}
535 | 		},
536 | 		"Valentine19Note": {
537 | 			"type": "dependency",
538 | 			"dependency": {
539 | 				"type": "keep_always",
540 | 				"dependent_params": ["Valentine19"]
541 | 			}
542 | 		},
543 | 		"Valentine20Note": {
544 | 			"type": "dependency",
545 | 			"dependency": {
546 | 				"type": "keep_always",
547 | 				"dependent_params": ["Valentine20"]
548 | 			}
549 | 		}
550 | 	},
551 | 	"prefer-wiki-data": []
552 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/ShipSkin.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "ShipSkin",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "",
 8 | 				"params": ["NoTabber", "ShipName", "SkinID", "SkinName", "SkinNameTL", "SkinNameEN", "SkinNameCN", "SkinNameCNTL", "SkinNameJP", "SkinNameJPTL"]
 9 | 			},
10 | 			{
11 | 				"comment": "",
12 | 				"params": ["SkinCategory", "CategoryOverride", "Background", "SpecialBackground", "BGImage", "TabType1", "SkinCategory1", "TabName1", "TabType2", "SkinCategory2", "TabName2", "TabType3", "SkinCategory3", "TabName3", "TabType4", "SkinCategory4", "TabName4", "TabType5", "SkinCategory5", "TabName5"]
13 | 			},
14 | 			{
15 | 				"comment": "",
16 | 				"params": ["Cost", "LimitedEN", "LimitedCN", "LimitedJP", "Live2D", "Music"]
17 | 			},
18 | 			{
19 | 				"comment": "",
20 | 				"params": ["EventName", "EventPage", "ActivityName", "EventCurrency"]
21 | 			}
22 | 		]
23 | 	},
24 | 	"behavior": {
25 | 		"default": {
26 | 			"type": "remove_empty"
27 | 		},
28 | 		"SkinID": {
29 | 			"type": "keep"
30 | 		},
31 | 		"SkinCategory": {
32 | 			"type": "keep"
33 | 		},
34 | 		"EventPage": {
35 | 			"type": "dependency",
36 | 			"dependency": {
37 | 				"type": "keep_empty",
38 | 				"dependent_params": ["EventName"]
39 | 			}
40 | 		}
41 | 	},
42 | 	"prefer-wiki-data": []
43 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/ShipSkin0.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "ShipSkin",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "",
 8 | 				"params": ["NoTabber", "ShipName", "SkinID", "SpecialBackground", "BGImage", "TabType1", "SkinCategory1", "TabName1", "Left1", "TabType2", "SkinCategory2", "TabName2", "Left2", "TabType3", "SkinCategory3", "TabName3", "Left3", "TabType4", "SkinCategory4", "TabName4", "Left4", "TabType5", "SkinCategory5", "TabName5", "Left5", "Live2D", "Music"]
 9 | 			}
10 | 		]
11 | 	},
12 | 	"behavior": {
13 | 		"default": {
14 | 			"type": "remove_empty"
15 | 		},
16 | 		"SkinID": {
17 | 			"type": "keep"
18 | 		}
19 | 	},
20 | 	"prefer-wiki-data": []
21 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/Story.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "Story",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "",
 8 | 				"params": ["Title", "Unlock", "Language"]
 9 | 			}
10 | 		]
11 | 	},
12 | 	"behavior": {
13 | 		"default": {
14 | 			"type": "keep"
15 | 		}
16 | 	},
17 | 	"prefer-wiki-data": []
18 | }


--------------------------------------------------------------------------------
/PythonScripts/templates/Template.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"template_name": "",
 3 | 	"template_sections": {
 4 | 		"comment": "",
 5 | 		"sections": [
 6 | 			{
 7 | 				"comment": "",
 8 | 				"sections": [
 9 | 					{
10 | 						"comment": "",
11 | 						"params": []
12 | 					}
13 | 				]
14 | 			}
15 | 		]
16 | 	},
17 | 	"behavior": {
18 | 		"default": {
19 | 			"type": "keep"
20 | 		},
21 | 		"SomeParam": {
22 | 			"type": "dependency",
23 | 			"dependency": {
24 | 				"type": "keep_empty",
25 | 				"dependent_params": []
26 | 			}
27 | 		}
28 | 	},
29 | 	"prefer-wiki-data": []
30 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # AzurLaneTools
 2 | → *the download and extraction tool has been moved to the new [Asset Downloader](https://github.com/nobbyfix/AzurLane-AssetDownloader) repo*
 3 | 
 4 | A collection of tools i use to work with AzurLane game data.  
 5 | Feel free to create pull requests and issues to let me know about problems or just to improve ugly code.
 6 | 
 7 | ## Additional Dependencies
 8 | Lua 5.1 (with cjson)  
 9 | Python 3.11 (or higher)
10 | 


--------------------------------------------------------------------------------
/lua_convert.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import subprocess
 3 | from enum import Enum
 4 | from pathlib import Path
 5 | 
 6 | 
 7 | class Client(Enum):
 8 | 	locale_code: str
 9 | 
10 | 	def __new__(cls, value, locale):
11 | 		obj = object.__new__(cls)
12 | 		obj._value_ = value
13 | 		obj.locale_code = locale
14 | 		return obj
15 | 
16 | 	EN = (1, "en-US")
17 | 	CN = (2, "zh-CN")
18 | 	JP = (3, "ja-JP")
19 | 	KR = (4, "ko-KR")
20 | 	TW = (5, "zh-TW")
21 | 
22 | 	@staticmethod
23 | 	def from_locale(locale):
24 | 		for client in Client:
25 | 			if client.locale_code == locale:
26 | 				return client
27 | 
28 | 
29 | def dump_json(target_path, content):
30 | 	with open(target_path, "w", encoding="utf8") as f:
31 | 		json.dump(content, f, indent=2, ensure_ascii=False)
32 | 
33 | 
34 | def convert_lua(filepath: Path, savedest: Path):
35 | 	if "sharecfg" in filepath.parts:
36 | 		# if file is also modified to contain function blocks, remove them
37 | 		modified_file = False
38 | 		with open(filepath, "r", encoding="utf8") as f:
39 | 			content = f.read()
40 | 		if "function ()" in content and "end()" in content:
41 | 			content_replaced = content.replace("function ()", "").replace("end()", "")
42 | 			with open(filepath, "w", encoding="utf8") as f:
43 | 				f.write(content_replaced)
44 | 			modified_file = True
45 | 
46 | 		# convert the file
47 | 		try:
48 | 			result = subprocess.check_output(["lua", "serializer.lua",
49 | 				str(filepath.with_suffix("")), filepath.stem], stderr=subprocess.DEVNULL)
50 | 		except: return
51 | 		finally:
52 | 			# revert the file, even if it fails to convert them
53 | 			if modified_file:
54 | 				with open(filepath, "w", encoding="utf8") as f:
55 | 					f.write(content)
56 | 
57 | 	# convert non-sharecfg files with other lua serializer script
58 | 	else:
59 | 		try:
60 | 			result = subprocess.check_output(["lua", "serializer2.lua",
61 | 				str(filepath.with_suffix(""))], stderr=subprocess.DEVNULL)
62 | 		except: return
63 | 
64 | 	json_string = result.decode("utf8")
65 | 	if json_string.startswith("null"):
66 | 		return
67 | 
68 | 	# parse json, if its empty (or an empty structure), skip
69 | 	if not (json_data := json.loads(json_string)):
70 | 		return
71 | 
72 | 	savedest.parent.mkdir(parents=True, exist_ok=True)
73 | 	dump_json(savedest, json_data)


--------------------------------------------------------------------------------
/lua_converter.py:
--------------------------------------------------------------------------------
 1 | import shutil
 2 | from pathlib import Path
 3 | import multiprocessing as mp
 4 | 
 5 | from lua_convert import Client, convert_lua
 6 | 
 7 | 
 8 | directory_destinations = [
 9 | 	(Path("sharecfg"), "sharecfg"),
10 | 	(Path("gamecfg", "buff"),  "buff"),
11 | 	(Path("gamecfg", "dungeon"), "dungeon"),
12 | 	(Path("gamecfg", "skill"), "skill"),
13 | 	(Path("gamecfg", "story"), "story"),
14 | 	(Path("gamecfg", "backyardtheme"), "backyardtheme"),
15 | 	(Path("gamecfg", "guide"), "guide"),
16 | ]
17 | 
18 | 
19 | def clear_json_files(client: Client):
20 | 	client_json_dir = Path("SrcJson", client.name)
21 | 	shutil.rmtree(client_json_dir, ignore_errors=True)
22 | 
23 | def convert_all_files(client: Client):
24 | 	with mp.Pool(processes=mp.cpu_count()) as pool:
25 | 		for DIR_FROM, DIR_TO in directory_destinations:
26 | 			# jp has different folder for story files
27 | 			if DIR_FROM.name == "story" and client.name == "JP":
28 | 				DIR_FROM = DIR_FROM.with_name(DIR_FROM.name+"jp")
29 | 
30 | 			# set path constants
31 | 			CONVERT_FROM = Path("Src", client.locale_code, DIR_FROM)
32 | 			CONVERT_TO = Path("SrcJson", client.name, DIR_TO)
33 | 
34 | 			# find all files inside the folder
35 | 			for file in CONVERT_FROM.rglob("*.lua"):
36 | 				target = Path(CONVERT_TO, file.relative_to(CONVERT_FROM).with_suffix(".json"))
37 | 				pool.apply_async(convert_lua, (file, target,))
38 | 		pool.close()
39 | 		pool.join()
40 | 
41 | def reconvert_all_files(client: Client):
42 | 	clear_json_files(client)
43 | 	convert_all_files(client)
44 | 
45 | 
46 | def main():
47 | 	client_input = input("Type the game version to convert: ")
48 | 	if not client_input in Client.__members__:
49 | 		print(f"Unknown client {client_input}, aborting.")
50 | 		return
51 | 	client = Client[client_input]
52 | 	reconvert_all_files(client)
53 | 
54 | if __name__ == "__main__":
55 | 	main()
56 | 


--------------------------------------------------------------------------------
/lua_converter_v2.py:
--------------------------------------------------------------------------------
  1 | import re
  2 | from pathlib import Path
  3 | import multiprocessing as mp
  4 | from argparse import ArgumentParser
  5 | from git import Repo
  6 | 
  7 | from lua_convert import Client, convert_lua
  8 | 
  9 | 
 10 | ALLOWED_GAMECFG_FOLDERS = {"buff", "dungeon", "skill", "story", "storyjp", "backyardtheme", "guide"}
 11 | 
 12 | LUA_REPO_NAME = "Src"
 13 | JSON_REPO_NAME = "SrcJson"
 14 | REGEX = re.compile(r"\[(..-..)\] AZ: (\d+\.\d+\.\d+)")
 15 | 
 16 | 
 17 | class SrcRepo(Repo):
 18 | 	def pull(self):
 19 | 		"""
 20 | 		Pulls from origin and returns old commit
 21 | 
 22 | 		:return: the old commit before pulling
 23 | 		"""
 24 | 		print("Pulling new changes from origin...")
 25 | 		pullinfo = self.remotes.origin.pull()[0]
 26 | 		oldcommit = pullinfo.old_commit
 27 | 		if oldcommit is None: print("No new commits available.")
 28 | 		else: print("New commits have been pulled.")
 29 | 		return pullinfo.old_commit
 30 | 
 31 | 	def pull_and_get_changes(self, override_old_commit=None):
 32 | 		old_commit = self.pull()
 33 | 
 34 | 		if override_old_commit is not None: old_commit = self.commit(override_old_commit)
 35 | 		if old_commit is None: return
 36 | 
 37 | 		commits = []
 38 | 		for commit in self.iter_commits():
 39 | 			if commit.hexsha == old_commit.hexsha:
 40 | 				break
 41 | 			commits.append(commit)
 42 | 
 43 | 		for commit in reversed(commits):
 44 | 			changes = self.changes_from_commit(commit)
 45 | 			if changes: yield changes
 46 | 
 47 | 	def changes_from_commit(self, commit):
 48 | 		"""
 49 | 		:return: the tuple (client, version, files)
 50 | 		where client is a string, version is a string and files a list
 51 | 
 52 | 		or None, if the commit is not a valid commit
 53 | 		"""
 54 | 		re_result = REGEX.findall(commit.message)
 55 | 		if re_result:
 56 | 			diff_index = commit.parents[0].diff(commit)
 57 | 			files = [diff.b_path for diff in diff_index if diff.change_type in ["A", "M"]]
 58 | 			return *re_result[0], files
 59 | 
 60 | 
 61 | def is_allowed_gamecfg(path: Path):
 62 | 	return bool(ALLOWED_GAMECFG_FOLDERS.intersection(path.parts))
 63 | 
 64 | def normalize_gamecfg_paths(path: Path):
 65 | 	if "storyjp" in path.parts:
 66 | 		return Path(str(path).replace("storyjp", "story"))
 67 | 	return path
 68 | 
 69 | 
 70 | def convert_new_files(override_commit: str = None):
 71 | 	repo = SrcRepo(LUA_REPO_NAME)
 72 | 	repo_json = SrcRepo(JSON_REPO_NAME)
 73 | 
 74 | 	for client, version, files in repo.pull_and_get_changes(override_commit):
 75 | 		client = Client.from_locale(client)
 76 | 
 77 | 		with mp.Pool(processes=mp.cpu_count()) as pool:
 78 | 			for filepath in files:
 79 | 				filepath = Path(filepath)
 80 | 				index = 1
 81 | 				if "gamecfg" in filepath.parts:
 82 | 					if not is_allowed_gamecfg(filepath):
 83 | 						continue
 84 | 					index += 1
 85 | 				elif "sharecfg" not in filepath.parts:
 86 | 					continue
 87 | 				# else is sharecfg file
 88 | 				path2 = filepath.relative_to(*filepath.parts[:index])
 89 | 
 90 | 				lua_require = Path(LUA_REPO_NAME, filepath)
 91 | 				json_destination = normalize_gamecfg_paths( Path(JSON_REPO_NAME, client.name, path2.with_suffix(".json")) )
 92 | 				pool.apply_async(convert_lua, (lua_require, json_destination,))
 93 | 
 94 | 			# explicitly join the pool
 95 | 			# since the pool only receives async tasks, this waits for their completion
 96 | 			pool.close()
 97 | 			pool.join()
 98 | 
 99 | 		repo_json.git.add(client.name) # adds only all files inside the current clients directory
100 | 		repo_json.git.commit("-m", f"{client.name} {version}", "--allow-empty")
101 | 	repo_json.remotes.origin.push()
102 | 
103 | 
104 | def main():
105 | 	parser = ArgumentParser()
106 | 	parser.add_argument("-c", "--commit-sha", type=str, help="commit sha from which to start converting")
107 | 	args = parser.parse_args()
108 | 
109 | 	if sha := args.commit_sha:
110 | 		convert_new_files(sha)
111 | 	else:
112 | 		convert_new_files()
113 | 
114 | if __name__ == "__main__":
115 | 	main()
116 | 


--------------------------------------------------------------------------------
/serializer.lua:
--------------------------------------------------------------------------------
1 | package.path = package.path .. ";?.lua"
2 | local cjson = require("cjson")
3 | cjson.encode_sparse_array(true)
4 | 
5 | uv0 = {}
6 | pg = uv0
7 | require(arg[1])
8 | 
9 | print(cjson.encode(pg[arg[2]]))


--------------------------------------------------------------------------------
/serializer2.lua:
--------------------------------------------------------------------------------
 1 | package.path = package.path .. ";?.lua"
 2 | local cjson = require("cjson")
 3 | cjson.encode_sparse_array(true)
 4 | 
 5 | function Vector3(a, b, c)
 6 |     return {a, b, c}
 7 | end
 8 | 
 9 | ltable = require(arg[1])
10 | print(cjson.encode(ltable))
11 | 


--------------------------------------------------------------------------------