Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

analysis.py

@@ -0,0 +1,673 @@
+<<<<<<< HEAD
+#this should be imported as a python module using 'import analysis'
+
+import statistics
+import math
+import csv
+import functools
+
+class c_entities:
+
+    c_names = []
+    c_ids = []
+    c_pos = []
+    c_porperties = []
+    c_logic = []
+
+class nc_entities:
+
+    c_names = []
+    c_ids = []
+    c_pos = []
+    c_properties = []
+    c_effects = []
+
+    def debug(self):
+        print ("nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of psoitions, 2d array of properties, and 2d array of effects.")
+        return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects]
+
+    def __init__(self, names, ids, pos, properties, effects):
+        self.c_names = names
+        self.c_ids = ids
+        self.c_pos = pos
+        self.c_properties = properties
+        self.c_effects = effects
+        return None
+
+    def append(self, n_name, n_id, n_pos, n_property, n_effect):
+        self.c_names.append(n_name)
+        self.c_ids.append(n_id)
+        self.c_pos.append(n_pos)
+        self.c_properties.append(n_property)
+        self.c_effects.append(n_effect)
+
+    def edit(self, search, n_name, n_id, n_pos, n_property, n_effect):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+        if n_name != "null":
+            self.c_names[position] = n_name
+
+        if n_id != "null":
+            self.c_ids[position] = n_id
+
+        if n_pos != "null":
+            self.c_pos[position] = n_pos
+
+        if n_property != "null":
+            self.c_properties[position] = n_property
+
+        if n_effect != "null":
+            self.c_effects[position] = n_effect
+
+        return None
+
+    def search(self, search):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_effects[position]]        
+
+class obstacles:
+
+    c_names = []
+    c_ids = []
+    c_perim = []
+    c_effects = []
+
+    def debug(self):
+        print("obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects.")
+        return [self.c_names, self.c_ids, self.c_perim, self.c_effects]
+
+    def __init__(self, names, ids, perims, effects):
+        self.c_names = names
+        self.c_ids = ids
+        self.c_perim = perims
+        self.c_effects = effects
+        return None
+
+    def append(self, n_name, n_id, n_perim, n_effect):
+        self.c_names.append(n_name)
+        self.c_ids.append(n_id)
+        self.c_perim.append(n_perim)
+        self.c_effects.append(n_effect)
+        return None
+
+    def edit(self, search, n_name, n_id, n_perim, n_effect):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        if n_name != "null":
+            self.c_names[position] = n_name
+
+        if n_id != "null":
+            self.c_ids[position] = n_id
+
+        if n_perim != "null":
+            self.c_perim[position] = n_perim
+
+        if n_effect != "null":
+            self.c_effects[position] = n_effect
+            
+        return None
+
+    def search(self, search):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        return [self.c_names[position], self.c_ids[position], self.c_perim[position], self.c_effects[position]]
+
+class objectives:
+    
+    c_names = []
+    c_ids = []
+    c_pos = []
+    c_effects = []
+
+    def debug(self):
+        print("objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects.")
+        return [self.c_names, self.c_ids, self.c_pos, self.c_effects]
+    
+    def __init__(self, names, ids, pos, effects):
+        self.c_names = names
+        self.c_ids = ids
+        self.c_pos = pos
+        self.c_effects = effects
+        return None
+    
+    def append(self, n_name, n_id, n_pos, n_effect):
+        self.c_names.append(n_name)
+        self.c_ids.append(n_id)
+        self.c_pos.append(n_pos)
+        self.c_effects.append(n_effect)
+        return None
+    
+    def edit(self, search, n_name, n_id, n_pos, n_effect):
+        position = 0
+        print(self.c_ids)
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        if n_name != "null":
+            self.c_names[position] = n_name
+
+        if n_id != "null":
+            self.c_ids[position] = n_id
+
+        if n_pos != "null":
+            self.c_pos[position] = n_pos
+
+        if n_effect != "null":
+            self.c_effects[position] = n_effect
+            
+        return None
+    
+    def search(self, search):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_effects[position]]
+
+def load_csv(filepath):
+    with open(filepath, newline = '') as csvfile:
+        file_array = list(csv.reader(csvfile))
+    return file_array
+
+def basic_stats(data, mode, arg): # data=array, mode = ['1d':1d_basic_stats, 'column':c_basic_stats, 'row':r_basic_stats], arg for mode 1 or mode 2 for column or row
+
+    if mode == 'debug':
+        out = "basic_stats requires 3 args: data, mode, arg; where data is data to be analyzed, mode is an int from 0 - 2 depending on type of analysis (by column or by row) and is only applicable to 2d arrays (for 1d arrays use mode 1), and arg is row/column number for mode 1 or mode 2; function returns: [mean, median, mode, stdev, variance]"
+        return out
+
+    if mode == "1d" or mode == 0:
+
+        data_t = []
+
+        for i in range (0, len(data) - 1, 1):
+
+            data_t.append(float(data[i]))
+    
+        mean = statistics.mean(data_t)
+        median = statistics.median(data_t)
+        try:
+            mode = statistics.mode(data_t)
+        except:
+            mode = None
+        stdev = statistics.stdev(data_t)
+        variance = statistics.variance(data_t)
+        
+        out = [mean, median, mode, stdev, variance]
+
+        return out
+    
+    elif mode == "column" or mode == 1:
+
+        c_data = []
+        c_data_sorted = []
+        
+        for i in data:
+            c_data.append(float(i[arg]))
+            
+        mean = statistics.mean(c_data)
+        median = statistics.median(c_data)
+        try:
+            mode = statistics.mode(c_data)
+        except:
+            mode = None
+        stdev = statistics.stdev(c_data)
+        variance = statistics.variance(c_data)
+        
+        out = [mean, median, mode, stdev, variance]
+
+        return out
+
+    elif mode == "row" or mode == 2:
+
+        r_data = []
+
+        for i in range(len(data[arg])):
+            r_data.append(float(data[arg][i]))
+        
+        mean = statistics.mean(r_data)
+        median = statistics.median(r_data)
+        try:
+            mode = statistics.mode(r_data)
+        except:
+            mode = None
+        stdev = statistics.stdev(r_data)
+        variance = statistics.variance(r_data)
+        
+        out = [mean, median, mode, stdev, variance]
+
+        return out
+    else:
+        return ["mode_error", "mode_error"]
+    
+def z_score(point, mean, stdev):
+    score = (point - mean)/stdev
+    return score
+
+def stdev_z_split(mean, stdev, delta, low_bound, high_bound):
+
+    z_split = []
+
+    i = low_bound
+
+    while True:
+
+        z_split.append(float((1 / (stdev * math.sqrt(2 * math.pi))) * math.e ** (-0.5 * (((i - mean) / stdev) ** 2))))
+
+        i = i + delta
+
+        if i > high_bound:
+
+            break
+
+    return z_split
+
+def histo_analysis(hist_data): #note: depreciated
+
+    if hist_data == 'debug':
+        return['lower estimate (5%)', 'lower middle estimate (25%)', 'middle estimate (50%)', 'higher middle estimate (75%)', 'high estimate (95%)', 'standard deviation', 'note: this has been depreciated']
+    
+    derivative = []
+    for i in range(0, len(hist_data) - 1, 1):
+        derivative.append(float(hist_data[i+1]) - float(hist_data[i]))
+        
+    derivative_sorted = sorted(derivative, key=int)
+    mean_derivative = basic_stats(derivative_sorted, "1d", 0)[0]
+    stdev_derivative = basic_stats(derivative_sorted, "1d", 0)[3]
+
+    low_bound = mean_derivative + -1.645 * stdev_derivative
+    lm_bound = mean_derivative + -0.674 * stdev_derivative
+    mid_bound = mean_derivative * 0 * stdev_derivative
+    hm_bound = mean_derivative + 0.674 * stdev_derivative
+    high_bound = mean_derivative + 1.645 * stdev_derivative
+
+    low_est = float(hist_data[-1:][0]) + low_bound
+    lm_est = float(hist_data[-1:][0]) + lm_bound
+    mid_est = float(hist_data[-1:][0]) + mid_bound
+    hm_est = float(hist_data[-1:][0]) + hm_bound
+    high_est = float(hist_data[-1:][0]) + high_bound
+
+    return [low_est, lm_est, mid_est, hm_est, high_est, stdev_derivative]
+
+def histo_analysis_2(hist_data, delta, low_bound, high_bound):
+
+    if hist_data == 'debug':
+        return ('returns list of predicted values based on historical data; input delta for delta step in z-score and lower and igher bounds in number for standard deviations')
+
+    derivative = []
+
+    for i in range(0, len(hist_data) - 1, 1):
+        derivative.append(float(hist_data[i + 1]) - float(hist_data [i]))
+
+    derivative_sorted = sorted(derivative, key=int)
+    mean_derivative = basic_stats(derivative_sorted,"1d", 0)[0]
+    stdev_derivative = basic_stats(derivative_sorted, "1d", 0)[3]
+
+    predictions = []
+    pred_change = 0
+
+    i = low_bound
+
+    while True:
+
+        pred_change = mean_derivative + i * stdev_derivative
+
+        predictions.append(float(hist_data[-1:][0]) + pred_change)
+
+        i = i + delta
+
+        if i > high_bound:
+
+            break
+
+    return predictions
+=======
+#this should be imported as a python module using 'import analysis'
+
+import statistics
+import math
+import csv
+import functools
+
+class c_entities:
+
+    c_names = []
+    c_ids = []
+    c_pos = []
+    c_porperties = []
+    c_logic = []
+
+class nc_entities:
+
+    c_names = []
+    c_ids = []
+    c_pos = []
+    c_properties = []
+    c_effects = []
+
+    def debug(self):
+        print ("nc_entities (non-controlable entities) has attributes names, ids, positions, properties, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of psoitions, 2d array of properties, and 2d array of effects.")
+        return[self.c_names, self.c_ids, self.c_pos, self.c_properties, self.c_effects]
+
+    def __init__(self, names, ids, pos, properties, effects):
+        self.c_names = names
+        self.c_ids = ids
+        self.c_pos = pos
+        self.c_properties = properties
+        self.c_effects = effects
+        return None
+
+    def append(self, n_name, n_id, n_pos, n_property, n_effect):
+        self.c_names.append(n_name)
+        self.c_ids.append(n_id)
+        self.c_pos.append(n_pos)
+        self.c_properties.append(n_property)
+        self.c_effects.append(n_effect)
+
+    def edit(self, search, n_name, n_id, n_pos, n_property, n_effect):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+        if n_name != "null":
+            self.c_names[position] = n_name
+
+        if n_id != "null":
+            self.c_ids[position] = n_id
+
+        if n_pos != "null":
+            self.c_pos[position] = n_pos
+
+        if n_property != "null":
+            self.c_properties[position] = n_property
+
+        if n_effect != "null":
+            self.c_effects[position] = n_effect
+
+        return None
+
+    def search(self, search):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_properties[position], self.c_effects[position]]        
+
+class obstacles:
+
+    c_names = []
+    c_ids = []
+    c_perim = []
+    c_effects = []
+
+    def debug(self):
+        print("obstacles has atributes names, ids, positions, perimeters, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 3d array of perimeters, 2d array of effects.")
+        return [self.c_names, self.c_ids, self.c_perim, self.c_effects]
+
+    def __init__(self, names, ids, perims, effects):
+        self.c_names = names
+        self.c_ids = ids
+        self.c_perim = perims
+        self.c_effects = effects
+        return None
+
+    def append(self, n_name, n_id, n_perim, n_effect):
+        self.c_names.append(n_name)
+        self.c_ids.append(n_id)
+        self.c_perim.append(n_perim)
+        self.c_effects.append(n_effect)
+        return None
+
+    def edit(self, search, n_name, n_id, n_perim, n_effect):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        if n_name != "null":
+            self.c_names[position] = n_name
+
+        if n_id != "null":
+            self.c_ids[position] = n_id
+
+        if n_perim != "null":
+            self.c_perim[position] = n_perim
+
+        if n_effect != "null":
+            self.c_effects[position] = n_effect
+            
+        return None
+
+    def search(self, search):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        return [self.c_names[position], self.c_ids[position], self.c_perim[position], self.c_effects[position]]
+
+class objectives:
+    
+    c_names = []
+    c_ids = []
+    c_pos = []
+    c_effects = []
+
+    def debug(self):
+        print("objectives has atributes names, ids, positions, and effects. __init__ takes self, 1d array of names, 1d array of ids, 2d array of position, 1d array of effects.")
+        return [self.c_names, self.c_ids, self.c_pos, self.c_effects]
+    
+    def __init__(self, names, ids, pos, effects):
+        self.c_names = names
+        self.c_ids = ids
+        self.c_pos = pos
+        self.c_effects = effects
+        return None
+    
+    def append(self, n_name, n_id, n_pos, n_effect):
+        self.c_names.append(n_name)
+        self.c_ids.append(n_id)
+        self.c_pos.append(n_pos)
+        self.c_effects.append(n_effect)
+        return None
+    
+    def edit(self, search, n_name, n_id, n_pos, n_effect):
+        position = 0
+        print(self.c_ids)
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        if n_name != "null":
+            self.c_names[position] = n_name
+
+        if n_id != "null":
+            self.c_ids[position] = n_id
+
+        if n_pos != "null":
+            self.c_pos[position] = n_pos
+
+        if n_effect != "null":
+            self.c_effects[position] = n_effect
+            
+        return None
+    
+    def search(self, search):
+        position = 0
+        for i in range(0, len(self.c_ids), 1):
+            if self.c_ids[i] == search:
+                position = i
+
+        return [self.c_names[position], self.c_ids[position], self.c_pos[position], self.c_effects[position]]
+
+def load_csv(filepath):
+    with open(filepath, newline = '') as csvfile:
+        file_array = list(csv.reader(csvfile))
+    return file_array
+
+def basic_stats(data, mode, arg): # data=array, mode = ['1d':1d_basic_stats, 'column':c_basic_stats, 'row':r_basic_stats], arg for mode 1 or mode 2 for column or row
+
+    if mode == 'debug':
+        out = "basic_stats requires 3 args: data, mode, arg; where data is data to be analyzed, mode is an int from 0 - 2 depending on type of analysis (by column or by row) and is only applicable to 2d arrays (for 1d arrays use mode 1), and arg is row/column number for mode 1 or mode 2; function returns: [mean, median, mode, stdev, variance]"
+        return out
+
+    if mode == "1d" or mode == 0:
+
+        data_t = []
+
+        for i in range (0, len(data) - 1, 1):
+
+            data_t.append(float(data[i]))
+    
+        mean = statistics.mean(data_t)
+        median = statistics.median(data_t)
+        try:
+            mode = statistics.mode(data_t)
+        except:
+            mode = None
+        stdev = statistics.stdev(data_t)
+        variance = statistics.variance(data_t)
+        
+        out = [mean, median, mode, stdev, variance]
+
+        return out
+    
+    elif mode == "column" or mode == 1:
+
+        c_data = []
+        c_data_sorted = []
+        
+        for i in data:
+            c_data.append(float(i[arg]))
+            
+        mean = statistics.mean(c_data)
+        median = statistics.median(c_data)
+        try:
+            mode = statistics.mode(c_data)
+        except:
+            mode = None
+        stdev = statistics.stdev(c_data)
+        variance = statistics.variance(c_data)
+        
+        out = [mean, median, mode, stdev, variance]
+
+        return out
+
+    elif mode == "row" or mode == 2:
+
+        r_data = []
+
+        for i in range(len(data[arg])):
+            r_data.append(float(data[arg][i]))
+        
+        mean = statistics.mean(r_data)
+        median = statistics.median(r_data)
+        try:
+            mode = statistics.mode(r_data)
+        except:
+            mode = None
+        stdev = statistics.stdev(r_data)
+        variance = statistics.variance(r_data)
+        
+        out = [mean, median, mode, stdev, variance]
+
+        return out
+    else:
+        return ["mode_error", "mode_error"]
+    
+def z_score(point, mean, stdev):
+    score = (point - mean)/stdev
+    return score
+
+def stdev_z_split(mean, stdev, delta, low_bound, high_bound):
+
+    z_split = []
+
+    i = low_bound
+
+    while True:
+
+        z_split.append(float((1 / (stdev * math.sqrt(2 * math.pi))) * math.e ** (-0.5 * (((i - mean) / stdev) ** 2))))
+
+        i = i + delta
+
+        if i > high_bound:
+
+            break
+
+    return z_split
+
+def histo_analysis(hist_data): #note: depreciated
+
+    if hist_data == 'debug':
+        return['lower estimate (5%)', 'lower middle estimate (25%)', 'middle estimate (50%)', 'higher middle estimate (75%)', 'high estimate (95%)', 'standard deviation', 'note: this has been depreciated']
+    
+    derivative = []
+    for i in range(0, len(hist_data) - 1, 1):
+        derivative.append(float(hist_data[i+1]) - float(hist_data[i]))
+        
+    derivative_sorted = sorted(derivative, key=int)
+    mean_derivative = basic_stats(derivative_sorted, "1d", 0)[0]
+    stdev_derivative = basic_stats(derivative_sorted, "1d", 0)[3]
+
+    low_bound = mean_derivative + -1.645 * stdev_derivative
+    lm_bound = mean_derivative + -0.674 * stdev_derivative
+    mid_bound = mean_derivative * 0 * stdev_derivative
+    hm_bound = mean_derivative + 0.674 * stdev_derivative
+    high_bound = mean_derivative + 1.645 * stdev_derivative
+
+    low_est = float(hist_data[-1:][0]) + low_bound
+    lm_est = float(hist_data[-1:][0]) + lm_bound
+    mid_est = float(hist_data[-1:][0]) + mid_bound
+    hm_est = float(hist_data[-1:][0]) + hm_bound
+    high_est = float(hist_data[-1:][0]) + high_bound
+
+    return [low_est, lm_est, mid_est, hm_est, high_est, stdev_derivative]
+
+def histo_analysis_2(hist_data, delta, low_bound, high_bound):
+
+    if hist_data == 'debug':
+        return ('returns list of predicted values based on historical data; input delta for delta step in z-score and lower and igher bounds in number for standard deviations')
+
+    derivative = []
+
+    for i in range(0, len(hist_data) - 1, 1):
+        derivative.append(float(hist_data[i + 1]) - float(hist_data [i]))
+
+    derivative_sorted = sorted(derivative, key=int)
+    mean_derivative = basic_stats(derivative_sorted,"1d", 0)[0]
+    stdev_derivative = basic_stats(derivative_sorted, "1d", 0)[3]
+
+    predictions = []
+    pred_change = 0
+
+    i = low_bound
+
+    while True:
+
+        pred_change = mean_derivative + i * stdev_derivative
+
+        predictions.append(float(hist_data[-1:][0]) + pred_change)
+
+        i = i + delta
+
+        if i > high_bound:
+
+            break
+
+    return predictions
+>>>>>>> 18189b45b17228228e192c270c12c3cc2cb7f8cf

