Esempio n. 1
0
 def __init__(self, replay):
     self._file = open(replay)
     game_type_name = self.replay_read()
     if game_type_name in ("multiplayer", "training"):
         self.default_triggers = _MultiplayerGame.default_triggers
     game_name = self.replay_read()
     version = self.replay_read()
     mods = self.replay_read()
     _compatibility_version = self.replay_read()
     if _compatibility_version != compatibility_version():
         voice.alert([1029, 4012]) # hostile sound  "version error"
         warning("Version mismatch. Version should be: %s. Mods should be: %s.",
                 version, mods)
     self.map = Map()
     self.map.unpack(self.replay_read())
     players = self.replay_read().split()
     self.alliances = map(int, self.replay_read().split())
     self.races = self.replay_read().split()
     self.seed = int(self.replay_read())
     self.me = ReplayClient(players[0], self)
     self.players = [self.me]
     for x in players[1:]:
         if x in ["aggressive", "easy"]: # the "ai_" prefix wasn't recorded
             self.players += [DummyClient(x)]
         else:
             self.players += [HalfDummyClient(x)]
             self.me.nb_humans += 1
Esempio n. 2
0
 def __init__(self, replay):
     self._file = open(replay)
     game_type_name = self.replay_read()
     if game_type_name in ("multiplayer", "training"):
         self.default_triggers = _MultiplayerGame.default_triggers
     game_name = self.replay_read()
     voice.alert([game_name])
     version = self.replay_read()
     mods = self.replay_read()
     if mods != config.mods:
         config.mods = mods
         reload_all()
     _compatibility_version = self.replay_read()
     if _compatibility_version != compatibility_version():
         voice.alert([1029, 4012])  # hostile sound  "version error"
         warning(
             "Version mismatch. Version should be: %s. Mods should be: %s.",
             version, mods)
     self.map = Map()
     self.map.unpack(self.replay_read())
     players = self.replay_read().split()
     self.alliances = map(int, self.replay_read().split())
     self.factions = self.replay_read().split()
     self.seed = int(self.replay_read())
     self.me = ReplayClient(players[0], self)
     self.players = [self.me]
     for x in players[1:]:
         if x in ["aggressive", "easy"]:  # the "ai_" prefix wasn't recorded
             self.players += [DummyClient(x)]
         else:
             self.players += [HalfDummyClient(x)]
             self.me.nb_humans += 1
Esempio n. 3
0
 def choose_server_ip_in_a_list(self):
     servers_list = None
     try:
         f = urllib.urlopen(SERVERS_LIST_URL)
         if f.read(len(SERVERS_LIST_HEADER)) == SERVERS_LIST_HEADER:
             servers_list = f.readlines()
     except:
         pass
     if servers_list is None:
         voice.alert([1029]) # hostile sound
         warning("couldn't get the servers list from the metaserver"
                 " => using the default servers list")
         servers_list = DEFAULT_SERVERS
     nb = 0
     menu = Menu()
     for s in servers_list:
         try:
             ip, version, login, port = s.split()[1:]
             # ignore the first parameter (time)
         except:
             warning("line not recognized from the metaserver: %s", s)
             continue
         nb += 1
         if version == compatibility_version():
             menu.append([login, 4073, login], (connect_and_play, ip, port))
     menu.title = nb2msg(len(menu.choices)) + [4078] + nb2msg(nb) + [4079]
     menu.append([4075, 4076], None)
     menu.run()
