Esempio n. 1
0
bool PhaseChangeSkill::trigger(TriggerEvent, ServerPlayer *player, QVariant &) const{
    bool skipped = onPhaseChange(player);
    if(skipped)
        player->skip(player->getPhase());

    return skipped;
}
Esempio n. 2
0
bool PhaseChangeSkill::trigger(TriggerEvent, ServerPlayer *player, QVariant &) const{
    return onPhaseChange(player);
}
Esempio n. 3
0
bool GameRule::trigger(TriggerEvent event, ServerPlayer *player, QVariant &data) const{
    Room *room = player->getRoom();

    switch(event){
    case GameStart: {
            if(player->getKingdom() == "god"){
                QString new_kingdom = room->askForKingdom(player);
                if(new_kingdom != "god")
                    room->setPlayerProperty(player, "kingdom", new_kingdom);

                LogMessage log;
                log.type = "#ChooseKingdom";
                log.from = player;
                log.arg = new_kingdom;
                room->sendLog(log);
            }

            player->drawCards(4, false);
            break;
        }

    case PhaseChange: onPhaseChange(player); break;
    case CardUsed: {
            if(data.canConvert<CardUseStruct>()){
                CardUseStruct card_use = data.value<CardUseStruct>();
                const Card *card = card_use.card;

                card_use.from->playCardEffect(card);
                card->use(room, card_use.from, card_use.to);
            }

            break;
        }

    case Dying:{
            DyingStruct dying = data.value<DyingStruct>();
            int got = room->askForPeaches(player, dying.peaches);
            if(got >= dying.peaches)
                room->setPlayerProperty(player, "hp", got - dying.peaches + 1);
            else{
                ServerPlayer *killer = NULL;
                if(dying.damage && dying.damage->from)
                    killer = dying.damage->from;

                room->killPlayer(player, killer);
            }
            break;
        }

    case Predamaged:{
            if(data.canConvert<DamageStruct>()){
                DamageStruct damage = data.value<DamageStruct>();
                room->sendDamageLog(damage);

                int new_hp = player->getHp() - damage.damage;
                room->damage(player, damage.damage);
                if(new_hp <= 0){
                    DyingStruct dying;
                    dying.damage = &damage;
                    dying.peaches = 1 - new_hp;

                    QVariant dying_data = QVariant::fromValue(dying);
                    room->getThread()->trigger(Dying, player, dying_data);
                }

                bool chained = player->isChained();
                if(damage.nature != DamageStruct::Normal && chained){
                    room->setPlayerProperty(player, "chained", false);

                    // iron chain effect
                    QList<ServerPlayer *> chained_players = room->getAllPlayers();
                    chained_players.removeOne(player);

                    foreach(ServerPlayer *chained_player, chained_players){
                        if(chained_player->isChained()){
                            DamageStruct chain_damage = damage;
                            chain_damage.to = chained_player;
                            chain_damage.chain = true;

                            room->setPlayerProperty(chained_player, "chained", false);
                            room->damage(chain_damage);
                        }
                    }
                }
            }

            break;
        }