def create_level(self):
"""Convert a list of points to a the level circuit"""
thickness = 10 # thickness of the grass
friction = 2 # friction of the grass
noise=perlin.Perlin(25)
# Points to create the map.
self.points = [[-20,SCREEN_HEIGHT]]
for x in range(100):
self.points.append([(x-1)*60, (noise.valueAt(x) * 200) +470])
self.points[-1][1] = SCREEN_HEIGHT
# create the circuit
for i in range(1, len(self.points)):
body = pymunk.Body(body_type=pymunk.Body.KINEMATIC)
floor = pymunk.Segment(body, (self.points[i-1][0], self.points[i-1][1]), (self.points[i][0], self.points[i][1]), thickness)
#floor = pymunk.Segment(body, (x+points[i-1][0]*2, y+points[i-1][1]), (x+points[i][0]*2, y+points[i][1]), thickness)
floor.friction = friction
floor.elasticity = 0.5
space.add(body, floor)
# create the points for the sky
self.sky_points = self.points
self.sky_points.insert(0, ([0,0]))
self.sky_points.append([self.points[-1][0]+SCREEN_WIDTH,SCREEN_HEIGHT])
self.sky_points.append([self.sky_points[-1][0],0])
def gouradRing(render, x, y, **kwargs):
w,v,u = kwargs["bar"]
nA, nB, nC = kwargs["normales"]
luz = kwargs["light"]
normx = nA.x*w + nB.x*v + nC.x*u
normy = nA.y*w + nB.y*v + nC.y*u
normz = nA.z*w + nB.z*v + nC.z*u
vnormal = Vector3(normx, normy, normz)
intensity = prodPunto(vnormal, luz)
if intensity < 0:
intensity =0
elif intensity >1:
intensity =1
intensity *= 2
# color de anillo
ring = (107,109,96)
pnoise = p.Perlin()
for m in range(800):
for n in range(800):
col = [int((pnoise.value(x/200.0, y/200.0, 0)+1) *200), ] *3
mul = [int((ring[0]/255.0*col[0])* intensity),int((ring[1]/255.0*col[1])* intensity),
int((ring[2]/255.0*col[2])* intensity)]
if mul[0] < 0: mul[0] =0
if mul[1] < 0: mul[1] = 0
if mul[2] < 0: mul[2] = 0
return color(mul[0], mul[1], mul[2])
def getTerrain(size, vertices, regions, cell_type, dist_to_coast, seed=None):
if seed is None:
seed = datetime.now().microsecond
print("Calculating large-scale terrain...")
print("Large-scale terrain seed: %d" % seed)
np.random.seed(seed)
noise = perlin.Perlin(size, 2, 3)
elevations = [noise[v] for v in vertices]
min_elevation = min(elevations)
elevations = [(el - min_elevation)**2 * dc**0.2 if dc >= 0 else -1
for el, dc in zip(elevations, dist_to_coast)]
max_elevation = max(elevations)
colors = [
np.mean(np.array(elevations)[r]) / max(elevations) * (1-LAND) + LAND
if cell_type[i] == LAND
else cell_type[i]
for i, r in enumerate(regions)
]
return colors
def __init__(self, width, height, scale, octaves, persistence):
self._width = width
self._height = height
self._scale = scale
self._octaves = octaves
self._persistence = persistence
self._gen = perlin.Perlin(self.octaves, self.persistence)
def show_perlin_noise():
noise=perlin.Perlin(15)
time=[i for i in range(200)]
values=[noise.valueAt(i) for i in time]
plt.title("Perlin Noise")
plt.xlabel("Time")
plt.ylabel("Value")
plt.plot(time, values)
plt.show()
def graph(intensity):
noise=perlin.Perlin(intensity)
time=[i for i in range(100)]
values=[noise.valueAt(i) for i in time]
titlestring = "Average "+words[0][random.randint(0,len(words[0]))]+" size by age in the UK"
plt.title(titlestring)
plt.xlabel("Age")
plt.ylabel("Size")
plt.plot(time, values)
plt.show()
def show_perlin_noise():
noise = perlin.Perlin(10)
time = [i for i in range(200)]
values = [noise.valueAt(i) for i in time]
multiplied_list = [(element * 100) + 450 for element in values]
plt.title("Perlin Noise")
plt.xlabel("Time")
plt.ylabel("Value")
plt.plot(time, multiplied_list)
plt.show()
def getBasicShape(size, neighbors, vertices, regions, seed=None):
if seed is None:
seed = datetime.now().microsecond
print("Calculating landmass shape...")
print("Landmass shape seed: %d" % seed)
np.random.seed(seed)
noise = perlin.Perlin(size, 8)
cell_type = []
def isLand(c):
v = [int(t) for t in c]
x = 2. * c[0] / size - 1
y = 2. * c[1] / size - 1
return noise[v[0], v[1]] > 0.316 * (1 + x**2 + y**2)
for r in regions:
land = 0
thresh = 0.7 * len(r)
for v in vertices[r]:
if np.any([v == 0, v == size]):
land = 0
break
if dist(v, (1756, 666)) < 25:
land = 0
break
land += 1 if isLand(v) else 0
cell_type.append(LAND if land > thresh else WATER)
corner = np.where(np.all(vertices == [0,0], axis=1))[0][0]
flood = [corner]
cur_index = 0
while cur_index < len(flood):
current = flood[cur_index]
cell_type[current] = OCEAN
cur_index += 1
for n in neighbors[current]:
if cell_type[n] == WATER and n not in flood:
flood.append(n)
return cell_type
def map_create():
newMap = [[strucTile(0) for y in range(0, mapY)] for x in range(0, mapX)]
noise = perlin.Perlin(6)
time = [i for i in range(80)]
values = [noise.valueAt(i) for i in time]
values = [values[i] * 12 for i in time]
values = [abs(round(values[i])) for i in time]
for y in range(0, mapY):
for x in range(0, mapX):
if y < 12:
newMap[x][values[x] + 13 + y].blockType = 3
if newMap[x][y].blockType == 3 and newMap[x][y - 1].blockType == 0:
newMap[x][y].blockType = 5
if newMap[x][y].blockType == 3 and newMap[x][y + 1].blockType == 0:
newMap[x][y].blockType = 4
if newMap[x][y].blockType == 4 and y < mapY - 1:
newMap[x][y + 1].blockType = 4
return newMap
def apply_noise(image, setup):
generator = perlin.Perlin()
octaves = 5
persistence = 5
coef = 30
width, height = setup['canvas'][0], setup['canvas'][1]
list_of_pixels = list(image.getdata())
for i, pixel in enumerate(list_of_pixels):
if pixel != (0, 0, 0, 0):
noise = generator.OctavePerlin((i % width) / coef,
i / (height * coef), 0, 1, 5)
new_pixel = [int(x * (1 + noise)) for x in pixel[:3]]
new_pixel.append(pixel[3])
list_of_pixels[i] = tuple(new_pixel)
image = Image.new(image.mode, image.size)
image.putdata(list_of_pixels)
return image
def gouradPlanet(render, x, y, **kwargs):
w,v,u = kwargs["bar"]
nA, nB, nC = kwargs["normales"]
luz = kwargs["light"]
normx = nA.x*w + nB.x*v + nC.x*u
normy = nA.y*w + nB.y*v + nC.y*u
normz = nA.z*w + nB.z*v + nC.z*u
vnormal = Vector3(normx, normy, normz)
intensity = prodPunto(vnormal, luz)
if intensity < 0:
intensity =0
elif intensity >1:
intensity =1
#lista de colores a utilizar, con su valor rgb.
dark_wood =(80,64,51)
light_wood = (147,129,107)
greywood = (105,95,85)
grey =(136,127,118)
light_grey = (143,144,139)
near_white = (183,183,181)
#aqui se crea el ruido (mediante perlin noise) para la generación de colores
pnoise = p.Perlin()
for m in range(800):
for n in range(800):
col = [int((pnoise.value(x/800.0, y/11.0, 0)+1) *200), ] *3
if col[1] > 220:
mul = [int((near_white[0]/255.0*col[0])* intensity),int((near_white[1]/255.0*col[1])* intensity),
int((near_white[2]/255.0*col[2])* intensity)]
if mul[0] < 0: mul[0] =0
if mul[1] < 0: mul[1] = 0
if mul[2] < 0: mul[2] = 0
return color(mul[0], mul[1], mul[2])
if col[1] >210:
mul = [int((light_grey[0]/255.0*col[0])* intensity),int((light_grey[1]/255.0*col[1])* intensity),
int((light_grey[2]/255.0*col[2])* intensity)]
if mul[0] < 0: mul[0] =0
if mul[1] < 0: mul[1] = 0
if mul[2] < 0: mul[2] = 0
return color(mul[0], mul[1], mul[2])
if col[1] >205:
mul = [int((greywood[0]/255.0*col[0])* intensity),int((greywood[1]/255.0*col[1])* intensity),
int((greywood[2]/255.0*col[2])* intensity)]
if mul[0] < 0: mul[0] =0
if mul[1] < 0: mul[1] = 0
if mul[2] < 0: mul[2] = 0
return color(mul[0], mul[1], mul[2])
if col[1] >170:
mul = [int((light_wood[0]/255.0*col[0])* intensity),int((light_wood[1]/255.0*col[1])* intensity),
int((light_wood[2]/255.0*col[2])* intensity)]
if mul[0] < 0: mul[0] =0
if mul[1] < 0: mul[1] = 0
if mul[2] < 0: mul[2] = 0
return color(mul[0], mul[1], mul[2])
if col[1] >150:
mul = [int((dark_wood[0]/255.0*col[0])* intensity),int((dark_wood[1]/255.0*col[1])* intensity),
int((dark_wood[2]/255.0*col[2])* intensity)]
if mul[0] < 0: mul[0] =0
if mul[1] < 0: mul[1] = 0
if mul[2] < 0: mul[2] = 0
return color(mul[0], mul[1], mul[2])
else:
mul = [int((grey[0]/255.0*col[0])* intensity),int((grey[1]/255.0*col[1])* intensity),
int((grey[2]/255.0*col[2])* intensity)]
if mul[0] < 0: mul[0] =0
if mul[1] < 0: mul[1] = 0
if mul[2] < 0: mul[2] = 0
return color(mul[0], mul[1], mul[2])
from PIL import Image
import perlin
perlin_generator = perlin.Perlin(frequency=50)
noise_image = Image.new("RGB", (500, 500))
for x in xrange(500):
for y in xrange(500):
colour = (int((perlin_generator.value(x / 500.0, y / 500.0, 0.0) + 1) *
128), ) * 3
noise_image.putpixel((x, y), colour)
out = open("perlin.png", "w")
noise_image.save(out)
out.close()
pip install perlin
Restart kernel
"""
import turtle
import perlin, random, math
panel = turtle.Screen()
w = 600
h = 600
panel.setup(width=w, height=h)
# perlin generates noise based on a seed (start point)
# we'll use a random value so that each iteration of a path is different!
y = perlin.Perlin(random.randint(0, 6000))
x = perlin.Perlin(random.randint(0, 6000))
perl = turtle.Turtle()
# 1D path
def perlinTrace(steps=10000):
for i in range(steps):
perl.goto(i, x.one(i))
# 2D path
def perlin2D(steps=10000):
for i in range(steps):
perl.goto(x.one(i), y.one(i))
img = PhotoImage(width=W, height=H)
can.create_image((W / 2, H / 2), image=img, state="normal")
for x in range(W):
for y in range(H):
img.put(value_color(get_noise_value(x / 32, y / 32)),
(x + 1, y + 1))
window.mainloop()
def clip(value, limit):
return min(value, limit) / limit
def get_noise_value(x, y):
v1 = noise.get_value(x / 2, 1.5 + y / 30)
v2 = noise.get_value(0.5 + x / 30, y)
v = v1 * v2
if (v < 0.5):
v = 0
else:
v = (v - 0.5) * 2
v = int(v * 0xff)
return v
noise = perlin.Perlin(int(input("Seed: ")))
#print(noise.get_value(4.5, 4.5))
show(noise)
# There will be three star colors: red, yellow, and blue.
star_colors = {
0: (255,0,0), # Red
1: (213,213,0), # Yellow
2: (0,0,255) # Blue
}
# Stars come in three sizes: dwarf, normal, and giant.
star_sizes = {
0: 5,
1: 10,
2: 25
}
# We have three noise generators: first for finding the star size, one for finding the star color, one for finding planet colors
color_noise = perlin.Perlin()
size_noise = perlin.Perlin()
planet_noise = perlin.Perlin()
# Ask the user what seed to use for the simulation.
seed = float(input('Enter the numerical seed: '))
pygame.display.flip()
# Game loop
running = True
while running:
# Clear the screen
screen.fill((0,0,0))
# Show the galaxy screen
if view_mode is 'galaxy':
def _reloadGen(self):
'''Recreate the noise generator with the current parameters.'''
self._gen = perlin.Perlin(self.octaves, self.persistence)
pygame.init()
screen = pygame.display.set_mode((500, 500))
pygame.display.set_caption('Biome Generation')
# We will see 50x50 blocks at any given time.
grid = [[0] * 50] * 50
# There will be three biomes in the terrain: desert, grass, and snowy. Each one is represented by its own color.
biome_colors = {
0: (255, 255, 0), # Yellow
1: (38, 108, 46), # Forest green
2: (255, 255, 255) # White
}
# Import an instance of our Perlin noise generator.
noise = perlin.Perlin()
# Ask the user what seed to use for the simulation.
seed = float(input('Enter the numerical seed: '))
screen.fill((255, 255, 255))
pygame.display.flip()
# Game loop
running = True
while running:
# Iterate through the biome list and determine the biome.
for x in range(left, 50 + left):
for y in range(top, 50 + top):
ans = noise.getNoise(x / 2, y / 2, seed)
if ans < .25: # Deserts should be relatively uncommon
color = biome_colors[0]