Esempio n. 4
0
 def __init__(self, replay):
     self._file = open(replay)
     game_type_name = self.replay_read()
     if game_type_name in ("multiplayer", "training"):
         self.default_triggers = _MultiplayerGame.default_triggers
     game_name = self.replay_read()
     voice.alert([game_name])
     version = self.replay_read()
     mods = self.replay_read()
     res.set_mods(mods)
     _compatibility_version = self.replay_read()
     if _compatibility_version != compatibility_version():
         voice.alert([1029, 4012]) # hostile sound  "version error"
         warning("Version mismatch. Version should be: %s. Mods should be: %s.",
                 version, mods)
     campaign_path_or_packed_map = self.replay_read()
     if game_type_name == "mission" and "***" not in campaign_path_or_packed_map:
         from campaign import Campaign
         self.map = Campaign(campaign_path_or_packed_map)._get(int(self.replay_read()))
     else:
         self.map = Map()
         self.map.unpack(campaign_path_or_packed_map)
     players = self.replay_read().split()
     self.alliances = map(int, self.replay_read().split())
     self.factions = self.replay_read().split()
     self.seed = int(self.replay_read())
     self.me = ReplayClient(players[0], self)
     self.players = [self.me]
     for x in players[1:]:
         if x in ["aggressive", "easy"]: # the "ai_" prefix wasn't recorded
             self.players += [DummyClient(x)]
         else:
             self.players += [HalfDummyClient(x)]
             self.me.nb_humans += 1
Esempio n. 5
0
def connect_and_play(host="127.0.0.1", port=options.port, auto=False):
    try:
        server = ConnectionToServer(host, port)
        ServerMenu(server, auto=auto).loop()
        server.close() # without this, the server isn't closed after a game
    except UnreachableServerError:
        voice.alert(mp.SERVER_UNREACHABLE)
    except WrongServerError:
        voice.alert(mp.UNEXPECTED_REPLY + [compatibility_version()])
    except CompatibilityOrLoginError:
        voice.alert(mp.CONNECTION_REJECTED + [compatibility_version()] + mp.OR_LOGIN_REJECTED)
    except ConnectionAbortedError:
        voice.alert(mp.CONNECTION_INTERRUPTED)
    except SystemExit:
        raise
    except:
        voice.alert(mp.ERROR_DURING_CONNECTION)
        exception("error during connection to server")
Esempio n. 6
0
 def pre_run(self):
     nb_human_players = len([p for p in self.players if p.login != "ai"])
     if nb_human_players > 1:
         if compatibility_version() != COMPATIBILITY_VERSION:
             warning("rules.txt or ai.txt has been modified"
                     " after the program started: exit...")
             sys.exit()
         send_platform_version_to_metaserver(self.map.get_name(), nb_human_players)
         self._countdown()
Esempio n. 7
0
def connect_and_play(host="127.0.0.1", port=options.port, auto=False):
    try:
        server = ConnectionToServer(host, port)
        ServerMenu(server, auto=auto).loop()
        server.close()  # without this, the server isn't closed after a game
    except UnreachableServerError:
        voice.alert(mp.SERVER_UNREACHABLE)
    except WrongServerError:
        voice.alert(mp.UNEXPECTED_REPLY + [compatibility_version()])
    except CompatibilityOrLoginError:
        voice.alert(mp.CONNECTION_REJECTED + [compatibility_version()] +
                    mp.OR_LOGIN_REJECTED)
    except ConnectionAbortedError:
        voice.alert(mp.CONNECTION_INTERRUPTED)
    except SystemExit:
        raise
    except:
        voice.alert(mp.ERROR_DURING_CONNECTION)
        exception("error during connection to server")
Esempio n. 8
0
 def _register(self):
     try:
         s = urllib.urlopen(REGISTER_URL + "?version=%s&login=%s&ip=%s&port=%s" %
                            (compatibility_version(), self.login, self.ip,
                             config.port)).read()
     except:
         s = "couldn't access to the metaserver"
     if s:
         warning("couldn't register to the metaserver (%s)", s[:80])
     else:
         info("server registered")
