|
import sqlite3 |
|
import random |
|
import json |
|
from tqdm import tqdm |
|
from multiprocessing import Pool, Value, Lock |
|
|
|
DATABASE_FILE = "discobase3-29-2021-9-32-09-PM.db" |
|
|
|
def get_actor_name(cursor, actor_id): |
|
"""Fetches the name of an actor from the actors table.""" |
|
cursor.execute("SELECT name FROM actors WHERE id=?", (actor_id,)) |
|
result = cursor.fetchone() |
|
return result[0] if result else f"Unknown Actor ({actor_id})" |
|
|
|
def get_dialogue_children(cursor, convo_id, dialogue_id): |
|
"""Fetches the child dialogue entries of a given dialogue entry.""" |
|
cursor.execute( |
|
"SELECT destinationconversationid, destinationdialogueid FROM dlinks WHERE originconversationid=? AND origindialogueid=?", |
|
(convo_id, dialogue_id), |
|
) |
|
return cursor.fetchall() |
|
|
|
def get_dialogue_entry(cursor, convo_id, dialogue_id): |
|
"""Fetches a specific dialogue entry from the dentries table.""" |
|
cursor.execute( |
|
"SELECT dialoguetext, actor, conversant, conditionstring, userscript FROM dentries WHERE conversationid=? AND id=?", |
|
(convo_id, dialogue_id), |
|
) |
|
return cursor.fetchone() |
|
|
|
def is_hub(entry): |
|
"""Checks if a dialogue entry is a HUB (actor is 'HUB' and dialoguetext is '0').""" |
|
if entry is None: |
|
return False |
|
dialogue_text, actor_id, conversant_id, _, _ = entry |
|
return dialogue_text == "0" and actor_id == 0 |
|
|
|
def generate_conversation_path(cursor, start_convo_id, start_dialogue_id, max_length=20): |
|
"""Generates a single conversation path, treating '0' entries as placeholders.""" |
|
path = [] |
|
current_convo_id = start_convo_id |
|
current_dialogue_id = start_dialogue_id |
|
|
|
for _ in range(max_length): |
|
entry = get_dialogue_entry(cursor, current_convo_id, current_dialogue_id) |
|
if not entry: |
|
print(f"Warning: Could not find dialogue entry for convo_id={current_convo_id}, dialogue_id={current_dialogue_id}. Path may be incomplete.") |
|
break |
|
|
|
dialogue_text, actor_id, conversant_id, conditionstring, userscript = entry |
|
|
|
if is_hub(entry): |
|
|
|
children = get_dialogue_children(cursor, current_convo_id, current_dialogue_id) |
|
if not children: |
|
break |
|
current_convo_id, current_dialogue_id = random.choice(children) |
|
continue |
|
|
|
actor_name = get_actor_name(cursor, actor_id) |
|
|
|
if dialogue_text == "0": |
|
|
|
placeholder_text = "[Action/Check: " |
|
if conditionstring: |
|
placeholder_text += f"Condition: {conditionstring}; " |
|
if userscript: |
|
placeholder_text += f"Script: {userscript}; " |
|
placeholder_text = placeholder_text.rstrip("; ") + "]" |
|
if placeholder_text == "[Action/Check:]": |
|
pass |
|
else: |
|
path.append({"actor": actor_name, "dialogue": placeholder_text}) |
|
else: |
|
path.append({"actor": actor_name, "dialogue": dialogue_text}) |
|
|
|
children = get_dialogue_children(cursor, current_convo_id, current_dialogue_id) |
|
if not children: |
|
break |
|
|
|
current_convo_id, current_dialogue_id = random.choice(children) |
|
|
|
return path |
|
|
|
def get_starting_dialogues(cursor): |
|
"""Get a list of potential starting dialogues (those with no parents).""" |
|
cursor.execute(""" |
|
SELECT dentries.conversationid, dentries.id |
|
FROM dentries |
|
LEFT JOIN dlinks ON dentries.conversationid = dlinks.destinationconversationid AND dentries.id = dlinks.destinationdialogueid |
|
WHERE dlinks.originconversationid IS NULL |
|
""") |
|
return cursor.fetchall() |
|
|
|
def format_conversation_output(conversation): |
|
""" |
|
Formats a conversation list into a string that resembles the game's output. |
|
|
|
Args: |
|
conversation: A list of dictionaries, where each dictionary represents a |
|
dialogue entry with "actor" and "dialogue" keys. |
|
""" |
|
|
|
output = "" |
|
for entry in conversation: |
|
actor = entry["actor"] |
|
dialogue = entry["dialogue"] |
|
|
|
if dialogue.startswith("["): |
|
output += f"{dialogue}\n" |
|
elif actor.upper() == actor: |
|
output += f"\n{actor} - {dialogue}\n" |
|
else: |
|
output += f"{actor} - {dialogue}\n" |
|
|
|
return output.strip() |
|
|
|
def worker_process(args): |
|
"""Worker function for parallel processing""" |
|
db_file, starting_dialogues = args |
|
conn = sqlite3.connect(db_file) |
|
cursor = conn.cursor() |
|
|
|
|
|
start_convo_id, start_dialogue_id = random.choice(starting_dialogues) |
|
path = generate_conversation_path(cursor, start_convo_id, start_dialogue_id) |
|
|
|
conn.close() |
|
return path |
|
|
|
def main(): |
|
"""Main function using multiprocessing""" |
|
starting_dialogues = get_starting_dialogues(sqlite3.connect(DATABASE_FILE).cursor()) |
|
if not starting_dialogues: |
|
print("Error: No starting dialogues found in the database.") |
|
return |
|
|
|
conversations = [] |
|
seen_windows = set() |
|
min_window_size = 5 |
|
num_paths_to_generate = 5000 |
|
|
|
|
|
worker_args = (DATABASE_FILE, starting_dialogues) |
|
|
|
|
|
counter = Value('i', 0) |
|
lock = Lock() |
|
|
|
def update_progress(_): |
|
with lock: |
|
counter.value += 1 |
|
if counter.value % 10 == 0: |
|
print(f"\rGenerated {counter.value}/{num_paths_to_generate} paths", end="") |
|
|
|
with Pool(processes=8) as pool: |
|
results = [] |
|
|
|
for _ in range(num_paths_to_generate * 2): |
|
results.append(pool.apply_async(worker_process, (worker_args,), callback=update_progress)) |
|
|
|
|
|
while len(conversations) < num_paths_to_generate and results: |
|
result = results.pop(0).get() |
|
if len(result) < 5: |
|
continue |
|
|
|
|
|
path_text = " ".join(entry["dialogue"].strip().lower() |
|
for entry in result if not entry["dialogue"].startswith("[")) |
|
|
|
def is_duplicate(new_text): |
|
"""Check if new conversation contains or is contained within existing conversations""" |
|
for existing in conversations: |
|
existing_text = " ".join(entry["dialogue"].strip().lower() for entry in existing if not entry["dialogue"].startswith("[")) |
|
if len(new_text) < min_window_size or len(existing_text) < min_window_size: |
|
continue |
|
|
|
if new_text in existing_text or existing_text in new_text: |
|
return True |
|
return False |
|
|
|
|
|
def is_added(current_path): |
|
"""Check for matching subsequences using sliding window""" |
|
path_dialogues = [entry["dialogue"] for entry in current_path if not entry["dialogue"].startswith("[")] |
|
window = [] |
|
for dialogue in path_dialogues: |
|
window.append(dialogue) |
|
if len(window) > min_window_size: |
|
window.pop(0) |
|
if len(window) == min_window_size: |
|
window_str = " ".join(window) |
|
if window_str in seen_windows: |
|
return True |
|
|
|
for i in range(len(path_dialogues) - min_window_size + 1): |
|
seen_windows.add(" ".join(path_dialogues[i:i+min_window_size])) |
|
return False |
|
|
|
if (not is_duplicate(path_text) and |
|
not is_added(result) and |
|
any(entry["dialogue"][0] != "[" for entry in result)): |
|
conversations.append(result) |
|
|
|
pool.close() |
|
pool.join() |
|
|
|
output = {"conversations": conversations} |
|
with open("output.json", "w") as f: |
|
json.dump(output, f, indent=4) |
|
|
|
if __name__ == "__main__": |
|
main() |
|
|