2179 lines
80 KiB
JavaScript
2179 lines
80 KiB
JavaScript
const CHARACTERS = [
|
||
{ name: '刘备', hp: 4, color: '#4169E1', skill: '仁德', skillDesc: '可以将任意手牌赠予其他角色' },
|
||
{ name: '曹操', hp: 4, color: '#8B4513', skill: '奸雄', skillDesc: '受到伤害后，可以获得造成伤害的牌' },
|
||
{ name: '孙权', hp: 4, color: '#228B22', skill: '制衡', skillDesc: '可以弃置任意张手牌，然后摸等量的牌' },
|
||
{ name: '关羽', hp: 4, color: '#DC143C', skill: '武圣', skillDesc: '可以将红色手牌当杀使用' },
|
||
{ name: '张飞', hp: 4, color: '#FF4500', skill: '咆哮', skillDesc: '出牌阶段可以使用任意张杀' },
|
||
{ name: '赵云', hp: 4, color: '#1E90FF', skill: '龙胆', skillDesc: '可以将杀当闪使用，或将闪当杀使用' },
|
||
{ name: '诸葛亮', hp: 3, color: '#9370DB', skill: '观星', skillDesc: '回合开始时可以查看牌堆顶的牌' },
|
||
{ name: '黄月英', hp: 3, color: '#FF69B4', skill: '集智', skillDesc: '使用锦囊牌后可以摸一张牌' },
|
||
{ name: '吕布', hp: 4, color: '#8B0000', skill: '无双', skillDesc: '使用杀时，目标需要使用两张闪' },
|
||
{ name: '貂蝉', hp: 3, color: '#FF1493', skill: '离间', skillDesc: '可以让两名男性角色决斗' }
|
||
];
|
||
|
||
const IDENTITIES = {
|
||
lord: { name: '主公', class: 'lord' },
|
||
loyalist: { name: '忠臣', class: 'loyalist' },
|
||
rebel: { name: '反贼', class: 'rebel' },
|
||
spy: { name: '内奸', class: 'spy' }
|
||
};
|
||
|
||
const EQUIPMENT_EFFECTS = {
|
||
'诸葛连弩': { range: 1, effect: '每回合可以使用任意张杀' },
|
||
'青龙偃月刀': { range: 3, effect: '攻击范围3' },
|
||
'丈八蛇矛': { range: 3, effect: '攻击范围3' },
|
||
'贯石斧': { range: 3, effect: '攻击范围3' },
|
||
'方天画戟': { range: 4, effect: '攻击范围4' },
|
||
'八卦阵': { effect: '需要判定是否受到伤害' },
|
||
'仁王盾': { effect: '黑色杀无效' },
|
||
'藤甲': { effect: '普通杀无效，火杀伤害+1' },
|
||
'的卢': { effect: '其他角色计算距离+1' },
|
||
'赤兔': { effect: '计算与其他角色距离-1' }
|
||
};
|
||
|
||
const CARD_IMAGES = {
|
||
'杀': {
|
||
background: 'linear-gradient(135deg, #8B0000 0%, #DC143C 50%, #FF6347 100%)',
|
||
icon: '⚔️',
|
||
pattern: 'attack'
|
||
},
|
||
'闪': {
|
||
background: 'linear-gradient(135deg, #006400 0%, #228B22 50%, #32CD32 100%)',
|
||
icon: '🛡️',
|
||
pattern: 'dodge'
|
||
},
|
||
'桃': {
|
||
background: 'linear-gradient(135deg, #FF69B4 0%, #FF1493 50%, #C71585 100%)',
|
||
icon: '🍑',
|
||
pattern: 'peach'
|
||
},
|
||
'决斗': {
|
||
background: 'linear-gradient(135deg, #4B0082 0%, #8A2BE2 50%, #9370DB 100%)',
|
||
icon: '⚡',
|
||
pattern: 'duel'
|
||
},
|
||
'过河拆桥': {
|
||
background: 'linear-gradient(135deg, #8B4513 0%, #A0522D 50%, #CD853F 100%)',
|
||
icon: '🌉',
|
||
pattern: 'destroy'
|
||
},
|
||
'顺手牵羊': {
|
||
background: 'linear-gradient(135deg, #DAA520 0%, #FFD700 50%, #FFA500 100%)',
|
||
icon: '🐑',
|
||
pattern: 'steal'
|
||
},
|
||
'万箭齐发': {
|
||
background: 'linear-gradient(135deg, #B22222 0%, #DC143C 50%, #FF4500 100%)',
|
||
icon: '🏹',
|
||
pattern: 'arrow'
|
||
},
|
||
'南蛮入侵': {
|
||
background: 'linear-gradient(135deg, #2F4F4F 0%, #008080 50%, #20B2AA 100%)',
|
||
icon: '🏹',
|
||
pattern: 'barbarian'
|
||
},
|
||
'无中生有': {
|
||
background: 'linear-gradient(135deg, #FF8C00 0%, #FFA500 50%, #FFD700 100%)',
|
||
icon: '✨',
|
||
pattern: 'create'
|
||
},
|
||
'借刀杀人': {
|
||
background: 'linear-gradient(135deg, #800080 0%, #9370DB 50%, #BA55D3 100%)',
|
||
icon: '🗡️',
|
||
pattern: 'borrow'
|
||
},
|
||
'无懈可击': {
|
||
background: 'linear-gradient(135deg, #191970 0%, #4169E1 50%, #6495ED 100%)',
|
||
icon: '🚫',
|
||
pattern: 'nullify'
|
||
},
|
||
'桃园结义': {
|
||
background: 'linear-gradient(135deg, #FF69B4 0%, #FFB6C1 50%, #FFC0CB 100%)',
|
||
icon: '🌸',
|
||
pattern: 'peachGarden'
|
||
},
|
||
'诸葛连弩': {
|
||
background: 'linear-gradient(135deg, #FF4500 0%, #FF6347 50%, #FF7F50 100%)',
|
||
icon: '🏹',
|
||
pattern: 'weapon'
|
||
},
|
||
'青龙偃月刀': {
|
||
background: 'linear-gradient(135deg, #006400 0%, #228B22 50%, #32CD32 100%)',
|
||
icon: '🗡️',
|
||
pattern: 'weapon'
|
||
},
|
||
'丈八蛇矛': {
|
||
background: 'linear-gradient(135deg, #8B0000 0%, #A52A2A 50%, #CD5C5C 100%)',
|
||
icon: '⚔️',
|
||
pattern: 'weapon'
|
||
},
|
||
'贯石斧': {
|
||
background: 'linear-gradient(135deg, #4B0082 0%, #6A5ACD 50%, #7B68EE 100%)',
|
||
icon: '🪓',
|
||
pattern: 'weapon'
|
||
},
|
||
'方天画戟': {
|
||
background: 'linear-gradient(135deg, #FFD700 0%, #FFA500 50%, #FF8C00 100%)',
|
||
icon: '🔱',
|
||
pattern: 'weapon'
|
||
},
|
||
'八卦阵': {
|
||
background: 'linear-gradient(135deg, #000080 0%, #4169E1 50%, #6495ED 100%)',
|
||
icon: '☯️',
|
||
pattern: 'armor'
|
||
},
|
||
'仁王盾': {
|
||
background: 'linear-gradient(135deg, #8B4513 0%, #A0522D 50%, #CD853F 100%)',
|
||
icon: '🛡️',
|
||
pattern: 'armor'
|
||
},
|
||
'藤甲': {
|
||
background: 'linear-gradient(135deg, #556B2F 0%, #6B8E23 50%, #8FBC8F 100%)',
|
||
icon: '🌿',
|
||
pattern: 'armor'
|
||
},
|
||
'的卢': {
|
||
background: 'linear-gradient(135deg, #808080 0%, #A9A9A9 50%, #C0C0C0 100%)',
|
||
icon: '🐎',
|
||
pattern: 'horse'
|
||
},
|
||
'赤兔': {
|
||
background: 'linear-gradient(135deg, #DC143C 0%, #FF6347 50%, #FF7F50 100%)',
|
||
icon: '🐎',
|
||
pattern: 'horse'
|
||
},
|
||
'五谷丰登': {
|
||
background: 'linear-gradient(135deg, #228B22 0%, #32CD32 50%, #90EE90 100%)',
|
||
icon: '🌾',
|
||
pattern: 'harvest'
|
||
},
|
||
'闪电': {
|
||
background: 'linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%)',
|
||
icon: '⚡',
|
||
pattern: 'lightning'
|
||
},
|
||
'乐不思蜀': {
|
||
background: 'linear-gradient(135deg, #e94560 0%, #ff6b6b 50%, #feca57 100%)',
|
||
icon: '🎵',
|
||
pattern: 'happy'
|
||
},
|
||
'兵粮寸断': {
|
||
background: 'linear-gradient(135deg, #5f27cd 0%, #341f97 50%, #222f3e 100%)',
|
||
icon: '🍚',
|
||
pattern: 'starvation'
|
||
},
|
||
'铁索连环': {
|
||
background: 'linear-gradient(135deg, #2c3e50 0%, #34495e 50%, #7f8c8d 100%)',
|
||
icon: '⛓️',
|
||
pattern: 'chain'
|
||
},
|
||
'火攻': {
|
||
background: 'linear-gradient(135deg, #e74c3c 0%, #c0392b 50%, #922b21 100%)',
|
||
icon: '🔥',
|
||
pattern: 'fireAttack'
|
||
},
|
||
'火杀': {
|
||
background: 'linear-gradient(135deg, #ff4500 0%, #ff6347 50%, #ff7f50 100%)',
|
||
icon: '🔥',
|
||
pattern: 'fireAttack'
|
||
},
|
||
'雷杀': {
|
||
background: 'linear-gradient(135deg, #4169e1 0%, #6495ed 50%, #87ceeb 100%)',
|
||
icon: '⚡',
|
||
pattern: 'thunderAttack'
|
||
}
|
||
};
|
||
|
||
class Card {
|
||
constructor(suit, rank, name, type, category = 'basic') {
|
||
this.suit = suit;
|
||
this.rank = rank;
|
||
this.name = name;
|
||
this.type = type;
|
||
this.category = category;
|
||
}
|
||
|
||
getSuitSymbol() {
|
||
const suits = {
|
||
'spade': '♠',
|
||
'heart': '♥',
|
||
'club': '♣',
|
||
'diamond': '♦'
|
||
};
|
||
return suits[this.suit] || '';
|
||
}
|
||
|
||
getDisplayRank() {
|
||
const ranks = {
|
||
'A': 'A', '2': '2', '3': '3', '4': '4', '5': '5',
|
||
'6': '6', '7': '7', '8': '8', '9': '9', '10': '10',
|
||
'J': 'J', 'Q': 'Q', 'K': 'K'
|
||
};
|
||
return ranks[this.rank] || this.rank;
|
||
}
|
||
|
||
isRed() {
|
||
return this.suit === 'heart' || this.suit === 'diamond';
|
||
}
|
||
|
||
isBlack() {
|
||
return this.suit === 'spade' || this.suit === 'club';
|
||
}
|
||
}
|
||
|
||
class Player {
|
||
constructor(index, character, identity, isHuman = false) {
|
||
this.index = index;
|
||
this.character = character;
|
||
this.identity = identity;
|
||
this.maxHp = character.hp;
|
||
this.currentHp = character.hp;
|
||
this.hand = [];
|
||
this.equipment = { weapon: null, armor: null, horsePlus: null, horseMinus: null };
|
||
this.isHuman = isHuman;
|
||
this.isAlive = true;
|
||
this.attackRange = 1;
|
||
this.statusEffects = {
|
||
lightning: false,
|
||
happy: false,
|
||
starvation: false,
|
||
chain: false
|
||
};
|
||
}
|
||
|
||
takeDamage(amount) {
|
||
this.currentHp = Math.max(0, this.currentHp - amount);
|
||
if (this.currentHp === 0) {
|
||
this.isAlive = false;
|
||
}
|
||
return this.currentHp;
|
||
}
|
||
|
||
heal(amount) {
|
||
this.currentHp = Math.min(this.maxHp, this.currentHp + amount);
|
||
return this.currentHp;
|
||
}
|
||
|
||
showDamageEffect() {
|
||
const playerCard = document.getElementById(`player-${this.index}`);
|
||
const damageEffect = document.createElement('div');
|
||
damageEffect.className = 'damage-effect';
|
||
damageEffect.textContent = '-1';
|
||
playerCard.appendChild(damageEffect);
|
||
|
||
setTimeout(() => {
|
||
damageEffect.remove();
|
||
}, 500);
|
||
}
|
||
|
||
showHealEffect() {
|
||
const playerCard = document.getElementById(`player-${this.index}`);
|
||
const healEffect = document.createElement('div');
|
||
healEffect.className = 'heal-effect';
|
||
healEffect.textContent = '+1';
|
||
playerCard.appendChild(healEffect);
|
||
|
||
setTimeout(() => {
|
||
healEffect.remove();
|
||
}, 500);
|
||
}
|
||
|
||
addCard(card) {
|
||
this.hand.push(card);
|
||
}
|
||
|
||
removeCard(index) {
|
||
return this.hand.splice(index, 1)[0];
|
||
}
|
||
|
||
equipCard(card) {
|
||
if (card.type === 'weapon') {
|
||
this.equipment.weapon = card;
|
||
const weaponRanges = {
|
||
'诸葛连弩': 1,
|
||
'青龙偃月刀': 3,
|
||
'丈八蛇矛': 3,
|
||
'贯石斧': 3,
|
||
'方天画戟': 4
|
||
};
|
||
this.attackRange = weaponRanges[card.name] || 1;
|
||
} else if (card.type === 'armor') {
|
||
this.equipment.armor = card;
|
||
} else if (card.type === 'horsePlus') {
|
||
this.equipment.horsePlus = card;
|
||
} else if (card.type === 'horseMinus') {
|
||
this.equipment.horseMinus = card;
|
||
}
|
||
}
|
||
}
|
||
|
||
class Game {
|
||
constructor() {
|
||
this.deck = [];
|
||
this.discardPile = [];
|
||
this.players = [];
|
||
this.currentPlayerIndex = 0;
|
||
this.phase = 'ready';
|
||
this.turnCount = 1;
|
||
this.selectedCardIndex = -1;
|
||
this.selectedTargetIndex = -1;
|
||
this.hasDrawn = false;
|
||
this.hasPlayed = false;
|
||
this.attackCount = 0;
|
||
this.gameOver = false;
|
||
|
||
this.initDeck();
|
||
this.initPlayers();
|
||
}
|
||
|
||
initDeck() {
|
||
const suits = ['spade', 'heart', 'club', 'diamond'];
|
||
const ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
|
||
|
||
for (let suit of suits) {
|
||
for (let rank of ranks) {
|
||
this.deck.push(new Card(suit, rank, '杀', 'attack', 'basic'));
|
||
this.deck.push(new Card(suit, rank, '闪', 'dodge', 'basic'));
|
||
}
|
||
}
|
||
|
||
for (let suit of suits) {
|
||
for (let i = 0; i < 5; i++) {
|
||
this.deck.push(new Card(suit, ranks[i], '火杀', 'attack', 'basic'));
|
||
this.deck.push(new Card(suit, ranks[i], '雷杀', 'attack', 'basic'));
|
||
}
|
||
}
|
||
|
||
for (let suit of suits) {
|
||
for (let i = 0; i < 3; i++) {
|
||
this.deck.push(new Card(suit, ranks[i], '桃', 'peach', 'basic'));
|
||
}
|
||
}
|
||
|
||
const scrollCards = [
|
||
{ name: '过河拆桥', type: 'dismantlement' },
|
||
{ name: '顺手牵羊', type: 'steal' },
|
||
{ name: '决斗', type: 'duel' },
|
||
{ name: '借刀杀人', type: 'borrow' },
|
||
{ name: '无中生有', type: 'draw' },
|
||
{ name: '万箭齐发', type: 'arrow' },
|
||
{ name: '南蛮入侵', type: 'barbarian' },
|
||
{ name: '无懈可击', type: 'nullify' },
|
||
{ name: '桃园结义', type: 'peachGarden' },
|
||
{ name: '五谷丰登', type: 'harvest' },
|
||
{ name: '闪电', type: 'lightning' },
|
||
{ name: '乐不思蜀', type: 'happy' },
|
||
{ name: '兵粮寸断', type: 'starvation' },
|
||
{ name: '铁索连环', type: 'chain' },
|
||
{ name: '火攻', type: 'fireAttack' }
|
||
];
|
||
|
||
for (let card of scrollCards) {
|
||
for (let suit of suits) {
|
||
for (let i = 0; i < 2; i++) {
|
||
this.deck.push(new Card(suit, ranks[i], card.name, card.type, 'scroll'));
|
||
}
|
||
}
|
||
}
|
||
|
||
const equipCards = [
|
||
{ name: '诸葛连弩', type: 'weapon', range: 1 },
|
||
{ name: '青龙偃月刀', type: 'weapon', range: 3 },
|
||
{ name: '丈八蛇矛', type: 'weapon', range: 3 },
|
||
{ name: '贯石斧', type: 'weapon', range: 3 },
|
||
{ name: '方天画戟', type: 'weapon', range: 4 },
|
||
{ name: '八卦阵', type: 'armor' },
|
||
{ name: '仁王盾', type: 'armor' },
|
||
{ name: '藤甲', type: 'armor' },
|
||
{ name: '的卢', type: 'horsePlus' },
|
||
{ name: '绝影', type: 'horsePlus' },
|
||
{ name: '赤兔', type: 'horseMinus' },
|
||
{ name: '紫骍', type: 'horseMinus' }
|
||
];
|
||
|
||
for (let card of equipCards) {
|
||
for (let suit of suits) {
|
||
this.deck.push(new Card(suit, 'A', card.name, card.type, 'equip'));
|
||
}
|
||
}
|
||
|
||
this.shuffleDeck();
|
||
}
|
||
|
||
shuffleDeck() {
|
||
for (let i = this.deck.length - 1; i > 0; i--) {
|
||
const j = Math.floor(Math.random() * (i + 1));
|
||
[this.deck[i], this.deck[j]] = [this.deck[j], this.deck[i]];
|
||
}
|
||
}
|
||
|
||
initPlayers() {
|
||
const availableCharacters = [...CHARACTERS];
|
||
const shuffledCharacters = availableCharacters.sort(() => Math.random() - 0.5);
|
||
|
||
const identities = ['lord', 'loyalist', 'rebel', 'rebel', 'spy'];
|
||
const shuffledIdentities = identities.sort(() => Math.random() - 0.5);
|
||
|
||
for (let i = 0; i < 5; i++) {
|
||
const isHuman = (i === 0);
|
||
const character = shuffledCharacters[i];
|
||
const identity = shuffledIdentities[i];
|
||
|
||
this.players.push(new Player(i, character, identity, isHuman));
|
||
|
||
if (identity === 'lord') {
|
||
this.players[i].maxHp++;
|
||
this.players[i].currentHp++;
|
||
}
|
||
}
|
||
|
||
for (let i = 0; i < 5; i++) {
|
||
for (let j = 0; j < 4; j++) {
|
||
const card = this.drawCard();
|
||
if (card) {
|
||
this.players[i].addCard(card);
|
||
}
|
||
}
|
||
}
|
||
|
||
const lordIndex = this.players.findIndex(p => p.identity === 'lord');
|
||
if (lordIndex !== -1) {
|
||
this.currentPlayerIndex = lordIndex;
|
||
}
|
||
}
|
||
|
||
drawCard() {
|
||
if (this.deck.length === 0) {
|
||
if (this.discardPile.length === 0) {
|
||
return null;
|
||
}
|
||
this.deck = [...this.discardPile];
|
||
this.discardPile = [];
|
||
this.shuffleDeck();
|
||
}
|
||
return this.deck.pop();
|
||
}
|
||
|
||
discardCard(card) {
|
||
this.discardPile.push(card);
|
||
}
|
||
|
||
getCurrentPlayer() {
|
||
return this.players[this.currentPlayerIndex];
|
||
}
|
||
|
||
getNextAlivePlayer(startIndex, direction = 1) {
|
||
let index = startIndex;
|
||
do {
|
||
index = (index + direction + 5) % 5;
|
||
if (this.players[index].isAlive) {
|
||
return index;
|
||
}
|
||
} while (index !== startIndex);
|
||
return startIndex;
|
||
}
|
||
|
||
startTurn() {
|
||
this.phase = 'draw';
|
||
this.hasDrawn = false;
|
||
this.hasPlayed = false;
|
||
this.attackCount = 0;
|
||
this.selectedCardIndex = -1;
|
||
this.selectedTargetIndex = -1;
|
||
|
||
const player = this.getCurrentPlayer();
|
||
this.addLog(`${player.character.name} 的回合开始`, true);
|
||
|
||
this.handleStatusEffects(player);
|
||
}
|
||
|
||
handleStatusEffects(player) {
|
||
if (!player.isAlive) return;
|
||
|
||
if (player.statusEffects.lightning) {
|
||
this.handleLightningEffect(player);
|
||
}
|
||
|
||
if (player.statusEffects.happy) {
|
||
this.handleHappyEffect(player);
|
||
}
|
||
|
||
if (player.statusEffects.starvation) {
|
||
this.handleStarvationEffect(player);
|
||
}
|
||
}
|
||
|
||
handleLightningEffect(player) {
|
||
const judgmentCard = this.drawCard();
|
||
this.addLog(`${player.character.name} 进行闪电判定，判定牌为 ${judgmentCard.getSuitSymbol()}${judgmentCard.getDisplayRank()}`);
|
||
|
||
if (judgmentCard.suit === 'spade' && ['2', '3', '4', '5', '6', '7', '8', '9'].includes(judgmentCard.rank)) {
|
||
player.takeDamage(3);
|
||
player.showDamageEffect();
|
||
this.addLog(`${player.character.name} 受到3点雷属性伤害！`);
|
||
this.checkDeath(player);
|
||
player.statusEffects.lightning = false;
|
||
} else {
|
||
this.addLog('闪电判定未通过，闪电传递给下家');
|
||
player.statusEffects.lightning = false;
|
||
const nextPlayerIndex = this.getNextAlivePlayer(player.index);
|
||
this.players[nextPlayerIndex].statusEffects.lightning = true;
|
||
this.addLog(`${this.players[nextPlayerIndex].character.name} 被闪电标记`);
|
||
}
|
||
|
||
this.discardCard(judgmentCard);
|
||
}
|
||
|
||
handleHappyEffect(player) {
|
||
const judgmentCard = this.drawCard();
|
||
this.addLog(`${player.character.name} 进行乐不思蜀判定，判定牌为 ${judgmentCard.getSuitSymbol()}${judgmentCard.getDisplayRank()}`);
|
||
|
||
if (judgmentCard.suit !== 'heart') {
|
||
this.addLog(`${player.character.name} 乐不思蜀判定未通过，本回合不能使用牌`);
|
||
player.statusEffects.happy = true;
|
||
} else {
|
||
this.addLog(`${player.character.name} 乐不思蜀判定通过，可以正常使用牌`);
|
||
player.statusEffects.happy = false;
|
||
}
|
||
|
||
this.discardCard(judgmentCard);
|
||
}
|
||
|
||
handleStarvationEffect(player) {
|
||
const judgmentCard = this.drawCard();
|
||
this.addLog(`${player.character.name} 进行兵粮寸断判定，判定牌为 ${judgmentCard.getSuitSymbol()}${judgmentCard.getDisplayRank()}`);
|
||
|
||
if (judgmentCard.suit !== 'club') {
|
||
this.addLog(`${player.character.name} 兵粮寸断判定未通过，本回合不能摸牌`);
|
||
player.statusEffects.starvation = true;
|
||
} else {
|
||
this.addLog(`${player.character.name} 兵粮寸断判定通过，可以正常摸牌`);
|
||
player.statusEffects.starvation = false;
|
||
}
|
||
|
||
this.discardCard(judgmentCard);
|
||
}
|
||
|
||
drawPhase() {
|
||
if (this.hasDrawn) return;
|
||
|
||
const player = this.getCurrentPlayer();
|
||
|
||
if (player.statusEffects.starvation) {
|
||
this.addLog(`${player.character.name} 兵粮寸断生效，本回合不能摸牌`);
|
||
player.statusEffects.starvation = false;
|
||
} else {
|
||
const drawCount = 2;
|
||
for (let i = 0; i < drawCount; i++) {
|
||
const card = this.drawCard();
|
||
if (card) {
|
||
player.addCard(card);
|
||
this.addLog(`${player.character.name} 摸了一张牌`);
|
||
}
|
||
}
|
||
}
|
||
|
||
this.hasDrawn = true;
|
||
this.phase = 'play';
|
||
}
|
||
|
||
useSkill() {
|
||
const player = this.getCurrentPlayer();
|
||
|
||
switch (player.character.name) {
|
||
case '刘备':
|
||
this.useLiuBeiSkill();
|
||
break;
|
||
case '曹操':
|
||
this.addLog('奸雄技能在受到伤害后自动触发');
|
||
break;
|
||
case '孙权':
|
||
this.useSunQuanSkill();
|
||
break;
|
||
case '关羽':
|
||
this.addLog('武圣技能：出牌时红色手牌可以当作杀使用');
|
||
break;
|
||
case '张飞':
|
||
this.addLog('咆哮技能：出牌阶段可以使用任意张杀');
|
||
break;
|
||
case '赵云':
|
||
this.addLog('龙胆技能：杀可以当闪使用，闪可以当杀使用');
|
||
break;
|
||
case '诸葛亮':
|
||
this.useZhugeLiangSkill();
|
||
break;
|
||
case '黄月英':
|
||
this.addLog('集智技能：使用锦囊牌后自动摸牌');
|
||
break;
|
||
case '吕布':
|
||
this.addLog('无双技能：使用杀时目标需要两张闪');
|
||
break;
|
||
case '貂蝉':
|
||
this.useDiaoChanSkill();
|
||
break;
|
||
default:
|
||
this.addLog('该角色没有主动技能');
|
||
}
|
||
}
|
||
|
||
useLiuBeiSkill() {
|
||
const player = this.getCurrentPlayer();
|
||
if (player.hand.length === 0) {
|
||
this.addLog('没有手牌可以赠送');
|
||
return;
|
||
}
|
||
|
||
const targetIndex = this.selectedTargetIndex;
|
||
if (targetIndex === -1 || targetIndex === player.index) {
|
||
this.addLog('请先选择一个目标');
|
||
return;
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive) {
|
||
this.addLog('目标已阵亡');
|
||
return;
|
||
}
|
||
|
||
const cardIndex = this.selectedCardIndex;
|
||
if (cardIndex === -1) {
|
||
this.addLog('请先选择一张手牌');
|
||
return;
|
||
}
|
||
|
||
const card = player.removeCard(cardIndex);
|
||
target.addCard(card);
|
||
this.addLog(`${player.character.name} 将【${card.name}】赠予 ${target.character.name}`);
|
||
this.selectedCardIndex = -1;
|
||
this.selectedTargetIndex = -1;
|
||
}
|
||
|
||
useSunQuanSkill() {
|
||
const player = this.getCurrentPlayer();
|
||
if (player.hand.length === 0) {
|
||
this.addLog('没有手牌可以弃置');
|
||
return;
|
||
}
|
||
|
||
const cardIndex = this.selectedCardIndex;
|
||
if (cardIndex === -1) {
|
||
this.addLog('请先选择要弃置的手牌');
|
||
return;
|
||
}
|
||
|
||
const card = player.removeCard(cardIndex);
|
||
this.discardCard(card);
|
||
this.addLog(`${player.character.name} 弃置了【${card.name}】`);
|
||
|
||
const newCard = this.drawCard();
|
||
if (newCard) {
|
||
player.addCard(newCard);
|
||
this.addLog(`${player.character.name} 摸了一张牌`);
|
||
}
|
||
|
||
this.selectedCardIndex = -1;
|
||
}
|
||
|
||
useZhugeLiangSkill() {
|
||
if (this.deck.length === 0) {
|
||
this.addLog('牌堆已空');
|
||
return;
|
||
}
|
||
|
||
const topCard = this.deck[this.deck.length - 1];
|
||
this.addLog(`牌堆顶的牌是：【${topCard.name}】`);
|
||
}
|
||
|
||
useDiaoChanSkill() {
|
||
const player = this.getCurrentPlayer();
|
||
const malePlayers = this.players.filter(p => p.isAlive && p.index !== player.index && p.character.name !== '貂蝉');
|
||
|
||
if (malePlayers.length < 2) {
|
||
this.addLog('场上男性角色不足');
|
||
return;
|
||
}
|
||
|
||
const target1Index = this.selectedTargetIndex;
|
||
if (target1Index === -1) {
|
||
this.addLog('请先选择第一个决斗目标');
|
||
return;
|
||
}
|
||
|
||
const target1 = this.players[target1Index];
|
||
if (!target1.isAlive || target1.character.name === '貂蝉') {
|
||
this.addLog('第一个目标无效');
|
||
return;
|
||
}
|
||
|
||
const target2 = malePlayers.find(p => p.index !== target1Index);
|
||
if (!target2) {
|
||
this.addLog('请选择第二个决斗目标');
|
||
return;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 发动【离间】，让 ${target1.character.name} 和 ${target2.character.name} 决斗`);
|
||
this.startDuel(target1, target2);
|
||
}
|
||
|
||
playCard(cardIndex, targetIndex = -1) {
|
||
const player = this.getCurrentPlayer();
|
||
const card = player.hand[cardIndex];
|
||
|
||
if (player.statusEffects.happy) {
|
||
this.addLog('乐不思蜀生效，本回合不能使用牌');
|
||
return false;
|
||
}
|
||
|
||
if (targetIndex === -1 && this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
}
|
||
|
||
if (card.category === 'basic') {
|
||
return this.playBasicCard(cardIndex, targetIndex);
|
||
} else if (card.category === 'scroll') {
|
||
return this.playScrollCard(cardIndex, targetIndex);
|
||
} else if (card.category === 'equip') {
|
||
return this.playEquipCard(cardIndex);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
playBasicCard(cardIndex, targetIndex = -1) {
|
||
const player = this.getCurrentPlayer();
|
||
const card = player.hand[cardIndex];
|
||
|
||
if (card.type === 'attack') {
|
||
if (this.attackCount >= 1 && !this.hasWeaponWithEffect('zhugeliannu') && player.character.name !== '张飞') {
|
||
this.addLog('每回合只能使用一张杀');
|
||
return false;
|
||
}
|
||
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive) {
|
||
this.addLog('目标已阵亡');
|
||
return false;
|
||
}
|
||
|
||
if (!this.isInRange(targetIndex)) {
|
||
this.addLog('目标不在攻击范围内');
|
||
return false;
|
||
}
|
||
|
||
const attackType = card.name === '火杀' ? '火' : (card.name === '雷杀' ? '雷' : '');
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【${card.name}】`);
|
||
this.showAttackAnimation(targetIndex);
|
||
|
||
let damage = 1;
|
||
let needsDodge = true;
|
||
|
||
if (target.equipment.armor && target.equipment.armor.name === '藤甲') {
|
||
if (card.name === '火杀') {
|
||
damage = 2;
|
||
this.addLog(`${target.character.name} 的藤甲受到火杀伤害+1`);
|
||
} else if (card.name !== '雷杀') {
|
||
needsDodge = false;
|
||
this.addLog(`${target.character.name} 的藤甲使普通杀无效`);
|
||
}
|
||
}
|
||
|
||
if (needsDodge && this.useDodge(target, player)) {
|
||
this.addLog(`${target.character.name} 使用了【闪】`);
|
||
} else {
|
||
target.takeDamage(damage);
|
||
target.showDamageEffect();
|
||
this.addLog(`${target.character.name} 受到${damage}点${attackType}属性伤害`);
|
||
|
||
if (target.statusEffects.chain) {
|
||
this.handleChainDamage(target, attackType);
|
||
}
|
||
|
||
this.checkDeath(target);
|
||
}
|
||
|
||
this.attackCount++;
|
||
} else if (card.type === 'peach') {
|
||
if (player.currentHp >= player.maxHp) {
|
||
this.addLog('体力已满，无法使用桃');
|
||
return false;
|
||
}
|
||
|
||
player.heal(1);
|
||
player.showHealEffect();
|
||
this.addLog(`${player.character.name} 使用了【桃】，回复1点体力`);
|
||
} else if (card.type === 'dodge') {
|
||
if (player.character.name === '赵云') {
|
||
if (this.attackCount >= 1 && !this.hasWeaponWithEffect('zhugeliannu')) {
|
||
this.addLog('每回合只能使用一张杀');
|
||
return false;
|
||
}
|
||
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive) {
|
||
this.addLog('目标已阵亡');
|
||
return false;
|
||
}
|
||
|
||
if (!this.isInRange(targetIndex)) {
|
||
this.addLog('目标不在攻击范围内');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 发动【龙胆】，将【闪】当作【杀】使用`);
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【杀】`);
|
||
this.showAttackAnimation(targetIndex);
|
||
|
||
if (this.useDodge(target, player)) {
|
||
this.addLog(`${target.character.name} 使用了【闪】`);
|
||
} else {
|
||
target.takeDamage(1);
|
||
target.showDamageEffect();
|
||
this.addLog(`${target.character.name} 受到1点伤害`);
|
||
|
||
if (target.statusEffects.chain) {
|
||
this.handleChainDamage(target, '');
|
||
}
|
||
|
||
this.checkDeath(target);
|
||
}
|
||
|
||
this.attackCount++;
|
||
} else {
|
||
this.addLog('闪只能在对方使用杀时使用');
|
||
return false;
|
||
}
|
||
} else if (player.character.name === '关羽' && card.isRed()) {
|
||
if (this.attackCount >= 1 && !this.hasWeaponWithEffect('zhugeliannu')) {
|
||
this.addLog('每回合只能使用一张杀');
|
||
return false;
|
||
}
|
||
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive) {
|
||
this.addLog('目标已阵亡');
|
||
return false;
|
||
}
|
||
|
||
if (!this.isInRange(targetIndex)) {
|
||
this.addLog('目标不在攻击范围内');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 发动【武圣】，将【${card.name}】当作【杀】使用`);
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【杀】`);
|
||
this.showAttackAnimation(targetIndex);
|
||
|
||
let damage = 1;
|
||
let needsDodge = true;
|
||
|
||
if (target.equipment.armor && target.equipment.armor.name === '藤甲') {
|
||
needsDodge = false;
|
||
this.addLog(`${target.character.name} 的藤甲使普通杀无效`);
|
||
}
|
||
|
||
if (needsDodge && this.useDodge(target, player)) {
|
||
this.addLog(`${target.character.name} 使用了【闪】`);
|
||
} else {
|
||
target.takeDamage(damage);
|
||
target.showDamageEffect();
|
||
this.addLog(`${target.character.name} 受到${damage}点伤害`);
|
||
|
||
if (target.statusEffects.chain) {
|
||
this.handleChainDamage(target, '');
|
||
}
|
||
|
||
this.checkDeath(target);
|
||
}
|
||
|
||
this.attackCount++;
|
||
}
|
||
|
||
const playedCard = player.removeCard(cardIndex);
|
||
this.discardCard(playedCard);
|
||
return true;
|
||
}
|
||
|
||
playScrollCard(cardIndex, targetIndex = -1) {
|
||
const player = this.getCurrentPlayer();
|
||
const card = player.hand[cardIndex];
|
||
|
||
if (card.type === 'dismantlement') {
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === this.currentPlayerIndex) {
|
||
this.addLog('无效的目标');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【过河拆桥】`);
|
||
this.showCardUseAnimation();
|
||
|
||
if (target.hand.length > 0) {
|
||
const randomIndex = Math.floor(Math.random() * target.hand.length);
|
||
const removedCard = target.removeCard(randomIndex);
|
||
this.discardCard(removedCard);
|
||
this.addLog(`${target.character.name} 的一张牌被拆掉了`);
|
||
}
|
||
|
||
} else if (card.type === 'steal') {
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === this.currentPlayerIndex) {
|
||
this.addLog('无效的目标');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【顺手牵羊】`);
|
||
this.showCardUseAnimation();
|
||
|
||
if (target.hand.length > 0) {
|
||
const randomIndex = Math.floor(Math.random() * target.hand.length);
|
||
const stolenCard = target.removeCard(randomIndex);
|
||
player.addCard(stolenCard);
|
||
this.addLog(`${player.character.name} 获得了 ${target.character.name} 的一张牌`);
|
||
}
|
||
|
||
} else if (card.type === 'draw') {
|
||
this.addLog(`${player.character.name} 使用了【无中生有】`);
|
||
this.showCardUseAnimation();
|
||
for (let i = 0; i < 2; i++) {
|
||
const newCard = this.drawCard();
|
||
if (newCard) {
|
||
player.addCard(newCard);
|
||
this.addLog(`${player.character.name} 摸了一张牌`);
|
||
}
|
||
}
|
||
|
||
} else if (card.type === 'duel') {
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === this.currentPlayerIndex) {
|
||
this.addLog('无效的目标');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 发起了【决斗】`);
|
||
this.showCardUseAnimation();
|
||
this.handleDuel(player, target);
|
||
|
||
} else if (card.type === 'peachGarden') {
|
||
this.addLog(`${player.character.name} 使用了【桃园结义】`);
|
||
this.showCardUseAnimation();
|
||
for (let p of this.players) {
|
||
if (p.isAlive && p.currentHp < p.maxHp) {
|
||
p.heal(1);
|
||
p.showHealEffect();
|
||
this.addLog(`${p.character.name} 回复1点体力`);
|
||
}
|
||
}
|
||
|
||
} else if (card.type === 'barbarian') {
|
||
this.addLog(`${player.character.name} 使用了【南蛮入侵】`);
|
||
this.showCardUseAnimation();
|
||
this.handleBarbarian(player);
|
||
|
||
} else if (card.type === 'arrow') {
|
||
this.addLog(`${player.character.name} 使用了【万箭齐发】`);
|
||
this.showCardUseAnimation();
|
||
this.handleArrow(player);
|
||
|
||
} else if (card.type === 'nullify') {
|
||
this.addLog('无懈可击需要在锦囊牌使用时使用');
|
||
return false;
|
||
} else if (card.type === 'lightning') {
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === this.currentPlayerIndex) {
|
||
this.addLog('无效的目标');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【闪电】`);
|
||
this.showCardUseAnimation();
|
||
target.statusEffects.lightning = true;
|
||
this.addLog(`${target.character.name} 被闪电标记`);
|
||
|
||
} else if (card.type === 'happy') {
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === this.currentPlayerIndex) {
|
||
this.addLog('无效的目标');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【乐不思蜀】`);
|
||
this.showCardUseAnimation();
|
||
target.statusEffects.happy = true;
|
||
this.addLog(`${target.character.name} 被乐不思蜀标记`);
|
||
|
||
} else if (card.type === 'starvation') {
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === this.currentPlayerIndex) {
|
||
this.addLog('无效的目标');
|
||
return false;
|
||
}
|
||
|
||
if (!this.isInRange(targetIndex)) {
|
||
this.addLog('目标不在攻击范围内');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【兵粮寸断】`);
|
||
this.showCardUseAnimation();
|
||
target.statusEffects.starvation = true;
|
||
this.addLog(`${target.character.name} 被兵粮寸断标记`);
|
||
|
||
} else if (card.type === 'chain') {
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === this.currentPlayerIndex) {
|
||
this.addLog('无效的目标');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【铁索连环】`);
|
||
this.showCardUseAnimation();
|
||
target.statusEffects.chain = true;
|
||
this.addLog(`${target.character.name} 被铁索连环标记`);
|
||
|
||
} else if (card.type === 'fireAttack') {
|
||
if (targetIndex === -1) {
|
||
if (this.selectedTargetIndex !== -1) {
|
||
targetIndex = this.selectedTargetIndex;
|
||
} else {
|
||
targetIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
}
|
||
}
|
||
|
||
const target = this.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === this.currentPlayerIndex) {
|
||
this.addLog('无效的目标');
|
||
return false;
|
||
}
|
||
|
||
this.addLog(`${player.character.name} 对 ${target.character.name} 使用了【火攻】`);
|
||
this.showCardUseAnimation();
|
||
|
||
if (target.hand.length === 0) {
|
||
this.addLog('目标没有手牌，火攻无效');
|
||
return false;
|
||
}
|
||
|
||
const randomCardIndex = Math.floor(Math.random() * target.hand.length);
|
||
const randomCard = target.hand[randomCardIndex];
|
||
this.addLog(`${target.character.name} 展示了一张 ${randomCard.name}`);
|
||
|
||
if (randomCard.suit === 'heart' || randomCard.suit === 'diamond') {
|
||
target.takeDamage(1);
|
||
target.showDamageEffect();
|
||
this.addLog(`${target.character.name} 受到1点火属性伤害`);
|
||
this.checkDeath(target);
|
||
} else {
|
||
this.addLog('火攻未造成伤害');
|
||
}
|
||
}
|
||
|
||
const playedCard = player.removeCard(cardIndex);
|
||
this.discardCard(playedCard);
|
||
|
||
if (player.character.name === '黄月英') {
|
||
const newCard = this.drawCard();
|
||
if (newCard) {
|
||
player.addCard(newCard);
|
||
this.addLog(`${player.character.name} 发动【集智】，摸了一张牌`);
|
||
}
|
||
}
|
||
|
||
this.showCardUseAnimation();
|
||
return true;
|
||
}
|
||
|
||
showCardUseAnimation() {
|
||
const cardElements = document.querySelectorAll('.card.selected');
|
||
cardElements.forEach(card => {
|
||
card.classList.add('use-animation');
|
||
setTimeout(() => {
|
||
card.classList.remove('use-animation');
|
||
}, 500);
|
||
});
|
||
}
|
||
|
||
playEquipCard(cardIndex) {
|
||
const player = this.getCurrentPlayer();
|
||
const card = player.hand[cardIndex];
|
||
|
||
player.equipCard(card);
|
||
this.addLog(`${player.character.name} 装备了【${card.name}】`);
|
||
|
||
const playedCard = player.removeCard(cardIndex);
|
||
this.discardCard(playedCard);
|
||
|
||
this.showCardUseAnimation();
|
||
return true;
|
||
}
|
||
|
||
useDodge(target, attacker) {
|
||
let dodgeCount = 1;
|
||
|
||
if (attacker && attacker.character.name === '吕布') {
|
||
dodgeCount = 2;
|
||
}
|
||
|
||
let dodgesUsed = 0;
|
||
for (let i = 0; i < dodgeCount; i++) {
|
||
let dodgeIndex = target.hand.findIndex(c => c.type === 'dodge');
|
||
|
||
if (target.character.name === '赵云' && dodgeIndex === -1) {
|
||
dodgeIndex = target.hand.findIndex(c => c.type === 'attack');
|
||
if (dodgeIndex !== -1) {
|
||
this.addLog(`${target.character.name} 发动【龙胆】，将【杀】当作【闪】使用`);
|
||
}
|
||
}
|
||
|
||
if (dodgeIndex !== -1) {
|
||
if (target.isHuman) {
|
||
dodgesUsed++;
|
||
} else {
|
||
const dodgeCard = target.removeCard(dodgeIndex);
|
||
this.discardCard(dodgeCard);
|
||
dodgesUsed++;
|
||
}
|
||
this.showShieldAnimation(target.index);
|
||
}
|
||
}
|
||
|
||
return dodgesUsed >= dodgeCount;
|
||
}
|
||
|
||
showShieldAnimation(playerIndex) {
|
||
const playerCard = document.getElementById(`player-${playerIndex}`);
|
||
const shieldAnimation = document.createElement('div');
|
||
shieldAnimation.className = 'shield-animation';
|
||
shieldAnimation.textContent = '🛡️';
|
||
playerCard.appendChild(shieldAnimation);
|
||
|
||
setTimeout(() => {
|
||
shieldAnimation.remove();
|
||
}, 800);
|
||
}
|
||
|
||
handleDuel(attacker, defender) {
|
||
let currentAttacker = attacker;
|
||
let currentDefender = defender;
|
||
|
||
while (true) {
|
||
const attackIndex = currentAttacker.hand.findIndex(c => c.type === 'attack');
|
||
if (attackIndex !== -1) {
|
||
const attackCard = currentAttacker.removeCard(attackIndex);
|
||
this.discardCard(attackCard);
|
||
this.showAttackAnimation(currentDefender.index);
|
||
|
||
const defendIndex = currentDefender.hand.findIndex(c => c.type === 'attack');
|
||
if (defendIndex !== -1) {
|
||
const defendCard = currentDefender.removeCard(defendIndex);
|
||
this.discardCard(defendCard);
|
||
[currentAttacker, currentDefender] = [currentDefender, currentAttacker];
|
||
} else {
|
||
currentDefender.takeDamage(1);
|
||
currentDefender.showDamageEffect();
|
||
this.addLog(`${currentDefender.character.name} 受到1点伤害`);
|
||
this.checkDeath(currentDefender);
|
||
break;
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
handleBarbarian(attacker) {
|
||
const targets = this.players.filter(p => p.isAlive && p.index !== attacker.index);
|
||
for (const target of targets) {
|
||
let attackIndex = target.hand.findIndex(c => c.type === 'attack');
|
||
|
||
if (attackIndex === -1 && target.character.name === '关羽') {
|
||
attackIndex = target.hand.findIndex(c => c.isRed());
|
||
if (attackIndex !== -1) {
|
||
this.addLog(`${target.character.name} 发动【武圣】，将【${target.hand[attackIndex].name}】当作【杀】使用`);
|
||
}
|
||
}
|
||
|
||
if (attackIndex === -1 && target.character.name === '赵云') {
|
||
attackIndex = target.hand.findIndex(c => c.type === 'dodge');
|
||
if (attackIndex !== -1) {
|
||
this.addLog(`${target.character.name} 发动【龙胆】，将【闪】当作【杀】使用`);
|
||
}
|
||
}
|
||
|
||
if (attackIndex !== -1) {
|
||
const attackCard = target.removeCard(attackIndex);
|
||
this.discardCard(attackCard);
|
||
this.addLog(`${target.character.name} 打出了【杀】`);
|
||
} else {
|
||
target.takeDamage(1);
|
||
target.showDamageEffect();
|
||
this.addLog(`${target.character.name} 受到1点伤害`);
|
||
this.checkDeath(target);
|
||
}
|
||
}
|
||
}
|
||
|
||
handleArrow(attacker) {
|
||
const targets = this.players.filter(p => p.isAlive && p.index !== attacker.index);
|
||
for (const target of targets) {
|
||
let dodgeIndex = target.hand.findIndex(c => c.type === 'dodge');
|
||
|
||
if (dodgeIndex === -1 && target.character.name === '赵云') {
|
||
dodgeIndex = target.hand.findIndex(c => c.type === 'attack');
|
||
if (dodgeIndex !== -1) {
|
||
this.addLog(`${target.character.name} 发动【龙胆】，将【杀】当作【闪】使用`);
|
||
}
|
||
}
|
||
|
||
if (dodgeIndex !== -1) {
|
||
const dodgeCard = target.removeCard(dodgeIndex);
|
||
this.discardCard(dodgeCard);
|
||
this.addLog(`${target.character.name} 打出了【闪】`);
|
||
} else {
|
||
target.takeDamage(1);
|
||
target.showDamageEffect();
|
||
this.addLog(`${target.character.name} 受到1点伤害`);
|
||
this.checkDeath(target);
|
||
}
|
||
}
|
||
}
|
||
|
||
startDuel(player1, player2) {
|
||
this.handleDuel(player1, player2);
|
||
}
|
||
|
||
isInRange(targetIndex) {
|
||
const player = this.getCurrentPlayer();
|
||
const target = this.players[targetIndex];
|
||
|
||
let range = player.attackRange;
|
||
if (player.equipment.horseMinus) {
|
||
range++;
|
||
}
|
||
|
||
let distance = 0;
|
||
let currentIndex = this.currentPlayerIndex;
|
||
|
||
while (currentIndex !== targetIndex) {
|
||
currentIndex = this.getNextAlivePlayer(currentIndex);
|
||
distance++;
|
||
if (this.players[currentIndex].equipment.horsePlus && currentIndex !== targetIndex) {
|
||
distance++;
|
||
}
|
||
}
|
||
|
||
if (target.equipment.horsePlus) {
|
||
distance++;
|
||
}
|
||
|
||
return distance <= range;
|
||
}
|
||
|
||
hasWeaponWithEffect(effect) {
|
||
const player = this.getCurrentPlayer();
|
||
return player.equipment.weapon && player.equipment.weapon.name === '诸葛连弩';
|
||
}
|
||
|
||
checkDeath(player) {
|
||
if (!player.isAlive) {
|
||
this.showKillEffect(player);
|
||
this.addLog(`${player.character.name} 阵亡！`, true);
|
||
|
||
const playerCard = document.getElementById(`player-${player.index}`);
|
||
playerCard.classList.add('dead');
|
||
|
||
if (player.identity === 'lord') {
|
||
this.gameOver = true;
|
||
this.checkWinCondition();
|
||
} else {
|
||
const lord = this.players.find(p => p.identity === 'lord');
|
||
if (lord) {
|
||
if (player.identity === 'rebel') {
|
||
lord.addCard(this.drawCard());
|
||
lord.addCard(this.drawCard());
|
||
lord.addCard(this.drawCard());
|
||
this.addLog(`${lord.character.name} 摸了3张牌`);
|
||
}
|
||
}
|
||
this.checkWinCondition();
|
||
}
|
||
}
|
||
}
|
||
|
||
showKillEffect(player) {
|
||
const killEffect = document.createElement('div');
|
||
killEffect.className = 'kill-effect';
|
||
killEffect.innerHTML = '<div class="kill-text">击杀！</div>';
|
||
document.body.appendChild(killEffect);
|
||
|
||
setTimeout(() => {
|
||
killEffect.remove();
|
||
}, 1000);
|
||
|
||
this.showDeathAnimation(player.index);
|
||
}
|
||
|
||
showDeathAnimation(playerIndex) {
|
||
const playerCard = document.getElementById(`player-${playerIndex}`);
|
||
const deathAnimation = document.createElement('div');
|
||
deathAnimation.className = 'death-animation';
|
||
deathAnimation.innerHTML = '💀';
|
||
playerCard.appendChild(deathAnimation);
|
||
|
||
setTimeout(() => {
|
||
deathAnimation.remove();
|
||
}, 800);
|
||
}
|
||
|
||
showAttackAnimation(targetIndex) {
|
||
const targetCard = document.getElementById(`player-${targetIndex}`);
|
||
const attackAnimation = document.createElement('div');
|
||
attackAnimation.className = 'attack-animation';
|
||
attackAnimation.textContent = '⚔️';
|
||
targetCard.appendChild(attackAnimation);
|
||
|
||
setTimeout(() => {
|
||
attackAnimation.remove();
|
||
}, 400);
|
||
}
|
||
|
||
handleChainDamage(sourcePlayer, damageType) {
|
||
if (!sourcePlayer.statusEffects.chain) return;
|
||
|
||
sourcePlayer.statusEffects.chain = false;
|
||
this.addLog(`${sourcePlayer.character.name} 的铁索连环传导伤害`);
|
||
|
||
const chainedPlayers = this.players.filter(p => p.isAlive && p.statusEffects.chain);
|
||
|
||
for (const player of chainedPlayers) {
|
||
player.takeDamage(1);
|
||
player.showDamageEffect();
|
||
this.addLog(`${player.character.name} 受到1点${damageType}属性传导伤害`);
|
||
player.statusEffects.chain = false;
|
||
this.checkDeath(player);
|
||
}
|
||
}
|
||
|
||
checkWinCondition() {
|
||
const alivePlayers = this.players.filter(p => p.isAlive);
|
||
const lord = this.players.find(p => p.identity === 'lord');
|
||
|
||
if (!lord || !lord.isAlive) {
|
||
const rebels = alivePlayers.filter(p => p.identity === 'rebel');
|
||
const spy = alivePlayers.find(p => p.identity === 'spy');
|
||
|
||
if (rebels.length > 0) {
|
||
this.addLog('反贼获胜！', true);
|
||
} else if (spy && alivePlayers.length === 1 && alivePlayers[0].identity === 'spy') {
|
||
this.addLog('内奸获胜！', true);
|
||
} else {
|
||
this.addLog('反贼获胜！', true);
|
||
}
|
||
this.gameOver = true;
|
||
} else {
|
||
const rebels = alivePlayers.filter(p => p.identity === 'rebel');
|
||
const loyalists = alivePlayers.filter(p => p.identity === 'loyalist');
|
||
const spy = alivePlayers.find(p => p.identity === 'spy');
|
||
|
||
if (alivePlayers.length === 1 && alivePlayers[0].identity === 'spy') {
|
||
this.addLog('内奸获胜！', true);
|
||
this.gameOver = true;
|
||
} else if (rebels.length === 0 && (!spy || !spy.isAlive)) {
|
||
this.addLog('主公和忠臣获胜！', true);
|
||
this.gameOver = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
endTurn() {
|
||
if (this.gameOver) return;
|
||
|
||
const player = this.getCurrentPlayer();
|
||
this.addLog(`${player.character.name} 结束回合`);
|
||
|
||
this.currentPlayerIndex = this.getNextAlivePlayer(this.currentPlayerIndex);
|
||
|
||
if (this.currentPlayerIndex === 0) {
|
||
this.turnCount++;
|
||
}
|
||
|
||
this.startTurn();
|
||
|
||
if (!this.getCurrentPlayer().isHuman) {
|
||
this.aiTurn();
|
||
}
|
||
}
|
||
|
||
aiTurn() {
|
||
const player = this.getCurrentPlayer();
|
||
|
||
setTimeout(() => {
|
||
this.drawPhase();
|
||
updateUI();
|
||
|
||
setTimeout(() => {
|
||
this.aiPlayCards(player);
|
||
}, 300);
|
||
}, 300);
|
||
}
|
||
|
||
aiPlayCards(player) {
|
||
const canUseMultipleAttacks = this.hasWeaponWithEffect('zhugeliannu') || player.character.name === '张飞';
|
||
|
||
const cardPriority = [
|
||
{ type: 'peach', condition: () => player.currentHp < player.maxHp, target: null },
|
||
{ type: 'attack', condition: () => this.attackCount === 0 || canUseMultipleAttacks, target: 'aiSelectTarget', skillCheck: true },
|
||
{ type: 'duel', condition: () => true, target: 'aiSelectDuelTarget' },
|
||
{ type: 'barbarian', condition: () => true, target: null },
|
||
{ type: 'arrow', condition: () => true, target: null },
|
||
{ type: 'fireAttack', condition: () => true, target: 'aiSelectFireAttackTarget' },
|
||
{ type: 'dismantlement', condition: () => true, target: 'aiSelectDismantleTarget' },
|
||
{ type: 'steal', condition: () => true, target: 'aiSelectStealTarget' },
|
||
{ type: 'chain', condition: () => true, target: 'aiSelectChainTarget' },
|
||
{ type: 'happy', condition: () => true, target: 'aiSelectHappyTarget' },
|
||
{ type: 'starvation', condition: () => true, target: 'aiSelectStarvationTarget' },
|
||
{ type: 'lightning', condition: () => true, target: 'aiSelectLightningTarget' },
|
||
{ type: 'draw', condition: () => true, target: null },
|
||
{ type: 'equip', condition: () => true, target: 'aiSelectEquipCard', isEquip: true }
|
||
];
|
||
|
||
const playNextCard = () => {
|
||
if (this.gameOver || this.getCurrentPlayer().index !== player.index) {
|
||
return;
|
||
}
|
||
|
||
const targets = this.players.filter(p => p.isAlive && p.index !== player.index);
|
||
let cardsUsed = false;
|
||
|
||
if (player.character.name === '刘备' && player.hand.length >= 2) {
|
||
const ally = targets.find(t => t.identity === 'loyalist' || t.identity === 'lord');
|
||
if (ally && ally.currentHp < ally.maxHp) {
|
||
const cardIndex = player.hand.findIndex(c => c.type === 'peach');
|
||
if (cardIndex !== -1) {
|
||
this.useLiuBeiSkillAI(player, ally, cardIndex);
|
||
cardsUsed = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!cardsUsed && player.character.name === '孙权' && player.hand.length >= 2) {
|
||
const uselessCards = player.hand.filter(c => c.type !== 'attack' && c.type !== 'peach' && c.type !== 'dodge');
|
||
if (uselessCards.length > 0) {
|
||
this.useSunQuanSkillAI(player, uselessCards[0]);
|
||
cardsUsed = true;
|
||
}
|
||
}
|
||
|
||
if (!cardsUsed && player.character.name === '貂蝉') {
|
||
const malePlayers = targets.filter(t => t.character.name !== '貂蝉');
|
||
if (malePlayers.length >= 2) {
|
||
const target1 = malePlayers[0];
|
||
const target2 = malePlayers[1];
|
||
this.useDiaoChanSkillAI(player, target1, target2);
|
||
cardsUsed = true;
|
||
}
|
||
}
|
||
|
||
if (!cardsUsed) {
|
||
for (const priority of cardPriority) {
|
||
if (cardsUsed) break;
|
||
|
||
let cardIndex = -1;
|
||
|
||
if (priority.isEquip) {
|
||
cardIndex = this[priority.target](player);
|
||
} else {
|
||
cardIndex = player.hand.findIndex(c => c.type === priority.type);
|
||
|
||
if (priority.skillCheck && cardIndex === -1) {
|
||
if (player.character.name === '关羽') {
|
||
cardIndex = player.hand.findIndex(c => c.isRed());
|
||
if (cardIndex !== -1) {
|
||
this.addLog(`${player.character.name} 发动【武圣】，将【${player.hand[cardIndex].name}】当作【杀】使用`);
|
||
}
|
||
} else if (player.character.name === '赵云') {
|
||
cardIndex = player.hand.findIndex(c => c.type === 'dodge');
|
||
if (cardIndex !== -1) {
|
||
this.addLog(`${player.character.name} 发动【龙胆】，将【闪】当作【杀】使用`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (cardIndex !== -1 && priority.condition()) {
|
||
let targetIndex = -1;
|
||
|
||
if (priority.target && !priority.isEquip) {
|
||
targetIndex = this[priority.target](player, targets);
|
||
}
|
||
|
||
if (targetIndex !== -1 || !priority.target || priority.isEquip) {
|
||
const result = this.playCard(cardIndex, targetIndex);
|
||
if (result) {
|
||
cardsUsed = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (cardsUsed) {
|
||
updateUI();
|
||
setTimeout(playNextCard, 300);
|
||
} else {
|
||
updateUI();
|
||
setTimeout(() => {
|
||
this.endTurn();
|
||
updateUI();
|
||
}, 300);
|
||
}
|
||
};
|
||
|
||
playNextCard();
|
||
}
|
||
|
||
aiSelectTarget(player, targets) {
|
||
const inRangeTargets = targets.filter(t => this.isInRange(t.index));
|
||
|
||
if (inRangeTargets.length === 0) {
|
||
return -1;
|
||
}
|
||
|
||
return this.selectTargetByIdentity(player, inRangeTargets);
|
||
}
|
||
|
||
useLiuBeiSkillAI(player, ally, cardIndex) {
|
||
const card = player.removeCard(cardIndex);
|
||
ally.addCard(card);
|
||
this.addLog(`${player.character.name} 发动【仁德】，将【${card.name}】赠予 ${ally.character.name}`);
|
||
}
|
||
|
||
useSunQuanSkillAI(player, card) {
|
||
const cardIndex = player.hand.indexOf(card);
|
||
if (cardIndex !== -1) {
|
||
player.removeCard(cardIndex);
|
||
this.discardCard(card);
|
||
this.addLog(`${player.character.name} 发动【制衡】，弃置了【${card.name}】`);
|
||
|
||
const newCard = this.drawCard();
|
||
if (newCard) {
|
||
player.addCard(newCard);
|
||
this.addLog(`${player.character.name} 摸了一张牌`);
|
||
}
|
||
}
|
||
}
|
||
|
||
useDiaoChanSkillAI(player, target1, target2) {
|
||
this.addLog(`${player.character.name} 发动【离间】，让 ${target1.character.name} 和 ${target2.character.name} 决斗`);
|
||
this.startDuel(target1, target2);
|
||
}
|
||
|
||
aiSelectDuelTarget(player, targets) {
|
||
const weakTargets = targets.filter(t => t.hand.length < 2);
|
||
if (weakTargets.length > 0) {
|
||
return this.aiSelectTarget(player, weakTargets);
|
||
}
|
||
return this.aiSelectTarget(player, targets);
|
||
}
|
||
|
||
aiSelectFireAttackTarget(player, targets) {
|
||
const target = this.aiSelectTarget(player, targets);
|
||
if (target !== -1) {
|
||
const targetPlayer = this.players[target];
|
||
const hasRedCard = targetPlayer.hand.some(c => c.suit === 'heart' || c.suit === 'diamond');
|
||
if (!hasRedCard) {
|
||
return target;
|
||
}
|
||
}
|
||
return this.aiSelectTarget(player, targets);
|
||
}
|
||
|
||
aiSelectDismantleTarget(player, targets) {
|
||
const targetWithCards = targets.filter(t => t.hand.length > 0 || t.equipment.weapon || t.equipment.armor || t.equipment.horsePlus || t.equipment.horseMinus);
|
||
if (targetWithCards.length > 0) {
|
||
return this.selectTargetByIdentity(player, targetWithCards);
|
||
}
|
||
return this.selectTargetByIdentity(player, targets);
|
||
}
|
||
|
||
aiSelectStealTarget(player, targets) {
|
||
const targetWithCards = targets.filter(t => t.hand.length > 0);
|
||
if (targetWithCards.length > 0) {
|
||
return this.selectTargetByIdentity(player, targetWithCards);
|
||
}
|
||
return this.selectTargetByIdentity(player, targets);
|
||
}
|
||
|
||
aiSelectChainTarget(player, targets) {
|
||
const unchainedTargets = targets.filter(t => !t.statusEffects.chain);
|
||
if (unchainedTargets.length > 0) {
|
||
return this.selectTargetByIdentity(player, unchainedTargets);
|
||
}
|
||
return this.selectTargetByIdentity(player, targets);
|
||
}
|
||
|
||
aiSelectHappyTarget(player, targets) {
|
||
const dangerousTargets = targets.filter(t => t.hand.length >= 3);
|
||
if (dangerousTargets.length > 0) {
|
||
return this.selectTargetByIdentity(player, dangerousTargets);
|
||
}
|
||
return this.selectTargetByIdentity(player, targets);
|
||
}
|
||
|
||
aiSelectStarvationTarget(player, targets) {
|
||
const inRangeTargets = targets.filter(t => this.isInRange(t.index));
|
||
if (inRangeTargets.length > 0) {
|
||
return this.selectTargetByIdentity(player, inRangeTargets);
|
||
}
|
||
return this.selectTargetByIdentity(player, targets);
|
||
}
|
||
|
||
aiSelectLightningTarget(player, targets) {
|
||
const enemyTargets = targets.filter(t => {
|
||
if (player.identity === 'lord' || player.identity === 'loyalist') {
|
||
return t.identity === 'rebel' || t.identity === 'spy';
|
||
} else if (player.identity === 'rebel') {
|
||
return t.identity === 'lord' || t.identity === 'loyalist';
|
||
} else {
|
||
return true;
|
||
}
|
||
});
|
||
|
||
if (enemyTargets.length > 0) {
|
||
return this.selectTargetByIdentity(player, enemyTargets);
|
||
}
|
||
return this.selectTargetByIdentity(player, targets);
|
||
}
|
||
|
||
selectTargetByIdentity(player, targets) {
|
||
if (targets.length === 0) return -1;
|
||
|
||
if (player.identity === 'lord') {
|
||
const rebel = targets.find(t => t.identity === 'rebel');
|
||
if (rebel) return rebel.index;
|
||
const spy = targets.find(t => t.identity === 'spy');
|
||
if (spy) return spy.index;
|
||
} else if (player.identity === 'loyalist') {
|
||
const rebel = targets.find(t => t.identity === 'rebel');
|
||
if (rebel) return rebel.index;
|
||
} else if (player.identity === 'rebel') {
|
||
const lord = targets.find(t => t.identity === 'lord');
|
||
if (lord) return lord.index;
|
||
const loyalist = targets.find(t => t.identity === 'loyalist');
|
||
if (loyalist) return loyalist.index;
|
||
} else if (player.identity === 'spy') {
|
||
const weakTarget = targets.reduce((weakest, t) =>
|
||
t.currentHp < weakest.currentHp ? t : weakest, targets[0]);
|
||
if (weakTarget) return weakTarget.index;
|
||
}
|
||
|
||
return targets.length > 0 ? targets[0].index : -1;
|
||
}
|
||
|
||
aiSelectEquipCard(player) {
|
||
const equipCards = player.hand.filter(c => c.category === 'equip');
|
||
if (equipCards.length === 0) return -1;
|
||
|
||
for (const card of equipCards) {
|
||
const cardIndex = player.hand.indexOf(card);
|
||
|
||
if (card.type === 'weapon') {
|
||
if (!player.equipment.weapon ||
|
||
(player.equipment.weapon.name !== '诸葛连弩' && card.name === '诸葛连弩')) {
|
||
return cardIndex;
|
||
}
|
||
} else if (card.type === 'armor') {
|
||
if (!player.equipment.armor) {
|
||
return cardIndex;
|
||
}
|
||
} else if (card.type === 'horseMinus') {
|
||
if (!player.equipment.horseMinus) {
|
||
return cardIndex;
|
||
}
|
||
} else if (card.type === 'horsePlus') {
|
||
if (!player.equipment.horsePlus) {
|
||
return cardIndex;
|
||
}
|
||
}
|
||
}
|
||
|
||
return player.hand.indexOf(equipCards[0]);
|
||
}
|
||
|
||
addLog(message, highlight = false) {
|
||
const logContainer = document.getElementById('game-log');
|
||
const logEntry = document.createElement('div');
|
||
logEntry.className = 'log-entry' + (highlight ? ' highlight' : '');
|
||
logEntry.textContent = message;
|
||
logContainer.appendChild(logEntry);
|
||
logContainer.scrollTop = logContainer.scrollHeight;
|
||
}
|
||
}
|
||
|
||
let game;
|
||
|
||
function startGame() {
|
||
document.getElementById('start-screen').style.display = 'none';
|
||
document.getElementById('game-container').style.display = 'block';
|
||
game = new Game();
|
||
updateUI();
|
||
setupEventListeners();
|
||
game.addLog('游戏初始化完成', true);
|
||
|
||
const currentPlayer = game.getCurrentPlayer();
|
||
if (!currentPlayer.isHuman) {
|
||
game.addLog(`${currentPlayer.character.name} 的回合开始`, true);
|
||
setTimeout(() => {
|
||
game.drawPhase();
|
||
updateUI();
|
||
setTimeout(() => {
|
||
game.aiPlayCards(currentPlayer);
|
||
}, 300);
|
||
}, 300);
|
||
} else {
|
||
game.addLog('点击"准备"开始游戏', true);
|
||
}
|
||
}
|
||
|
||
function initGame() {
|
||
document.getElementById('start-btn').addEventListener('click', startGame);
|
||
}
|
||
|
||
let updateUIPending = false;
|
||
let updateUITimer = null;
|
||
|
||
function updateUI() {
|
||
if (updateUIPending) {
|
||
return;
|
||
}
|
||
|
||
updateUIPending = true;
|
||
|
||
if (updateUITimer) {
|
||
clearTimeout(updateUITimer);
|
||
}
|
||
|
||
updateUITimer = setTimeout(() => {
|
||
updateUIPending = false;
|
||
renderUI();
|
||
}, 50);
|
||
}
|
||
|
||
function renderUI() {
|
||
const player = game.getCurrentPlayer();
|
||
|
||
document.getElementById('current-phase').textContent = `阶段: ${game.phase === 'ready' ? '准备' : game.phase === 'draw' ? '摸牌' : game.phase === 'play' ? '出牌' : '结束'}`;
|
||
document.getElementById('turn-count').textContent = `回合: ${game.turnCount}`;
|
||
document.getElementById('deck-count').textContent = game.deck.length;
|
||
|
||
const attackRange = calculateAttackRange(player);
|
||
document.getElementById('attack-range').textContent = `攻击距离: ${attackRange}`;
|
||
|
||
const isPlayPhase = game.phase === 'play';
|
||
const hasSelectedCard = game.selectedCardIndex !== -1 && player.isHuman && isPlayPhase;
|
||
const selectedCard = hasSelectedCard ? player.hand[game.selectedCardIndex] : null;
|
||
const isAttackOrScroll = selectedCard && (selectedCard.type === 'attack' || selectedCard.category === 'scroll');
|
||
|
||
for (let i = 0; i < 5; i++) {
|
||
const p = game.players[i];
|
||
|
||
if (!playerInfoCache[i]) {
|
||
playerInfoCache[i] = {
|
||
name: null,
|
||
identity: null,
|
||
skill: null
|
||
};
|
||
}
|
||
|
||
const infoCache = playerInfoCache[i];
|
||
|
||
const playerCard = document.getElementById(`player-${i}`);
|
||
|
||
playerCard.classList.remove('active', 'targetable', 'targeted', 'out-of-range');
|
||
if (i === game.currentPlayerIndex) {
|
||
playerCard.classList.add('active');
|
||
}
|
||
|
||
if (hasSelectedCard && isAttackOrScroll && i !== game.currentPlayerIndex && p.isAlive) {
|
||
if (game.isInRange(i)) {
|
||
playerCard.classList.add('targetable');
|
||
} else {
|
||
playerCard.classList.add('out-of-range');
|
||
}
|
||
}
|
||
|
||
if (game.selectedTargetIndex === i) {
|
||
playerCard.classList.add('targeted');
|
||
}
|
||
|
||
if (infoCache.name !== p.character.name) {
|
||
const avatar = document.getElementById(`avatar-${i}`);
|
||
avatar.src = `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='60' height='60'%3E%3Crect width='60' height='60' fill='${p.character.color}'/%3E%3Ctext x='30' y='35' text-anchor='middle' fill='white' font-size='12'%3E${p.character.name}%3C/text%3E%3C/svg%3E`;
|
||
document.getElementById(`name-${i}`).textContent = p.character.name;
|
||
infoCache.name = p.character.name;
|
||
}
|
||
|
||
const identityEl = document.getElementById(`identity-${i}`);
|
||
const identityInfo = IDENTITIES[p.identity];
|
||
const showIdentity = p.isHuman || p.identity === 'lord' || !p.isAlive;
|
||
const identityText = showIdentity ? identityInfo.name : '???';
|
||
const identityClass = showIdentity ? `identity ${identityInfo.class}` : 'identity hidden';
|
||
|
||
if (infoCache.identity !== identityText) {
|
||
identityEl.textContent = identityText;
|
||
identityEl.className = identityClass;
|
||
infoCache.identity = identityText;
|
||
}
|
||
|
||
const hpFill = document.getElementById(`hp-bar-${i}`).querySelector('.hp-fill');
|
||
|
||
if (!hpCache[i]) {
|
||
hpCache[i] = {
|
||
currentHp: null,
|
||
maxHp: null,
|
||
handLength: null
|
||
};
|
||
}
|
||
|
||
const hpData = hpCache[i];
|
||
|
||
if (hpData.currentHp !== p.currentHp || hpData.maxHp !== p.maxHp) {
|
||
hpFill.style.width = `${(p.currentHp / p.maxHp) * 100}%`;
|
||
hpFill.classList.remove('damaged');
|
||
void hpFill.offsetWidth;
|
||
hpFill.classList.add('damaged');
|
||
document.getElementById(`hp-value-${i}`).textContent = `${p.currentHp}/${p.maxHp}`;
|
||
hpData.currentHp = p.currentHp;
|
||
hpData.maxHp = p.maxHp;
|
||
}
|
||
|
||
if (hpData.handLength !== p.hand.length) {
|
||
document.getElementById(`cards-${i}`).textContent = p.hand.length;
|
||
hpData.handLength = p.hand.length;
|
||
}
|
||
|
||
renderEquipment(i);
|
||
|
||
const skillEl = document.getElementById(`skill-${i}`);
|
||
const skillText = p.character.skill || '';
|
||
if (infoCache.skill !== skillText) {
|
||
skillEl.textContent = skillText;
|
||
skillEl.title = p.character.skillDesc || '';
|
||
infoCache.skill = skillText;
|
||
}
|
||
|
||
renderHand(i);
|
||
}
|
||
|
||
const drawBtn = document.getElementById('draw-btn');
|
||
const playBtn = document.getElementById('play-btn');
|
||
const endTurnBtn = document.getElementById('end-turn-btn');
|
||
const readyBtn = document.getElementById('ready-btn');
|
||
const skillBtn = document.getElementById('skill-btn');
|
||
|
||
readyBtn.disabled = game.phase !== 'ready' || !player.isHuman || game.gameOver;
|
||
drawBtn.disabled = game.phase !== 'draw' || !player.isHuman || game.hasDrawn || game.gameOver;
|
||
skillBtn.disabled = game.phase !== 'play' || !player.isHuman || game.gameOver;
|
||
playBtn.disabled = game.phase !== 'play' || !player.isHuman || game.selectedCardIndex === -1 || game.gameOver;
|
||
endTurnBtn.disabled = game.gameOver || !player.isHuman || game.phase === 'ready';
|
||
}
|
||
|
||
const handCache = {};
|
||
const equipmentCache = {};
|
||
const playerInfoCache = {};
|
||
const hpCache = {};
|
||
|
||
function renderHand(playerIndex) {
|
||
const player = game.players[playerIndex];
|
||
const handContainer = document.getElementById(`hand-${playerIndex}`);
|
||
|
||
if (!handCache[playerIndex]) {
|
||
handCache[playerIndex] = {
|
||
handLength: 0,
|
||
cards: [],
|
||
selectedCardIndex: -1
|
||
};
|
||
}
|
||
|
||
const cache = handCache[playerIndex];
|
||
const currentHandLength = player.hand.length;
|
||
const currentSelectedIndex = player.isHuman ? game.selectedCardIndex : -1;
|
||
|
||
if (currentHandLength === cache.handLength && currentSelectedIndex === cache.selectedCardIndex) {
|
||
return;
|
||
}
|
||
|
||
if (currentHandLength === cache.handLength && player.isHuman) {
|
||
const existingCards = handContainer.querySelectorAll('.card');
|
||
const changedIndex = currentSelectedIndex !== cache.selectedCardIndex ? currentSelectedIndex : -1;
|
||
|
||
if (changedIndex !== -1) {
|
||
existingCards.forEach((cardElement, index) => {
|
||
cardElement.classList.toggle('selected', index === currentSelectedIndex);
|
||
});
|
||
}
|
||
cache.selectedCardIndex = currentSelectedIndex;
|
||
return;
|
||
}
|
||
|
||
handContainer.innerHTML = '';
|
||
cache.handLength = currentHandLength;
|
||
cache.cards = [];
|
||
cache.selectedCardIndex = currentSelectedIndex;
|
||
|
||
if (player.isHuman) {
|
||
player.hand.forEach((card, index) => {
|
||
const cardElement = document.createElement('div');
|
||
const cardImage = CARD_IMAGES[card.name] || { background: '#fff', icon: '🃏', pattern: 'default' };
|
||
|
||
cardElement.className = `card ${card.category}` + (index === currentSelectedIndex ? ' selected' : '');
|
||
cardElement.style.background = cardImage.background;
|
||
cardElement.innerHTML = `
|
||
<div class="card-icon">${cardImage.icon}</div>
|
||
<div class="card-suit">${card.getSuitSymbol()}</div>
|
||
<div class="card-rank">${card.getDisplayRank()}</div>
|
||
<div class="card-name">${card.name}</div>
|
||
<div class="card-type">${card.category === 'basic' ? '基本' : card.category === 'scroll' ? '锦囊' : '装备'}</div>
|
||
`;
|
||
cardElement.onclick = () => selectCard(index);
|
||
handContainer.appendChild(cardElement);
|
||
cache.cards.push(card.name);
|
||
});
|
||
} else {
|
||
for (let i = 0; i < player.hand.length; i++) {
|
||
const cardElement = document.createElement('div');
|
||
cardElement.className = 'card-back';
|
||
handContainer.appendChild(cardElement);
|
||
}
|
||
}
|
||
}
|
||
|
||
function renderEquipment(playerIndex) {
|
||
const player = game.players[playerIndex];
|
||
const equipmentEl = document.getElementById(`equipment-${playerIndex}`);
|
||
|
||
if (!equipmentCache[playerIndex]) {
|
||
equipmentCache[playerIndex] = {
|
||
weapon: null,
|
||
armor: null,
|
||
horsePlus: null,
|
||
horseMinus: null
|
||
};
|
||
}
|
||
|
||
const cache = equipmentCache[playerIndex];
|
||
|
||
if (cache.weapon === player.equipment.weapon?.name &&
|
||
cache.armor === player.equipment.armor?.name &&
|
||
cache.horsePlus === player.equipment.horsePlus?.name &&
|
||
cache.horseMinus === player.equipment.horseMinus?.name) {
|
||
return;
|
||
}
|
||
|
||
equipmentEl.innerHTML = '';
|
||
cache.weapon = player.equipment.weapon?.name || null;
|
||
cache.armor = player.equipment.armor?.name || null;
|
||
cache.horsePlus = player.equipment.horsePlus?.name || null;
|
||
cache.horseMinus = player.equipment.horseMinus?.name || null;
|
||
|
||
const equipmentTypes = [
|
||
{ key: 'weapon', class: 'weapon' },
|
||
{ key: 'armor', class: 'armor' },
|
||
{ key: 'horsePlus', class: 'horse' },
|
||
{ key: 'horseMinus', class: 'horse' }
|
||
];
|
||
|
||
equipmentTypes.forEach(({ key, class: className }) => {
|
||
const equip = player.equipment[key];
|
||
if (equip) {
|
||
const equipCard = document.createElement('div');
|
||
equipCard.className = `equipment-card ${className}`;
|
||
equipCard.textContent = equip.name.substring(0, 2);
|
||
const effect = EQUIPMENT_EFFECTS[equip.name];
|
||
if (effect) {
|
||
equipCard.title = `${equip.name}\n效果: ${effect.effect}`;
|
||
}
|
||
equipmentEl.appendChild(equipCard);
|
||
}
|
||
});
|
||
}
|
||
|
||
function selectCard(index) {
|
||
if (game.phase !== 'play' || !game.getCurrentPlayer().isHuman) return;
|
||
|
||
if (game.selectedCardIndex === index) {
|
||
game.selectedCardIndex = -1;
|
||
game.selectedTargetIndex = -1;
|
||
} else {
|
||
game.selectedCardIndex = index;
|
||
game.selectedTargetIndex = -1;
|
||
}
|
||
|
||
updateUI();
|
||
}
|
||
|
||
function selectTarget(targetIndex) {
|
||
const player = game.getCurrentPlayer();
|
||
if (!player.isHuman || game.phase !== 'play' || game.selectedCardIndex === -1) return;
|
||
|
||
const target = game.players[targetIndex];
|
||
if (!target.isAlive || targetIndex === game.currentPlayerIndex) return;
|
||
|
||
const selectedCard = player.hand[game.selectedCardIndex];
|
||
if (!selectedCard) return;
|
||
|
||
if (!game.isInRange(targetIndex)) {
|
||
game.addLog('目标不在攻击范围内');
|
||
return;
|
||
}
|
||
|
||
if (game.selectedTargetIndex === targetIndex) {
|
||
game.selectedTargetIndex = -1;
|
||
} else {
|
||
game.selectedTargetIndex = targetIndex;
|
||
}
|
||
|
||
updateUI();
|
||
}
|
||
|
||
function calculateAttackRange(player) {
|
||
let range = player.attackRange;
|
||
if (player.equipment.horseMinus) {
|
||
range++;
|
||
}
|
||
return Math.max(1, range);
|
||
}
|
||
|
||
function setupEventListeners() {
|
||
document.getElementById('ready-btn').onclick = () => {
|
||
if (game.getCurrentPlayer().isHuman && game.phase === 'ready') {
|
||
game.drawPhase();
|
||
updateUI();
|
||
}
|
||
};
|
||
|
||
document.getElementById('draw-btn').onclick = () => {
|
||
if (game.getCurrentPlayer().isHuman && game.phase === 'draw') {
|
||
game.drawPhase();
|
||
updateUI();
|
||
}
|
||
};
|
||
|
||
document.getElementById('skill-btn').onclick = () => {
|
||
if (game.getCurrentPlayer().isHuman && game.phase === 'play') {
|
||
game.useSkill();
|
||
updateUI();
|
||
}
|
||
};
|
||
|
||
document.getElementById('play-btn').onclick = () => {
|
||
if (game.selectedCardIndex !== -1 && game.getCurrentPlayer().isHuman) {
|
||
if (game.playCard(game.selectedCardIndex)) {
|
||
game.selectedCardIndex = -1;
|
||
game.selectedTargetIndex = -1;
|
||
updateUI();
|
||
}
|
||
}
|
||
};
|
||
|
||
document.getElementById('end-turn-btn').onclick = () => {
|
||
if (game.getCurrentPlayer().isHuman) {
|
||
game.endTurn();
|
||
updateUI();
|
||
}
|
||
};
|
||
|
||
const modal = document.getElementById('card-modal');
|
||
const closeBtn = document.querySelector('.close');
|
||
|
||
closeBtn.onclick = () => {
|
||
modal.style.display = 'none';
|
||
};
|
||
|
||
window.onclick = (event) => {
|
||
if (event.target === modal) {
|
||
modal.style.display = 'none';
|
||
}
|
||
};
|
||
}
|
||
|
||
window.onload = initGame; |