Esempio n. 9
0
def connect_and_play(host="127.0.0.1", port=config.port):
    try:
        server = ConnectionToServer(host, port)
        ServerMenu(server).loop()
        server.close()  # without this, the server isn't closed after a game
    except UnreachableServerError:
        # "failure: the server unreachable. The server is closed or behind a firewall or behind a router."
        voice.alert([4081])
    except WrongServerError:
        # "failure: unexpected reply from the server. The server is not a SoundRTS server" (version)
        voice.alert([4082, compatibility_version()])
    except CompatibilityOrLoginError:
        # "failure: connexion rejected the server. The server is not a SoundRTS server" (version)
        # "or your login has been rejected"
        voice.alert([4083, compatibility_version(), 4084])
    except ConnectionAbortedError:
        voice.alert([4102])  # connection aborted
    except SystemExit:
        raise
    except:
        voice.alert([4085])  # "error during connexion to server"
        exception("error during connection to server")
Esempio n. 10
0
def connect_and_play(host="127.0.0.1", port=config.port):
    try:
        server = ConnectionToServer(host, port)
        ServerMenu(server).loop()
        server.close() # without this, the server isn't closed after a game
    except UnreachableServerError:
        # "failure: the server unreachable. The server is closed or behind a firewall or behind a router."
        voice.alert([4081])
    except WrongServerError:
        # "failure: unexpected reply from the server. The server is not a SoundRTS server" (version)
        voice.alert([4082, compatibility_version()])
    except CompatibilityOrLoginError:
        # "failure: connexion rejected the server. The server is not a SoundRTS server" (version)
        # "or your login has been rejected"
        voice.alert([4083, compatibility_version(), 4084])
    except ConnectionAbortedError:
        voice.alert([4102]) # connection aborted
    except SystemExit:
        raise
    except:
        voice.alert([4085]) # "error during connexion to server"
        exception("error during connection to server")
Esempio n. 11
0
 def create_replay(self):
     self._replay_file = open(os.path.join(REPLAYS_PATH, "%s.txt" % int(time.time())), "w")
     self.replay_write(self.game_type_name)
     players = " ".join([p.login for p in self.players])
     self.replay_write(self.map.get_name() + " " + players)
     self.replay_write(VERSION)
     self.replay_write(config.mods)
     self.replay_write(compatibility_version())
     self.replay_write(self.map.pack())
     self.replay_write(players)
     self.replay_write(" ".join(map(str, self.alliances)))
     self.replay_write(" ".join(self.races))
     self.replay_write(str(self.seed))
Esempio n. 12
0
 def create_replay(self):
     self._replay_file = open(
         os.path.join(REPLAYS_PATH, "%s.txt" % int(time.time())), "w")
     self.replay_write(self.game_type_name)
     players = " ".join([p.login for p in self.players])
     self.replay_write(self.map.get_name() + " " + players)
     self.replay_write(VERSION)
     self.replay_write(config.mods)
     self.replay_write(compatibility_version())
     self.replay_write(self.map.pack())
     self.replay_write(players)
     self.replay_write(" ".join(map(str, self.alliances)))
     self.replay_write(" ".join(self.factions))
     self.replay_write(str(self.seed))
Esempio n. 13
0
 def open(self):
     try:
         self.tn = telnetlib.Telnet(self.host, self.port)
     except socket.error:
         raise UnreachableServerError
     try:
         if self.tn.read_until(":", 3) != ":":
             raise WrongServerError
         self.tn.write("login " + compatibility_version() + " %s\n" % config.login)
     except (EOFError, socket.error):
         raise WrongServerError
     try:
         self.tn.read_until("ok!", 5)
     except EOFError:
         raise CompatibilityOrLoginError
Esempio n. 14
0
 def open(self):
     try:
         self.tn = telnetlib.Telnet(self.host, self.port)
     except socket.error:
         raise UnreachableServerError
     try:
         if self.tn.read_until(":", 3) != ":":
             raise WrongServerError
         self.tn.write("login " + compatibility_version() +
                       " %s\n" % config.login)
     except (EOFError, socket.error):
         raise WrongServerError
     try:
         self.tn.read_until("ok!", 5)
     except EOFError:
         raise CompatibilityOrLoginError
