def __init__(self, seed=None):
Joinable.__init__(self)
self.buf = ffi.new('char[]', 4096)
if seed is None:
seed = random.randint(0, 0xffffffff)
self.seed = seed
self.duel = lib.create_duel(seed)
self.cm = callback_manager.CallbackManager()
self.keep_processing = False
self.to_ep = False
self.to_m2 = False
self.current_phase = 0
self.watchers = []
self.private = False
self.started = False
self.debug_mode = False
self.debug_fp = None
self.players = [None, None]
self.tag_players = []
self.lp = [8000, 8000]
self.started = False
self.message_map = {}
self.state = ''
self.cards = [None, None]
self.tag_cards = [None, None]
self.revealed = {}
self.say = Say()
self.watch = Watchers()
self.tags = [Tag(), Tag()]
self.bind_message_handlers()
self.pause_timer = None
def __init__(self, seed=None):
self.buf = ffi.new('char[]', 4096)
if seed is None:
seed = random.randint(0, 0xffffffff)
self.seed = seed
self.duel = lib.create_duel(seed)
lib.set_player_info(self.duel, 0, 8000, 5, 1)
lib.set_player_info(self.duel, 1, 8000, 5, 1)
self.cm = callback_manager.CallbackManager()
self.keep_processing = False
self.to_ep = False
self.to_m2 = False
self.current_phase = 0
self.watchers = []
self.private = False
self.started = False
self.debug_mode = False
self.debug_fp = None
self.players = [None, None]
self.lp = [8000, 8000]
self.started = False
self.message_map = {}
self.state = ''
self.cards = [None, None]
self.revealed = {}
self.bind_message_handlers()
def set_responseb(self, r):
buf = ffi.new('char[64]', r)
lib.set_responseb(self.duel, ffi.cast('byte *', buf))
self.cm.call_callbacks('debug',
event_type='set_responseb',
response=r.decode('latin1'))
cd.lscale = (row['level'] >> 24) & 0xff
cd.rscale = (row['level'] >> 16) & 0xff
cd.attack = row['atk']
cd.defense = row['def']
if cd.type & TYPE.LINK:
cd.link_marker = cd.defense
cd.defense = 0
else:
cd.link_marker = 0
cd.race = row['race']
cd.attribute = row['attribute']
return 0
lib.set_card_reader(lib.card_reader_callback)
scriptbuf = ffi.new('char[131072]')
@ffi.def_extern()
def script_reader_callback(name, lenptr):
fn = ffi.string(name)
if not os.path.exists(fn):
lenptr[0] = 0
return ffi.NULL
s = open(fn, 'rb').read()
buf = ffi.buffer(scriptbuf)
buf[0:len(s)] = s
lenptr[0] = len(s)
return ffi.cast('byte *', scriptbuf)
lib.set_script_reader(lib.script_reader_callback)
def __init__(self, seed=None):
self.buf = ffi.new('char[]', 4096)
if seed is None:
seed = random.randint(0, 0xffffffff)
self.seed = seed
self.duel = lib.create_duel(seed)
lib.set_player_info(self.duel, 0, 8000, 5, 1)
lib.set_player_info(self.duel, 1, 8000, 5, 1)
self.cm = callback_manager.CallbackManager()
self.started = False
self.message_map = {
90: self.msg_draw,
40: self.msg_new_turn,
41: self.msg_new_phase,
11: self.msg_idlecmd,
1: self.msg_retry,
2: self.msg_hint,
18: self.msg_select_place,
24: self.msg_select_place,
37: self.msg_reversedeck,
38: self.msg_decktop,
50: self.msg_move,
55: self.msg_swap,
56: self.msg_field_disabled,
60: self.msg_summoning,
16: self.msg_select_chain,
61: self.msg_summoned,
64: self.msg_flipsummoning,
54: self.msg_set,
10: self.msg_select_battlecmd,
101: self.msg_counters,
102: self.msg_counters,
110: self.msg_attack,
113: self.msg_begin_damage,
114: self.msg_end_damage,
111: self.msg_battle,
91: self.msg_damage,
15: self.msg_select_card,
14: self.msg_select_option,
92: self.msg_recover,
20: self.msg_select_tribute,
53: self.msg_pos_change,
70: self.msg_chaining,
19: self.msg_select_position,
13: self.msg_yesno,
62: partial(self.msg_summoning, special=True),
12: self.msg_select_effectyn,
5: self.msg_win,
100: self.msg_pay_lpcost,
21: self.msg_sort_chain,
141: self.msg_announce_attrib,
142: self.msg_announce_card,
143: self.msg_announce_number,
144: self.msg_announce_card_filter,
23: self.msg_select_sum,
140: self.msg_announce_race,
22: self.msg_select_counter,
83: self.msg_become_target,
25: self.msg_sort_card,
130: self.msg_toss_coin,
131: partial(self.msg_toss_coin, dice=True),
31: self.msg_confirm_cards,
73: self.msg_chain_solved,
93: self.msg_equip,
94: self.msg_lpupdate,
32: self.msg_shuffle,
}
self.state = ''
self.cards = [None, None]
self.revealed = {}
def main():
player_factory = {'manual': FakePlayer, 'random': RandomAI}
parser = argparse.ArgumentParser()
parser.add_argument("--deck1",
help="deck for player 1",
type=str,
required=True)
parser.add_argument("--deck2",
help="deck for player 2",
type=str,
required=True)
parser.add_argument("--lp1",
help="starting lp for player 1",
type=int,
default=8000)
parser.add_argument("--lp2",
help="starting lp for player 2",
type=int,
default=8000)
parser.add_argument("--p1",
help="type of player 1",
type=str,
default='random',
choices=player_factory.keys())
parser.add_argument("--p2",
help="type of player 1",
type=str,
default='random',
choices=player_factory.keys())
parser.add_argument("--preload",
help="path to preload script",
type=str,
default=None)
args = parser.parse_args()
decks = [load_deck(args.deck1), load_deck(args.deck2)]
glb.language_handler = LanguageHandler()
glb.language_handler.add("english", "en")
glb.language_handler.set_primary_language("english")
glb.server = server.Server()
glb.server.db = sqlite3.connect("locale/en/cards.cdb")
glb.server.db.row_factory = sqlite3.Row
duel = dm.Duel()
duel.room = FakeRoom()
config = {"players": ["Alice", "Bob"], "decks": decks}
players = [
player_factory[args.p1](0, config["decks"][0]),
player_factory[args.p2](1, config["decks"][1])
]
for i, name in enumerate(config["players"]):
players[i].nickname = name
duel.load_deck(players[i])
duel.players = players
duel.set_player_info(0, args.lp1)
duel.set_player_info(1, args.lp2)
# rules = 1, Traditional
# rules = 0, Default
# rules = 4, Link
# rules = 5, MR5
rules = 5
options = 0
if args.preload:
fn = args.preload
fn_buff = ffi.new("char[]", fn.encode('ascii'))
lib.preload_script(duel.duel, fn_buff, len(fn))
duel.start(((rules & 0xFF) << 16) + (options & 0xFFFF))
process_duel(duel)
print(duel.lp)
