
import pandas as pd
import scipy.stats as st
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import ast
from pedal import *


clear_report()
def get_called_function(node):
    # use Pedal to get called function 
    if node.ast_name == "Attribute":
        left = get_called_function(node.value)
        right = node.attr
        return f"{left}.{right}"
    elif node.ast_name == "Name":
        return node.id
    
def make_cont_tables(df, headers): 
    # make contingency tables for each survey based on prior experience.
    for header in headers: 
        print(header + ' totals and contingency table based on prior experience')
        print(df[header].str.strip().str.lower().value_counts())
        display(make_exp_table(df, header))
    
def make_table_by_q(df, header):
    # make frequency table for one question sliced by survey version
    print(header + ' contingency table')
    table = (pd.crosstab(df.Version, df[header], margins = True))
    # display(table)
    return table

def make_exp_table(df, header): 
    # make frequency table for one question sliced by prior experience
    print(header + ' by experience')
    table = pd.crosstab([df.Prior, df.PriorGameDev], df[header].str.lower().str.strip(), margins=True)
    # display(table)
    return table
        
def perform_all_chi(df, headers): 
    # perform chi-square independence test on each question sliced by survey version.
    p_values = []
    for header in headers: 
        cont_tbl = pd.crosstab(df['Version'], df[header], margins=False)
        chi = st.chi2_contingency(cont_tbl.values.tolist())
        p_values.append(chi[1])
    return p_values
    
def perform_exp_chi(df, headers): 
    # perform chi-square indpendence test on each question sliced by experience.
    p_values = []
    for header in headers:
        cont_tbl = pd.crosstab([df.Prior, df.PriorGameDev], df[header], margins = False)
        chi = st.chi2_contingency(cont_tbl.values.tolist())
        p_values.append(chi[1])
    return p_values

def analyze_free_response(df, header, exp): 
    # analyze free response questions 
    pd.set_option("display.max_rows", None, "display.max_columns", None)
    if exp: 
        table = make_exp_table(df, header)
        table = table.drop('All', axis=1).dropna().sort_values(('All',''), axis=1, ascending=False)
    else: 
        table = make_table_by_q(df, header)
        table = table.drop('All', axis=1).sort_values(by='All', axis=1, ascending=False)
    return table

def analyze_open_end(df, header):
    # analyze open ended code 
    total = {
        'methods': 0,
        'functions': 0,
        'both': 0,
        'test cases': 0,
        'graphics': 0,
        'pens': 0,
        'for': 0,
        'while': 0, 
        'if': 0,
        'func def': 0
    }
    for code in df[header]:
        methods = False
        functions = False
        clear_report()
        code = str(code)
        calls = find_asts("Call", code)
        num_for = len(find_asts("For", code))
        num_while = len(find_asts("While", code))
        called_functions = [get_called_function(c.func) for c in calls]
        for c in calls:   
            if c.func.ast_name == "Name":
                methods = True
            if c.func.ast_name == "Attribute":
                functions = True    
        if functions & methods:
            total['both'] += 1
            methods = 0
            functions = 0
        if methods:
            total['methods'] += 1
        if functions:
            total['functions'] += 1
        if "assert_equal" in code:
            total['test cases'] += 1
        if "graphics" in code:
            total['graphics'] += 1
        if " pen" in code:
            total['pens'] += 1
        if 'if' in code:
            total['if'] += 1
        if 'def' in code:
            total['func def'] += 1
        if num_for != 0: 
            total['for'] += 1
        if num_while != 0:
            total['while'] += 1
    lines_char = avg_lines_char(df, header)
    show_line_char_graph_calc(lines_char)
    analyze_open_code(df)
    return total

def chi_per_version(headers): 
    # perform chi squared test for independence based on survey version
    for header in headers:
        cont_tbl = pd.crosstab([v1.Prior, v1.PriorGameDev], v1[header], margins = False)
        chi = st.chi2_contingency(cont_tbl.values.tolist())
        print(f"p-value of v1 based on prior experience: {chi[1]}")
        cont_tbl = pd.crosstab([v2.Prior, v2.PriorGameDev], v2[header], margins = False)
        chi = st.chi2_contingency(cont_tbl.values.tolist())
        print(f"p-value of v2 based on prior experience: {chi[1]}")
         