Esempio n. 15
0
 def create_replay(self):
     self._replay_file = open(os.path.join(REPLAYS_PATH, "%s.txt" % int(time.time())), "w")
     self.replay_write(self.game_type_name)
     players = " ".join([p.login for p in self.players])
     self.replay_write(self.map.get_name() + " " + players)
     self.replay_write(VERSION)
     self.replay_write(res.mods)
     self.replay_write(compatibility_version())
     if self.game_type_name == "mission":
         self.replay_write(self.map.campaign.path)
         self.replay_write(str(self.map.id))
     else:
         self.replay_write(self.map.pack())
     self.replay_write(players)
     alliances = [p.alliance for p in self.players]
     self.replay_write(" ".join(map(str, alliances)))
     factions = [p.faction for p in self.players]
     self.replay_write(" ".join(factions))
     self.replay_write(str(self.seed))
Esempio n. 16
0
 def __init__(self, replay):
     self._file = open(replay)
     game_type_name = self.replay_read()
     if game_type_name in ("multiplayer", "training"):
         self.default_triggers = _MultiplayerGame.default_triggers
         self.must_apply_equivalent_type = True
     game_name = self.replay_read()
     voice.alert([game_name])
     version = self.replay_read()
     mods = self.replay_read()
     res.set_mods(mods)
     _compatibility_version = self.replay_read()
     if _compatibility_version != compatibility_version():
         voice.alert(mp.BEEP + mp.VERSION_ERROR)
         warning(
             "Version mismatch. Version should be: %s. Mods should be: %s.",
             version, mods)
     campaign_path_or_packed_map = self.replay_read()
     if game_type_name == "mission" and "***" not in campaign_path_or_packed_map:
         from campaign import Campaign
         self.map = Campaign(campaign_path_or_packed_map)._get(
             int(self.replay_read()))
     else:
         self.map = Map()
         self.map.unpack(campaign_path_or_packed_map)
     players = self.replay_read().split()
     alliances = self.replay_read().split()
     factions = self.replay_read().split()
     self.seed = int(self.replay_read())
     self.me = ReplayClient(players[0], self)
     self.players = [self.me]
     for x in players[1:]:
         if x.startswith("ai_"):
             x = x[3:]
         if x in ["aggressive", "easy", "ai2"]:
             self.players += [DummyClient(x)]
         else:
             self.players += [RemoteClient(x)]
             self.me.nb_humans += 1
     for p, a, f in zip(self.players, alliances, factions):
         p.alliance = a
         p.faction = f
Esempio n. 17
0
 def create_replay(self):
     self._replay_file = open(
         os.path.join(REPLAYS_PATH, "%s.txt" % int(time.time())), "w")
     self.replay_write(self.game_type_name)
     players = " ".join([p.login for p in self.players])
     self.replay_write(self.map.get_name() + " " + players)
     self.replay_write(VERSION)
     self.replay_write(res.mods)
     self.replay_write(compatibility_version())
     if self.game_type_name == "mission":
         self.replay_write(self.map.campaign.path)
         self.replay_write(str(self.map.id))
     else:
         self.replay_write(self.map.pack())
     self.replay_write(players)
     alliances = [p.alliance for p in self.players]
     self.replay_write(" ".join(map(str, alliances)))
     factions = [p.faction for p in self.players]
     self.replay_write(" ".join(factions))
     self.replay_write(str(self.seed))
Esempio n. 18
0
 def open(self):
     try:
         self.tn = telnetlib.Telnet(self.host, self.port)
     except socket.error:
         raise UnreachableServerError
     try:
         # Activate TCP Keepalive to prevent connections from silently dropping
         self.tn.get_socket().ioctl(socket.SIO_KEEPALIVE_VALS, (1, 60000, 2000))
     except:
         # platform different than Windows
         pass
     try:
         if self.tn.read_until(":", 3) != ":":
             raise WrongServerError
         self.tn.write("login " + compatibility_version() + " %s\n" % config.login)
     except (EOFError, socket.error):
         raise WrongServerError
     try:
         self.tn.read_until("ok!", 5)
     except EOFError:
         raise CompatibilityOrLoginError