analysis_test.py

@@ -0,0 +1,43 @@
+<<<<<<< HEAD
+import analysis
+
+data = analysis.load_csv('data.txt')
+print(analysis.basic_stats(0, 'debug', 0))
+print(analysis.basic_stats(data, "column", 0))
+print(analysis.basic_stats(data, "row", 0))
+print(analysis.z_score(10, analysis.basic_stats(data, "column", 0)[0],analysis.basic_stats(data, "column", 0)[3]))
+print(analysis.histo_analysis(data[0]))
+print(analysis.histo_analysis_2(data[0], 0.01, -1, 1))
+print(analysis.stdev_z_split(3.3, 0.2, 0.1, -5, 5))
+
+game_nc_entities = analysis.nc_entities(["cube", "cube", "ball"], [0, 1, 2], [[0, 0.5], [1, 1.5], [2, 2]], ["1;1;1;10', '2;1;1;20", "r=0.5, 5"], ["1", "1", "0"])
+game_nc_entities.append("cone", 3, [1, -1], "property", "effect")
+game_nc_entities.edit(2, "sphere", 10, [5, -5], "new prop", "new effect")
+print(game_nc_entities.search(10))
+print(game_nc_entities.debug())
+
+game_obstacles = analysis.obstacles(["wall", "fortress", "castle"], [0, 1, 2],[[[10, 10], [10, 9], [9, 10], [9, 9]], [[-10, 9], [-10, -9], [-9, -10]], [[5, 0], [4, -1], [-4, -1]]] , [0, 0.01, 10])
+game_obstacles.append("bastion", 3, [[50, 50], [49, 50], [50, 49], [49, 49]], 75)
+game_obstacles.edit(0, "motte and bailey", "null", [[10, 10], [9, 10], [10, 9], [9, 9]], 0.01)
+print(game_obstacles.search(0))
+print(game_obstacles.debug())
+
+game_objectives = analysis.objectives(["switch", "scale", "climb"], [0,1,2], [[0,0],[1,1],[2,0]], ["0,1", "1,1", "0,5"])
+game_objectives.append("auto", 3, [0, 10], "1, 10")
+game_objectives.edit(3, "null", 4, "null", "null")
+print(game_objectives.search(4))
+print(game_objectives.debug())
+=======
+import analysis
+
+data = analysis.load_csv('data.txt')
+print(analysis.basic_stats(0, 'debug', 0))
+print(analysis.basic_stats(data, 1, 0))
+print(analysis.basic_stats(data, 2, 0))
+print(analysis.z_score(10, analysis.basic_stats(data, 1, 0)[0],analysis.basic_stats(data, 1, 0)[3]))
+print(analysis.histo_analysis(data[0]))
+print(analysis.histo_analysis_2(data[0], 0.01, -1, 1))
+print(analysis.stdev_z_split(3.3, 0.2, 0.1, -5, 5))
+
+x = analysis.objectives(["switch", "scale", "climb"], [0,1,2], [[0,0],[1,1],[2,0]], ["0,1", "1,1", "0,5"])
+>>>>>>> 18189b45b17228228e192c270c12c3cc2cb7f8cf