def clean_text(text):
    # function applied to open-ended responses to uniformize responses
    text = str(text)
    text.lower()
    if 'def' in text:
        text = text.replace('def', '')
    if '()' in text:
        text = text.replace('()', '')
    if text[-1] == 's':
        text = text[:-1]
    text = text.strip()
    return text
    
def analyze_open_code(df): 
    # process open-ended responses 
    # function not written by KH, written by co-PI
    student_programs = df['GameDevOpenCode']
    broken, working = 0, 0
    for program in student_programs:
        try:
            program = str(program)
            ast.parse(program)
            working += 1
        except SyntaxError:
            broken += 1
    print(f"\nBroken: {broken}; Working: {working}")
    
def show_line_char_graph_calc(lines_char):
    # shows graphs for distribution of open-ended responses based on line and character length
    # performs Shapiro Wilks test for normality on responses
    plt.hist(lines_char[0])
    plt.title("Distribution of Number of Lines per Response")
    plt.show()
    plt.hist(lines_char[1])
    plt.title("Distribution of Number of Characters per Response")
    plt.show()
    lines_stat, line_p = st.shapiro(lines_char[0])
    char_stat, char_p = st.shapiro(lines_char[1])
    print("Num Lines Normality on an interval of .05: ", lines_stat, line_p, line_p < 0.05)
    print("Num Characters Normality on an interval of .05: ", char_stat, char_p, char_p < 0.05)

def avg_lines_char(df, header): 
    # calculates lines and characters averages as well as lists of line count responses and char count respones 
    lines_count = 0
    char_count = 0
    student_codes = df[header].dropna()
    num_codes = len(student_codes)
    lines_all = []
    char_all = []
    for code in student_codes:
        code = str(code)
        len_code = len(code)
        lines = (code.count('\n') + 1)
        lines_count += lines
        char_count += len_code
        lines_all.append(lines)
        char_all.append(len_code)
    lines_avg = lines_count / num_codes
    char_avg = char_count / num_codes
    return [lines_all, char_all]


v1 = pd.read_csv('f20_game_dev_library_data.csv')
v1 = v1.drop(columns=['FinalGrade', 'Midterm', 'CanvasGrade', 'Section', 'Lab', 'TAEngagement', 'TACommunication', 'MeanDiffRank', 'Points', 'Hours Spent in BlockPy', 'Median # of Days Submitted Before Due Date', 'Number of Days Spent Working', 'Assignments With 0s', 'Native Speaker?', 'Location', 'Race/Ethnicity', 'coarse_race', 'PointsGrade', 'MockMidterm14', 'Level', 'OpenPython', 'OpenCode'])


v1 = v1.dropna(subset=['PriorGameDev'])
v1['PriorGameDev'] = v1['PriorGameDev'].mask(v1['PriorGameDev'] != 'No.', 'Yes.')


survey_headers = ['OpenShape', 'OpenScreen', 'ClosedScreen', 'OpenMovement', 'ClosedMovement', 'ClosedWave', 'ClosedStep', 'ClosedEvent', 'ClosedState', 'OpenSprite',
                 'ClosedSprite']


v1_dist = pd.crosstab(v1['Prior'], v1['PriorGameDev'], margins=False)
display(v1_dist)


v2 = pd.read_csv('s21_game_dev_library_data.csv')
column_names = v2.iloc[0]
v2.columns = column_names
v2 = v2.drop([0, 1])
v2 = v2.reset_index(drop=True)


v2 = v2.drop(columns=['Status', 'IPAddress', 'Duration (in seconds)', 'Progress', 'Finished', 'RecordedDate', 'ResponseId', 'RecipientLastName',
                     'RecipientFirstName', 'RecipientEmail', 'ExternalReference', 'LocationLatitude', 'LocationLongitude', 'DistributionChannel', 'UserLanguage'])


v2 = v2[v2.Q16 != 'I do not consent to participate in the research study.']
print('Number of consenting participants: ' + str(len(v2)))

Number of consenting participants: 118


v2['PriorGameDev'] = v2['PriorGameDev'].mask(v2['PriorGameDev'] != 'No.', 'Yes.')
v2['Prior'] = v2['Prior'].mask(v2['Prior'] != ('None'), True)
v2['Prior'] = v2['Prior'].mask(v2['Prior'] != True, False)


v2['Gender'].value_counts()

Man                         67
Woman                       39
Man,Prefer not to answer     1
Name: Gender, dtype: int64


survey_headers.remove('OpenMovement')


v2_dist = pd.crosstab(v2['Prior'], v2['PriorGameDev'], margins=False)
display(v2_dist)
pi_wedges = v1_dist.groupby(['Prior', 'PriorGameDev']).sum().values.flatten()
wedge_labels = ['No prior programming, no prior game dev.', 'No prior programming, prior game dev.', 'Prior programming, no prior game dev.', 'Prior programming, prior game dev.']
plt.figure(figsize=(6, 6))
plt.pie(x=pi_wedges, colors=['lightcoral', 'lavender', 'lightblue', 'moccasin'],  autopct='%.2f%%', textprops={'fontsize': 12})
plt.legend(wedge_labels, bbox_to_anchor=(1.05, 1), prop={'size': 12})
plt.title('Percentages of Prior Experience Groups for V1', fontsize=15)
plt.show()
pi_wedges_2 = v2_dist.groupby(['Prior', 'PriorGameDev']).sum().values.flatten()
plt.figure(figsize=(6, 6))
plt.pie(x=pi_wedges_2, colors=['lightcoral', 'lavender', 'lightblue', 'moccasin'], autopct='%.2f%%', textprops={'fontsize': 12})
plt.legend(wedge_labels, bbox_to_anchor=(1.05, 1), prop={'size': 12})                                                                              
plt.title('Percentages of Prior Experience Groups for V2', fontsize=15)
plt.show()


v1['Version'] = 1
v2['Version'] = 2
total = pd.concat([v1, v2])
total['ClosedSprite'] = total['ClosedSprite'].str.strip().str.lower()
total['OpenShape'] = total['OpenShape'].str.lower()
all_chi = perform_all_chi(total, survey_headers)
exp_chi = perform_exp_chi(total, survey_headers)
total_p_values = pd.DataFrame(list(zip(all_chi, exp_chi)), columns=['sliced by survey version', 'sliced by experience'], index=survey_headers).transpose()
print("P-Values from Chi Square Independence Test performed individually by survey version and experience level: ")
display(total_p_values)
print("\n\nP-Values from Chi Square Indpendence Test performed by experience level on responses with significant difference based on survey version: ")
version_headers = ['OpenShape', 'ClosedScreen', 'ClosedMovement']
exp_chi_version1 = perform_exp_chi(v1, version_headers)
exp_chi_version2= perform_exp_chi(v2, version_headers)
pd.DataFrame(list(zip(exp_chi_version1, exp_chi_version2)), columns=['v1', 'v2'], index=version_headers).transpose()

P-Values from Chi Square Independence Test performed individually by survey version and experience level:


P-Values from Chi Square Indpendence Test performed by experience level on responses with significant difference based on survey version:


upd_total = total.drop(['OpenShape', 'OpenScreen', 'ClosedScreen', 'ClosedMovement', 'OpenMovement'], axis=1)


wave_total = upd_total['ClosedWave'].value_counts()
print(wave_total)
plt.figure(figsize=(6,6))
plt.pie(x=wave_total, colors=['lightcoral', 'lightblue', 'moccasin'], autopct='%.2f%%', textprops={'fontsize': 14})
plt.title('ClosedWave results from V1 and V2', fontsize=16)
plt.legend(['Animation', 'Action', 'Movement'], bbox_to_anchor=(1.05, 1), prop={'size':14})
plt.show()

Animation    82
Action       73
Movement     29
Name: ClosedWave, dtype: int64


step_total = upd_total['ClosedStep'].value_counts()
print(step_total)
plt.figure(figsize=(6,6))
plt.pie(x=step_total, colors=['lightcoral', 'lavender', 'lightblue', 'moccasin'], autopct='%.2f%%', textprops={'fontsize': 14})
plt.title('ClosedStep results from V1 and V2', fontsize = 16)
plt.legend(['Repeat', 'Iteration', 'Step', 'Update'], bbox_to_anchor=(1.05, 1), prop={'size':14})
plt.show()

Repeat       99
Iteration    62
Step         19
Update        4
Name: ClosedStep, dtype: int64


event_total = upd_total['ClosedEvent'].value_counts()
print(event_total)
plt.figure(figsize=(6,6))
plt.pie(x=event_total, colors=['lightcoral', 'lavender', 'lightblue', 'moccasin', 'darkseagreen'], autopct='%.2f%%', textprops={'fontsize': 14})
plt.title('ClosedEvent results from V1 and V2', fontsize = 16)
plt.legend(['When', 'Attach', 'Connect', 'Register', 'On'], bbox_to_anchor=(1.05, 1), prop={'size':14})
plt.show()

When        75
Attach      36
Connect     31
Register    24
On          18
Name: ClosedEvent, dtype: int64


state_total = make_exp_table(upd_total, 'ClosedState')
state_total = state_total.drop(labels="All", axis=0)
display(state_total)
moment = state_total['moment']
labels = ['No Prgm.,\nNo Game Dev.', 'No Prgm.,\nGame Dev.', 'Prgm.,\nNo Game Dev.', 'Prgm.,\nGame Dev.']
x = np.arange(len(labels))
width = .20
fig, ax = plt.subplots(figsize=(8,8))
moment_bar = ax.bar(x - width*(3/2), moment, width, label="moment", color='lightcoral')
state = state_total['state']
state_bar = ax.bar(x - width*.5, state, width, label="state", color='lightblue')
status = state_total['status']
status_bar = ax.bar(x+width*.5, status, width, label='status', color='moccasin')
world = state_total['world']
world_bar = ax.bar(x + width*1.5, world, width, label='world', color='darkseagreen')
ax.set_title('ClosedState Responses by Experience', fontsize=20)
ax.set_ylabel('Responses', fontsize=20)
ax.set_xlabel('Prior Experience Level', fontsize = 20)
ax.set_xticks(x)
ax.set_xticklabels(labels, fontsize=12)
ax.legend(prop={'size':14})
fig.tight_layout()
plt.show()

ClosedState by experience


upd_total['OpenSprite'] = upd_total['OpenSprite'].apply(clean_text)
open_results = (analyze_free_response(upd_total, 'OpenSprite', True))
open_results = open_results.drop(open_results.columns[16:], axis=1)
open_results

OpenSprite by experience


sprite = make_exp_table(upd_total, 'ClosedSprite').sort_values(('All',''), axis=1, ascending=False)
sprite = sprite.drop(labels="All", axis=0)
display(sprite)
objects = sprite['objects']
labels = ['No Prog.,\nNo Game', 'No Prog.,\nGame', 'Prog.,\nNo Game', 'Prog.,\nGame']
x = np.arange(len(labels))
width = .20
fig, ax = plt.subplots(figsize=(8,8))
objects_bar = ax.bar(x - width, objects, width, label="objects", color='lightcoral')
characters = sprite['characters']
char_bar = ax.bar(x, characters, width, label="characters", color='lightblue')
sprites = sprite['sprites']
sprites_bar = ax.bar(x + width, sprites, width, label='sprites', color='moccasin')
ax.set_title('ClosedSprite Responses by Experience',fontsize=20)
ax.set_ylabel('Responses', fontsize=20)
ax.set_xlabel('Prior Experience Level', fontsize=20)
ax.set_xticks(x)
ax.set_xticklabels(labels, fontsize=12)
ax.legend(prop={'size':14})
fig.tight_layout()

ClosedSprite by experience


total['OpenShape'] = total['OpenShape'].apply(clean_text)
open_shape_results = analyze_free_response(total, 'OpenShape', False)
open_shape_results  = open_shape_results.drop(open_shape_results.columns[15:], axis=1)
open_shape_results

OpenShape contingency table


closed_tot = (make_table_by_q(total, 'ClosedScreen').sort_values(by='All', axis=1, ascending=False))
display(closed_tot)
closed_tot = closed_tot.drop(labels="All", axis=1)
display(closed_tot)
labels = ['window', 'screen', 'view', 'scene', 'world', 'level']
labels_v1 = labels[1:]
v1_data = closed_tot.iloc[0]
v1_data = v1_data[1:6]
v2_data = closed_tot.iloc[1]
v2_data = v2_data[:6]
plt.figure(figsize=(6,6))
plt.title('ClosedScreen Results V1', fontsize = 16)
v1_pi = plt.pie(v1_data, colors=['lightcoral', 'lavender', 'lightblue', 'moccasin', 'darkseagreen'], autopct='%.2f%%', textprops={'fontsize': 14})
plt.legend(labels_v1, bbox_to_anchor=(1.05, 1), prop={'size':14})
plt.show()
plt.figure(figsize=(6,6))
plt.title('ClosedScreen Results V2', fontsize = 16)
v2_pi = plt.pie(v2_data, colors=['sandybrown', 'lightcoral', 'lavender', 'lightblue', 'moccasin', 'darkseagreen'], autopct='%.2f%%', textprops={'fontsize': 12})
plt.legend(labels, bbox_to_anchor=(1.05, 1), prop={'size':14})
plt.show()

ClosedScreen contingency table


movement_tot = make_table_by_q(total, 'ClosedMovement')
movement_tot = movement_tot.drop(labels="All", axis=1)
display(movement_tot)
labels = ['action', 'animation', 'glide', 'movement']
v1_data = movement_tot.iloc[0]
v2_data = movement_tot.iloc[1]
plt.figure(figsize=(6,6))
plt.title('ClosedMovement Results V1', fontsize = 16)
v1_pi = plt.pie(v1_data, colors=['lightcoral', 'lavender', 'lightblue', 'moccasin'], autopct='%.2f%%', textprops={'fontsize': 14})
plt.legend(labels, bbox_to_anchor=(1.05, 1), prop={'size':14})
plt.show()
plt.figure(figsize=(6,6))
plt.title('ClosedMovement Results from V2', fontsize = 16)
v2_pi = plt.pie(v2_data, colors=['lightcoral', 'lavender', 'lightblue', 'moccasin'], autopct='%.2f%%', textprops={'fontsize': 14})
plt.legend(labels, bbox_to_anchor=(1.05, 1), prop={'size':14})
plt.show()

ClosedMovement contingency table


print('V1: ')
print(analyze_open_end(v1, 'GameDevOpenCode'))
print('V2: ')
print(analyze_open_end(v2, 'GameDevOpenCode'))

V1:

Num Lines Normality on an interval of .05:  0.8001936078071594 2.4016699171625078e-06 True
Num Characters Normality on an interval of .05:  0.7900149822235107 1.4448777392317425e-06 True

Broken: 6; Working: 70
{'methods': 18, 'functions': 15, 'both': 2, 'test cases': 0, 'graphics': 0, 'pens': 0, 'for': 3, 'while': 2, 'if': 2, 'func def': 7}
V2:

Num Lines Normality on an interval of .05:  0.4858640432357788 7.884292787326171e-16 True
Num Characters Normality on an interval of .05:  0.7452929019927979 6.568793425865138e-11 True

Broken: 34; Working: 84
{'methods': 31, 'functions': 11, 'both': 1, 'test cases': 0, 'graphics': 0, 'pens': 0, 'for': 0, 'while': 1, 'if': 2, 'func def': 5}


v1_char_line = avg_lines_char(v1, 'GameDevOpenCode')
v2_char_line = avg_lines_char(v2, 'GameDevOpenCode')
line_mwu, line_mwu_p = st.mannwhitneyu(x=v1_char_line[0], y=v2_char_line[0])
char_mwu, char_mwu_p = st.mannwhitneyu(x=v1_char_line[1], y=v2_char_line[1])
print(f"P-value of lines per response: {line_mwu_p},\nP-value of characters per response: {char_mwu_p}")

P-value of lines per response: 1.1529999803013193e-16,
P-value of characters per response: 1.8128938277980706e-06


# code not written by me, written by co-PI
def attrib(code):
    clear_report()
    code = str(code)
    calls = find_asts("Call", code)
    num_for = len(find_asts("For", code))
    num_while = len(find_asts("While", code))
    num_assign = len(find_asts("Assign", code))
    num_def = len(find_asts("FunctionDef", code))
    called_functions = [get_called_function(c.func) for c in calls]
    call = False
    for c in calls: 
        if (c.func.ast_name == "Name") or (c.func.ast_name == "Attribute"): 
            call = True
        else: 
            call = False
    try:
        code = str(code)
        ast.parse(code)
        working = True
    except SyntaxError:
        working = False
    if code == 'nan':
         return "empty"
    elif num_def:
        return "function definition"
    elif num_for or num_while:
        return "other construct"
    elif call:
        return "method/function call"
    elif num_assign:
        return "assignment"
    elif '#' in code or "'''" in code or '"""' in code:
        return "comment"
    elif not working: 
         return "did not compile"

def open_by_version(df):
    return df.groupby(['Prior', 'PriorGameDev'])['GameDevOpenCode'].apply(attrib).count()