Esempio n. 19
0
 def __init__(self, replay):
     self._file = open(replay)
     game_type_name = self.replay_read()
     if game_type_name in ("multiplayer", "training"):
         self.default_triggers = _MultiplayerGame.default_triggers
         self.must_apply_equivalent_type = True
     game_name = self.replay_read()
     voice.alert([game_name])
     version = self.replay_read()
     mods = self.replay_read()
     res.set_mods(mods)
     _compatibility_version = self.replay_read()
     if _compatibility_version != compatibility_version():
         voice.alert(mp.BEEP + mp.VERSION_ERROR)
         warning("Version mismatch. Version should be: %s. Mods should be: %s.",
                 version, mods)
     campaign_path_or_packed_map = self.replay_read()
     if game_type_name == "mission" and "***" not in campaign_path_or_packed_map:
         from campaign import Campaign
         self.map = Campaign(campaign_path_or_packed_map)._get(int(self.replay_read()))
     else:
         self.map = Map()
         self.map.unpack(campaign_path_or_packed_map)
     players = self.replay_read().split()
     alliances = self.replay_read().split()
     factions = self.replay_read().split()
     self.seed = int(self.replay_read())
     self.me = ReplayClient(players[0], self)
     self.players = [self.me]
     for x in players[1:]:
         if x.startswith("ai_"):
             x = x[3:]
         if x in ["aggressive", "easy", "ai2"]:
             self.players += [DummyClient(x)]
         else:
             self.players += [RemoteClient(x)]
             self.me.nb_humans += 1
     for p, a, f in zip(self.players, alliances, factions):
         p.alliance = a
         p.faction = f
Esempio n. 20
0
 def open(self):
     try:
         self.tn = telnetlib.Telnet(self.host, self.port)
     except socket.error:
         raise UnreachableServerError
     try:
         # Activate TCP Keepalive to prevent connections from silently dropping
         self.tn.get_socket().ioctl(socket.SIO_KEEPALIVE_VALS,
                                    (1, 60000, 2000))
     except:
         # platform different than Windows
         pass
     try:
         if self.tn.read_until(":", 3) != ":":
             raise WrongServerError
         self.tn.write("login " + compatibility_version() +
                       " %s\n" % config.login)
     except (EOFError, socket.error):
         raise WrongServerError
     try:
         self.tn.read_until("ok!", 5)
     except EOFError:
         raise CompatibilityOrLoginError
Esempio n. 21
0
from definitions import style
from game import TrainingGame, ReplayGame, reload_all
from lib.log import exception
from multimaps import worlds_multi
from msgs import nb2msg
from package import get_packages, get_all_packages_paths
from paths import REPLAYS_PATH, SAVE_PATH
import res
from singlemaps import campaigns
import stats
from version import compatibility_version


_ds = open("cfg/default_servers.txt").readlines()
_ds = [_x.split() for _x in _ds]
DEFAULT_SERVERS = [" ".join(["0"] + _x[:1] + [compatibility_version()] + _x[1:]) for _x in _ds]
SERVERS_LIST_HEADER = "SERVERS_LIST"
SERVERS_LIST_URL = MAIN_METASERVER_URL + "servers.php?header=%s&include_ports=1" % SERVERS_LIST_HEADER


class Application(object):

    def choose_server_ip_in_a_list(self):
        servers_list = None
        try:
            f = urllib.urlopen(SERVERS_LIST_URL)
            if f.read(len(SERVERS_LIST_HEADER)) == SERVERS_LIST_HEADER:
                servers_list = f.readlines()
        except:
            pass
        if servers_list is None: