486 lines
14 KiB
Dart
486 lines
14 KiB
Dart
import 'dart:math';
|
||
import '../data/formation_positions.dart';
|
||
import '../data/player_attributes.dart';
|
||
import '../data/league_data.dart';
|
||
import '../data/cardtype_data.dart';
|
||
|
||
enum ConstraintMode { playstyle, league, cardType, pool }
|
||
|
||
class FormationGenerator {
|
||
static final Random _rand = Random();
|
||
|
||
/// playerPool:
|
||
/// [{'name':'A', 'positions':['CF','ST']}, ...]
|
||
static Map<String, dynamic> generate({
|
||
required ConstraintMode mode,
|
||
bool rareStyleOn = false,
|
||
String? selectedLeague,
|
||
String? selectedCardType,
|
||
List<Map<String, dynamic>> playerPool = const [],
|
||
Map<String, int>? teamStyleWeights,
|
||
}) {
|
||
final formation = formations[_rand.nextInt(formations.length)];
|
||
final layout = getFormationLayout(formation);
|
||
final roles = _assignRolesForFormation(formation, layout);
|
||
final teamStyle = _pickTeamStyle(teamStyleWeights);
|
||
|
||
|
||
// poolモードのときだけ名前を割り当てる（混ぜない）
|
||
final names = (mode == ConstraintMode.pool)
|
||
? _assignNamesByRole(roles: roles, pool: playerPool)
|
||
: List.filled(roles.length, '');
|
||
|
||
final result = <Map<String, String>>[];
|
||
|
||
for (int i = 0; i < roles.length; i++) {
|
||
final pos = roles[i];
|
||
|
||
String styleOrValue;
|
||
switch (mode) {
|
||
case ConstraintMode.playstyle:
|
||
styleOrValue = _pickStyle(pos, rareStyleOn); // ←プレスタはそのまま
|
||
break;
|
||
|
||
case ConstraintMode.league:
|
||
// ランダムなら「ポジションごと」に抽選
|
||
styleOrValue = (selectedLeague == null)
|
||
? leagues[_rand.nextInt(leagues.length)]
|
||
: selectedLeague;
|
||
break;
|
||
|
||
case ConstraintMode.cardType:
|
||
styleOrValue = (selectedCardType == null)
|
||
? cardTypes[_rand.nextInt(cardTypes.length)]
|
||
: selectedCardType;
|
||
break;
|
||
|
||
case ConstraintMode.pool:
|
||
// poolモードでは「style」は表示用に空（混ぜない）
|
||
styleOrValue = '';
|
||
break;
|
||
}
|
||
|
||
result.add({
|
||
'pos': pos,
|
||
'style': styleOrValue,
|
||
'name': names[i],
|
||
});
|
||
}
|
||
|
||
return {
|
||
'formation': formation,
|
||
'mode': mode.name,
|
||
'constraintLabel': _constraintLabel(mode, selectedLeague, selectedCardType),
|
||
'positions': result,
|
||
'teamStyle':teamStyle
|
||
};
|
||
}
|
||
|
||
// =====================
|
||
// チームスタイル抽選
|
||
// =====================
|
||
static const List<String> teamStyles = [
|
||
'ポゼッション',
|
||
'ショートカウンター',
|
||
'ロングカウンター',
|
||
'サイドアタック',
|
||
'ロングボール',
|
||
];
|
||
|
||
static String _pickTeamStyle(Map<String, int>? weights) {
|
||
final w = weights ??
|
||
{
|
||
'ポゼッション': 50,
|
||
'ショートカウンター': 50,
|
||
'ロングカウンター': 50,
|
||
'サイドアタック': 50,
|
||
'ロングボール': 50,
|
||
};
|
||
|
||
final entries = teamStyles
|
||
.map((s) => MapEntry(s, w[s] ?? 0))
|
||
.where((e) => e.value > 0)
|
||
.toList();
|
||
|
||
if (entries.isEmpty) {
|
||
return teamStyles[_rand.nextInt(teamStyles.length)];
|
||
}
|
||
|
||
final total = entries.fold<int>(0, (sum, e) => sum + e.value);
|
||
int r = _rand.nextInt(total);
|
||
|
||
for (final e in entries) {
|
||
r -= e.value;
|
||
if (r < 0) return e.key;
|
||
}
|
||
|
||
return entries.last.key;
|
||
}
|
||
|
||
|
||
static String _constraintLabel(
|
||
ConstraintMode mode,
|
||
String? selectedLeague,
|
||
String? selectedCardType,
|
||
) {
|
||
switch (mode) {
|
||
case ConstraintMode.playstyle:
|
||
return 'プレースタイル縛り';
|
||
case ConstraintMode.league:
|
||
return selectedLeague != null
|
||
? 'リーグ縛り: $selectedLeague'
|
||
: 'リーグ縛り: ランダム（ポジション別）';
|
||
case ConstraintMode.cardType:
|
||
return selectedCardType != null
|
||
? 'カードタイプ縛り: $selectedCardType'
|
||
: 'カードタイプ縛り: ランダム（ポジション別）';
|
||
case ConstraintMode.pool:
|
||
return '選手プール抽選';
|
||
}
|
||
}
|
||
|
||
// ============================
|
||
// プール割り当て（完全一致）
|
||
// ============================
|
||
static List<String> _assignNamesByRole({
|
||
required List<String> roles,
|
||
required List<Map<String, dynamic>> pool,
|
||
}) {
|
||
final remaining = pool
|
||
.map((p) => {
|
||
'name': (p['name'] ?? '').toString().trim(),
|
||
'positions': List<String>.from(p['positions'] ?? const <String>[]),
|
||
})
|
||
.where((p) => (p['name'] as String).isNotEmpty)
|
||
.toList();
|
||
|
||
final assigned = <String>[];
|
||
|
||
for (final role in roles) {
|
||
final candidates = remaining
|
||
.where((p) => (p['positions'] as List<String>).contains(role))
|
||
.toList();
|
||
|
||
if (candidates.isEmpty) {
|
||
assigned.add('未登録');
|
||
continue;
|
||
}
|
||
|
||
final pick = candidates[_rand.nextInt(candidates.length)];
|
||
assigned.add(pick['name'] as String);
|
||
remaining.remove(pick);
|
||
}
|
||
return assigned;
|
||
}
|
||
|
||
// ============================
|
||
// プレスタ（触らない）
|
||
// ============================
|
||
static String _pickStyle(String pos, bool rareStyleOn) {
|
||
final list = playerAttributes[pos];
|
||
final baseList = (list == null || list.isEmpty) ? allPlayStyle : list;
|
||
return _weightedRandomStyle(baseList, rareStyleOn);
|
||
}
|
||
|
||
static String _weightedRandomStyle(List<String> styles, bool rareStyleOn) {
|
||
const rareStyles = {
|
||
'デコイラン',
|
||
'ナンバー10',
|
||
'ターゲットマン',
|
||
'インナーラップサイドバック',
|
||
'オーバーラップ',
|
||
'インサイドレシーバー',
|
||
};
|
||
|
||
if (rareStyleOn) {
|
||
return styles[_rand.nextInt(styles.length)];
|
||
}
|
||
|
||
final weights = <double>[];
|
||
double total = 0;
|
||
for (final s in styles) {
|
||
final w = rareStyles.contains(s) ? 0.3 : 1.0;
|
||
weights.add(w);
|
||
total += w;
|
||
}
|
||
|
||
final r = _rand.nextDouble() * total;
|
||
double acc = 0;
|
||
for (int i = 0; i < styles.length; i++) {
|
||
acc += weights[i];
|
||
if (r <= acc) return styles[i];
|
||
}
|
||
return styles.last;
|
||
}
|
||
|
||
// =====================================
|
||
// フォメ + レイアウトに応じて役割を割り当て
|
||
// =====================================
|
||
static List<String> _assignRolesForFormation(
|
||
String formation,
|
||
List<List<Map<String, double>>> layout,
|
||
) {
|
||
final parts = formation.split('-').map(int.parse).toList();
|
||
final int dfCount = parts[0];
|
||
final int fwCount = parts.last;
|
||
final bool isFourLineFormation = parts.length == 4; // 4-1-4-1, 4-2-3-1 など
|
||
|
||
// 中盤総人数（「4-4-2」なら 4、『4-2-3-1』なら 2+3=5）
|
||
int mfPlayers = 0;
|
||
if (parts.length > 2) {
|
||
mfPlayers = parts.sublist(1, parts.length - 1).reduce((a, b) => a + b);
|
||
}
|
||
|
||
final roles = <String>[];
|
||
|
||
int mfRowIndex = 0; // MF行の中での何列目か (0 = 2列目 = FW直下)
|
||
|
||
for (int row = 0; row < layout.length; row++) {
|
||
final slots = layout[row].length;
|
||
final isTop = row == 0;
|
||
final isBottom = row == layout.length - 1;
|
||
final isDfRow = row == layout.length - 2;
|
||
|
||
if (isTop) {
|
||
// 一番上の行 → FW
|
||
roles.addAll(_assignFW(fwCount));
|
||
} else if (isBottom) {
|
||
// 一番下の行 → GK（スロットすべて GK 扱いだが基本1人）
|
||
for (int i = 0; i < slots; i++) {
|
||
roles.add('GK');
|
||
}
|
||
} else if (isDfRow) {
|
||
// DF行
|
||
roles.addAll(_assignDF(dfCount));
|
||
} else {
|
||
// MF行
|
||
roles.addAll(_assignMFRow(
|
||
formation: formation,
|
||
isFourLineFormation: isFourLineFormation,
|
||
mfRowIndex: mfRowIndex,
|
||
slots: slots,
|
||
mfPlayers: mfPlayers,
|
||
));
|
||
mfRowIndex++;
|
||
}
|
||
}
|
||
|
||
return roles;
|
||
}
|
||
|
||
// =====================================
|
||
static List<String> _assignFW(int count) {
|
||
// 1トップ → LWG/RWG は出さない（CF/STだけ）
|
||
if (count == 1) {
|
||
return [_rand.nextDouble() < 0.8 ? 'CF' : 'ST'];
|
||
}
|
||
|
||
// 2トップ → サイド禁止（CF/STだけ）
|
||
if (count == 2) {
|
||
final pool = <String>['CF', 'CF', 'CF', 'ST'];
|
||
return List.generate(2, (_) => pool[_rand.nextInt(pool.length)]);
|
||
}
|
||
|
||
// 3トップ → 左LWG / 中央CF or ST / 右RWG に固定
|
||
if (count == 3) {
|
||
return [
|
||
'LWG',
|
||
_rand.nextBool() ? 'CF' : 'ST',
|
||
'RWG',
|
||
];
|
||
}
|
||
|
||
// 想定外 → とりあえずCFで埋める
|
||
return List.filled(count, 'CF');
|
||
}
|
||
|
||
// =====================================
|
||
// DF ロジック
|
||
// =====================================
|
||
static List<String> _assignDF(int count) {
|
||
if (count == 5) {
|
||
// 5バック
|
||
return ['LSB', 'CB', 'CB', 'CB', 'RSB'];
|
||
}
|
||
if (count == 4) {
|
||
// 4バック（3パターンから抽選）
|
||
final patterns = [
|
||
['LSB', 'CB', 'CB', 'RSB'],
|
||
['LSB', 'CB', 'CB', 'CB'],
|
||
['CB', 'CB', 'CB', 'RSB'],
|
||
];
|
||
return patterns[_rand.nextInt(patterns.length)];
|
||
}
|
||
if (count == 3) {
|
||
// 3バック
|
||
return ['CB', 'CB', 'CB'];
|
||
}
|
||
|
||
// それ以外 → 全部CBで埋める
|
||
return List.filled(count, 'CB');
|
||
}
|
||
|
||
// =====================================
|
||
// MF行ごとの割り当て
|
||
// =====================================
|
||
static List<String> _assignMFRow({
|
||
required String formation,
|
||
required bool isFourLineFormation,
|
||
required int mfRowIndex, // 0 = 最前線の一つ後ろ（2列目）
|
||
required int slots, // そのMF行の人数（レイアウト上）
|
||
required int mfPlayers, // 中盤総人数
|
||
}) {
|
||
final parts = formation.split('-').map(int.parse).toList();
|
||
bool allowWideMF = false;
|
||
|
||
if (isFourLineFormation) {
|
||
final int v2 = parts[1]; // 2列目MF
|
||
final int v3 = parts[2]; // 3列目MF
|
||
|
||
// ★ 4列フォメの3列目(mfRowIndex == 1)には LMF/RMF を絶対出さない
|
||
if (mfRowIndex == 1) {
|
||
allowWideMF = false;
|
||
} else {
|
||
// 2列目(mfRowIndex == 0)のみチェック
|
||
if (v2 + v3 >= 4 && mfRowIndex == 0 && slots >= 3) {
|
||
allowWideMF = true;
|
||
}
|
||
}
|
||
} else {
|
||
// 3列フォメ
|
||
final int mid = parts[1];
|
||
if (mid >= 4 && mfRowIndex == 0 && slots >= 3) {
|
||
allowWideMF = true;
|
||
}
|
||
}
|
||
|
||
return _assignMFLogic(
|
||
formation: formation,
|
||
isFourLineFormation: isFourLineFormation,
|
||
mfRowIndex: mfRowIndex,
|
||
slots: slots,
|
||
mfPlayers: mfPlayers,
|
||
allowWideMF: allowWideMF,
|
||
);
|
||
}
|
||
|
||
// =====================================
|
||
// OMF / DMF の制約
|
||
// =====================================
|
||
static List<String> _applyMFConstraints(
|
||
List<String> row, bool isFourLineFormation, int mfRowIndex) {
|
||
// OMF制約
|
||
row = row.map((p) {
|
||
if (p == 'OMF') {
|
||
if (!isFourLineFormation) return 'CMF';
|
||
if (mfRowIndex != 0) return 'CMF';
|
||
}
|
||
return p;
|
||
}).toList();
|
||
|
||
// DMF制約：4列フォメの2列目のみ禁止
|
||
if (isFourLineFormation && mfRowIndex == 0) {
|
||
row = row.map((p) => p == 'DMF' ? 'CMF' : p).toList();
|
||
}
|
||
|
||
return row;
|
||
}
|
||
|
||
// =====================================
|
||
// MF ロジック本体
|
||
// =====================================
|
||
static List<String> _assignMFLogic({
|
||
required String formation,
|
||
required bool isFourLineFormation,
|
||
required int mfRowIndex,
|
||
required int slots,
|
||
required int mfPlayers,
|
||
required bool allowWideMF,
|
||
}) {
|
||
final r = _rand;
|
||
final bool useWide = allowWideMF;
|
||
|
||
if (slots == 1) {
|
||
final row = ['DMF'];
|
||
return _applyMFConstraints(row, isFourLineFormation, mfRowIndex);
|
||
}
|
||
|
||
if (useWide && slots >= 3) {
|
||
List<String> row = List.filled(slots, 'CMF');
|
||
row[0] = 'LMF';
|
||
row[slots - 1] = 'RMF';
|
||
|
||
for (int i = 1; i < slots - 1; i++) {
|
||
if (isFourLineFormation && mfRowIndex == 0) {
|
||
final centerPool = ['OMF', 'OMF', 'OMF', 'CMF'];
|
||
row[i] = centerPool[r.nextInt(centerPool.length)];
|
||
} else if (isFourLineFormation) {
|
||
final centerPool = ['DMF', 'DMF', 'DMF', 'CMF'];
|
||
row[i] = centerPool[r.nextInt(centerPool.length)];
|
||
} else {
|
||
final centerPool = ['DMF', 'DMF', 'DMF', 'CMF'];
|
||
row[i] = centerPool[r.nextInt(centerPool.length)];
|
||
}
|
||
}
|
||
|
||
return _applyMFConstraints(row, isFourLineFormation, mfRowIndex);
|
||
}
|
||
|
||
if (slots == 2) {
|
||
List<String> row;
|
||
|
||
if (isFourLineFormation) {
|
||
if (mfRowIndex == 0) {
|
||
final pool = ['OMF', 'OMF', 'OMF', 'CMF'];
|
||
row = [
|
||
pool[r.nextInt(pool.length)],
|
||
pool[r.nextInt(pool.length)],
|
||
];
|
||
} else {
|
||
final pool = ['DMF', 'DMF', 'DMF', 'CMF'];
|
||
row = [
|
||
pool[r.nextInt(pool.length)],
|
||
pool[r.nextInt(pool.length)],
|
||
];
|
||
}
|
||
} else {
|
||
final pool = ['DMF', 'CMF', 'CMF'];
|
||
row = [
|
||
pool[r.nextInt(pool.length)],
|
||
pool[r.nextInt(pool.length)],
|
||
];
|
||
}
|
||
|
||
return _applyMFConstraints(row, isFourLineFormation, mfRowIndex);
|
||
}
|
||
|
||
if (slots == 3 && !useWide) {
|
||
List<String> row;
|
||
|
||
if (isFourLineFormation) {
|
||
if (mfRowIndex == 0) {
|
||
final pool = ['OMF', 'OMF', 'CMF'];
|
||
row = [
|
||
pool[r.nextInt(pool.length)],
|
||
pool[r.nextInt(pool.length)],
|
||
pool[r.nextInt(pool.length)],
|
||
];
|
||
} else {
|
||
row = ['DMF', 'DMF', 'CMF'];
|
||
}
|
||
} else {
|
||
row = ['CMF', 'DMF', 'CMF'];
|
||
}
|
||
|
||
return _applyMFConstraints(row, isFourLineFormation, mfRowIndex);
|
||
}
|
||
|
||
List<String> row = List.filled(slots, 'CMF');
|
||
final center = slots ~/ 2;
|
||
row[center] = 'DMF';
|
||
if (center - 1 >= 0) row[center - 1] = 'DMF';
|
||
if (center + 1 < slots) row[center + 1] = 'DMF';
|
||
return _applyMFConstraints(row, isFourLineFormation, mfRowIndex);
|
||
}
|
||
}
|