def run(self,msg):
if msg == self.LEFT:
self.nowpos[1] -= 1
if self.__errmove__():
self.nowpos[1] += 1
elif msg == self.RIGHT:
self.nowpos[1] += 1
if self.__errmove__():
self.nowpos[1] -= 1
elif msg == self.STEPDOWN:
self.nowpos[0] += 1
if self.__errmove__():
self.nowpos[0] -= 1
self.freeze()
self.newblock()
elif msg == self.ROTATE:
self.now = Blocks.rotate(self.now)
if self.__errmove__():
self.now = Blocks.undorotate(self.now)
elif msg == self.DOWN:
self.nowpos[0] += 1
while not self.__errmove__():
self.nowpos[0] += 1
else:
self.nowpos[0] -= 1
self.freeze()
self.newblock()
self.clearline()
def compute(self):
"""
Fungsi untuk menghitung karakteristik blok citra
:return: None
"""
print "Step 2/4: Menghitung fitur karakteristik"
imageWidthOverlap = self.imageWidth - self.blockDimension
imageHeightOverlap = self.imageHeight - self.blockDimension
time.sleep(0.1)
if self.isRGB:
for i in tqdm(range(0, imageWidthOverlap + 1, 1)):
for j in range(0, imageHeightOverlap + 1, 1):
imageBlockRGB = self.image.crop(
(i, j, i + self.blockDimension,
j + self.blockDimension))
imageBlockGrayscale = self.imageGrayscale.crop(
(i, j, i + self.blockDimension,
j + self.blockDimension))
imageBlock = Blocks.Blocks(imageBlockGrayscale,
imageBlockRGB, i, j,
self.blockDimension)
self.featureContainer.addBlock(imageBlock.computeBlock())
else:
for i in range(imageWidthOverlap + 1):
for j in range(imageHeightOverlap + 1):
imageBlockGrayscale = self.image.crop(
(i, j, i + self.blockDimension,
j + self.blockDimension))
imageBlock = Blocks.Blocks(imageBlockGrayscale, None, i, j,
self.blockDimension)
self.featureContainer.addBlock(imageBlock.computeBlock())
def block(self, options=Map()):
if self.options.gradient:
color = self.color(options)
if (type(color) == tuple and len(color) == 3) or (type(color)
== str):
block_obj = Blocks.closest_by_color(color,
self.options + options)
else:
error_string = "Error - Texture1D block color (\"" + str(
color) + "\") not recognized"
if Blocks.DEBUG_MODE == 1:
raise ValueError(error_string)
else:
print(error_string)
block_obj = Blocks.block_by_id(0)
else:
if self.blocks and self.chances:
block = weighted_choice(self.chances, self.blocks)
elif self.blocks:
block = rnd.choice(self.blocks)
else:
block = self.material
block_obj = Blocks.block(block)
return block_obj
def compute(self):
"""
To compute the characteristic features of image block
:return: None
"""
print "Step 2 of 4: Computing characteristic features"
imageWidthOverlap = self.imageWidth - self.blockDimension
imageHeightOverlap = self.imageHeight - self.blockDimension
if self.isThisRGBImage:
for i in tqdm(range(0, imageWidthOverlap + 1, 1)):
for j in range(0, imageHeightOverlap + 1, 1):
imageBlockRGB = self.imageData.crop(
(i, j, i + self.blockDimension,
j + self.blockDimension))
imageBlockGrayscale = self.imageGrayscale.crop(
(i, j, i + self.blockDimension,
j + self.blockDimension))
imageBlock = Blocks.Blocks(imageBlockGrayscale,
imageBlockRGB, i, j,
self.blockDimension)
self.featuresContainer.addBlock(imageBlock.computeBlock())
else:
for i in range(imageWidthOverlap + 1):
for j in range(imageHeightOverlap + 1):
imageBlockGrayscale = self.imageData.crop(
(i, j, i + self.blockDimension,
j + self.blockDimension))
imageBlock = Blocks.Blocks(imageBlockGrayscale, None, i, j,
self.blockDimension)
self.featuresContainer.addBlock(imageBlock.computeBlock())
def Decoder(inputTensor, outputSize, blockName):
with tf.variable_scope(blockName):
conv1x1_1 = bs.SmallUniteConvolutionBlock(
inputTensor,
kernalSize=1,
outChannels=128,
gNum=4,
blockName="Conv1x1_Decoder_First_Step")
conv1x1_2 = bs.SmallUniteConvolutionBlock(
conv1x1_1,
kernalSize=1,
outChannels=64,
gNum=4,
blockName="Conv1x1_Decoder_Second_Step")
globalPooling = keras.layers.GlobalAvgPool2D(
data_format="channels_first", name="AVG_Global_Decoder")(conv1x1_2)
weight1 = bf.WeightCreation(shape=[64, 128], name="TransWeight1")
bias1 = tf.constant(value=0.,
dtype=tf.float32,
shape=[128],
name="Bias1")
layer1 = keras.layers.PReLU(trainable=True)(tf.add(
tf.matmul(globalPooling, weight1), bias1))
weight2 = bf.WeightCreation(shape=[128, outputSize],
name="TransWeight2")
bias2 = tf.constant(value=0.,
dtype=tf.float32,
shape=[outputSize],
name="Bias2")
outputTensor = tf.add(tf.matmul(layer1, weight2), bias2)
return outputTensor
def decorate_outside(obj, options=Map()):
obj.points = []
obj.points_edges = []
obj.material_clear = Blocks.AIR
border = flatten_list_of_lists(
[vg.get_line_from_points(l[0], l[1]) for l in options.lines])
if options.options.outside == "flowers":
flowers_1 = []
flowers_2 = []
for i, b in enumerate(border):
# TODO: Refactor to have multiple numbers of flowers
if (i % 2) == 0:
flowers_1.append(b)
else:
flowers_2.append(b)
colors = Blocks.kind("Flower")
np.random.shuffle(colors)
obj.features.append(
Feature("flowers", flowers_1, Map(material=colors[0])))
obj.features.append(
Feature("flowers", flowers_2, Map(material=colors[1])))
elif options.options.outside == "trees":
trees = []
for i, b in enumerate(border):
if (i % 3) == 0:
trees.append(b)
colors = Blocks.kind("Sapling")
np.random.shuffle(colors)
obj.features.append(Feature("flowers", trees, Map(material=colors[0])))
elif options.options.outside == "grass":
trees = []
for i, b in enumerate(border):
if (i % 3) == 0:
trees.append(b)
obj.features.append(
Feature("flowers", trees, Map(material=Blocks.DOUBLETALLGRASS)))
elif options.options.outside == "fence":
fence_type = np.random.random_integers(188, 192)
obj.features.append(Feature("fence", border, Map(material=fence_type)))
return obj
def start(self, level):
self.isover = False
self.next = Blocks.randblock(self.shapen)
self.now = Blocks.randblock(self.shapen)
self.nowpos = [0,self.size[1]/2-2]
for ph in xrange(self.size[0]):
for pw in xrange(self.size[1]):
self.map[ph][pw] = -1
self.level = level
self.line = 0
self.score = 0
def draw_tips(scr,block):
scr.fill(Colors.WHITE)
brect = Blocks.getminirect(block)
lh = brect[2] - brect[0] + 1
lw = brect[3] - brect[1] + 1
sh = (Blocks.BLOCKH - lh) * RECTH / 2 + 10
sw = (Blocks.BLOCKW - lw) * RECTW / 2 + 10
shape = Blocks.getshape(block)
for th in range(lh):
for tw in range(lw):
if shape[brect[0] + th][brect[1] + tw] == 0: continue
rect = [sw + tw * RECTW, sh + th * RECTH, RECTW, RECTH]
draw_rect(scr, Colors.color[block[0]], rect)
def scan(show_location=False):
direction = my_rot()
target = vg.up(my_pos())
# print("Facing:", direction)
if direction == 'w':
x_range = [1]
z_range = [-2, -1, 0, 1, 2]
elif direction == 'e':
x_range = [-1]
z_range = [2, 1, 0, -1, -2]
elif direction == 's':
x_range = [-3, -2, -1, 0, 1]
z_range = [0]
else:
# n
x_range = [-2, -1, 0, 1, 2]
z_range = [-2]
blocks = []
for y in [2, 1, 0, -1, -2]:
text = ""
for x in x_range:
for z in z_range:
new_point = target + V3(x, y, z)
b = mc.getBlockWithData(new_point.x, new_point.y, new_point.z)
name = Blocks.name_by_id(b.id, b.data)
loc = str(new_point.x) + "," + str(new_point.y) + "," + str(
new_point.z) + " : " if show_location else ""
line = "(" + loc + str(b.id) + "," + str(b.data) + ": " + name + ") "
text += line.ljust(28)
blocks.append(b)
print(text)
def __create_blocks(self,file_name):
coil_points = read_and_transform.extract_coil_samples(self.normalized_points)
#print "Tamano coil: %s" %len(coil_points)
#Get file name
temp = file_name.split('/')
lastone = len(temp)
newfile = temp[lastone-1]
csvfile="calib_data/calib_points/"+newfile
#Save file with calib coil_points
with open(csvfile, "w") as output:
writer = csv.writer(output, lineterminator='\n')
writer.writerows([coil_points])
#Generate new coil points
self._create_csv(csvfile)
coil_points=self._create_new_data(coil_points,csvfile)
#print 'Nuevos datos coil'
#print coil_points
#Generate blocks to visualize
blocks_indices = Blocks.get_blocks(coil_points, 7)
# remove small blocks
blocks_indices = filter(lambda x: len(x) > 5, blocks_indices)
blocks = []
for bi in blocks_indices:
#print 'Creating blocks'
points = [coil_points[i] for i in bi]
b = TmsBlock(points)
b.calculate_sphere_intersection(self.sphere_radius, self.sphere_center)
b.find_hemisphere(self.calibration_points, self.sphere_center)
blocks.append(b)
self.blocks = blocks
def freeze(self):
shape = Blocks.getshape(self.now)
for tph in range(Blocks.BLOCKH):
for tpw in range(Blocks.BLOCKW):
if shape[tph][tpw] == 0: continue
ph = self.nowpos[0] + tph
pw = self.nowpos[1] + tpw
self.map[ph][pw] = self.now[0]
def __errmove__(self):
shape = Blocks.getshape(self.now)
for tph in range(Blocks.BLOCKH):
for tpw in range(Blocks.BLOCKW):
if shape[tph][tpw] == 0: continue
if self.nowpos[0]+tph < 0: return True
if self.nowpos[1]+tpw < 0: return True
if self.nowpos[0]+tph >= self.size[0]: return True
if self.nowpos[1]+tpw >= self.size[1]: return True
if self.map[self.nowpos[0]+tph][self.nowpos[1]+tpw] != -1: return True
return False
def build_map_array(self):
""" Bulding this array of cells helps programming movement
and space indications."""
map_array = []
border_list = []
B_unbreakable_list = []
B_breakable_list = []
for column in range(0, 25): # Adds top and bottom borders.
border_list.append([column, 0])
border_list.append([column, 18])
for row in range(1, 18): # Adds left and right borders.
border_list.append([0, row])
border_list.append([24, row])
for x in range(0, 25):
for y in range(0, 19):
if [x, y] in border_list:
"""
Creates array based on x and y values in
for and fills them with solid blocks if the
cells are inside of the 'border_list' list,
making them incapable of being stepped on.
"""
map_array.append(Cells.Cells([x, y], Blocks.Blocks()))
elif (x % 2) == 0 and (y % 2) == 0:
map_array.append(
Cells.Cells([x, y], Blocks.B_unbreakable()))
B_unbreakable_list.append([x, y])
else:
if x > 3 and y > 3:
B_breakable_list.append([x, y])
map_array.append(Cells.Cells([x, y], None))
B_breakable_list = random.choices(B_breakable_list, k=60)
for cell in range(len(B_breakable_list)):
for cell2 in range(len(map_array)):
if map_array[cell2].position == B_breakable_list[cell]:
map_array[cell2].content = Blocks.B_breakable()
self.map_array = map_array
self.B_unbreakable_list = B_unbreakable_list
self.B_breakable_list = B_breakable_list
def __Decoder_Net_Build(self,mediumActiveMap):
with tf.variable_scope("DECODER"):
mediumActiveMap_2 = bs.SmallResBlockWith2xUpSampling(mediumActiveMap,kernelSize=1,gNum=4,outChannels=512,
blockName="ActiveMap2xUp")
mediumActiveMap_4 = bs.SmallResBlockWith2xUpSampling(mediumActiveMap_2,kernelSize=2,gNum=4,outChannels=256,
blockName="ActiveMap4xUp")
mediumActiveMap_8 = bs.SmallResBlockWith2xUpSampling(mediumActiveMap_4,kernelSize=3,gNum=4,outChannels=128,
blockName="ActiveMap8xUp")
mediumActiveMap_16 = bs.SmallResBlockWith2xUpSampling(mediumActiveMap_8,kernelSize=4,gNum=4,outChannels=64,
blockName="ActiveMap16xUp")
self.ActivityMap = bs.SmallResBlockWith2xUpSampling(mediumActiveMap_16,kernelSize=5,gNum=4,outChannels=32,
blockName="ActiveMap32xUp")
print("Activity Map :",self.ActivityMap)
globalPoolingTensor = keras.layers.GlobalAveragePooling2D(name="FinalGlobalAVGPooling")(self.ActivityMap)
self.ActivityWeight = tf.get_variable(name="ActivityWeights" , shape=[32 , self.__outLabelNum],
dtype=tf.float32,
initializer=tf.truncated_normal_initializer(
stddev=math.pow(1.25 / np.sum([32 , self.__outLabelNum]),0.5))
,trainable=True)
self.Final_D_OUT = tf.matmul(globalPoolingTensor,self.ActivityWeight,name="FinalOp")
print("Final Output :",self.Final_D_OUT)
def decorate_roof(obj, options=Map()):
settings = options.options
if not settings.roof:
return obj
material = Blocks.match(settings.roof_material)
if material:
obj.material = material
if str.startswith(settings.roof, "pointy"):
height = settings.roof_pointy_multiplier * options.radius
pointy = V3(options.center.x,
options.center.y + options.height + height,
options.center.z)
for i, vec in enumerate(options.corner_vectors):
roof_line = vg.getLine(vec.x, vec.y + 1, vec.z, pointy.x,
pointy.y + 1, pointy.z)
obj.points_edges += roof_line
if not settings.roof == "pointy_lines":
next_roof_point = options.corner_vectors[(i + 1) % len(
options.corner_vectors)]
# Triangle to pointy face
triangle_face = [vec, pointy, next_roof_point]
roof_face = vg.unique_points(
vg.getFace([V3(v.x, v.y + 1, v.z) for v in triangle_face]))
obj.points = obj.points.union(roof_face)
elif str.startswith(settings.roof, "triangular"):
obj.decorations.append("roof_triangular")
elif str.startswith(settings.roof, "battlement"):
height = settings.roof_battlement_height or 1
spacing = settings.roof_battlement_space or 2
for i, vec in enumerate(options.corner_vectors):
next_roof_point = options.corner_vectors[(i + 1) % len(
options.corner_vectors)]
# TODO: Add X,Z outward from center as option
roof_line = vg.getLine(vec.x, vec.y + height, vec.z,
next_roof_point.x,
next_roof_point.y + height,
next_roof_point.z)
obj.points = obj.points.union(
vg.points_spaced(roof_line, Map(every=spacing)))
elif str.startswith(settings.roof, "shape"):
obj.decorations.append("roof_floating_shape")
return obj
def Encoder(inputTensor, outputChannels, blockName):
with tf.variable_scope(blockName):
conv1x1_1 = bs.SmallUniteConvolutionBlock(
inputTensor,
kernalSize=1,
outChannels=64,
gNum=4,
blockName="Conv1x1_Encoder_First_Step")
Transformer_E_2 = bs.TransformerEncoderBlock(
conv1x1_1,
outputChannels=64,
blockName="Transformer_Encoder_Second_Step")
conv1x1_3 = bs.TransChannelsConvolutionBlock(
Transformer_E_2,
kernalSize=1,
outChannels=outputChannels,
blockName="Conv1x1_Encoder_Third_Step")
pool_Down = bf.Pooling(conv1x1_3,
windowShape=[2, 2],
poolingType="MAX",
stride=[2, 2],
name="Pooling_Encoder_Fourth_Step")
return conv1x1_1, Transformer_E_2, conv1x1_3, pool_Down
def hex_to_rgb(color):
""" "#FFFFFF" -> [255,255,255] '''
Note: Pass 16 to the integer function for change of base"""
try:
# out = [int(hex[i:i+2], 16) for i in range(1,6,2)]
out_rgb = Blocks.color_as_rgb(color)
out = [out_rgb[0], out_rgb[1], out_rgb[2]]
except ValueError:
print("Hex invalid", color)
out = color
return out
def color(self, options=Map()):
options = self.options + options
if self.options.gradient:
hex_colors = self.get_calculated_steps(options)
if options.step:
step = options.step
elif options.point and options.bounds:
if self.axis == "y":
bounds_lowest = options.bounds.lowest
# bounds_highest = options.bounds.highest
step = options.point.y - bounds_lowest
elif self.axis == "x":
bounds_lowest = options.bounds.x_low
# bounds_highest = options.bounds.x_high
step = options.point.x - bounds_lowest
else:
# if self.axis == "z":
bounds_lowest = options.bounds.z_low
# bounds_highest = options.bounds.z_high
step = options.point.z - bounds_lowest
step = int(step)
# step_range = bounds_highest - bounds_lowest + 1
# step = dist_from_low
else:
step = 0
if "hex" in hex_colors:
hex_colors = hex_colors["hex"]
if step > len(hex_colors) - 1:
step = len(hex_colors) - 1
elif step < 0:
step = 0
return hex_colors[step]
else:
if self.blocks and self.chances:
block = weighted_choice(self.chances, self.blocks)
elif self.blocks:
block = rnd.choice(self.blocks)
else:
block = self.material
block_obj = Blocks.block(block)
return block_obj["main_color"]
def draw_blocks(scr, size, gamemap, block = None, blockpos = None):
scr.fill(Colors.WHITE)
for ph in xrange(size[0]):
for pw in xrange(size[1]):
if gamemap[ph][pw] == -1: continue
draw_rect(scr, Colors.color[gamemap[ph][pw]], block_rect(ph,pw))
if block != None and blockpos != None:
shape = Blocks.getshape(block)
for tph in range(Blocks.BLOCKH):
for tpw in range(Blocks.BLOCKW):
if shape[tph][tpw] == 0: continue
ph = blockpos[0] + tph
pw = blockpos[1] + tpw
if ph < 0 or ph > size[0]: continue
if pw < 0 or pw > size[1]: continue
draw_rect(scr, Colors.color[block[0]], block_rect(ph,pw))
def decorate_roof_shape(obj, options=Map()):
settings = options.options
if settings.roof_shape_color_pattern == "RainbowGlass":
material = Texture1D.COMMON_TEXTURES.RainbowGlass
elif settings.roof_shape_color_pattern == "OldStoneWall":
material = Texture1D.COMMON_TEXTURES.OldStoneWall
elif settings.roof_shape_color_pattern == "WoodBlends":
material = Texture1D.COMMON_TEXTURES.WoodBlends
elif settings.roof_shape_color_pattern == "Glow":
material = Texture1D.COMMON_TEXTURES.Glow
else:
material = Blocks.match(settings.roof_material)
if not material:
material = obj.material
boundaries = vg.bounds(options.corner_vectors)
min_radius = min(boundaries.x_radius, boundaries.z_radius)
pos = boundaries.center
if settings.roof_shape_object == "cylinder":
func = vg.cylinder
height = min_radius * (settings.roof_shape_height_multiplier or 1)
elif settings.roof_shape_object == "cone":
func = vg.cone
height = min_radius * (settings.roof_shape_height_multiplier or 1)
elif settings.roof_shape_object == "box":
func = vg.box
height = min_radius * (settings.roof_shape_height_multiplier or 1)
else: # sphere
func = vg.oblate_sphere
height = None
if settings.roof_shape_floating:
pos = vg.up(boundaries.center, min_radius)
sides = func(pos, min_radius, tight=settings.roof_shape_tight, height=height,
options=Map(min_y_pct=.5, x_radius=boundaries.x_radius, z_radius=boundaries.z_radius))
roof_lists = list()
roof_lists.append(Map(blocks=sides, material=material))
obj.features.append(Feature("roof", boundaries.center, Map(block_lists=roof_lists)))
obj.points_edges = []
return obj
def set_options(self, options=Map()):
self.options = options
if options.gradient:
self.axis = options.gradient_axis or "y"
self.gradient_type = options.gradient_type or "linear"
self.colors_names = options.colors or rand_hex_color(2)
self.colors = [
Blocks.color_as_rgb(color_name)
for color_name in self.colors_names
]
elif options.blocks:
self.blocks = options.blocks
if options.chances:
self.chances = options.chances
else:
self.material = options.color or options.material or rand_hex_color(
1)
def decorate_roof_triangular(obj, options=Map()):
settings = options.options
material = Blocks.match(settings.roof_material)
if material:
obj.material = material
p1, p2, radius, ends, sides = vg.best_points_for_triangular_roof(
options.corner_vectors)
chop_pct = settings.roof_triangular_chop_pct or 0
radius += settings.roof_triangular_overhang
height = radius
if round(height) == int(height):
height += 1
if settings.roof_triangular_stairs or settings.roof_triangular_end_cap_in:
# It's a more complex roof, build it as a Feature
roof_lists = vg.prism_roof(
p1,
p2,
height=height,
radius=radius,
chop_pct=chop_pct,
sloped=settings.roof_triangular_sloped,
material=obj.material,
endpoint_out=settings.roof_triangular_end_cap_out)
obj.features.append(Feature("roof", p1, Map(block_lists=roof_lists)))
else:
# Nothing fancy, color each block all the same type
roof = vg.triangular_prism(p1,
p2,
height=height,
radius=radius,
chop_pct=chop_pct,
sloped=settings.roof_triangular_sloped)
obj.points.update(roof)
obj.points_edges = []
return obj
def compute(self):
"""
To compute the characteristic features of image block
:return: None
"""
print("Step 2 of 4: Computing feature vectors")
for i in tqdm(range(0, self.imageWidth, self.blockDimension)):
# print (i)
for j in range(0, self.imageHeight, self.blockDimension):
imageBlockRGB = self.imageData.crop(
(i, j, i + self.blockDimension, j + self.blockDimension))
imageBlockGrayscale = self.imageGrayscale.crop(
(i, j, i + self.blockDimension, j + self.blockDimension))
imageBlock = Blocks.Blocks(imageBlockGrayscale, imageBlockRGB,
i, j, self.blockDimension)
keypoints, descriptors = imageBlock.computeBlock()
self.blockPairContainer.addBlock([i, j])
self.featuresContainerKeypoints.addBlock(keypoints)
self.featuresContainerDescriptors.addBlock(descriptors)
def __init__(self, x, y):
Blocks.__init__(x,y)
def main(time1):
pygame.init()
run = True
screen = pygame.display.set_mode(DISPLAY)
pygame.display.set_caption('Labirint')
bg = Surface((WIN_WIDTH, WIN_HEIGHT))
bg.fill(Color(BACKGROUND_COLOR))
left = right = up = down = False
entities = pygame.sprite.Group()
entities_exit = pygame.sprite.Group()
pf_exit = []
platforms = []
level = [
"----------------------------------------",
"- - - -",
"- -- --------------- - -- ------ -",
"- - - - - - - -",
"- -- - - - ------- - - - - -",
"- - - - - - - - - -",
"- - - - ---- - - - -",
"- - - - ------------------- -",
"- - ------ - -- -",
"--- - - ---- - -----------",
"- - - - - - -",
"- - - ----- - ----- - -",
"- - - ------------- -",
"- - --------- ------- - -",
"- - --------------- -",
"- ---- -------------- - -",
"- - - ---------- -",
"- -------------------- - ---",
"- - - - - -- ----- - -",
"-------- - - - - - - - - -",
"- - - - - - - - - ------ -",
"- - - - - - - - - - -",
"- - - - - - --------- -",
"- ----- ------------ --- -",
"- --------",
"- --- --------------------------- -",
"- - -- - - -",
"- - --- ---- ------- - - ---- -",
"- -- -- - - - - - - -",
"- - ------- - - - - - - -",
"- - - - ------ - - - - - -",
"- - - - - - ---- - -- - - - -",
"- - - - - - --- - - - -",
"- - - - - - -- ---- - - - -",
"- - - - - - -------- -",
"- - - - - - - ----- -",
"- - - - - - - ---- ---- -",
"- - - ------ --- - ---- - --- -",
"- - - -",
"----------------------------------------"
]
start_x = start_y = x = y = q = i = 0
k1 = int(random.uniform(1, 38))
while k1 == 3 or k1 == 31:
k1 = int(random.uniform(1, 38))
k2 = int(random.uniform(1, 38))
while k2 == 12 or k2 == 23:
k2 = int(random.uniform(1, 38))
for row in level:
for col in row:
if col == "-" and q == k1 and i == 0:
pf_exit = Blocks.Platform(x, y)
entities_exit.add(pf_exit)
elif col == "-" and q == k2 and i == 39:
start_x = x
start_y = y
pf = Blocks.Platform(x, y)
entities.add(pf)
platforms.append(pf)
elif col == "-":
pf = Blocks.Platform(x, y)
entities.add(pf)
platforms.append(pf)
x += PLATFORM_WIDTH
q += 1
y += PLATFORM_HEIGHT
q = 0
x = 0
i += 1
movements = 0
font = pygame.font.SysFont('arial', 30)
hero = Player_L.Player(start_x, start_y - 15, run, COLOR)
entities.add(hero)
entities_exit.add(hero)
while run:
time = pygame.time.get_ticks() // 1000 - time1
clock.tick(60)
for e in pygame.event.get():
if e.type == QUIT or (e.type == KEYDOWN and e.key == K_q):
raise SystemExit
if e.type == KEYDOWN and e.key == K_a:
time1 = pygame.time.get_ticks() // 1000
main(time1)
if e.type == KEYDOWN and e.key == K_UP:
up = True
movements += 1
if e.type == KEYDOWN and e.key == K_LEFT:
left = True
movements += 1
if e.type == KEYDOWN and e.key == K_RIGHT:
right = True
movements += 1
if e.type == KEYDOWN and e.key == K_DOWN:
down = True
movements += 1
if e.type == KEYUP and e.key == K_LEFT:
left = False
if e.type == KEYUP and e.key == K_RIGHT:
right = False
if e.type == KEYUP and e.key == K_UP:
up = False
if e.type == KEYUP and e.key == K_DOWN:
down = False
screen.blit(bg, (0, 0))
hero.update(left, right, up, down, platforms, pf_exit)
if hero.run == False:
run = False
entities.draw(screen)
text_m2 = font.render(str(movements), 1, (50, 205, 50))
text_m1 = font.render("шаги:", 1, (50, 205, 50))
text_time1 = font.render("время:", 1, (50, 205, 50))
text_time2 = font.render(str(time), 1, (50, 205, 50))
text_finish = font.render("Чтобы завершить игру нажмите q", 1,
(50, 205, 50))
text_repeat = font.render("Чтобы начать игру заново нажмите a", 1,
(50, 205, 50))
place_m2 = text_m2.get_rect(center=(585, 620))
place_m1 = text_m1.get_rect(center=(540, 620))
place_time1 = text_time1.get_rect(center=(530, 660))
place_time2 = text_time1.get_rect(center=(610, 660))
place_finish = text_finish.get_rect(center=(300, 700))
place_repeat = text_finish.get_rect(center=(300, 750))
screen.blit(text_m1, place_m1)
screen.blit(text_m2, place_m2)
screen.blit(text_time1, place_time1)
screen.blit(text_time2, place_time2)
screen.blit(text_finish, place_finish)
screen.blit(text_repeat, place_repeat)
pygame.display.update()
while True:
clock.tick(60)
font = pygame.font.SysFont('arial', 20)
screen.blit(bg, (0, 0))
text_end = font.render(
"Вы выйграли,нажмите а, чтобы начать сначала или q, чтобы выйти",
1, (50, 205, 50))
place_end = text_end.get_rect(center=(300, 400))
screen.blit(text_end, place_end)
for e in pygame.event.get():
if e.type == QUIT or (e.type == KEYDOWN and e.key == K_q):
raise SystemExit
if e.type == KEYDOWN and e.key == K_a:
time1 = pygame.time.get_ticks() // 1000
main(time1)
pygame.display.update()
entities.add(player)
level = [
"- ", "- - ",
"- ------ ", "- - ",
"- - ---", "-- -- --- ----------",
"-------------------------"
]
bg = pygame.image.load('/home/vovek/PythonGame/assets/fon.jpg')
clock = pygame.time.Clock()
x = y = 0
for row in level:
for col in row:
if col == '-':
block = Blocks.Blocks((50, 50, 50), x, y)
entities.add(block)
blocks.append(block)
x += Blocks.Blocks_Width
y += Blocks.Blocks_Height
x = 0
def play_music():
pygame.mixer.music.load('/home/vovek/PythonGame/music/Led')
pygame.mixer.music.set_volume(0.45)
pygame.mixer.music.play(-1, 0.0)
def drawWindow():
def find_block_info(material, data=None, options=Map()):
if type(material) == list:
global BLOCK_DRAW_INCREMENTER
if options.choice_type == "rotate":
block_id = BLOCK_DRAW_INCREMENTER % (len(material))
material = material[block_id]
BLOCK_DRAW_INCREMENTER += 1
elif options.choice_type == "rebound":
group = math.ceil(BLOCK_DRAW_INCREMENTER / (len(material)))
block_id = BLOCK_DRAW_INCREMENTER % (len(material))
if group % 2 == 0:
block_id = len(material) - 1 - block_id
material = material[block_id]
BLOCK_DRAW_INCREMENTER += 1
else: # Random
material = np.random.choice(material)
elif type(material) == Texture1D.Texture1D:
block_obj = material.block(options=options)
data = block_obj["data"]
material = block_obj["id"]
elif type(material) == Map and "id" in material:
data = material["data"] if "data" in material else None
material = material["id"]
elif type(material) == tuple:
if len(material) == 2:
data = material[1]
material = material[0]
elif len(material) == 3:
block_color = Blocks.closest_by_color(material)
data = block_color["data"]
material = block_color["id"]
if type(material) == dict:
block_id = material["id"]
data = material["data"] or data or None
material = block_id
if type(material) == tuple and len(material) == 2:
material, data = material
if material is None:
print("ERROR - material is None")
elif type(material) == Map:
print("ERROR - Map material passed in:", material)
elif type(material) == block.Block:
material = material.id
else:
try:
material = int(material)
except:
print("ERROR CONVERTING MATERIAL", type(material))
if type(data) == Map:
print("ERROR - Map material Data passed in:", data)
elif data is None:
# do nothing
pass
if data is not None:
data = int(data)
return material, data
import Blocks
# define a variable that contains the name of your image file
input_image_file = 'mountain.jpg'
#define a variable that contains the name of output file
output_image_file = 'mountain_out.jpg'
# open your input file for binary read with the 'with' statement
with open(input_image_file, 'rb') as infile:
# read the contents of the file into a variable
file_contents = infile.read()
# pass the contents to Blocks.start() as a parameter, the result should
# be stored in a new variable
new_contents = Blocks.start(file_contents)
# open a file for binary write with the 'with' statement
with open(output_image_file, 'wb') as outfile:
# write the new contents to the output file
outfile.write(new_contents)
def newblock(self):
if self.isover: return
self.now = self.next
self.next = Blocks.randblock(self.shapen)
self.nowpos = [0,self.size[1]/2-2]
if self.__errmove__(): self.isover = True
def __init__(self, x, y):
Blocks.__init__(x, y)
from Enemy import *
from Person import *
from getchunix import *
from Wall import *
from Board import *
from alarmexception import *
getch = GetchUnix()
'''
The following code initializes the Game
'''
bomb = None
b = board()
Board = b.makeBoard()
wall = Wall()
wall.insertWall(Board)
blocks = Blocks()
player = Bomberman()
blocks.insertBlocks(Board, player)
player.placeBomberman(player.getX(), player.getY(), Board)
enemy = Enemy()
enemy.generateEnemy(Board, enemy.getNumEnemies())
def hello():
print("Hello")
def alarmHandler(signum, frame):
raise AlarmException
def __Encoder_Net_Build(self):
with tf.variable_scope("ENCODER"):
######################
### Bottom to Up
######################
### 32 channels
with tf.variable_scope("C1_Block"):
C1_M = bs.SmallUniteConvolutionBlock(self.inPlaceHolder, kernalSize=8,
outChannels=16, gNum=4, blockName="Initial_Conv6x6_C1")
C1_M = bs.MimicTransformerEncoder(C1_M,outputChannels=32,blockName="Transformer_0")
self.C1 = C1 = bf.Pooling(C1_M, windowShape=[2, 2], poolingType="AVG", stride=[2, 2],
padding="VALID", name="DownSampling_1")
print("C1 ",C1)
### 64 channels
with tf.variable_scope("C2_Block"):
C2_M = bs.SmallUniteConvolutionBlock(C1,kernalSize=4,
outChannels=32,gNum=4,blockName="Initial_Conv5x5_C2")
C2_M = bs.MimicTransformerEncoder(C2_M, outputChannels=64, blockName="Transformer_1")
self.C2 = C2 = bf.Pooling(C2_M, windowShape=[2, 2], poolingType="MAX", stride=[2, 2],
padding="VALID", name="DownSampling_2")
print("C2 ",C2)
### 128 channels
with tf.variable_scope("C3_Block"):
C3_M = bs.SmallUniteConvolutionBlock(C2,kernalSize=4,
outChannels=64,gNum=4,blockName="Initial_Conv4x4_C3")
C3_M = bs.MimicTransformerEncoder(C3_M, outputChannels=128, blockName="Transformer_2")
self.C3 = C3 = bf.Pooling(C3_M, windowShape=[2, 2], poolingType="MAX", stride=[2, 2],
padding="VALID", name="DownSampling_3")
print("C3 ",C3)
### 256 channels
with tf.variable_scope("C4_Block"):
C4_M = bs.SmallUniteConvolutionBlock(C3,kernalSize=2,
outChannels=128,gNum=4,blockName="Initial_Conv3x3_C4")
C4_M = bs.MimicTransformerEncoder(C4_M, outputChannels=256, blockName="Transformer_3")
self.C4 = C4 = bf.Pooling(C4_M, windowShape=[2, 2], poolingType="MAX", stride=[2, 2],
padding="VALID", name="DownSampling_4")
print("C4 ",C4)
### 512 channels
with tf.variable_scope("C5_Block"):
C5_M = bs.SmallUniteConvolutionBlock(C4,kernalSize=1,
outChannels=256,gNum=4,blockName="Initial_Conv2x2_C5")
C5_M = bs.MimicTransformerEncoder(C5_M, outputChannels=512, blockName="Transformer_5")
self.C5 = C5 = bf.Pooling(C5_M, windowShape=[2, 2], poolingType="MAX", stride=[2, 2],
padding="VALID", name="DownSampling_5")
print("C5 ",C5)
#####################
### Up to Bottom
#####################
### 512
with tf.variable_scope("P5_Block"):
self.P5 = P5_Out = bs.SmallUniteConvolutionBlock(C5, kernalSize=1,
outChannels=512, gNum=4, blockName="P5_Out")
print("P5 ",P5_Out)
### 256
with tf.variable_scope("P4_Block"):
P5_Trans = bs.TransChannelsConvolutionBlock(P5_Out, kernalSize=1, outChannels=256
, blockName="P5_Trans")
P5_Up = keras.layers.UpSampling2D(size=(2, 2),
name="UpSam_P5")(P5_Trans)
P4_M = bs.SmallUniteConvolutionBlock(C4, kernalSize=1, outChannels=256, gNum=4,
blockName="P4_M")
self.P4 = P4_Out = tf.add(P4_M, P5_Up, name="P4_Out")
print("P4 ",P4_Out)
### 128
with tf.variable_scope("P3_Block"):
P4_Trans = bs.TransChannelsConvolutionBlock(P4_Out, kernalSize=1, outChannels=128,
blockName="P4_Trans")
P4_Up = keras.layers.UpSampling2D(size=(2, 2),
name="UpSam_P4")(P4_Trans)
P3_M = bs.SmallUniteConvolutionBlock(C3, kernalSize=1, outChannels=128, gNum=4,
blockName="P3_M")
self.P3 = P3_Out = tf.add(P4_Up, P3_M, name="P3_Out")
print("P3 ",P3_Out)
### 64
with tf.variable_scope("P2_Block"):
P3_Trans = bs.TransChannelsConvolutionBlock(P3_Out, kernalSize=1, outChannels=64,
blockName="P3_Trans")
P3_Up = keras.layers.UpSampling2D(size=(2, 2),
name="UpSam_P3")(P3_Trans)
P2_M = bs.SmallUniteConvolutionBlock(C2, kernalSize=1, outChannels=64, gNum=4,
blockName="P2_M")
self.P2 = P2_Out = tf.add(P3_Up, P2_M, name="P2_Out")
print("P2 ",P2_Out)
##########################
### sub process
##########################
with tf.variable_scope("P2_D_Block"):
P2_D = bs.SmallResBlockWithAVG2xDownSampling(self.P2,kernalSize=4,gNum=4,
outChannels=64,blockName="P2_D_C1")
P2_D = bs.SmallResBlockWithAVG2xDownSampling(P2_D,kernalSize=3,gNum=4,
outChannels=128,blockName="P2_D_C2")
P2_D = bs.SmallResBlockWithAVG2xDownSampling(P2_D,kernalSize=2,gNum=4,
outChannels=256,blockName="P2_D_C3")
self.P2_D_OUT = bs.SmallUniteConvolutionBlock(P2_D, kernalSize=1,
outChannels=512, gNum=4, blockName="P2_D_C4")
with tf.variable_scope("P3_D_Block"):
P3_D = bs.SmallResBlockWithAVG2xDownSampling(self.P3,kernalSize=3,gNum=4,
outChannels=128,blockName="P3_D_C1")
P3_D = bs.SmallResBlockWithAVG2xDownSampling(P3_D,kernalSize=2,gNum=4,
outChannels=256,blockName="P3_D_C2")
self.P3_D_OUT = bs.SmallUniteConvolutionBlock(P3_D,kernalSize=1,outChannels=512,
gNum=4,blockName="P3_D_C3")
with tf.variable_scope("P4_D_Block"):
P4_D = bs.SmallResBlockWithAVG2xDownSampling(self.P4,kernalSize=2,gNum=4,
outChannels=256,blockName="P4_D_C1")
self.P4_D_OUT = bs.SmallUniteConvolutionBlock(P4_D,kernalSize=1,outChannels=512,gNum=4,
blockName="P4_D_C2")
with tf.variable_scope("P5_D_Block"):
self.P5_D_OUT = bs.SmallUniteConvolutionBlock(self.P5,kernalSize=1,outChannels=512,gNum=4,
blockName="P5_D_C1")
with tf.variable_scope("ImagesAdd"):
###2
p2_weight = tf.Variable(initial_value=1.,dtype=tf.float32,name="p2_weight")
p2_trans = tf.nn.sigmoid(p2_weight)
p2_weight_out = tf.scalar_mul(scalar=p2_trans,x=self.P2_D_OUT)
###3
p3_weight = tf.Variable(initial_value=1.,dtype=tf.float32,name="p3_weight")
p3_trans = tf.nn.sigmoid(p3_weight)
p3_weight_out = tf.scalar_mul(scalar=p3_trans,x=self.P3_D_OUT)
###4
p4_weight = tf.Variable(initial_value=1.,dtype=tf.float32,name="p4_weight")
p4_trans = tf.nn.sigmoid(p4_weight)
p4_weight_out = tf.scalar_mul(scalar=p4_trans,x=self.P4_D_OUT)
###5
p5_weight = tf.Variable(initial_value=1.,dtype=tf.float32,name="p5_weight")
p5_trans = tf.nn.sigmoid(p5_weight)
p5_weight_out = tf.scalar_mul(scalar=p5_trans,x=self.P5_D_OUT)
mediumActiveMap = tf.concat(values=[p2_weight_out,p3_weight_out,p4_weight_out,p5_weight_out],axis=-1
,name = "FinalConcatInfor")
return mediumActiveMap
#======打印训练集和测试集的大小======
print('train size: %s ,test size:%s' % (len(train_x), len(test_x)))
#======分批次 每个批次取100张======
batch_size = 100 #批的大小
num_batch = len(train_x) // batch_size #完整地把训练集训练完，至少需要多少批
#======占位符======
x = tf.placeholder(tf.float32, [None, size, size, 3]) #占位符，图片
y_ = tf.placeholder(tf.float32, [None, 2]) #占位符，标签
keep_prob_5 = tf.placeholder(tf.float32)
keep_prob_75 = tf.placeholder(tf.float32)
#======网络======
Conv1 = Blocks.Conv(x, 3, 1, 32, keep_prob_5)
Conv2 = Blocks.Conv(Conv1, 3, 1, 64, keep_prob_5)
Conv3 = Blocks.Conv(Conv2, 3, 1, 64, keep_prob_5)
#print(Conv3.shape)
Conv3 = tf.reshape(
Conv3,
[-1, int(Conv3.shape[1]) * int(Conv3.shape[2]) * int(Conv3.shape[3])])
#print(Conv3.shape)
Affine = Blocks.Affine(Conv3, int(Conv3.shape[1]), 512, keep_prob_75)
Output = Blocks.Output(Affine, 512, 2)
#======损失函数======
#print(Output.shape)
#print(y_.shape)
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=Output, labels=y_))
