def test_worker_milestones():
replay = sc2reader.load_replay(
'replays/Nerchio vs Neeb ZvP Newkirk Precinct TE (Void) WCS Austin.SC2Replay',
engine=sc2reader.engine.GameEngine(plugins=[
APMTracker(),
SelectionTracker(),
ContextLoader(),
GameHeartNormalizer(),
workers_analysis(),
]),
load_map=False)
if replay.players[0].name == "Neeb":
neeb = replay.players[0]
nerchio = replay.players[1]
else:
nerchio = replay.players[0]
neeb = replay.players[1]
assert neeb.worker_milestones[40] == 5493
assert nerchio.worker_milestones[40] == 5213
assert neeb.worker_milestones[50] == 7466
assert nerchio.worker_milestones[50] == 7247
assert neeb.worker_milestones[60] == 8668
assert nerchio.worker_milestones[60] == 11838
assert neeb.worker_milestones[70] == 14631
assert nerchio.worker_milestones[70] == 17087
def test_workers_at_frame():
replay = sc2reader.load_replay(
'replays/Nerchio vs Neeb ZvP Newkirk Precinct TE (Void) WCS Austin.SC2Replay',
engine=sc2reader.engine.GameEngine(plugins=[
APMTracker(),
SelectionTracker(),
ContextLoader(),
GameHeartNormalizer(),
workers_analysis(),
]),
load_map=False)
if replay.players[0].name == "Neeb":
neeb = replay.players[0]
nerchio = replay.players[1]
else:
nerchio = replay.players[0]
neeb = replay.players[1]
assert workers_at_frame(neeb, time_to_frame('4:06')) == 40
assert workers_at_frame(nerchio, time_to_frame('4:31')) == 40
assert workers_at_frame(nerchio, time_to_frame('5:25')) == 50
assert workers_at_frame(neeb, time_to_frame('5:34')) == 50
assert workers_at_frame(neeb, time_to_frame('6:28')) == 60
assert workers_at_frame(neeb, time_to_frame('10:56')) == 70
assert workers_at_frame(nerchio, time_to_frame('12:22')) == 58
assert workers_at_frame(nerchio, time_to_frame('12:23')) == 61
def test_alive_at_this_time():
replay = sc2reader.load_replay(
'replays/Nerchio vs Neeb ZvP Newkirk Precinct TE (Void) WCS Austin.SC2Replay',
engine=sc2reader.engine.GameEngine(plugins=[
APMTracker(),
SelectionTracker(),
ContextLoader(),
GameHeartNormalizer(),
workers_analysis(),
]),
load_map=False)
if replay.players[0].name == "Neeb":
neeb = replay.players[0]
nerchio = replay.players[1]
else:
nerchio = replay.players[0]
neeb = replay.players[1]
probe = neeb.units[54]
assert alive_at_this_time(probe, 0, replay.frames) is False
assert alive_at_this_time(probe, 28870, replay.frames) is False
assert alive_at_this_time(probe, 26000, replay.frames) is False
assert alive_at_this_time(probe, 4500, replay.frames) is True
assert alive_at_this_time(probe, 2000, replay.frames) is False
def parse_input(replay_path, VERBOSE=False):
try:
replay_file = replay_path
except NameError:
print(
'\n'
'SETUP ERROR: Please follow the directions to add a .SC2Replay file and use\n'
' "Insert to code" to set the streaming_body_1 variable to the resulting bytes.\n'
' You may need to rename the data_* variable.')
raise
replay = sc2reader.load_replay(
replay_file,
engine=sc2reader.engine.GameEngine(
plugins=[ContextLoader(
), APMTracker(), SelectionTracker()]))
participants = []
for plays in replay.players:
participants.append(plays)
participants.append(plays.result)
if VERBOSE:
print("Replay successfully loaded.")
for players in replay.players:
print(players.result, players)
is_AI = False
for players in replay.players:
if isinstance(players, (sc2reader.objects.Computer)):
is_AI = True
if VERBOSE:
print('found an A.I.\n')
if (len(replay.players) != 2) or (is_AI == True):
if VERBOSE:
if (is_AI == True):
print('this is an A.I. game')
else:
print('this is not a 1v1 game')
return None
else:
replay_object = ReplayData.parse_replay(replay=replay)
try:
y_data = list(replay_object.as_dict().get('winners'))[0][0]
except:
y_data = 3
x_data, data_dict_full = get_stats(replay_object)
data_dict_full['winner'] = y_data
data_dict = {'seq': [x_data], 'label': [y_data]}
return data_dict, participants, data_dict_full, replay_object.as_dict(
).get('stats')
def main():
args = parse_args(sys.argv[1:])
print("Accessing replay, id: {0}".format(args.sha1sum))
r = get_replay(args.sha1sum)
replay = sc2reader.load_replay(r,
engine=sc2reader.engine.GameEngine(plugins=[
ContextLoader(),
GameHeartNormalizer(),
]))
for p in replay.players:
print(p)
def test_engine_plugins(self):
from sc2reader.engine.plugins import ContextLoader, APMTracker, SelectionTracker
replay = sc2reader.load_replay(
"test_replays/2.0.5.25092/cn1.SC2Replay",
engine=sc2reader.engine.GameEngine(plugins=[
ContextLoader(),
APMTracker(),
SelectionTracker(),
]))
code, details = replay.plugins['ContextLoader']
self.assertEqual(code, 0)
self.assertEqual(details, dict())
def parse_replay(cls, replay=None, replay_file=None, file_object=None):
replay_data = ReplayData(replay_file)
try:
# This is the engine that holds some required plugins for parsing
engine = sc2reader.engine.GameEngine(
plugins=[ContextLoader(),
APMTracker(),
SelectionTracker()])
if replay:
pass
elif replay_file and not file_object:
# Then we are not using ObjectStorage for accessing replay files
replay = sc2reader.load_replay(replay_file, engine=engine)
elif file_object:
# We are using ObjectStorage to access replay files
replay = sc2reader.load_replay(file_object, engine=engine)
else:
pass
# Get the number of frames (one frame is 1/16 of a second)
replay_data.frames = replay.frames
# Gets the game mode (if available)
replay_data.game_mode = replay.real_type
# Gets the map hash (if we want to download the map, or do map-based analysis)
replay_data.map_hash = replay.map_hash
# Use the parsers to get data
for event in replay.events:
for parser in cls.__parsers__:
parser(replay_data, event)
# Check if there was a winner
if replay.winner is not None:
replay_data.winners = replay.winner.players
replay_data.losers = [
p for p in replay.players if p not in replay.winner.players
]
else:
replay_data.winners = []
replay_data.losers = []
# Check to see if expansion data is available
replay_data.expansion = replay.expansion
return replay_data
except:
# print our error and return NoneType object
print_exc()
return None, None
def load_replays(self, glob_path, limit=None, verbose=True):
'''
Loads SC2 replays found in the provided path.
If the argument 'amount' is passed, then only that amount will be loaded.
Parameters
----------
glob_path : str
Path to .SC2Replay files as a glob string
limit : int, optional
Number of replays to be loaded (default is All)
verbose : bool, optional
Show verbose information (default is True)
Returns
-------
None
'''
paths = [path for path in glob(glob_path, recursive=True)]
loader_amount = len(
paths) if limit is None or limit > len(paths) else limit
n_replays = len(paths)
register_plugin(APMTracker())
register_plugin(SelectionTracker())
register_plugin(ContextLoader())
replays = load_replays(paths[:limit])
if verbose:
print('Loaded {} replays out of {}.'.format(
loader_amount, n_replays))
self.paths = paths[:limit]
self.replays = replays
self.n_replays = n_replays
self.loader_amount = loader_amount
"losers": [(s.pid, s.name, s.detail_data['race']) for s in self.losers],
"stats_names": [k for k in self.players[1].keys()],
"stats": {player: data for player, data in self.players.items()}
}
def __init__(self, replay):
self.players = defaultdict(lambda: defaultdict(list))
self.replay = replay
self.winners = []
self.losers = []
self.expansion = None
## change your files to the
PATH = 'C:\\Program Files (x86)\\StarCraft II\\Replays\\samples\\'
filenames = os.listdir(PATH)
replay = sc2reader.load_replay(PATH+filenames[0], engine=GameEngine(plugins=[ContextLoader(), APMTracker(), SelectionTracker()]))
replay_object = ReplayData.parse_replay(replay=replay)
replay_dict = replay_object.as_dict()
print(filenames[0])
print("Date: %s" % replay.date)
print("Map Name: " + replay.map_name)
for player in replay.players:
print("%s: %s" % (player.result, player))
pprint(replay_dict)
print("--------------------------")
"""
If you want to add more replays to the dataset you can add them to a PATH folder
then run the code below which tries to check if the replay file is parseable.
## path to replays in my machine, change to your own
def main(): # noqa: C901
args = parse_args(sys.argv[1:])
r = get_replay(args.sha1sum)
replay = sc2reader.load_replay(r,
engine=sc2reader.engine.GameEngine(plugins=[
ContextLoader(),
GameHeartNormalizer(),
]))
data = {}
data['map'] = replay.map_name
data['players'] = []
for player in replay.players:
if not player.is_human:
continue
if player.is_observer:
continue
player_data = {}
player_data['name'] = player.name
unit_supplies = {}
for unit_type in army_units:
unit_supplies[unit_type] = []
# All done in frames
times = []
game_end = replay.frames
game_start = 0
for current_frame in range(game_start, game_end, 160):
times.append(current_frame)
supply_per_unit = {}
for unit_type in army_units:
supply_per_unit[unit_type] = 0
# Scan all units owned by player
for unit in player.units:
if unit.name not in army_units:
continue
if alive_at_this_time(unit, current_frame, replay.frames):
supply_per_unit[unit.name] += unit.supply
for unit_name, supply in supply_per_unit.items():
unit_supplies[unit_name].append(supply)
to_pop = []
for key, value in unit_supplies.items():
if sum(value) == 0:
to_pop.append(key)
for key in to_pop:
unit_supplies.pop(key, None)
# Create visualization-ready json object
constructed_data = []
for key, value in unit_supplies.items():
obj = {}
obj['name'] = key
color = "#" + hashlib.sha224(bytes(key, 'utf-8')).hexdigest()[:6]
obj['color'] = color
xy_tuples = []
for index, number in enumerate(value):
point = {}
point['x'] = times[index]
point['y'] = number
xy_tuples.append(point)
obj['data'] = xy_tuples
constructed_data.append(obj)
player_data['army_supply'] = constructed_data
data['players'].append(player_data)
print(json.dumps(data))
races.append(player.play_race)
matchup = "v".join(race[0] for race in sorted(races))
return matchup
if __name__ == "__main__":
data = []
replays = glob.glob("all_replays/**/*.SC2Replay", recursive=True)
for filename in replays:
replay = sc2reader.load_replay(
filename,
engine=sc2reader.engine.GameEngine(plugins=[
APMTracker(),
SelectionTracker(),
ContextLoader(),
GameHeartNormalizer(),
]))
#game['matchup'] = replay.matchup
for human in replay.players:
game = {}
game['length'] = replay.frames / 22.4
game['map'] = replay.map_name
game['matchup'] = classify_matchup(replay)
game['name'] = human.name
game['race'] = human.play_race
game['players'] = str(replay.players)
game['buildings'] = {}
game['buildings']['stargates'] = []
for unit in human.units:
if unit.name == 'Stargate':
def get_plugins(cls):
return [ContextLoader(), APMTracker(), SelectionTracker()]
def test_hotkey_plugin(self):
from sc2reader.engine.plugins import ContextLoader,HotkeyCount
import os
from math import ceil
root = "test_replays/hotkey_replays"
#we test the plugin with several different kinds of replays so we see it doesn't crash
for path in os.listdir(root):
path = os.path.join(root,path)
replay = sc2reader.load_replay(path,engine=sc2reader.engine.GameEngine(plugins=[ContextLoader(),HotkeyCount()]))
code, details = replay.plugins['HotkeyCount']
self.assertEqual(code, 0)
self.assertEqual(details, dict())
length = int(ceil(replay.game_length.seconds / 60)) + 1
self.assertEqual(len(replay.players[0].num_hotkeys_used),len(range(1,length)))
self.assertEqual(len(replay.players[0].hotkeys_used),len(range(1,length)))
#numerical output check from a normal game I played on the Korean server
replay = sc2reader.load_replay(
"test_replays/hotkey_replays/1v1.SC2Replay",
engine=sc2reader.engine.GameEngine(plugins=[
ContextLoader(),
HotkeyCount()
])
)
code, details = replay.plugins['HotkeyCount']
self.assertEqual(code, 0)
self.assertEqual(details, dict())
self.assertEqual(replay.players[1].hotkeys_used[1],[5])
self.assertEqual(replay.players[1].num_hotkeys_used[1],1)
self.assertEqual(replay.players[0].hotkeys_used[1],[])
self.assertEqual(replay.players[0].num_hotkeys_used[1],0)
self.assertEqual(replay.players[1].hotkeys_used[3],[5,1])
self.assertEqual(replay.players[1].num_hotkeys_used[3],2)
#numerical output check from a game I played in the EU server to debug
replay = sc2reader.load_replay(
"test_replays/hotkey_replays/protoss.SC2Replay",
engine=sc2reader.engine.GameEngine(plugins=[
ContextLoader(),
HotkeyCount()
])
)
code, details = replay.plugins['HotkeyCount']
self.assertEqual(code, 0)
self.assertEqual(details, dict())
self.assertEqual(replay.players[1].hotkeys_used[1],[1,2,3])
self.assertEqual(replay.players[1].num_hotkeys_used[1],3)
self.assertEqual(replay.players[1].hotkeys_used[4],[])
self.assertEqual(replay.players[1].num_hotkeys_used[4],0)
self.assertEqual(replay.players[1].hotkeys_used[7],[1,2,3,4,6])
self.assertEqual(replay.players[1].num_hotkeys_used[7],5)
self.assertEqual(replay.players[1].hotkeys_used[17],[1,2,6])
self.assertEqual(replay.players[1].num_hotkeys_used[17],3)
self.assertEqual(replay.players[1].hotkeys_used[20],[])
self.assertEqual(replay.players[1].num_hotkeys_used[20],0)
import sc2reader
from sc2reader.engine.plugins import SelectionTracker, APMTracker,\
ContextLoader, GameHeartNormalizer
sc2reader.engine.register_plugin(SelectionTracker())
sc2reader.engine.register_plugin(APMTracker())
sc2reader.engine.register_plugin(ContextLoader())
sc2reader.engine.register_plugin(GameHeartNormalizer())
from src.db.raw.config import db
from src.db.raw.models.datapack.unit_type import UNIT_TYPE
from src.db.raw.models.datapack.ability import ABILITY
from src.db.raw.models.replay.info import INFO
from src.db.raw.models.replay.map import MAP
from src.db.raw.models.replay.objects import OBJECT
from src.db.raw.models.replay.player import PLAYER
from src.db.raw.inject import INJECT
from os import listdir
import argparse
parser = argparse.ArgumentParser(description='sdm : Starcraft 2 Data Project')
parser.add_argument('action',
metavar='action',
type=str,
help='db : run database injection \n app : run app')
args = parser.parse_args()
action = args.action