generate_data.py

@@ -0,0 +1,16 @@
+import random
+
+def generate(filename, x, y, low, high):
+
+    file = open(filename, "w")
+
+    for i in range (0, y - 1, 1):
+
+        temp = ""
+        
+        for j in range (0, x - 1, 1):
+
+            temp = str(random.uniform(low, high)) +  ","  + temp
+
+        temp = temp + str(random.uniform(low, high))
+        file.write(temp + "\n")

repack_json.py

@@ -0,0 +1,28 @@
+import os
+import json
+import ordereddict
+import collections
+import unicodecsv
+
+content = open("realtimeDatabaseExport2018.json").read()
+
+dict_content = json.loads(content)
+list_of_new_data = []
+
+for datak, datav in dict_content.iteritems():
+    for teamk, teamv in datav["teams"].iteritems():
+        for matchk, matchv in teamv.iteritems():
+            for detailk, detailv in matchv.iteritems():
+                new_data = collections.OrderedDict(detailv)
+                new_data["uuid"] = detailk
+                new_data["match"] = matchk
+                new_data["team"] = teamk
+                
+                list_of_new_data.append(new_data)
+
+allkey = reduce(lambda x, y: x.union(y.keys()), list_of_new_data, set())
+output_file = open('realtimeDatabaseExport2018.csv', 'wb')
+dict_writer = unicodecsv.DictWriter(csvfile=output_file, fieldnames=allkey)
+dict_writer.writerow(dict((fn,fn) for fn in dict_writer.fieldnames))
+dict_writer.writerows(list_of_new_data)
+output_file.close()