Exemple #1
0
def yesno(self, player, desc):
    pl = self.players[player]
    old_parser = pl.connection.parser

    def r(caller):
        if caller.text.lower().startswith('y'):
            self.set_responsei(1)
            reactor.callLater(0, process_duel, self)
        elif caller.text.lower().startswith('n'):
            self.set_responsei(0)
            reactor.callLater(0, process_duel, self)
        else:
            pl.notify(opt)
            pl.notify(DuelReader, r, restore_parser=old_parser)

    if desc > 10000:
        code = desc >> 4
        card = Card(code)
        opt = card.get_strings(pl)[desc & 0xF]
        if opt == "":
            opt = pl._("Unknown question from %s. Yes or no?") % (
                card.get_name(pl))
    else:
        opt = "String %d" % desc
        opt = pl.strings["system"].get(desc, opt)
    pl.notify(opt)
    pl.notify(DuelReader, r, restore_parser=old_parser)
Exemple #2
0
def yesno(self, player, desc):
    pl = self.players[player]
    old_parser = pl.connection.parser

    def yes(caller):
        self.set_responsei(1)
        reactor.callLater(0, process_duel, self)

    def no(caller):
        self.set_responsei(0)
        reactor.callLater(0, process_duel, self)

    if desc > 10000:
        code = desc >> 4
        card = Card(code)
        opt = card.get_strings(pl)[desc & 0xf]
        if opt == '':
            opt = pl._('Unknown question from %s. Yes or no?') % (
                card.get_name(pl))
    else:
        opt = "String %d" % desc
        opt = pl.strings['system'].get(desc, opt)
    pl.notify(yes_or_no_parser, opt, yes, no=no, restore_parser=old_parser)
