259 lines
8.7 KiB
Python
259 lines
8.7 KiB
Python
"""
|
||
Безопасное добавление уровней без удаления старых.
|
||
Использует только words.csv.
|
||
"""
|
||
import asyncio
|
||
import asyncpg
|
||
import json
|
||
import random
|
||
import csv
|
||
from config import DB_CONFIG
|
||
|
||
|
||
DIRECTIONS = [(-1,0),(0,-1),(0,1),(1,0)]
|
||
ALPHABET = "AĄBCĆDEĘFGHIJKLŁMNŃOÓPRSŚTUWYZŹŻ"
|
||
|
||
|
||
def load_words_from_csv(filenames):
|
||
words_by_theme = {}
|
||
translations = {}
|
||
for filename in filenames:
|
||
with open(filename, 'r', encoding='utf-8') as f:
|
||
reader = csv.DictReader(f)
|
||
for row in reader:
|
||
theme = row['theme']
|
||
word = row['polish'].lower()
|
||
if theme not in words_by_theme:
|
||
words_by_theme[theme] = []
|
||
if word not in words_by_theme[theme]:
|
||
words_by_theme[theme].append(word)
|
||
translations[word] = {
|
||
'en': row['english'],
|
||
'ru': row['russian'],
|
||
'uk': row['ukrainian']
|
||
}
|
||
return words_by_theme, translations
|
||
|
||
|
||
def get_words_for_grid(words_by_theme, theme, num_words, grid_size):
|
||
max_len = grid_size
|
||
candidates = [w for w in words_by_theme[theme] if len(w) <= max_len]
|
||
if len(candidates) < num_words:
|
||
candidates = words_by_theme[theme]
|
||
random.shuffle(candidates)
|
||
return candidates[:num_words]
|
||
|
||
|
||
def try_place_word(word, grid_size, occupied, max_attempts=500):
|
||
word = word.upper()
|
||
for _ in range(max_attempts):
|
||
start = (random.randrange(grid_size), random.randrange(grid_size))
|
||
if start in occupied:
|
||
continue
|
||
path = [start]
|
||
visited = {start}
|
||
ok = True
|
||
for _ in range(len(word) - 1):
|
||
r, c = path[-1]
|
||
candidates = []
|
||
for dr, dc in DIRECTIONS:
|
||
nr, nc = r + dr, c + dc
|
||
if 0 <= nr < grid_size and 0 <= nc < grid_size:
|
||
if (nr, nc) not in occupied and (nr, nc) not in visited:
|
||
candidates.append((nr, nc))
|
||
if not candidates:
|
||
ok = False
|
||
break
|
||
nxt = random.choice(candidates)
|
||
path.append(nxt)
|
||
visited.add(nxt)
|
||
if ok and len(path) == len(word):
|
||
return path
|
||
return None
|
||
|
||
|
||
def fill_empty_cells(grid, grid_size, occupied, words_by_theme, all_words):
|
||
empty_cells = set()
|
||
for r in range(grid_size):
|
||
for c in range(grid_size):
|
||
if (r, c) not in occupied:
|
||
empty_cells.add((r, c))
|
||
|
||
if not empty_cells:
|
||
return [], {}
|
||
|
||
filler_words = []
|
||
for theme in words_by_theme:
|
||
for w in words_by_theme[theme]:
|
||
if 2 <= len(w) <= 4 and w not in all_words:
|
||
filler_words.append(w)
|
||
|
||
filler_words = sorted(list(set(filler_words)), key=len, reverse=True)
|
||
random.shuffle(filler_words)
|
||
|
||
filled_paths = {}
|
||
filled_words = []
|
||
remaining_empty = empty_cells.copy()
|
||
|
||
for word in filler_words:
|
||
if len(word) > len(remaining_empty):
|
||
continue
|
||
|
||
for _ in range(500):
|
||
if not remaining_empty:
|
||
break
|
||
start = random.choice(list(remaining_empty))
|
||
|
||
path = [start]
|
||
visited = {start}
|
||
ok = True
|
||
|
||
for _ in range(len(word) - 1):
|
||
r, c = path[-1]
|
||
candidates = []
|
||
for dr, dc in DIRECTIONS:
|
||
nr, nc = r + dr, c + dc
|
||
if 0 <= nr < grid_size and 0 <= nc < grid_size:
|
||
if (nr, nc) in remaining_empty and (nr, nc) not in visited:
|
||
candidates.append((nr, nc))
|
||
if not candidates:
|
||
ok = False
|
||
break
|
||
nxt = random.choice(candidates)
|
||
path.append(nxt)
|
||
visited.add(nxt)
|
||
|
||
if ok and len(path) == len(word):
|
||
for (r, c), letter in zip(path, word.upper()):
|
||
grid[r][c] = letter
|
||
if (r, c) in remaining_empty:
|
||
remaining_empty.remove((r, c))
|
||
|
||
filled_paths[word] = [list(p) for p in path]
|
||
filled_words.append(word)
|
||
break
|
||
|
||
for r, c in remaining_empty:
|
||
grid[r][c] = random.choice(ALPHABET)
|
||
|
||
return filled_words, filled_paths
|
||
|
||
|
||
def generate_grid(words, grid_size, words_by_theme, max_restarts=200):
|
||
words_sorted = sorted(words, key=len, reverse=True)
|
||
for _ in range(max_restarts):
|
||
grid = [['' for _ in range(grid_size)] for _ in range(grid_size)]
|
||
occupied = set()
|
||
word_paths = {}
|
||
success = True
|
||
|
||
for word in words_sorted:
|
||
path = try_place_word(word, grid_size, occupied)
|
||
if path is None:
|
||
success = False
|
||
break
|
||
for (r, c), letter in zip(path, word.upper()):
|
||
grid[r][c] = letter
|
||
occupied.update(path)
|
||
word_paths[word] = [list(p) for p in path]
|
||
|
||
if not success:
|
||
continue
|
||
|
||
all_words = set(words_sorted)
|
||
filled_words, filled_paths = fill_empty_cells(
|
||
grid, grid_size, occupied, words_by_theme, all_words
|
||
)
|
||
|
||
word_paths.update(filled_paths)
|
||
all_placed_words = words_sorted + filled_words
|
||
|
||
return grid, word_paths, all_placed_words
|
||
|
||
return None, None, None
|
||
|
||
|
||
async def save_level(conn, level_num, grid_size, theme, grid, word_paths, words, translations):
|
||
level = await conn.fetchrow(
|
||
"""INSERT INTO levels (level_number, grid_size, theme, grid_letters, word_paths)
|
||
VALUES ($1, $2, $3, $4, $5) RETURNING id""",
|
||
level_num, grid_size, theme, json.dumps(grid), json.dumps(word_paths)
|
||
)
|
||
level_id = level['id']
|
||
for word in words:
|
||
trans = translations.get(word, {})
|
||
await conn.execute(
|
||
"""INSERT INTO level_words (level_id, word_pl, translation_ru, translation_uk, translation_en)
|
||
VALUES ($1, $2, $3, $4, $5)""",
|
||
level_id, word,
|
||
trans.get('ru', ''),
|
||
trans.get('uk', ''),
|
||
trans.get('en', '')
|
||
)
|
||
|
||
|
||
async def main():
|
||
# ============ НАСТРОЙКИ ============
|
||
words_by_theme, translations = load_words_from_csv([
|
||
'words.csv'
|
||
])
|
||
|
||
NEW_LEVEL_CONFIG = [
|
||
(25, 10, 9), # 25 уровней: 10x10, 9 слов
|
||
(25, 10, 10), # 25 уровней: 10x10, 10 слов
|
||
(25, 10, 11), # 25 уровней: 10x10, 11 слов
|
||
(25, 10, 12), # 25 уровней: 10x10, 12 слов
|
||
]
|
||
# ==================================
|
||
|
||
conn = await asyncpg.connect(**DB_CONFIG)
|
||
|
||
current_max = await conn.fetchval("SELECT COALESCE(MAX(level_number), 0) FROM levels")
|
||
print(f"Сейчас уровней в базе: {current_max}")
|
||
print(f"Добавляем уровни {current_max + 1}–{current_max + 100}")
|
||
|
||
themes = list(words_by_theme.keys())
|
||
random.shuffle(themes)
|
||
|
||
level_num = current_max
|
||
theme_idx = 0
|
||
total_generated = 0
|
||
|
||
for count, grid_size, num_words in NEW_LEVEL_CONFIG:
|
||
for i in range(count):
|
||
level_num += 1
|
||
|
||
for attempt in range(15):
|
||
theme = themes[theme_idx % len(themes)]
|
||
theme_idx += 1
|
||
|
||
words = get_words_for_grid(words_by_theme, theme, num_words, grid_size)
|
||
if len(words) < num_words:
|
||
continue
|
||
|
||
grid, word_paths, all_words = generate_grid(
|
||
words, grid_size, words_by_theme
|
||
)
|
||
if grid is not None:
|
||
await save_level(
|
||
conn, level_num, grid_size, theme,
|
||
grid, word_paths, all_words, translations
|
||
)
|
||
total_cells = grid_size * grid_size
|
||
filled_cells = sum(len(w) for w in all_words)
|
||
print(f"✅ Level {level_num}: {grid_size}x{grid_size}, "
|
||
f"theme={theme}, words={len(all_words)} ({num_words} main), "
|
||
f"fill={filled_cells}/{total_cells}")
|
||
total_generated += 1
|
||
break
|
||
else:
|
||
print(f"❌ FAILED: Level {level_num} after 15 attempts")
|
||
level_num -= 1
|
||
|
||
await conn.close()
|
||
print(f"\n🎉 Готово! Добавлено {total_generated} новых уровней. Теперь всего уровней: {level_num}")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
asyncio.run(main())
|