647 lines
23 KiB
Python
647 lines
23 KiB
Python
"""
|
|
routes/attack_planner.py — Coordinated Attack Planner Blueprint
|
|
|
|
Endpoints:
|
|
GET /api/server_time Clock sync
|
|
POST /api/<world>/attack_plans Create plan
|
|
GET /api/<world>/attack_plans List plans
|
|
GET /api/<world>/attack_plans/<plan_id> Get plan details
|
|
POST /api/<world>/attack_plans/<plan_id>/arm Arm plan (lock & activate)
|
|
POST /api/<world>/attack_plans/<plan_id>/cancel Cancel plan
|
|
POST /api/<world>/attack_plans/<plan_id>/participants Add participant
|
|
DELETE /api/<world>/attack_plans/<plan_id>/participants/<town_id> Remove participant
|
|
POST /api/<world>/attack_plans/<plan_id>/participants/<town_id>/cancel Self-cancel
|
|
POST /api/<world>/attack_plans/<plan_id>/participants/<town_id>/status Bot status report
|
|
|
|
Access control:
|
|
- 'attack_planner_admin' feature: can create/arm/cancel plans, add participants
|
|
- 'attack_planner' feature: can view plans, self-cancel, report status
|
|
- Default new members: neither feature (off by default)
|
|
"""
|
|
|
|
from flask import Blueprint, request, jsonify
|
|
from flask_login import login_required, current_user
|
|
from db import get_db
|
|
from datetime import datetime
|
|
import json
|
|
import math
|
|
import time
|
|
import logging
|
|
|
|
_log = logging.getLogger(__name__)
|
|
|
|
attack_planner = Blueprint('attack_planner', __name__)
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# GET /api/server_time
|
|
# Used by Tampermonkey to measure clock offset (no auth required,
|
|
# it's just a timestamp — no sensitive data).
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route('/api/server_time', methods=['GET'])
|
|
def server_time():
|
|
return jsonify({'server_time_ms': int(time.time() * 1000)})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# Helpers
|
|
# ------------------------------------------------------------------
|
|
def _get_clan_from_request():
|
|
key = request.headers.get('X-Clan-Key', '').strip()
|
|
if not key:
|
|
return None
|
|
conn = get_db()
|
|
clan = conn.execute('SELECT * FROM clans WHERE clan_key = ?', (key,)).fetchone()
|
|
conn.close()
|
|
return clan
|
|
|
|
|
|
def _get_member_features(clan_id, player_id):
|
|
"""Return set of feature strings for this player in this clan."""
|
|
conn = get_db()
|
|
row = conn.execute(
|
|
'SELECT features FROM clan_members WHERE clan_id = ? AND player_id = ?',
|
|
(clan_id, str(player_id))
|
|
).fetchone()
|
|
conn.close()
|
|
if not row:
|
|
return set()
|
|
return set(f.strip() for f in (row['features'] or '').split(',') if f.strip())
|
|
|
|
|
|
def _has_feature(clan_id, player_id, feature):
|
|
return feature in _get_member_features(clan_id, player_id)
|
|
|
|
|
|
def _get_world_data(world_id):
|
|
"""Fetch world_speed and unit_speeds from kv_store."""
|
|
conn = get_db()
|
|
row = conn.execute(
|
|
"SELECT value FROM kv_store WHERE key = ?",
|
|
(f'world_data_{world_id}',)
|
|
).fetchone()
|
|
conn.close()
|
|
if not row:
|
|
return None
|
|
try:
|
|
return json.loads(row['value'])
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _calculate_participant(origin_x, origin_y, origin_sea,
|
|
target_x, target_y, target_sea,
|
|
units, world_data):
|
|
"""
|
|
Calculate travel_time, send_time, return_time, attack_type,
|
|
transport_needed, transport_count for one participant.
|
|
|
|
Returns dict with all calculated fields, or sets is_feasible=False with error_msg.
|
|
"""
|
|
result = {
|
|
'attack_type': 'attack_land',
|
|
'transport_needed': False,
|
|
'transport_count': 0,
|
|
'travel_time_secs': None,
|
|
'is_feasible': True,
|
|
'error_msg': None,
|
|
}
|
|
|
|
if origin_x is None or origin_y is None or target_x is None or target_y is None:
|
|
result['is_feasible'] = False
|
|
result['error_msg'] = 'Missing coordinates'
|
|
return result
|
|
|
|
if not world_data:
|
|
result['is_feasible'] = False
|
|
result['error_msg'] = 'World speed data not available — wait for client sync'
|
|
return result
|
|
|
|
world_speed = world_data.get('world_speed', 1.0)
|
|
unit_speeds = world_data.get('unit_speeds', {})
|
|
|
|
# Distance (Pythagorean)
|
|
distance = math.sqrt((target_x - origin_x) ** 2 + (target_y - origin_y) ** 2)
|
|
|
|
# Determine attack type: sea if different sea zone
|
|
is_sea = (origin_sea is not None and target_sea is not None and origin_sea != target_sea)
|
|
result['attack_type'] = 'attack_sea' if is_sea else 'attack_land'
|
|
|
|
# Find slowest unit speed
|
|
min_speed = None
|
|
total_land_pop = 0
|
|
has_units = False
|
|
|
|
for unit_id, count in (units or {}).items():
|
|
if not isinstance(count, int) or count <= 0:
|
|
continue
|
|
ud = unit_speeds.get(unit_id)
|
|
if not ud:
|
|
continue
|
|
has_units = True
|
|
speed = ud.get('speed', 1.0)
|
|
if min_speed is None or speed < min_speed:
|
|
min_speed = speed
|
|
if not ud.get('is_naval', False):
|
|
total_land_pop += count * ud.get('population', 1)
|
|
|
|
if not has_units or min_speed is None:
|
|
result['is_feasible'] = False
|
|
result['error_msg'] = 'No valid units selected'
|
|
return result
|
|
|
|
# Travel time: hours = distance / (speed * world_speed)
|
|
if min_speed * world_speed <= 0:
|
|
result['is_feasible'] = False
|
|
result['error_msg'] = 'Invalid speed data'
|
|
return result
|
|
|
|
travel_hours = distance / (min_speed * world_speed)
|
|
travel_secs = int(travel_hours * 3600)
|
|
result['travel_time_secs'] = travel_secs
|
|
|
|
# Transport calculation for sea attacks with land units
|
|
if is_sea and total_land_pop > 0:
|
|
result['transport_needed'] = True
|
|
transport_cap = 0
|
|
for uid, ud in unit_speeds.items():
|
|
if ud.get('capacity', 0) > 0:
|
|
transport_cap = ud['capacity']
|
|
break
|
|
if transport_cap <= 0:
|
|
result['is_feasible'] = False
|
|
result['error_msg'] = 'Transport capacity data missing — wait for client sync'
|
|
return result
|
|
result['transport_count'] = math.ceil(total_land_pop / transport_cap)
|
|
|
|
return result
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# POST /api/<world_id>/attack_plans
|
|
# Create a new plan (draft). Requires attack_planner_admin feature.
|
|
# Body: { player_id, plan_name, target_town_name, target_x, target_y,
|
|
# target_sea, target_arrival_time }
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route('/api/<world_id>/attack_plans', methods=['POST'])
|
|
def create_plan(world_id):
|
|
clan = _get_clan_from_request()
|
|
if not clan:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
player_id = str(data.get('player_id', '')).strip()
|
|
|
|
if not _has_feature(clan['id'], player_id, 'attack_planner_admin'):
|
|
return jsonify({'error': 'No attack_planner_admin permission'}), 403
|
|
|
|
plan_name = data.get('plan_name', '').strip() or 'Επίθεση'
|
|
target_name = data.get('target_town_name', '').strip()
|
|
target_x = data.get('target_x')
|
|
target_y = data.get('target_y')
|
|
arrival = data.get('target_arrival_time') # unix epoch int
|
|
|
|
if not arrival:
|
|
return jsonify({'error': 'target_arrival_time required'}), 400
|
|
|
|
now = int(time.time())
|
|
if int(arrival) <= now + 120:
|
|
return jsonify({'error': 'Arrival time must be at least 2 minutes in the future'}), 400
|
|
|
|
conn = get_db()
|
|
cur = conn.execute('''
|
|
INSERT INTO attack_plans
|
|
(world_id, plan_name, created_by_player_id,
|
|
target_town_name, target_x, target_y,
|
|
target_arrival_time, status)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, 'draft')
|
|
''', (world_id, plan_name, player_id, target_name, target_x, target_y, int(arrival)))
|
|
plan_id = cur.lastrowid
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
return jsonify({'ok': True, 'plan_id': plan_id})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# GET /api/<world_id>/attack_plans
|
|
# List all non-cancelled plans for this world.
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route('/api/<world_id>/attack_plans', methods=['GET'])
|
|
@login_required
|
|
def list_plans(world_id):
|
|
conn = get_db()
|
|
rows = conn.execute('''
|
|
SELECT ap.*,
|
|
COUNT(app.id) as participant_count
|
|
FROM attack_plans ap
|
|
LEFT JOIN attack_plan_participants app ON app.plan_id = ap.id
|
|
WHERE ap.world_id = ? AND ap.status != 'cancelled'
|
|
GROUP BY ap.id
|
|
ORDER BY ap.target_arrival_time ASC
|
|
''', (world_id,)).fetchall()
|
|
conn.close()
|
|
return jsonify([dict(r) for r in rows])
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# GET /api/<world_id>/attack_plans/<plan_id>
|
|
# Full plan details including participants.
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route('/api/<world_id>/attack_plans/<int:plan_id>', methods=['GET'])
|
|
@login_required
|
|
def get_plan(world_id, plan_id):
|
|
conn = get_db()
|
|
plan = conn.execute(
|
|
'SELECT * FROM attack_plans WHERE id = ? AND world_id = ?',
|
|
(plan_id, world_id)
|
|
).fetchone()
|
|
if not plan:
|
|
conn.close()
|
|
return jsonify({'error': 'Plan not found'}), 404
|
|
|
|
participants = conn.execute(
|
|
'SELECT * FROM attack_plan_participants WHERE plan_id = ? ORDER BY send_time ASC',
|
|
(plan_id,)
|
|
).fetchall()
|
|
conn.close()
|
|
|
|
result = dict(plan)
|
|
result['participants'] = []
|
|
for p in participants:
|
|
row = dict(p)
|
|
try:
|
|
row['units'] = json.loads(row['units'])
|
|
except Exception:
|
|
row['units'] = {}
|
|
result['participants'].append(row)
|
|
|
|
return jsonify(result)
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# POST /api/<world_id>/attack_plans/<plan_id>/participants
|
|
# Add a participant town to the plan.
|
|
# Body: { player_id, origin_town_id, origin_town_name, origin_x, origin_y,
|
|
# origin_sea, units: {unit_id: count, ...} }
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route('/api/<world_id>/attack_plans/<int:plan_id>/participants', methods=['POST'])
|
|
def add_participant(world_id, plan_id):
|
|
clan = _get_clan_from_request()
|
|
if not clan:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
requester_id = str(data.get('requester_player_id', '')).strip()
|
|
|
|
if not _has_feature(clan['id'], requester_id, 'attack_planner_admin'):
|
|
return jsonify({'error': 'No attack_planner_admin permission'}), 403
|
|
|
|
conn = get_db()
|
|
plan = conn.execute(
|
|
"SELECT * FROM attack_plans WHERE id = ? AND world_id = ? AND status = 'draft'",
|
|
(plan_id, world_id)
|
|
).fetchone()
|
|
if not plan:
|
|
conn.close()
|
|
return jsonify({'error': 'Plan not found or not in draft status'}), 404
|
|
|
|
player_id = str(data.get('player_id', '')).strip()
|
|
origin_town_id = str(data.get('origin_town_id', '')).strip()
|
|
origin_town_name = data.get('origin_town_name', '')
|
|
origin_x = data.get('origin_x')
|
|
origin_y = data.get('origin_y')
|
|
origin_sea = data.get('origin_sea')
|
|
units = data.get('units', {})
|
|
|
|
if not player_id or not origin_town_id:
|
|
conn.close()
|
|
return jsonify({'error': 'player_id and origin_town_id required'}), 400
|
|
|
|
# Get target sea from plan (we store it? No — we need to infer from coordinates)
|
|
# Approximate: sea = floor(x/100)*10 + floor(y/100)
|
|
target_x = plan['target_x']
|
|
target_y = plan['target_y']
|
|
target_sea = None
|
|
if target_x is not None and target_y is not None:
|
|
target_sea = int(math.floor(target_x / 100)) * 10 + int(math.floor(target_y / 100))
|
|
|
|
world_data = _get_world_data(world_id)
|
|
calc = _calculate_participant(
|
|
origin_x, origin_y, origin_sea,
|
|
target_x, target_y, target_sea,
|
|
units, world_data
|
|
)
|
|
|
|
arrival = plan['target_arrival_time']
|
|
send_time = None
|
|
return_time = None
|
|
if calc['travel_time_secs'] is not None:
|
|
send_time = arrival - calc['travel_time_secs']
|
|
return_time = arrival + calc['travel_time_secs']
|
|
|
|
# Validate: send_time must be at least 2 min in future
|
|
now = int(time.time())
|
|
if send_time <= now + 120:
|
|
calc['is_feasible'] = False
|
|
calc['error_msg'] = (
|
|
f"Send time is too soon ({(send_time - now)//60}m remaining). "
|
|
"Choose a later arrival time or remove this town."
|
|
)
|
|
|
|
try:
|
|
conn.execute('''
|
|
INSERT INTO attack_plan_participants
|
|
(plan_id, player_id, world_id, origin_town_id, origin_town_name,
|
|
units, attack_type, transport_needed, transport_count,
|
|
travel_time_secs, send_time, return_time, is_feasible, error_msg)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT(plan_id, origin_town_id) DO UPDATE SET
|
|
player_id = excluded.player_id,
|
|
units = excluded.units,
|
|
attack_type = excluded.attack_type,
|
|
transport_needed= excluded.transport_needed,
|
|
transport_count = excluded.transport_count,
|
|
travel_time_secs= excluded.travel_time_secs,
|
|
send_time = excluded.send_time,
|
|
return_time = excluded.return_time,
|
|
is_feasible = excluded.is_feasible,
|
|
error_msg = excluded.error_msg,
|
|
updated_at = datetime('now')
|
|
''', (
|
|
plan_id, player_id, world_id,
|
|
origin_town_id, origin_town_name,
|
|
json.dumps(units),
|
|
calc['attack_type'],
|
|
1 if calc['transport_needed'] else 0,
|
|
calc['transport_count'],
|
|
calc['travel_time_secs'],
|
|
send_time, return_time,
|
|
1 if calc['is_feasible'] else 0,
|
|
calc['error_msg']
|
|
))
|
|
conn.commit()
|
|
except Exception as e:
|
|
conn.close()
|
|
return jsonify({'error': str(e)}), 500
|
|
|
|
conn.close()
|
|
return jsonify({
|
|
'ok': True,
|
|
'is_feasible': calc['is_feasible'],
|
|
'error_msg': calc['error_msg'],
|
|
'attack_type': calc['attack_type'],
|
|
'transport_count': calc['transport_count'],
|
|
'travel_time_secs': calc['travel_time_secs'],
|
|
'send_time': send_time,
|
|
'return_time': return_time,
|
|
})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# DELETE /api/<world_id>/attack_plans/<plan_id>/participants/<town_id>
|
|
# Remove a participant (coordinator/admin only, plan must be draft).
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route(
|
|
'/api/<world_id>/attack_plans/<int:plan_id>/participants/<town_id>',
|
|
methods=['DELETE']
|
|
)
|
|
def remove_participant(world_id, plan_id, town_id):
|
|
clan = _get_clan_from_request()
|
|
if not clan:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
requester_id = str(data.get('requester_player_id', '')).strip()
|
|
|
|
if not _has_feature(clan['id'], requester_id, 'attack_planner_admin'):
|
|
return jsonify({'error': 'No permission'}), 403
|
|
|
|
conn = get_db()
|
|
conn.execute(
|
|
'DELETE FROM attack_plan_participants WHERE plan_id = ? AND origin_town_id = ?',
|
|
(plan_id, town_id)
|
|
)
|
|
conn.commit()
|
|
conn.close()
|
|
return jsonify({'ok': True})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# POST /api/<world_id>/attack_plans/<plan_id>/participants/<town_id>/cancel
|
|
# Player self-cancels their own town's participation (if > 2min before send).
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route(
|
|
'/api/<world_id>/attack_plans/<int:plan_id>/participants/<town_id>/cancel',
|
|
methods=['POST']
|
|
)
|
|
def cancel_participant(world_id, plan_id, town_id):
|
|
clan = _get_clan_from_request()
|
|
if not clan:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
player_id = str(data.get('player_id', '')).strip()
|
|
|
|
conn = get_db()
|
|
row = conn.execute(
|
|
'''SELECT app.*, ap.status as plan_status
|
|
FROM attack_plan_participants app
|
|
JOIN attack_plans ap ON ap.id = app.plan_id
|
|
WHERE app.plan_id = ? AND app.origin_town_id = ? AND app.player_id = ?''',
|
|
(plan_id, town_id, player_id)
|
|
).fetchone()
|
|
|
|
if not row:
|
|
conn.close()
|
|
return jsonify({'error': 'Participant not found'}), 404
|
|
|
|
now = int(time.time())
|
|
send_time = row['send_time'] or 0
|
|
if send_time > 0 and (send_time - now) < 120:
|
|
conn.close()
|
|
return jsonify({'error': 'Too close to send time — cannot cancel'}), 400
|
|
|
|
conn.execute(
|
|
"UPDATE attack_plan_participants SET status='cancelled', updated_at=datetime('now') "
|
|
"WHERE plan_id = ? AND origin_town_id = ?",
|
|
(plan_id, town_id)
|
|
)
|
|
conn.commit()
|
|
conn.close()
|
|
return jsonify({'ok': True})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# POST /api/<world_id>/attack_plans/<plan_id>/participants/<town_id>/status
|
|
# Tampermonkey bot reports its status (armed, sent, missed).
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route(
|
|
'/api/<world_id>/attack_plans/<int:plan_id>/participants/<town_id>/status',
|
|
methods=['POST']
|
|
)
|
|
def report_participant_status(world_id, plan_id, town_id):
|
|
clan = _get_clan_from_request()
|
|
if not clan:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
new_status = data.get('status', '').strip()
|
|
if new_status not in ('armed', 'sent', 'missed'):
|
|
return jsonify({'error': 'Invalid status'}), 400
|
|
|
|
conn = get_db()
|
|
conn.execute(
|
|
"UPDATE attack_plan_participants SET status=?, updated_at=datetime('now') "
|
|
"WHERE plan_id = ? AND origin_town_id = ?",
|
|
(new_status, plan_id, town_id)
|
|
)
|
|
conn.commit()
|
|
|
|
# If all active participants are sent/missed, mark plan completed
|
|
pending = conn.execute(
|
|
"SELECT COUNT(*) as n FROM attack_plan_participants "
|
|
"WHERE plan_id = ? AND status NOT IN ('sent','missed','cancelled')",
|
|
(plan_id,)
|
|
).fetchone()['n']
|
|
if pending == 0:
|
|
conn.execute(
|
|
"UPDATE attack_plans SET status='completed', updated_at=datetime('now') WHERE id=?",
|
|
(plan_id,)
|
|
)
|
|
conn.commit()
|
|
|
|
conn.close()
|
|
return jsonify({'ok': True})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# POST /api/<world_id>/attack_plans/<plan_id>/arm
|
|
# Lock the plan and activate it. Validates all participants feasible.
|
|
# Requires attack_planner_admin.
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route('/api/<world_id>/attack_plans/<int:plan_id>/arm', methods=['POST'])
|
|
def arm_plan(world_id, plan_id):
|
|
clan = _get_clan_from_request()
|
|
if not clan:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
player_id = str(data.get('player_id', '')).strip()
|
|
|
|
if not _has_feature(clan['id'], player_id, 'attack_planner_admin'):
|
|
return jsonify({'error': 'No permission'}), 403
|
|
|
|
conn = get_db()
|
|
plan = conn.execute(
|
|
"SELECT * FROM attack_plans WHERE id = ? AND world_id = ? AND status = 'draft'",
|
|
(plan_id, world_id)
|
|
).fetchone()
|
|
if not plan:
|
|
conn.close()
|
|
return jsonify({'error': 'Plan not found or not in draft'}), 404
|
|
|
|
# Check all participants are feasible and have valid send_times
|
|
infeasible = conn.execute(
|
|
"SELECT COUNT(*) as n FROM attack_plan_participants "
|
|
"WHERE plan_id = ? AND is_feasible = 0 AND status != 'cancelled'",
|
|
(plan_id,)
|
|
).fetchone()['n']
|
|
if infeasible > 0:
|
|
conn.close()
|
|
return jsonify({'error': f'{infeasible} participant(s) are not feasible — fix or remove them first'}), 400
|
|
|
|
now = int(time.time())
|
|
# Check earliest send_time is >= 2 min away
|
|
earliest = conn.execute(
|
|
"SELECT MIN(send_time) as earliest FROM attack_plan_participants "
|
|
"WHERE plan_id = ? AND status != 'cancelled'",
|
|
(plan_id,)
|
|
).fetchone()['earliest']
|
|
if earliest and (earliest - now) < 120:
|
|
conn.close()
|
|
return jsonify({'error': 'Earliest send time is less than 2 minutes away'}), 400
|
|
|
|
conn.execute(
|
|
"UPDATE attack_plans SET status='active', updated_at=datetime('now') WHERE id=?",
|
|
(plan_id,)
|
|
)
|
|
conn.commit()
|
|
conn.close()
|
|
return jsonify({'ok': True})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# POST /api/<world_id>/attack_plans/<plan_id>/cancel
|
|
# Cancel the entire plan.
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route('/api/<world_id>/attack_plans/<int:plan_id>/cancel', methods=['POST'])
|
|
def cancel_plan(world_id, plan_id):
|
|
clan = _get_clan_from_request()
|
|
if not clan:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
data = request.get_json(silent=True) or {}
|
|
player_id = str(data.get('player_id', '')).strip()
|
|
|
|
if not _has_feature(clan['id'], player_id, 'attack_planner_admin'):
|
|
return jsonify({'error': 'No permission'}), 403
|
|
|
|
conn = get_db()
|
|
conn.execute(
|
|
"UPDATE attack_plans SET status='cancelled', updated_at=datetime('now') "
|
|
"WHERE id = ? AND world_id = ?",
|
|
(plan_id, world_id)
|
|
)
|
|
conn.commit()
|
|
conn.close()
|
|
return jsonify({'ok': True})
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
# GET /api/<world_id>/attack_plans/active
|
|
# Tampermonkey polls this to get active plans for its towns.
|
|
# Returns plans where this player has active participants.
|
|
# ------------------------------------------------------------------
|
|
@attack_planner.route('/api/<world_id>/attack_plans/active', methods=['GET'])
|
|
def get_active_plans(world_id):
|
|
clan = _get_clan_from_request()
|
|
if not clan:
|
|
return jsonify({'error': 'Unauthorized'}), 403
|
|
|
|
player_id = request.args.get('player_id', '').strip()
|
|
if not player_id:
|
|
return jsonify({'error': 'player_id required'}), 400
|
|
|
|
conn = get_db()
|
|
rows = conn.execute('''
|
|
SELECT ap.id as plan_id, ap.plan_name,
|
|
ap.target_town_name, ap.target_x, ap.target_y,
|
|
ap.target_arrival_time, ap.status as plan_status,
|
|
app.id as participant_id,
|
|
app.origin_town_id, app.origin_town_name,
|
|
app.units, app.attack_type,
|
|
app.transport_count,
|
|
app.send_time, app.return_time,
|
|
app.status as participant_status
|
|
FROM attack_plans ap
|
|
JOIN attack_plan_participants app ON app.plan_id = ap.id
|
|
WHERE ap.world_id = ?
|
|
AND ap.status = 'active'
|
|
AND app.player_id = ?
|
|
AND app.status IN ('pending', 'armed')
|
|
ORDER BY app.send_time ASC
|
|
''', (world_id, player_id)).fetchall()
|
|
conn.close()
|
|
|
|
result = []
|
|
for r in rows:
|
|
row = dict(r)
|
|
try:
|
|
row['units'] = json.loads(row['units'])
|
|
except Exception:
|
|
row['units'] = {}
|
|
result.append(row)
|
|
|
|
return jsonify(result)
|