Exemple #3
0
def move(self, code, location, newloc, reason):
    card = Card(code)
    card.set_location(location)
    cnew = Card(code)
    cnew.set_location(newloc)
    pl = self.players[card.controller]
    op = self.players[1 - card.controller]
    plspec = card.get_spec(pl)
    opspec = card.get_spec(op)
    plnewspec = cnew.get_spec(pl)
    opnewspec = cnew.get_spec(op)

    getspec = lambda p: plspec if p.duel_player == pl.duel_player else opspec
    getnewspec = lambda p: plnewspec if p.duel_player == pl.duel_player else opnewspec

    card_visible = True

    if card.position & POSITION.FACEDOWN and cnew.position & POSITION.FACEDOWN:
        card_visible = False

    getvisiblename = lambda p: card.get_name(p) if card_visible else p._(
        "Face-down card")

    if reason & REASON.DESTROY and card.location != cnew.location:
        self.inform(
            pl, (INFORM.ALLIES, lambda p: p._("Card %s (%s) destroyed.") %
                 (plspec, card.get_name(p))),
            (INFORM.OPPONENTS, lambda p: p._("Card %s (%s) destroyed.") %
             (opspec, card.get_name(p))))
    elif card.location == cnew.location and card.location & LOCATION.ONFIELD:
        if card.controller != cnew.controller:
            # controller changed too (e.g. change of heart)
            self.inform(
                pl,
                (INFORM.PLAYER, lambda p: p.
                 _("your card {spec} ({name}) changed controller to {op} and is now located at {targetspec}."
                   ).format(spec=plspec,
                            name=card.get_name(p),
                            op=op.nickname,
                            targetspec=plnewspec)),
                (INFORM.OPPONENT, lambda p: p.
                 _("you now control {plname}s card {spec} ({name}) and its located at {targetspec}."
                   ).format(plname=pl.nickname,
                            spec=opspec,
                            name=card.get_name(p),
                            targetspec=opnewspec)),
                (INFORM.WATCHERS | INFORM.TAG_PLAYERS, lambda p: p.
                 _("{plname}s card {spec} ({name}) changed controller to {op} and is now located at {targetspec}."
                   ).format(plname=pl.nickname,
                            op=op.nickname,
                            spec=getspec(p),
                            targetspec=getnewspec(p),
                            name=card.get_name(p))),
            )
        else:
            # only column changed (alien decks e.g.)
            self.inform(
                pl,
                (INFORM.PLAYER, lambda p: p.
                 _("your card {spec} ({name}) switched its zone to {targetspec}."
                   ).format(spec=plspec,
                            name=card.get_name(p),
                            targetspec=plnewspec)),
                (INFORM.OTHER, lambda p: p.
                 _("{plname}s card {spec} ({name}) changed its zone to {targetspec}."
                   ).format(plname=pl.nickname,
                            spec=getspec(p),
                            targetspec=getnewspec(p),
                            name=card.get_name(p))),
            )
    elif reason & REASON.DISCARD and card.location != cnew.location:
        self.inform(
            pl,
            (INFORM.PLAYER, lambda p: p._("you discarded {spec} ({name}).").
             format(spec=plspec, name=card.get_name(p))),
            (INFORM.OTHER,
             lambda p: p._("{plname} discarded {spec} ({name}).").format(
                 plname=pl.nickname, spec=getspec(p), name=card.get_name(p))),
        )
    elif card.location == LOCATION.REMOVED and cnew.location & LOCATION.ONFIELD:
        self.inform(
            pl,
            (INFORM.PLAYER, lambda p: p.
             _("your banished card {spec} ({name}) returns to the field at {targetspec}."
               ).format(
                   spec=plspec, name=card.get_name(p), targetspec=plnewspec)),
            (INFORM.OTHER, lambda p: p.
             _("{plname}'s banished card {spec} ({name}) returned to their field at {targetspec}."
               ).format(plname=pl.nickname,
                        spec=getspec(p),
                        targetspec=getnewspec(p),
                        name=card.get_name(p))),
        )
    elif card.location == LOCATION.GRAVE and cnew.location & LOCATION.ONFIELD:
        self.inform(
            pl,
            (INFORM.PLAYER, lambda p: p.
             _("your card {spec} ({name}) returns from the graveyard to the field at {targetspec}."
               ).format(
                   spec=plspec, name=card.get_name(p), targetspec=plnewspec)),
            (INFORM.OTHER, lambda p: p.
             _("{plname}s card {spec} ({name}) returns from the graveyard to the field at {targetspec}."
               ).format(plname=pl.nickname,
                        spec=getspec(p),
                        targetspec=getnewspec(p),
                        name=card.get_name(p))),
        )
    elif cnew.location == LOCATION.HAND and card.location != cnew.location:
        self.inform(
            pl,
            (INFORM.PLAYER | INFORM.TAG_PLAYER,
             lambda p: p._("Card {spec} ({name}) returned to hand.").format(
                 spec=plspec, name=card.get_name(p))),
            (INFORM.WATCHERS | INFORM.OPPONENTS, lambda p: p._(
                "{plname}'s card {spec} ({name}) returned to their hand.").
             format(plname=pl.nickname,
                    spec=getspec(p),
                    name=getvisiblename(p))),
        )
    elif reason & (REASON.RELEASE
                   | REASON.SUMMON) and card.location != cnew.location:
        self.inform(
            pl,
            (INFORM.PLAYER, lambda p: p._("You tribute {spec} ({name}).").
             format(spec=plspec, name=card.get_name(p))),
            (INFORM.OTHER,
             lambda p: p._("{plname} tributes {spec} ({name}).").format(
                 plname=pl.nickname, spec=getspec(p), name=getvisiblename(p))),
        )
    elif card.location == LOCATION.OVERLAY | LOCATION.MZONE and cnew.location & LOCATION.ONFIELD:
        self.inform(
            pl,
            (INFORM.PLAYER, lambda p: p._("you detached %s.") %
             (card.get_name(p))),
            (INFORM.OTHER, lambda p: p._("%s detached %s") %
             (pl.nickname, card.get_name(p))),
        )
    elif card.location != cnew.location and cnew.location == LOCATION.GRAVE:
        self.inform(
            pl,
            (INFORM.PLAYER, lambda p: p._(
                "your card {spec} ({name}) was sent to the graveyard.").format(
                    spec=plspec, name=card.get_name(p))),
            (INFORM.OTHER, lambda p: p._(
                "{plname}'s card {spec} ({name}) was sent to the graveyard.").
             format(plname=pl.nickname, spec=getspec(p), name=card.get_name(p))
             ),
        )
    elif card.location != cnew.location and cnew.location == LOCATION.REMOVED:
        self.inform(
            pl,
            (INFORM.PLAYER,
             lambda p: p._("your card {spec} ({name}) was banished.").format(
                 spec=plspec, name=card.get_name(p))),
            (INFORM.OTHER, lambda p: p.
             _("{plname}'s card {spec} ({name}) was banished.").format(
                 plname=pl.nickname, spec=getspec(p), name=getvisiblename(p))),
        )
    elif card.location != cnew.location and cnew.location == LOCATION.DECK:
        self.inform(
            pl,
            (INFORM.PLAYER,
             lambda p: p._("your card {spec} ({name}) returned to your deck."
                           ).format(spec=plspec, name=card.get_name(p))),
            (INFORM.OTHER, lambda p: p._(
                "{plname}'s card {spec} ({name}) returned to their deck.").
             format(plname=pl.nickname,
                    spec=getspec(p),
                    name=getvisiblename(p))),
        )
    elif card.location != cnew.location and cnew.location == LOCATION.EXTRA:
        self.inform(
            pl,
            (INFORM.PLAYER, lambda p: p._(
                "your card {spec} ({name}) returned to your extra deck.").
             format(spec=plspec, name=card.get_name(pl))),
            (INFORM.OTHER, lambda p: p
             ._("{plname}'s card {spec} ({name}) returned to their extra deck."
                ).format(
                    plname=pl.nickname, spec=getspec(p), name=card.get_name(p))
             ),
        )
    elif card.location == LOCATION.DECK and cnew.location == LOCATION.SZONE:

        def fn(p):
            if p.soundpack and cnew.type & TYPE.SPELL:
                p.notify("### activate_spell")
            elif p.soundpack and cnew.type & TYPE.TRAP:
                p.notify("### activate_trap")

            if p is pl:
                if cnew.position & POSITION.FACEDOWN:
                    return p._("You set %s (%s) in %s position.") % (
                        cnew.get_spec(p), cnew.get_name(p),
                        cnew.get_position(p))
                else:
                    return p._("Activating {0} ({1})").format(
                        cnew.get_spec(p), cnew.get_name(p))
            else:
                if cnew.position & POSITION.FACEDOWN:
                    return p._("%s sets %s in %s position.") % (
                        pl.nickname, cnew.get_spec(p), cnew.get_position(p))
                else:
                    return p._("{0} activating {1} ({2})").format(
                        pl.nickname, cnew.get_spec(p), cnew.get_name(p))

        self.inform(pl, (INFORM.ALL, fn))

    elif cnew.location == (LOCATION.OVERLAY | LOCATION.MZONE):
        attached_to = self.get_card(cnew.controller,
                                    cnew.location ^ LOCATION.OVERLAY,
                                    cnew.sequence)

        self.inform(
            pl,
            (INFORM.PLAYER, lambda p: p.
             _("your card {spec} ({name}) was attached to {targetspec} ({targetname}) as XYZ material"
               ).format(spec=getspec(p),
                        name=card.get_name(p),
                        targetspec=attached_to.get_spec(p),
                        targetname=attached_to.get_name(p))),
            (INFORM.OTHER, lambda p: p.
             _("{plname}'s card {spec} ({name}) was attached to {targetspec} ({targetname}) as XYZ material"
               ).format(spec=getspec(p),
                        name=card.get_name(p),
                        targetspec=attached_to.get_spec(p),
                        targetname=attached_to.get_name(p),
                        plname=pl.nickname)),
        )
