def __init__(self, factor1='0', factor2='0', answer='0', operator='+'):
#因子1
self.factor1 = Factors(factor1)
#因子2
self.factor2 = Factors(factor2)
#结果
self.answer = Factors(answer)
#符号
self.operator = Operators(operator)
#是否为等式
if self.operator.val() == 1:
if self.factor1.val() + self.factor2.val() == self.answer.val():
self.equal = True
else:
self.equal = False
elif self.operator.val() == 2:
if self.factor1.val() - self.factor2.val() == self.answer.val():
self.equal = True
else:
self.equal = False
else:
if self.factor1.val() * self.factor2.val() == self.answer.val():
self.equal = True
else:
self.equal = False
def initialize(self):
# Sets up the numbers and operators that move down the screen.
self.answer_numbers = [4, 13, 21, 34, 48, 64, 85, 110] # possible answers for game, ideally will randomize in final game
# Creates objects for each number
self.number_objects = []
for number in range(1,10):
image = self.final_number_font.render(str(number), True, self.chosen_number_colors[number])
new_number = Numbers(self.screen, image, number, False)
self.number_objects.append(new_number)
plus_image = pygame.image.load("plussymbol.png").convert_alpha()
minus_image = pygame.image.load("minussymbol.png").convert_alpha()
multiply_image = pygame.image.load("multiplysymbol.png").convert_alpha()
divide_image = pygame.image.load("dividesymbol.png").convert_alpha()
power_image = pygame.image.load("caret.png").convert_alpha()
# Creates objects for each operator (may remove minus and divide)
self.plus = Operators(self.screen, plus_image, '+', False)
self.minus = Operators(self.screen, minus_image, '-', False)
self.multiply = Operators(self.screen, multiply_image, '*', False)
self.divide = Operators(self.screen, divide_image, '/', False)
self.power = Operators(self.screen, power_image, '^', False)
# A lot of initializations
self.hit_number = False
self.hit_operator = False
self.points = 0
self.temporary_operator = '+' # Initalizes the operator
self.answer_numbers_index = 0 # Defines current answer player strives for. Increments everytime the correct answer is chosen
self.accumulating_answer = 0 # Keeps track of current value user calculates after shooting the numbers and operators.
self.number_operators_used = 0 # Keeps track of number of operators used (for points)
self.random_operator_count = 0 # Determines when operator will appear, spaces them out with
self.random_number_count = 0
self.x = 319
self.y = 350
self.player_ship = Ship(self.screen, self.avatar, self.x, self.y)
self.ships = pygame.sprite.Group()
self.ships.add(self.player_ship)
self.moving_numbers = pygame.sprite.Group()
self.moving_operators = pygame.sprite.Group()
self.moving_laser = LaserFactory(self.screen, self.final_laser_choice)
self.introMenu()
def IntermolecularIneffectiveCollision(self, mole, oldMol1, oldMol2,
index1, index2):
operator = Operators()
newMol1, newMol2 = operator.Intermolecular(oldMol1, oldMol2)
pe1 = CRO().CalculatePE(mole, newMol1)
pe2 = CRO().CalculatePE(mole, newMol2)
e_inter = 0
gamma4 = random.uniform(0, 1)
mole.numHit[index1] = mole.numHit[index1] + 1
mole.numHit[index2] = mole.numHit[index2] + 1
e_inter = (mole.PE1[index1] + mole.PE1[index2] + mole.KE1[index1] +
mole.KE1[index2]) - (pe1 + pe2)
if (e_inter >= 0):
mole.moleculeTable[index1] = newMol1
mole.moleculeTable[index2] = newMol2
mole.PE1[index1] = pe1
mole.PE1[index2] = pe2
mole.KE1[index1] = e_inter * gamma4
mole.KE1[index2] = e_inter * (1 - gamma4)
if (mole.PE1[index1] < mole.minPE[index1]):
mole.minStruct[index1] = mole.moleculeTable[index1]
mole.minPE[index1] = mole.PE1[index1]
mole.minHit[index1] = mole.numHit[index1]
# endif
if (mole.PE1[index2] < mole.minPE[index2]):
mole.minStruct[index2] = mole.moleculeTable[index2]
mole.minPE[index2] = mole.PE1[index2]
mole.minHit[index2] = mole.numHit[index2]
def __init__(self,param,grid):
self.list_param=['forcing','noslip','timestepping','diffusion','Kdiff',
'forcing_module','gravity','isisland',
'customized','custom_module','additional_tracer']
param.copy(self,self.list_param)
# for potential energy
self.list_param=['xr','yr','nh','Lx','msk','area','mpitools']
grid.copy(self,self.list_param)
# for variables
param.varname_list=['vorticity','psi','u','v','buoyancy']
param.tracer_list=['vorticity','buoyancy']
param.whosetspsi=('vorticity')
if hasattr(self,'additional_tracer'):
for k in range(len(self.additional_tracer)):
trac=self.additional_tracer[k]
param.varname_list.append(trac)
param.tracer_list.append(trac)
print('Tracers are :',param.tracer_list)
param.sizevar =[grid.nyl,grid.nxl]
self.var = Var(param)
self.source = zeros(param.sizevar)
# for operators
self.ope = Operators(param,grid)
# for timescheme
self.tscheme = Timescheme(param,self.var.state)
self.tscheme.set(self.dynamics, self.timestepping)
if self.forcing:
try:
f = import_module(self.forcing_module)
except:
print('module %s for forcing cannot be found'%self.forcing_module)
print('make sure file **%s.py** exists'%self.forcing_module)
exit(0)
self.forc = f.Forcing(param,grid)
self.diags={}
if self.customized:
try:
f = import_module(self.custom_module)
print(f)
self.extrastep = f.Step(param,grid)
except:
print('module %s for forcing cannot be found'%self.custom_module)
print('make sure file **%s.py** exists'%self.custom_module)
exit(0)
def __init__(self, param, grid):
self.list_param = ['forcing', 'noslip', 'timestepping',
'forcing_module', 'additional_tracer',
'myrank',
'gravity', 'diffusion', 'Kdiff', 'f0']
param.copy(self, self.list_param)
# for potential energy
self.list_param = ['xr', 'yr', 'nh',
'Lx', 'msk', 'area', 'mpitools', 'dx']
grid.copy(self, self.list_param)
# for variables
param.varname_list = ['vorticity', 'psi',
'u', 'v', 'buoyancy', 'V', 'qE']
param.tracer_list = ['vorticity', 'buoyancy', 'V']
param.whosetspsi = ('vorticity')
if hasattr(self, 'additional_tracer'):
for k in range(len(self.additional_tracer)):
trac = self.additional_tracer[k]
param.varname_list.append(trac)
param.tracer_list.append(trac)
param.sizevar = [grid.nyl, grid.nxl]
self.var = Var(param)
# for operators
self.ope = Operators(param, grid)
# for timescheme
self.tscheme = Timescheme(param, self.var.state)
if self.forcing:
if self.forcing_module == 'embedded':
print('Warning: check that you have indeed added the forcing to the model')
print('Right below the line : model = f2d.model')
print('you should have the line: model.forc = Forcing(param, grid)')
pass
else:
try:
f = import_module(self.forcing_module)
except ImportError:
print('module %s for forcing cannot be found'
% self.forcing_module)
print('make sure file **%s.py** exists' % self.forcing_module)
sys.exit(0)
self.forc = f.Forcing(param, grid)
self.diags = {}
def __init__(self, param, grid):
self.list_param = [
'forcing', 'diffusion', 'Kdiff', 'noslip', 'timestepping', 'beta',
'Rd', 'forcing_module'
]
param.copy(self, self.list_param)
# for diagnostics
self.list_param = ['yr', 'nh', 'msk', 'area', 'mpitools']
grid.copy(self, self.list_param)
# for variables
param.varname_list = ('pv1', 'psi1', 'u1', 'v1', 'pv2', 'psi2', 'u2',
'v2')
param.sizevar = [grid.nyl, grid.nxl]
self.var = Var(param)
self.source = zeros(param.sizevar)
# self.ipva = self.var.varname_list.index('pvanom')
# self.ipv = self.var.varname_list.index('pv')
# self.ivor = self.var.varname_list.index('vorticity')
# self.ipsi = self.var.varname_list.index('psi')
# background pv
self.pvback = self.beta * (grid.yr - grid.Ly * .5) * grid.msk
# for operators
param.tracer_list = ['pv1', 'pv2']
param.whosetspsi = ('pvanom')
param.qgoperator = True
self.ope = Operators(param, grid)
# for timescheme
self.tscheme = Timescheme(param, self.var.state)
self.dx0 = self.tscheme.dx0
self.kt = 0
if self.forcing:
try:
f = import_module(self.forcing_module)
except:
print('module %s for forcing cannot be found' %
self.forcing_module)
print('make sure file **%s.py** exists' % self.forcing_module)
exit(0)
self.forc = f.Forcing(param, grid)
self.diags = {}
self.tscheme.set(self.dynamics, self.timestepping)
def add_tile(self, input_name, loops, axis, output_name):
layer = caffe_net.LayerParameter(name=output_name, type='Tile',
bottom=[input_name], top=[output_name])
layer.tile_param(axis, loops)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.tile(self.data_dict[input_name], loops, axis, output_name)
return output_name
def add_expand_dims(self, input_name, axis, output_name):
layer = caffe_net.LayerParameter(name=output_name, type='Unsqueeze',
bottom=[input_name], top=[output_name])
layer.unsqueeze_param(axis)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.expand_dims(self.data_dict[input_name], axis, output_name)
return output_name
def add_swish(self, input_name, output_name, beta=1.0):
layer = caffe_net.LayerParameter(name=output_name, type='Swish',
bottom=[input_name],
top=[output_name])
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.swish(self.data_dict[input_name], beta, output_name)
return output_name
def add_sigmoid(self, input_name, output_name):
layer = caffe_net.LayerParameter(name=output_name, type='Sigmoid',
bottom=[input_name],
top=[output_name])
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.sigmoid(self.data_dict[input_name], output_name)
return output_name
def add_relative_shift(self, input_name, output_name, axis, shift_length):
layer = caffe_net.LayerParameter(name=output_name, type='RelativeShift',
bottom=[input_name], top=[output_name])
layer.relative_shift_param(axis, shift_length)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.relative_shift(self.data_dict[input_name], axis, shift_length, output_name)
return output_name
def add_power(self, input_name, output_name, scale=1, shift=0, power=1):
layer = caffe_net.LayerParameter(name=output_name, type='Power',
bottom=[input_name], top=[output_name])
layer.power_param(scale, shift, power)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.power(self.data_dict[input_name], scale, shift, power, output_name)
return output_name
def add_transpose(self, input_name, output_name, dim):
layer = caffe_net.LayerParameter(name=output_name, type='Permute',
bottom=[input_name], top=[output_name])
layer.permute_param(dim)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.transpose(self.data_dict[input_name], dim, output_name)
return output_name
def add_reshape(self, input_name, output_name, shape):
layer = caffe_net.LayerParameter(name=output_name, type='Reshape',
bottom=[input_name], top=[output_name])
layer.reshape_param(shape)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.reshape(self.data_dict[input_name], shape, output_name)
return output_name
def add_argmax(self, input_name, axis, output_name):
layer = caffe_net.LayerParameter(name=output_name, type='ArgMax',
bottom=[input_name], top=[output_name])
layer.argmax_param(axis)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.argmax(self.data_dict[input_name], axis, output_name)
return output_name
def add_copy(self, src_name, src_batch_stride, src_stride, src_offset,
dst_name, dst_batch_stride, dst_stride, dst_offset,
length,
output_name,
src_index_name=None, dst_index_name=None):
src_index = None
dst_index = None
if (src_index_name is None):
layer = caffe_net.LayerParameter(name=output_name, type='Copy',
bottom=[src_name, dst_name], top=[output_name])
else:
layer = caffe_net.LayerParameter(name=output_name, type='Copy',
bottom=[src_name, dst_name, src_index_name, dst_index_name], top=[output_name])
src_index = self.data_dict[src_index_name]
dst_index = self.data_dict[dst_index_name]
layer.copy_param(src_batch_stride, src_stride, src_offset, dst_batch_stride, dst_stride, dst_offset, length)
self.caffe_model.add_layer(layer)
self.data_dict[dst_name] = Operators.copy(self.data_dict[src_name],
src_batch_stride, src_stride, src_offset,
self.data_dict[dst_name],
dst_batch_stride, dst_stride, dst_offset,
length,
dst_name,
src_index, dst_index)
return dst_name
def add_l2norm(self, input_name, output_name):
layer = caffe_net.LayerParameter(name=output_name, type='L2Norm',
bottom=[input_name],
top=[output_name])
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.l2_norm(self.data_dict[input_name], output_name)
return output_name
def add_pad(self, input_name, output_name, padding_shapes, padding_values=None):
layer = caffe_net.LayerParameter(name=output_name, type='Pad',
bottom=[input_name], top=[output_name])
layer.padding_param(padding_shapes, padding_values)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.pad(self.data_dict[input_name], padding_shapes, padding_values, output_name)
return output_name
def add_relu6(self, input_name, output_name):
layer = caffe_net.LayerParameter(name=output_name, type='ReLU6',
bottom=[input_name],
top=[output_name])
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.relu(self.data_dict[input_name], output_name, max_value=6)
return output_name
def add_memory(self, memory_name, memory_shapes, data_type):
layer = caffe_net.LayerParameter(name=memory_name+"_mem", type='PreAllocatedMemory',
top=[memory_name])
layer.memory_param(memory_shapes, data_type)
self.caffe_model.add_layer(layer)
self.data_dict[memory_name] = Operators.zeros(memory_shapes, memory_name)
return memory_name
def generate(self, input = None):
#batch_seq_length = 16
input_text_name = "input_text"
input_text_shape = [self.batch, 16]
self.add_input(input_text_name, input_text_shape)
self.set_input(input)
#embedding
x = self.extract_embedding(input_text_name, 0, "emb_table", "embedding_lookup")
#bilstm
x = self.extract_lstm(x, None, "BiLSTM", 0, steps = -2, scope_name = ["BiLSTM/fw/lstm_cell", "BiLSTM/bw/lstm_cell"])
#FC
weight = self.get_weight("W")
bias = self.get_weight("b")
layer = caffe_net.LayerParameter("wb_fc_output", type='InnerProduct',
bottom=[x], top=["wb_fc_output"])
num_output = len(weight[0])
weight = weight.transpose((1,0))
layer.inner_product_param(num_output, bias_term=bias is not None)
if len(bias) != num_output:
print("[ERROR] extract_dense failed")
exit(0)
layer.add_data(weight, bias)
self.caffe_model.add_layer(layer)
self.data_dict["wb_fc_output"] = Operators.fully_connect(self.data_dict[x],
weight.transpose((1, 0)), bias,
"wb_fc_output")
x = "wb_fc_output"
#softmax
x = self.add_softmax(x, "softmax_output", -1)
#argmax
x = self.add_argmax(x, -1, "output")
self.save_caffe_model()
def extract_dense(self,
input_name,
output_name,
scope_id,
scope_name="dense"):
if (isinstance(scope_name, str)):
layer_names = [scope_name, "kernel", "bias"]
elif (isinstance(scope_name, list)):
layer_names = scope_name
else:
print("[ERROR] unsupported dense scope_name")
exit(1)
kernel, bias = self.get_weights(scope_id, layer_names)
layer = caffe_net.LayerParameter(name=output_name,
type='InnerProduct',
bottom=[input_name],
top=[output_name])
num_output = len(kernel[0])
kernel = kernel.transpose((1, 0))
layer.inner_product_param(num_output, bias_term=bias is not None)
if bias is not None:
if len(bias) != num_output:
print("[ERROR] extract_dense failed")
exit(0)
layer.add_data(kernel, bias)
else:
layer.add_data(kernel)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.fully_connect(
self.data_dict[input_name], kernel.transpose((1, 0)), bias,
output_name)
return output_name
def extract_scale(self,
input_name,
output_name,
scope_id,
data_format="NCHW",
axis=1,
layer_names=["scale", "gamma", "beta"]):
assert (data_format == "NCHW")
gamma, beta = self.get_weights(scope_id, layer_names)
layer = caffe_net.LayerParameter(name=output_name,
type='Scale',
bottom=[input_name],
top=[output_name])
if beta is not None:
layer.scale_param(axis=axis, bias_term=True)
layer.add_data(gamma, beta)
else:
layer.scale_param(axis=axis, bias_term=False)
layer.add_data(gamma)
self.caffe_model.add_layer(layer)
if (self.data_dict[input_name] is not None):
input_data, input_shape, inv_transpose_dims = self.preprocess_nchwc8_nchw_input(
input_name, axis)
output_data = Operators.scale(input_data, gamma, beta, output_name)
self.data_dict[output_name] = self.postprocess_nchwc8_nchw_output(
output_data, input_shape, inv_transpose_dims)
else:
self.data_dict[output_name] = None
return output_name
def extract_batch_norm(
self,
input_name,
output_name,
scope_id,
data_format="NCHW",
axis=1,
eps=1e-3,
layer_names=["bn", "moving_mean", "moving_variance"]):
assert (data_format == "NCHW")
mean, var = self.get_weights(scope_id, layer_names)
layer = caffe_net.LayerParameter(name=output_name,
type='BatchNorm',
bottom=[input_name],
top=[output_name])
layer.batch_norm_param(axis=axis, eps=eps)
layer.add_data(mean, var)
self.caffe_model.add_layer(layer)
if (self.data_dict[input_name] is not None):
input_data, input_shape, inv_transpose_dims = self.preprocess_nchwc8_nchw_input(
input_name, axis)
output_data = Operators.batch_norm(input_data, mean, var, eps,
output_name)
self.data_dict[output_name] = self.postprocess_nchwc8_nchw_output(
output_data, input_shape, inv_transpose_dims)
else:
self.data_dict[output_name] = None
gamma = self.get_weights(scope_id, [layer_names[0], "gamma"])
if (gamma is not None):
scale_name = self.extract_scale(output_name, output_name + "_s",
scope_id, data_format, axis,
[layer_names[0], "gamma", "beta"])
self.data_dict[output_name] = self.data_dict[scale_name]
output_name = scale_name
return output_name
def extract_layer_norm(self,
input_name,
layer_norm_name,
scope_id,
layer_names=None):
if (layer_names is None):
self.scopes[scope_id] = "LayerNorm"
self.scopes[scope_id + 1] = "gamma"
gamma_name = self.generate_name(self.scopes, scope_id + 2)
self.scopes[scope_id + 1] = "beta"
beta_name = self.generate_name(self.scopes, scope_id + 2)
else:
self.scopes[scope_id] = layer_names[0]
self.scopes[scope_id + 1] = layer_names[1]
gamma_name = self.generate_name(self.scopes, scope_id + 2)
self.scopes[scope_id + 1] = layer_names[2]
beta_name = self.generate_name(self.scopes, scope_id + 2)
gamma = self.get_tensor(gamma_name)
beta = self.get_tensor(beta_name)
layer = caffe_net.LayerParameter(name=layer_norm_name,
type='LayerNorm',
bottom=[input_name],
top=[layer_norm_name])
layer.add_data(gamma, beta)
self.caffe_model.add_layer(layer)
self.data_dict[layer_norm_name] = Operators.layer_norm(
self.data_dict[input_name], gamma, beta, layer_norm_name)
return layer_norm_name
def extract_group_norm(self,
input_name,
groups,
output_name,
scope_id,
data_format="NCHW",
axis=1,
layer_names=["GroupNorm", "gamma", "beta"]):
assert (data_format == "NCHW")
gamma, beta = self.get_weights(scope_id, layer_names)
layer = caffe_net.LayerParameter(name=output_name,
type='GroupNorm',
bottom=[input_name],
top=[output_name])
layer.add_data(gamma, beta)
layer.group_norm_param(groups)
self.caffe_model.add_layer(layer)
if (self.data_dict[input_name] is not None):
input_data, input_shape, inv_transpose_dims = self.preprocess_nchwc8_nchw_input(
input_name, axis)
output_data = Operators.group_norm(input_data, groups, gamma, beta,
output_name)
self.data_dict[output_name] = self.postprocess_nchwc8_nchw_output(
output_data, input_shape, inv_transpose_dims)
else:
self.data_dict[output_name] = None
return output_name
def extract_lstm(self,
input_name,
state_name,
output_name,
scope_id,
steps=-1,
scope_name="basic_lstm_cell"):
self.scopes[scope_id] = scope_name
self.scopes[scope_id + 1] = "kernel"
kernel_name = self.generate_name(self.scopes, scope_id + 2)
kernel = self.get_tensor(kernel_name)
self.scopes[scope_id + 1] = "bias"
bias_name = self.generate_name(self.scopes, scope_id + 2)
bias = self.get_tensor(bias_name)
layer = caffe_net.LayerParameter(name=output_name,
type='LSTM',
bottom=[input_name, state_name],
top=[output_name])
num_output_4 = len(kernel[0])
if (bias is not None):
if (len(bias) != num_output_4):
print("[ERROR] extract_lstm failed")
exit(0)
num_output = num_output_4 // 4
layer.lstm_param(num_output, steps)
layer.add_data(kernel.transpose([1, 0]), bias)
self.caffe_model.add_layer(layer)
self.data_dict[output_name], self.data_dict[
state_name] = Operators.lstm(self.data_dict[input_name],
self.data_dict[state_name], kernel,
bias, output_name, state_name)
return output_name
def extract_dense(self,
input_name,
dense_name,
scope_id,
scope_name="dense"):
self.scopes[scope_id] = scope_name
self.scopes[scope_id + 1] = "kernel"
kernel_name = self.generate_name(self.scopes, scope_id + 2)
kernel = self.get_tensor(kernel_name)
self.scopes[scope_id + 1] = "bias"
bias_name = self.generate_name(self.scopes, scope_id + 2)
bias = self.get_tensor(bias_name)
layer = caffe_net.LayerParameter(name=dense_name,
type='InnerProduct',
bottom=[input_name],
top=[dense_name])
num_output = len(kernel[0])
kernel = kernel.transpose((1, 0))
layer.inner_product_param(num_output, bias_term=bias is not None)
if bias is not None:
if len(bias) != num_output:
print("[ERROR] extract_dense failed")
exit(0)
layer.add_data(kernel, bias)
else:
layer.add_data(kernel)
self.caffe_model.add_layer(layer)
self.data_dict[dense_name] = Operators.fully_connect(
self.data_dict[input_name], kernel.transpose((1, 0)), bias,
dense_name)
return dense_name
def add_clip(self, input_name, output_name, min_value, max_value):
layer = caffe_net.LayerParameter(name=output_name, type='Clip',
bottom=[input_name],
top=[output_name])
layer.clip_param(min_value, max_value)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.clip(self.data_dict[input_name], min_value, max_value, output_name)
return output_name
def add_matmul(self, input_a_name, input_b_name, output_name, transpose_a=False, transpose_b=False):
layer = caffe_net.LayerParameter(name=output_name, type='MatMul',
bottom=[input_a_name, input_b_name], top=[output_name])
layer.matmul_param(transpose_a, transpose_b)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.matmul(self.data_dict[input_a_name], transpose_a,
self.data_dict[input_b_name], transpose_b, output_name)
return output_name
def add_reduce_mean(self, input_name, axis, keep_dim, output_name):
operation = 4 # MEAN
layer = caffe_net.LayerParameter(name=output_name, type='Reduction',
bottom=[input_name], top=[output_name])
layer.reduction_param(operation, axis, keep_dim)
self.caffe_model.add_layer(layer)
self.data_dict[output_name] = Operators.reduction(self.data_dict[input_name], None, operation, axis, output_name)
return output_name
def __init__(self):
self.tokens = None
self.current = None
self.operators_precendence = Operators()
class Parser:
def __init__(self):
self.tokens = None
self.current = None
self.operators_precendence = Operators()
def next(self):
self.current = next(self.tokens)
def parse_number_expression(self):
"""
numberexpr ::= number
"""
result = NumberExpression(self.current.value)
self.next()
return result
def parse_parenthesis_expression(self):
"""
parenexpr ::= '(' expression ')'
"""
self.next() # consume '('
contents = self.parse_expression()
if self.current != ClosedParenthesisToken():
raise ParserException("Expected ')', got " + str(self.current))
self.next() # consume ')'
return contents
def parse_expression(self):
"""
expression ::= primary binoprhs
"""
left = self.parse_primary_expression()
return self.parse_binary_op(left, 0)
def parse_binary_op(self, left, left_precedence):
"""
binoprhs ::= (operator primary)*
"""
while True:
precedence = self.operators_precendence.get(self.current)
if precedence < left_precedence:
return left
operator = self.current.char
self.next()
right = self.parse_primary_expression()
next_precedence = self.operators_precendence.get(self.current)
if precedence < next_precedence:
right = self.parse_binary_op(right, precedence + 1)
left = BinaryOperatorExpression(operator, left, right)
def parse_if_expression(self):
"""
ifexpr ::= 'if' expression 'then' expression 'else' expression
"""
self.next()
condition = self.parse_expression()
if not isinstance(self.current, ThenToken):
raise ParserException("Expected 'then' after if, got " + str(self.current))
self.next()
then_expression = self.parse_expression()
if not isinstance(self.current, ElseToken):
raise ParserException("Expected 'else' after if, got " + str(self.current))
self.next()
else_expression = self.parse_expression()
return IfExpression(condition, then_expression, else_expression)
def parse_for_expression(self):
"""
forexpr ::= 'for' identifier '=' expr ',' expr (',' expr)? 'in' expression
"""
self.next()
if not isinstance(self.current, IdentifierToken):
raise ParserException("Expected identifier after 'for', got " + str(self.current))
loop_variable = self.current.name
self.next()
if self.current != AssignToken():
raise ParserException("Expected '=' after variable in for, got " + str(self.current))
self.next()
start = self.parse_expression()
if self.current != CommaToken():
raise ParserException("Expected ',' after variable start value in for, got " + str(self.current))
self.next()
end = self.parse_expression()
if self.current == CommaToken():
self.next()
step = self.parse_expression()
else:
step = None
if not isinstance(self.current, InToken):
raise ParserException("Expected 'in' after the loop, got " + str(self.current))
self.next()
body = self.parse_expression()
return ForExpression(loop_variable, start, end, step, body)
def parse_identifier_expression(self):
"""
identifierexpr ::= identifier | identifier '(' expression* ')'
"""
identifier_name = self.current.name
self.next()
if self.current != OpenParenthesisToken():
return VariableExpression(identifier_name)
self.next() # consume '('
arguments = []
if self.current != ClosedParenthesisToken():
while True:
arguments.append(self.parse_expression())
if self.current == ClosedParenthesisToken():
break
if self.current != CommaToken():
raise ParserException("Expected ',' or ')' in the argument list")
self.next()
self.next() # consume ')'
return FunctionCallExpression(identifier_name, arguments)
def parse_primary_expression(self):
"""
primary ::= identifierexpr | numberexpr | parenexpr | ifexpression | forexpression
"""
if isinstance(self.current, IdentifierToken):
return self.parse_identifier_expression()
elif isinstance(self.current, NumberToken):
return self.parse_number_expression()
elif isinstance(self.current, IfToken):
return self.parse_if_expression()
elif isinstance(self.current, ForToken):
return self.parse_for_expression()
elif self.current == OpenParenthesisToken():
return self.parse_parenthesis_expression()
else:
raise ParserException("Unknown token when parsing primary: " + str(self.current))
def parse_prototype_expression(self):
"""
prototype ::= id '(' id* ')'
"""
if not isinstance(self.current, IdentifierToken):
raise ParserException("Expected function name in prototype")
function_name = self.current.name
self.next()
if self.current != OpenParenthesisToken():
raise ParserException("Expected '(' in function prototype")
self.next()
argument_names = []
while isinstance(self.current, IdentifierToken):
argument_names.append(self.current.name)
self.next()
if self.current != ClosedParenthesisToken():
raise ParserException("Expected ')' in function prototype")
self.next()
return PrototypeNode(function_name, argument_names)
def parse_definition(self):
"""
definition ::= 'def' prototype expression
"""
self.next()
prototype = self.parse_prototype_expression()
expression = self.parse_expression()
return FunctionNode(prototype, expression)
def parse_external(self):
"""
external ::= 'extern' prototype
"""
self.next()
return self.parse_prototype_expression()
def parse_toplevel_expression(self):
"""
toplevelexpr ::= expression
"""
expression = self.parse_expression()
return FunctionNode.create_anonymous(expression)
def parse(self, string):
"""
top ::= definition | external | expression | EOF
"""
lexer = Lexer()
self.tokens = lexer.tokenize(string)
self.next()
if isinstance(self.current, EOFToken):
pass
elif isinstance(self.current, DefToken):
print('Parsed a function definition.')
return self.parse_definition()
elif isinstance(self.current, ExternToken):
print('Parsed an extern.')
return self.parse_external()
else:
print('Parsed a top-level expression.')
return self.parse_toplevel_expression()
def _flatten(self, ast):
if isinstance(ast, NumberExpression):
return ['Number', ast.value]
elif isinstance(ast, VariableExpression):
return ['Variable', ast.name]
elif isinstance(ast, BinaryOperatorExpression):
return ['Binop', ast.operator,
self._flatten(ast.left), self._flatten(ast.right)]
elif isinstance(ast, FunctionCallExpression):
args = [self._flatten(arg) for arg in ast.arguments]
return ['Call', ast.function, args]
elif isinstance(ast, PrototypeNode):
return ['Prototype', ast.name, ' '.join(ast.arguments)]
elif isinstance(ast, FunctionNode):
return ['Function',
self._flatten(ast.prototype), self._flatten(ast.body)]
else:
raise TypeError('unknown type in _flatten: {0}'.format(type(ast)))
class GalagaVariant: # tentative title
def __init__(self):
pygame.init()
pygame.mixer.init()
pygame.display.set_caption("Arithiga")
self.screen = pygame.display.set_mode((640,480),0,32)
self.screen.fill([0, 0, 0]) # background will be black
# Parameter testing, not used for now
def Parameters(self):
# self.background_color
# self.number_font
# self.chosen_number_colors (array)
# self.avatar
# self.final_laser_choice
selection_font = pygame.font.SysFont('arial', 20)
intro_directions = selection_font.render("Press the n key to cycle through the options", True, (250, 50, 0), (0, 0, 0))
intro_directions2 = selection_font.render("Press the space key to select your choice or continue", True, (250, 50, 0), (0,0,0))
intro_directions3 = selection_font.render("To the next screen", True, (250, 50, 0), (0,0,0))
pygame.display.flip()
while True:
self.screen.blit(intro_directions, (125, 100))
self.screen.blit(intro_directions2, (75, 150))
self.screen.blit(intro_directions3, (220, 200))
pygame.display.flip()
event = pygame.event.wait()
if event.type is pygame.QUIT:
sys.exit()
if event.type is pygame.KEYDOWN:
if event.key is K_SPACE:
break
self.screen.fill([0,0,0])
self.screen.fill([0,0,0])
selection_font = pygame.font.SysFont('arial', 20)
background_colors = [(0,0,0), (255, 212, 0), (255, 157, 255), (106, 185, 132), (255, 255, 255), (255, 255, 0)]
which_back_color = selection_font.render("Which background color would you like to use?", True, (250, 50, 0), (0, 0, 0))
pygame.display.flip()
locations = [100, 200, 300, 400, 500, 600]
option = 0
back_color_count = 0
while True:
self.screen.blit(which_back_color, (100, 100))
count = 0
for color in background_colors:
count += 1
pygame.draw.rect(self.screen, color, pygame.Rect(100 * count, 300, 30, 30))
pygame.draw.circle(self.screen, (255, 255, 255), (locations[option], 300), 3)
pygame.display.update()
event = pygame.event.wait()
if event.type is pygame.QUIT:
sys.exit()
if event.type is pygame.KEYDOWN:
if event.key is K_n:
self.screen.fill([0,0,0])
back_color_count += 1
if back_color_count == 6:
option = 0
back_color_count = 0
else:
option += 1
if event.key is K_SPACE:
self.background_color = background_colors[option]
break
self.screen.fill([0,0,0])
font_choices = ['impact', 'arial', 'silom', 'corbel', 'optima']
option = 0
font_count = 0
while True:
event = pygame.event.wait()
if event.type is pygame.QUIT:
sys.exit()
if event.type is pygame.KEYDOWN:
if event.key is K_n:
self.screen.fill([0,0,0])
font_count += 1
if font_count == 5:
option = 0
font_count = 0
else:
option += 1
if event.key is K_SPACE:
self.number_font = font_choices[option]
break
which_font = selection_font.render("Which font do you want to use for the numbers?", True, (200, 50, 0), (0, 0, 0))
current_font = pygame.font.SysFont(font_choices[option], 20)
number = current_font.render('5', True, (200, 50, 0), (0, 0, 0))
self.screen.blit(which_font, (50, 100))
self.screen.blit(number, (300, 300))
pygame.display.update()
number_colors = [(255, 255, 255), (255, 212, 0), (255, 157, 255), (106, 185, 132), (0,0,0), (255, 255, 0), (201, 103, 255), (233, 54, 0), (0, 247, 194), (216, 164, 95), (73, 133, 246)]
self.chosen_number_colors = []
self.final_number_font = pygame.font.SysFont(self.number_font, 20)
number_color_counter = 0
for number in range(0,10):
self.screen.fill([0,0,0])
option = 0
while True:
event = pygame.event.wait()
if event.type is pygame.QUIT:
sys.exit()
if event.type is pygame.KEYDOWN:
if event.key is K_n:
self.screen.fill([0,0,0])
number_color_counter += 1
if number_color_counter == 11:
option = 0
number_color_counter = 0
else:
option += 1
if event.key is K_SPACE:
self.chosen_number_colors.append(number_colors[option])
break
which_number_color = selection_font.render("For each number, what color do you want?", True, (200, 50, 0), (0, 0, 0))
self.screen.blit(which_number_color, (50, 100))
the_number = self.final_number_font.render(str(number), True, number_colors[option], self.background_color)
self.screen.blit(the_number, (300, 300))
pygame.display.update()
self.screen.fill([0,0,0])
# Select the type of ship you want
ship_option = pygame.image.load("galaga-ship.jpg").convert_alpha()
bug_option = pygame.image.load("bug.jpg").convert_alpha()
ghost_option = pygame.image.load("ghost.jpg").convert_alpha()
avatar_options = [ship_option, bug_option, ghost_option]
locations = [150, 300, 450]
option = 0
avatar_count = 0
while True:
which_avatar = selection_font.render("Which avatar would you like to use?", True, (200, 50, 0), (0, 0, 0))
self.screen.blit(which_avatar, (100, 100))
count = 0
for avatar in avatar_options:
count += 1
self.screen.blit(avatar_options[count - 1], (150 * count, 300))
pygame.draw.circle(self.screen, (255, 255, 255), (locations[option], 300), 3)
pygame.display.flip()
event = pygame.event.wait()
if event.type is pygame.QUIT:
sys.exit()
if event.type is pygame.KEYDOWN:
if event.key is K_n:
avatar_count += 1
if avatar_count == 3:
option = 0
avatar_count = 0
else:
option += 1
if event.key is K_SPACE:
self.avatar = avatar_options[option]
break
self.screen.fill([0,0,0])
self.screen.fill([0,0,0])
square_green_option = pygame.image.load("squaregreenlaser.png").convert_alpha()
long_green_option = pygame.image.load("longgreenlaser.png").convert_alpha()
square_or_long = [square_green_option, long_green_option]
locations = [200, 400]
option = 0
laser_count = 0
while True:
which_laser = selection_font.render("Which laser would you like to use?", True, (200, 50, 0), (0, 0, 0))
self.screen.blit(which_laser, (100, 100))
count = 0
for laser in square_or_long:
count += 1
self.screen.blit(square_or_long[count - 1], (200 * count, 300))
pygame.draw.circle(self.screen, (255, 255, 255), (locations[option], 300), 3)
pygame.display.flip()
event = pygame.event.wait()
if event.type is pygame.QUIT:
sys.exit()
if event.type is pygame.KEYDOWN:
if event.key is K_n:
laser_count += 1
if laser_count == 2:
option = 0
laser_count = 0
else:
option += 1
if event.key is K_SPACE:
self.laser_choice = square_or_long[option]
break
self.screen.fill([0,0,0])
if self.laser_choice is square_green_option:
square_blue_option = pygame.image.load("squarebluelaser.png").convert_alpha()
square_yellow_option = pygame.image.load("squareyellowlaser.png").convert_alpha()
square_red_option = pygame.image.load("squareredlaser.png").convert_alpha()
square_lasers = [square_green_option, square_blue_option, square_red_option, square_yellow_option]
self.screen.fill([0,0,0])
locations = [100, 200, 300, 400]
option = 0
laser_count = 0
while True:
which_color = selection_font.render("Which color would you like to use?", True, (200, 50, 0), (0, 0, 0))
self.screen.blit(which_color, (100, 100))
count = 1
for color in square_lasers:
self.screen.blit(color, (100 * count, 300))
count += 1
pygame.draw.circle(self.screen, (255, 255, 255), (locations[option], 300), 3)
pygame.display.flip()
event = pygame.event.wait()
if event.type is pygame.QUIT:
sys.exit()
if event.type is pygame.KEYDOWN:
if event.key is K_n:
laser_count += 1
if laser_count == 4:
option = 0
laser_count = 0
else:
option += 1
if event.key is K_SPACE:
self.final_laser_choice = square_lasers[option]
break
self.screen.fill([0,0,0])
elif self.laser_choice is long_green_option:
long_blue_option = pygame.image.load("longbluelaser.png").convert_alpha()
long_red_option = pygame.image.load("longredlaser.png").convert_alpha()
long_yellow_option = pygame.image.load("longyellowlaser.png").convert_alpha()
long_lasers = [long_green_option, long_blue_option, long_red_option, long_yellow_option]
self.screen.fill([0,0,0])
locations = [100, 200, 300, 400]
option = 0
laser_count = 0
while True:
which_color = selection_font.render("Which color would you like to use?", True, (200, 50, 0), (0, 0, 0))
self.screen.blit(which_color, (100, 100))
count = 0
for color in long_lasers:
count += 1
self.screen.blit(long_lasers[count - 1], (100 * count, 300))
pygame.draw.circle(self.screen, (255, 255, 255), (locations[option], 300), 3)
pygame.display.flip()
event = pygame.event.wait()
if event.type is pygame.QUIT:
sys.exit()
if event.type is pygame.KEYDOWN:
if event.key is K_n:
laser_count += 1
if laser_count == 4:
option = 0
laser_count = 0
else:
option += 1
if event.key is K_SPACE:
self.final_laser_choice = long_lasers[option]
break
self.screen.fill([0,0,0])
self.initialize()
def initialize(self):
# Sets up the numbers and operators that move down the screen.
self.answer_numbers = [4, 13, 21, 34, 48, 64, 85, 110] # possible answers for game, ideally will randomize in final game
# Creates objects for each number
self.number_objects = []
for number in range(1,10):
image = self.final_number_font.render(str(number), True, self.chosen_number_colors[number])
new_number = Numbers(self.screen, image, number, False)
self.number_objects.append(new_number)
plus_image = pygame.image.load("plussymbol.png").convert_alpha()
minus_image = pygame.image.load("minussymbol.png").convert_alpha()
multiply_image = pygame.image.load("multiplysymbol.png").convert_alpha()
divide_image = pygame.image.load("dividesymbol.png").convert_alpha()
power_image = pygame.image.load("caret.png").convert_alpha()
# Creates objects for each operator (may remove minus and divide)
self.plus = Operators(self.screen, plus_image, '+', False)
self.minus = Operators(self.screen, minus_image, '-', False)
self.multiply = Operators(self.screen, multiply_image, '*', False)
self.divide = Operators(self.screen, divide_image, '/', False)
self.power = Operators(self.screen, power_image, '^', False)
# A lot of initializations
self.hit_number = False
self.hit_operator = False
self.points = 0
self.temporary_operator = '+' # Initalizes the operator
self.answer_numbers_index = 0 # Defines current answer player strives for. Increments everytime the correct answer is chosen
self.accumulating_answer = 0 # Keeps track of current value user calculates after shooting the numbers and operators.
self.number_operators_used = 0 # Keeps track of number of operators used (for points)
self.random_operator_count = 0 # Determines when operator will appear, spaces them out with
self.random_number_count = 0
self.x = 319
self.y = 350
self.player_ship = Ship(self.screen, self.avatar, self.x, self.y)
self.ships = pygame.sprite.Group()
self.ships.add(self.player_ship)
self.moving_numbers = pygame.sprite.Group()
self.moving_operators = pygame.sprite.Group()
self.moving_laser = LaserFactory(self.screen, self.final_laser_choice)
self.introMenu()
# Conducts operation of inputed values
def Operation(self, temporary_operator, temporary_number_one, temporary_number_two):
if temporary_operator == '+':
return (temporary_number_one + temporary_number_two)
elif temporary_operator == '-':
return (temporary_number_one - temporary_number_two)
elif temporary_operator == '*':
return (temporary_number_one * temporary_number_two)
elif temporary_operator == '/':
return (temporary_number_one / temporary_number_two)
else:
return (temporary_number_one ** temporary_number_two)
def introMenu(self):
self.screen.fill(self.background_color)
font = pygame.font.SysFont('impact', 40)
text = font.render("Arithiga", True, (200, 50, 0))
self.screen.blit(text, (250, 50))
font2 = pygame.font.SysFont('arial', 25)
text2 = font2.render("Press the Space to Start", True, (200, 50, 0))
self.screen.blit(text2, (250, 240))
pygame.display.flip()
while True:
event = pygame.event.wait()
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
self.Directions()
def endGame(self):
self.screen.fill(self.background_color)
end_font = pygame.font.SysFont('arial', 25)
end_text = end_font.render("Game Over", True, (200, 50, 0))
continue_text = end_font.render("Press f to Continue", True, (200, 50, 0))
quit_text = end_font.render("Press q to Quit", True, (200, 50, 0))
self.screen.blit(end_text, (310, 180))
pygame.display.flip()
pygame.time.wait(1100)
self.screen.blit(continue_text, (310, 211))
self.screen.blit(quit_text, (310, 250))
pygame.display.flip()
while True:
event = pygame.event.wait()
if event.type is pygame.KEYDOWN:
if event.key is pygame.K_f:
self.initialization()
if event.key is pygame.K_q:
sys.exit()
if event.type is pygame.QUIT:
sys.exit()
def Directions(self):
self.screen.fill(self.background_color)
directions_font = pygame.font.SysFont('arial', 15)
direction_text = directions_font.render("Move the Mouse to Move the Ship, Press it To Shoot A Laser", True, (200,50,0))
direction_text2 = directions_font.render("Shoot The Numbers and Operators to Get the Given Number!", True, (200, 50, 0))
direction_text3 = directions_font.render("The Less Operators You Use, the More Points You'll Get", True, (200,50,0))
direction_text4 = directions_font.render("You Have Three Lives", True, (200, 50, 0))
self.screen.blit(direction_text, (100, 140))
self.screen.blit(direction_text2, (100, 160))
self.screen.blit(direction_text3, (100, 180))
self.screen.blit(direction_text4, (100, 200))
pygame.display.flip()
while True:
event = pygame.event.wait()
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
self.run()
# Updates info on top of the screen.
def changeInfo(self):
info_font = pygame.font.SysFont('arial', 18)
answer_text = info_font.render("Current Number: " + str(self.answer_numbers[self.answer_numbers_index]), True, (200, 50, 0))
self.screen.blit(answer_text, (325, 40))
number_of_lives_text = info_font.render("Current Lives: " + str(self.player_ship.CurrentLives()), True, (200,50,0))
self.screen.blit(number_of_lives_text, (180, 40))
accumulating_text = info_font.render("Current Result: " + str(self.accumulating_answer), True, (200, 50, 0))
self.screen.blit(accumulating_text, (25, 40))
points_text = info_font.render("Current Points: " + str(self.points), True, (200,50,0))
self.screen.blit(points_text, (490, 40))
# Runs the game
def run(self):
pygame.time.set_timer(pygame.USEREVENT, 50)
self.screen.fill(self.background_color)
while True:
event = pygame.event.wait()
if event.type is pygame.QUIT:
print 'quit'
sys.exit()
# Movement of mouse determines movement of spaceship
if event.type is pygame.MOUSEMOTION:
self.x, self.y = pygame.mouse.get_pos()
self.player_ship.update(self.x, self.y)
# Determines shooting the laser
if event.type is pygame.MOUSEBUTTONDOWN:
self.moving_laser.NewLaser(self.player_ship.XPosition(), self.player_ship.YPosition())
if event.type is not pygame.USEREVENT:
continue
for laser in self.moving_laser.getLasers():
if laser.YPosition() == 80:
self.moving_laser.getLasers().remove(laser)
else:
laser.update()
random_value = int(random() * 9.9) # Randomizes what number appears at the top
random_operator = random() * 5 # Randomizes what operator appears at the top
start_position_operator = 610.0 * random() # Randomizes where the number will appear at the top
start_position_number = 610.0 * random() # Randomizes where the operator will appear at the top
# For loop instead?
self.random_number_count += 1
# Series of if-else statements to initalize movment of a number given the random value
if self.random_number_count == 4:
self.random_number_count = 0
if (not self.number_objects[random_value].moving()):
self.number_objects[random_value].setXPosition(start_position_number)
self.moving_numbers.add(self.number_objects[random_value])
self.number_objects[random_value].toggle()
for number in self.moving_numbers:
if number.YPosition() > 480:
number.reset()
self.moving_numbers.remove(number)
number.toggle()
else:
number.update()
self.random_operator_count += 1 # Increments count
# Initalizes movement of an operator everytime random_operator_count is 3
if self.random_operator_count == 6:
self.random_operator_count = 0
if (not self.plus.moving()) and random_operator > 0 and random_operator <= 1:
self.plus.setXPosition(start_position_operator)
self.moving_operators.add(self.plus)
self.plus.toggle()
elif (not self.minus.moving()) and random_operator > 1 and random_operator <= 2:
self.minus.setXPosition(start_position_operator)
self.moving_operators.add(self.minus)
self.minus.toggle()
elif (not self.multiply.moving()) and random_operator > 2 and random_operator <= 3:
self.multiply.setXPosition(start_position_operator)
self.moving_operators.add(self.multiply)
self.multiply.toggle()
elif (not self.divide.moving()) and random_operator > 3 and random_operator <= 4:
self.divide.setXPosition(start_position_operator)
self.moving_operators.add(self.divide)
self.divide.toggle()
elif (not self.power.moving()) and random_operator > 4 and random_operator <= 5:
self.power.setXPosition(start_position_operator)
self.moving_operators.add(self.power)
self.power.toggle()
for operator in self.moving_operators:
if operator.YPosition() > 480:
operator.reset()
self.moving_operators.remove(operator)
operator.toggle()
else:
operator.update()
# Take into account the first number that is shot, should only occur once
# For every answer
if ((not self.hit_number) and (not self.hit_operator)):
for laser in self.moving_laser.getLasers():
laser_number_collision = pygame.sprite.spritecollide(laser, self.moving_numbers, True)
for number in laser_number_collision:
self.moving_laser.getLasers().remove(laser)
self.accumulating_answer = number.getValue()
number.reset()
number.toggle()
self.hit_number = True
# Shoots operator after hit the number
elif self.hit_number:
if not self.hit_operator:
for laser in self.moving_laser.getLasers():
laser_operator_collision = pygame.sprite.spritecollide(laser, self.moving_operators, True)
for operator in laser_operator_collision:
operator.toggle()
operator.reset()
self.moving_laser.getLasers().remove(laser)
self.temporary_operator = operator.getOperator()
self.hit_operator = True
self.number_operators_used += 1
# Shoot another number
elif self.hit_operator:
for laser in self.moving_laser.getLasers():
laser_number_collision = pygame.sprite.spritecollide(laser, self.moving_numbers, True)
for number in laser_number_collision:
self.moving_laser.getLasers().remove(laser)
self.accumulating_answer = self.Operation(self.temporary_operator, self.accumulating_answer, number.getValue())
number.reset()
number.toggle()
self.hit_operator = False # Only changes operator to false so user can build upon the accumulating number
# Moves on to the next number as an answer if the accumulating_answer equals to the given number.
# Calculates points depending on how many operators are used.
if self.accumulating_answer == self.answer_numbers[self.answer_numbers_index]:
self.accumulating_answer = 0
self.answer_numbers_index += 1
self.hit_number = False
if (self.number_operators_used > 0) and (self.number_operators_used <= 2):
self.points += 100
elif (self.number_operators_used > 2) and (self.number_operators_used <= 5):
self.points += 50
else:
self.points += 25
# Reduce the number of lives everytime the ship hits a number or operator
ship_number_collisions = pygame.sprite.spritecollide(self.player_ship, self.moving_numbers, True)
for number in ship_number_collisions:
print self.player_ship.CurrentLives()
self.player_ship.ReduceLives()
number.toggle()
number.reset()
self.moving_numbers.remove(number)
self.accumulating_answer = 0
self.hit_number = False
self.hit_operator = False
pygame.time.delay(1000)
self.x = 319
self.y = 350
# Reduce the number of lives everytime the ship hits a number or operator
ship_operator_collisions = pygame.sprite.spritecollide(self.player_ship, self.moving_operators, True)
for operator in ship_operator_collisions:
print self.player_ship.CurrentLives()
self.player_ship.ReduceLives()
self.accumulating_answer = 0
operator.toggle()
operator.reset()
self.moving_operators.remove(operator)
self.hit_number = False
self.hit_operator = False
pygame.time.delay(1000)
self.x = 319
self.y = 350
# Ends game when the player runs out of lives
if self.player_ship.CurrentLives() == 0:
break
self.ships.draw(self.screen)
self.moving_numbers.draw(self.screen)
self.moving_operators.draw(self.screen)
self.moving_laser.getLasers().draw(self.screen)
self.changeInfo()
pygame.display.flip()
self.screen.fill(self.background_color)
self.endGame()
