import numpy as np

# 初始参数设定
initial_score = 2.0
score_gain = 1.5
hit_probability_decay = 0.85

# 计算小明在不同决策点的期望积分
def expected_score_after_n_fights(n):
    # 初始积分和击落积分增加
    score = initial_score
    time_cost = 0  # 时间代价计算
    
    for i in range(1, n + 1):
        hit_probability = hit_probability_decay ** i
        score += score_gain * hit_probability  # 击落敌机获得积分的期望贡献
        time_cost += 1  # 每架敌机的出现时间期望为1
        
        # 如果小明被击落，游戏结束，期望积分即为当前计算的积分
        if np.random.random() < (1 - hit_probability):
            break
    
    # 时间代价，每单位时间积分减1
    final_score = score - time_cost
    
    return final_score

# 模拟多次以获取平均期望值
def simulate(n, trials=10000):
    scores = [expected_score_after_n_fights(n) for _ in range(trials)]
    return np.mean(scores)

# 测试 1, 2, 3, 4 架敌机后的情况
n_options = [1, 2, 3, 4]
results = {n: simulate(n) for n in n_options}

results

import math

def simulate_game_fixed_intervals():
    score = 2.0
    time = 0.0
    enemy_count = 0
    scores = []
    
    while score > 0:
        # Fixed time to next enemy: e^(-n), where n is the enemy_count + 1
        time_to_next_enemy = math.exp(-(enemy_count + 1))
        time += time_to_next_enemy
        
        # Score decreases linearly with time
        score -= time_to_next_enemy
        
        # Check if score drops to zero or below
        if score <= 0:
            score = 0
            break
        
        # Increment enemy counter
        enemy_count += 1
        
        # Probability of defeating the enemy
        p_defeat = 0.85 ** enemy_count
        
        # Decide if defeated or defeated by the enemy
        if np.random.rand() <= p_defeat:
            # Defeated enemy, score increases
            score += 1.5
            # Record score if choosing to exit
            scores.append(score)
        else:
            # Defeated by enemy, game ends
            score = 0
            break
    
    return scores

# Simulate the game many times to find optimal stopping scores with fixed intervals
def find_optimal_score_fixed_intervals(num_simulations=10000):
    all_scores = []
    for _ in range(num_simulations):
        scores_in_game = simulate_game_fixed_intervals()
        all_scores.extend(scores_in_game)
    
    # Compute the mean score for each possible exit point
    if all_scores:
        average_score = np.mean(all_scores)
    else:
        average_score = 0
    
    return average_score

# Run the simulations with fixed intervals
optimal_score_fixed_intervals = find_optimal_score_fixed_intervals()
optimal_score_fixed_intervals