Exemple #4
0
def move(self, code, location, newloc, reason):
	card = Card(code)
	card.set_location(location)
	pl = self.players[card.controller]
	op = self.players[1 - card.controller]
	plspec = card.get_spec(pl.duel_player)
	ploc = (location >> 8) & 0xff
	pnewloc = (newloc >> 8) & 0xff
	if reason & 0x01 and ploc != pnewloc:
		pl.notify(pl._("Card %s (%s) destroyed.") % (plspec, card.get_name(pl)))
		for w in self.watchers+[op]:
			s = card.get_spec(w.duel_player)
			w.notify(w._("Card %s (%s) destroyed.") % (s, card.get_name(w)))
	elif ploc == pnewloc and ploc in (LOCATION_MZONE, LOCATION_SZONE):
		cnew = Card(code)
		cnew.set_location(newloc)

		if (location & 0xff) != (newloc & 0xff):
			# controller changed too (e.g. change of heart)
			pl.notify(pl._("your card {spec} ({name}) changed controller to {op} and is now located at {targetspec}.").format(spec=plspec, name = card.get_name(pl), op = op.nickname, targetspec = cnew.get_spec(pl.duel_player)))
			op.notify(op._("you now control {plname}s card {spec} ({name}) and its located at {targetspec}.").format(plname=pl.nickname, spec=card.get_spec(op.duel_player), name = card.get_name(op), targetspec = cnew.get_spec(op.duel_player)))
			for w in self.watchers:
				s = card.get_spec(w.duel_player)
				ts = cnew.get_spec(w.duel_player)
				w.notify(w._("{plname}s card {spec} ({name}) changed controller to {op} and is now located at {targetspec}.").format(plname=pl.nickname, op=op.nickname, spec=s, targetspec=ts, name=card.get_name(w)))
		else:
			# only place changed (alien decks e.g.)
			pl.notify(pl._("your card {spec} ({name}) switched its zone to {targetspec}.").format(spec=plspec, name=card.get_name(pl), targetspec=cnew.get_spec(pl.duel_player)))
			for w in self.watchers+[op]:
				s = card.get_spec(w.duel_player)
				ts = cnew.get_spec(w.duel_player)
				w.notify(w._("{plname}s card {spec} ({name}) changed its zone to {targetspec}.").format(plname=pl.nickname, spec=s, targetspec=ts, name=card.get_name(w)))
	elif reason & 0x4000 and ploc != pnewloc:
		pl.notify(pl._("you discarded {spec} ({name}).").format(spec = plspec, name = card.get_name(pl)))
		for w in self.watchers+[op]:
			s = card.get_spec(w.duel_player)
			w.notify(w._("{plname} discarded {spec} ({name}).").format(plname=pl.nickname, spec=s, name=card.get_name(w)))
	elif ploc == LOCATION_REMOVED and pnewloc in (LOCATION_SZONE, LOCATION_MZONE):
		cnew = Card(code)
		cnew.set_location(newloc)
		pl.notify(pl._("your banished card {spec} ({name}) returns to the field at {targetspec}.").format(spec=plspec, name=card.get_name(pl), targetspec=cnew.get_spec(pl.duel_player)))
		for w in self.watchers+[op]:
			s=card.get_spec(w.duel_player)
			ts = cnew.get_spec(w.duel_player)
			w.notify(w._("{plname}'s banished card {spec} ({name}) returned to their field at {targetspec}.").format(plname=pl.nickname, spec=s, targetspec=ts, name=card.get_name(w)))
	elif ploc == LOCATION_GRAVE and pnewloc in (LOCATION_SZONE, LOCATION_MZONE):
		cnew = Card(code)
		cnew.set_location(newloc)
		pl.notify(pl._("your card {spec} ({name}) returns from the graveyard to the field at {targetspec}.").format(spec=plspec, name=card.get_name(pl), targetspec=cnew.get_spec(pl.duel_player)))
		for w in self.watchers+[op]:
			s = card.get_spec(w.duel_player)
			ts = cnew.get_spec(w.duel_player)
			w.notify(w._("{plname}s card {spec} ({name}) returns from the graveyard to the field at {targetspec}.").format(plname = pl.nickname, spec=s, targetspec=ts, name = card.get_name(w)))
	elif pnewloc == LOCATION_HAND and ploc != pnewloc:
		pl.notify(pl._("Card {spec} ({name}) returned to hand.")
			.format(spec=plspec, name=card.get_name(pl)))
		for w in self.watchers+[op]:
			if card.position in (POS_FACEDOWN_DEFENSE, POS_FACEDOWN):
				name = w._("Face-down card")
			else:
				name = card.get_name(w)
			s = card.get_spec(w.duel_player)
			w.notify(w._("{plname}'s card {spec} ({name}) returned to their hand.")
				.format(plname=pl.nickname, spec=s, name=name))
	elif reason & 0x12 and ploc != pnewloc:
		pl.notify(pl._("You tribute {spec} ({name}).")
			.format(spec=plspec, name=card.get_name(pl)))
		for w in self.watchers+[op]:
			s = card.get_spec(w.duel_player)
			if card.position in (POS_FACEDOWN_DEFENSE, POS_FACEDOWN):
				name = w._("%s card") % card.get_position(w)
			else:
				name = card.get_name(w)
			w.notify(w._("{plname} tributes {spec} ({name}).")
				.format(plname=pl.nickname, spec=s, name=name))
	elif ploc == LOCATION_OVERLAY+LOCATION_MZONE and pnewloc in (LOCATION_GRAVE, LOCATION_REMOVED):
		pl.notify(pl._("you detached %s.")%(card.get_name(pl)))
		for w in self.watchers+[op]:
			w.notify(w._("%s detached %s")%(pl.nickname, card.get_name(w)))
	elif ploc != pnewloc and pnewloc == LOCATION_GRAVE:
		pl.notify(pl._("your card {spec} ({name}) was sent to the graveyard.").format(spec=plspec, name=card.get_name(pl)))
		for w in self.watchers+[op]:
			s = card.get_spec(w.duel_player)
			w.notify(w._("{plname}'s card {spec} ({name}) was sent to the graveyard.").format(plname=pl.nickname, spec=s, name=card.get_name(w)))
	elif ploc != pnewloc and pnewloc == LOCATION_REMOVED:
		pl.notify(pl._("your card {spec} ({name}) was banished.").format(spec=plspec, name=card.get_name(pl)))
		for w in self.watchers+[op]:
			if card.position in (POS_FACEDOWN_DEFENSE, POS_FACEDOWN):
				name = w._("%s card")%(card.get_position(w))
			else:
				name = card.get_name(w)
			s = card.get_spec(w.duel_player)
			w.notify(w._("{plname}'s card {spec} ({name}) was banished.").format(plname=pl.nickname, spec=s, name=name))
	elif ploc != pnewloc and pnewloc == LOCATION_DECK:
		pl.notify(pl._("your card {spec} ({name}) returned to your deck.").format(spec=plspec, name=card.get_name(pl)))
		for w in self.watchers+[op]:
			s = card.get_spec(w.duel_player)
			w.notify(w._("{plname}'s card {spec} ({name}) returned to their deck.").format(plname=pl.nickname, spec=s, name=card.get_name(w)))
	elif ploc != pnewloc and pnewloc == LOCATION_EXTRA:
		pl.notify(pl._("your card {spec} ({name}) returned to your extra deck.").format(spec=plspec, name=card.get_name(pl)))
		for w in self.watchers+[op]:
			s = card.get_spec(w.duel_player)
			w.notify(w._("{plname}'s card {spec} ({name}) returned to their extra deck.").format(plname=pl.nickname, spec=s, name=card.get_name(w)))