def open_by_version(df):
    classified = df.assign(classification=df.GameDevOpenCode.apply(attrib))
    grouped_classes = classified.groupby(['Prior', 'PriorGameDev']).classification
    classes_counts = grouped_classes.value_counts()
    return classes_counts.unstack().fillna(0).astype(int)
v1_open = open_by_version(v1).loc[False,'No.']
# v1_open = v1_open.div(v1_open.agg(sum)).multiply(100).round(1)
v2_open = open_by_version(v2).loc[False, 'No.']
# v2_open = v2_open.div(v2_open.agg(sum)).multiply(100).round(1)
open_total = pd.concat([v1_open, v2_open], axis = 1)
open_total.columns = ['V1', 'V2']
open_total = open_total.fillna(0)
print("Code conventions present in version 1 and version 2 responses: ")
open_total

Percentages of code conventions present in version 1 and version 2 responses:


chi = st.chi2_contingency(pd.crosstab(open_total['V1'], open_total['V2']))
print(f'P-value of response conventions based on survey version: {chi[1]}.')

P-value of response conventions based on survey version: 0.10511012676905432.

	OpenShape	OpenScreen	ClosedScreen	ClosedMovement	ClosedWave	ClosedStep	ClosedEvent	ClosedState	OpenSprite	ClosedSprite
sliced by survey version	0.008233	0.422553	1.857338e-12	0.000001	0.499849	0.222499	0.815481	0.069710	0.158248	0.647583
sliced by experience	0.333725	0.011658	7.237847e-03	0.249262	0.152158	0.237950	0.149999	0.040338	0.019545	0.001064

	OpenShape	ClosedScreen	ClosedMovement
v1	0.185385	0.297430	0.786123
v2	0.818702	0.168839	0.494844

Video Games and CS Education: Data analysis to understand how students think about game design¶

Problem Description:¶

Problem Background:¶

Dataset:¶

Research Questions:¶

RQ1. What vocabulary do novices use when thinking about video games?¶

RQ2. Is there significant difference between survey results based on survey version (1 or 2) or participants prior programming and game development experience?¶

RQ3. Do results indicate game development vocabulary that best aligns with how novices think about video games? If so, what vocabulary is ideal?¶

Ethical Concerns:¶

Helper functions and data¶

Analysis process¶

Data Cleaning/Transformation Survey v1¶

Data Distribution Survey v1¶

Data Cleaning Spring 21 Survey v2¶

Data Distribution Survey v2 and Comparison¶

Compare Survey v1 and v2 Distributions¶

Pooling V1 and V2 when appropriate¶

ClosedWave¶

ClosedStep¶

ClosedEvent¶

ClosedState¶

OpenSprite¶

Closed Sprite¶

When V1 and V2 data cannot be pooled¶

OpenShape¶

ClosedScreen¶

ClosedMovement¶

Open-Ended Coding Question¶

Results¶

RQ1: What vocabulary do novices use when thinking about video games? and RQ2. Is there significant difference between survey results based on survey version (1 or 2) or participants prior programming and game development experience?¶

RQ3. Do results indicate game development vocabulary that best aligns with how novices think about video games? If so, what vocabulary is ideal?¶

Conclusion¶

	ClosedState	moment	state	status	world	All
Prior	PriorGameDev
False	No.	28	22	18	2	70
False	Yes.	3	1	2	0	6
True	No.	12	21	19	0	52
True	Yes.	7	30	18	1	56

OpenShape	rectangle	draw_rectangle	nan	make_rectangle	create_rectangle	generate_rectangle	shape	draw_square	rect	generate_rect	square	make_rect	makerectangle	draw_rect	i don't know
Version
1	11	16	0	11	7	2	2	4	2	1	2	1	1	1	0
2	51	6	14	1	5	4	3	0	2	1	0	1	1	1	2
All	62	22	14	12	12	6	5	4	4	2	2	2	2	2	2

	V1	V2
classification
assignment	0	1.0
comment	0	0.0
did not compile	3	19.0
empty	7	11.0
function definition	1	0.0
method/function call	6	17.0
other construct	1	0.0

ClosedScreen	All	Window	Screen	View	Scene	World	Level	Camera
Version
1	76	0	30	23	15	4	2	2
2	107	53	22	6	12	7	7	0
All	183	53	52	29	27	11	9	2

ClosedScreen	Window	Screen	View	Scene	World	Level	Camera
Version
1	0	30	23	15	4	2	2
2	53	22	6	12	7	7	0
All	53	52	29	27	11	9	2