def create_sprite_grid(w: Window, x0, y0, m, n, scale=1, sprite_cls=Sprite):
grid: List[List[Sprite]] = []
for i in range(m):
row = []
for j in range(n):
s = w.create_sprite(sprite_cls)
s.scale = scale
s.x = x0 + j * (1 + s.width)
s.y = y0 + i * (1 + s.height)
row.append(s)
grid.append(row)
def create_level(n, m, scale, x0, y0, w: Window, Csprite=Sprite):
rows, cols = n, m
grid = []
for i in range(rows):
row = []
for j in range(cols):
q = w.create_sprite(Csprite)
q.scale = scale
q.x = x0 + j * (2 + q.width)
q.y = y0 + i * (2 + q.height)
r = row.append(q)
grid.append(r)
def create_sprite(splited, scale, x0, y0, w: Window, Csprite=Sprite):
rows, cols = len(splited), len(splited[0])
grid = []
for i in range(rows):
row = []
for j in range(cols):
p = w.create_sprite(Csprite)
p.texture = ni.get_texture_from_array(splited[i][j])
p.scale = scale
p.x = x0 + j * (2 + p.width)
p.y = y0 + i * (2 + p.height)
r = row.append(p)
grid.append(r)
def create(w: Window,
sub_array: List[List[ndarray]],
scale=1,
sprite_cls=Sprite):
s, n = len(sub_array), len(sub_array[0])
grid: List[List[Sprite]] = []
for i in range(s):
row = []
for j in range(n):
s = w.create_sprite(sprite_cls)
s.texture = np.get_texture_from_array(sub_array[i][j])
s.scale = scale
s.x = s.width / 2 + (j * s.width)
s.y = s.height / 2 + (i * s.height)
row.append(s)
grid.append(row)
def __init__(self,
w: Window,
rows: int,
cols: int,
x: float = None,
y: float = None,
scale: float = 10,
cell_gap: float = 1,
cell_cls: Callable[..., T] = Sprite):
self.__x = scale / 2 if x is None else x
self.__y = scale / 2 if y is None else y
self.__scale = scale
self.__cell_gap = cell_gap
self.__rows = rows
self.__cols = cols
self.__cells = [[w.create_sprite(cell_cls) for j in range(cols)]
for i in range(rows)]
self.__update_cells()
from pycat.core import Window, Sprite, KeyCode
window = Window(background_image='img/sea.png')
class Player(Sprite):
def on_create(self):
self.image = 'img/owl.png'
def on_update(self, dt):
self.move_forward(10)
if window.is_key_down(KeyCode.UP):
self.rotation = 90
if window.is_key_down(KeyCode.DOWN):
self.rotation = 270
if window.is_key_down(KeyCode.LEFT):
self.rotation = 180
if window.is_key_down(KeyCode.RIGHT):
self.rotation = 0
if self.x > 1225:
print("You Win!")
window.close()
if self.is_touching_any_sprite():
print("You Lose!")
window.close()
s = window.create_sprite()
s.image = "img/beach.png"
from pycat.core import Window
from pycat.base import NumpyImage as Image
w = Window()
image01 = Image.get_array_from_file("4_0.jpg")
image02 = Image.get_array_from_file("10_0.jpg")
image03 = Image.get_array_from_file("11_0.jpg")
image04 = Image.get_array_from_file("16_0.jpg")
image06 = Image.get_array_from_file("22_0.jpg")
rows1, cols1, channels1 = image01.shape
rows2, cols2, channels2 = image02.shape
rows3, cols3, channels3 = image03.shape
rows4, cols4, channels4 = image04.shape
rows6, cols6, channels6 = image06.shape
isprite1 = w.create_sprite()
isprite1.scale = 1.6
isprite1.texture = Image.get_texture_from_array(image01)
isprite1.position = (430, 460)
isprite2 = w.create_sprite()
isprite2.scale = 1.6
isprite2.texture = Image.get_texture_from_array(image02)
isprite2.position = (860, 460)
isprite3 = w.create_sprite()
isprite3.scale = 1.6
isprite3.texture = Image.get_texture_from_array(image03)
isprite3.position = (360, 290)
from pycat.core import Window, Sprite, Color
from pycat.label import Label
w = Window()
class Cell(Sprite):
def on_create(self):
self.height = 80
self.width = 80
self.color = Color.RED
def create_label(self, value):
self.value = value
self.label = w.create_label()
self.label.text = str(value)
self.label.x = self.x
self.label.y = self.y
def set_color(self, max, min):
scale = (self.value - min) / (max - min)
self.color = Color(255, (1 - scale) * 255, (1 - scale) * 255)
my_list = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
list_min = list_max = my_list[0][0]
for i in range(3):
for j in range(4):
v = my_list[i][j]
if v < list_min:
"c":Color.AMBER,
"d":Color.BLACK,
}
my_list = [
"wwwwwww",
"ppppppp",
"pbpppbp",
"ppppppp",
"ppwwwpp",
]
current_color = Color.WHITE
w = Window(width=len(my_list[0])*PIXEL+100, height=len(my_list)*PIXEL)
class Pixel(Sprite):
def on_create(self):
self.scale = PIXEL
class ColorChoice(Sprite):
def on_create(self):
self.scale = PIXEL
def on_left_click(self):
global current_color
current_color = self.color
for i in range(len(my_list)):
for j in range(len(my_list[i])):
p = w.create_sprite(Pixel)
from pycat.core import Window
from pycat.base import NumpyImage
w = Window()
original_image = NumpyImage.get_array_from_file("view.PNG")
print(original_image.shape)
sub = original_image[:386, :567, :]
sub2 = original_image[386:, 567:, :]
# sub3 = original_image[386:, :567, :]
# sub4 = original_image[:386, 567:, :]
s = w.create_sprite(x=250, y=200)
s.texture = NumpyImage.get_texture_from_array(sub)
s2 = w.create_sprite(x=900, y=400)
s2.texture = NumpyImage.get_texture_from_array(sub2)
w.run()
from pycat.core import Window, Sprite, KeyCode
from pycat.base import NumpyImage as Image
import random
w = Window()
original_image = Image.get_array_from_file("baboon.jpeg")
def get_max_rgb_image():
rows, cols, channels = original_image.shape
new_image = Image(rows, cols)
for i in range(rows):
for j in range(cols):
r, g, b, a = original_image[i][j]
new_image[i][j] = max(r, g, b)
return new_image
def get_luminance_image():
rows, cols, channels = original_image.shape
luminance_image = Image(rows, cols)
for i in range(rows):
for j in range(cols):
r, g, b, a = original_image[i][j]
luminance_image[i][j] = .299 * r + .587 * g + .114 * b
return luminance_image
def get_complement_image():
rows, cols, channels = original_image.shape
complement_image = Image(rows, cols, channels)
for i in range(rows):
from numpy import ndarray
from pycat.core import Window, Sprite, Color
from pycat.base import NumpyImage as np
from pycat.base import Texture
from pycat.base.event import MouseEvent
from typing import List, TypeVar
w = Window(is_sharp_pixel_scaling=True)
w.set_clear_color(100, 100, 100)
def sprite_array(row, col, file):
array = np.get_array_from_file(file)
m, n, _ = array.shape
di = m // row
dj = n // col
result = []
for i in range(row):
row = []
for j in range(col):
row.append(array[i * di:(i + 1) * di, j * dj:(j + 1) * dj, :])
result.append(row)
return result
def create(w: Window,
sub_array: List[List[ndarray]],
scale=1,
sprite_cls=Sprite):
s, n = len(sub_array), len(sub_array[0])
grid: List[List[Sprite]] = []
from pycat.core import Window, Sprite, Label
import random
w = Window(width=1000)
ima = [
'squirrel.jpg',
'bird.jpg',
'sheep.jpg',
'cow.jpg',
'seal.jpg',
'cat.jpg',
'hedgehog.jpg',
'meerkat.jpg',
]
texts = [
'Red squirrel',
'Pheasant',
'Sheep',
'Cow',
'Seal',
'Cat',
'Hedgehog',
'Meerkat',
]
imnum = 0
text0 = Label('', 400, 50)
w.add_label(text0)
w.background_image = ima[imnum]
from typing import List
from pycat.base.color import Color
from pycat.core import Window, Sprite
from pyglet.gl.glext_arb import GL_EXT_x11_sync_object
ROW = 6
COL = 10
CELL_SIZE = 100
w = Window(width=COL * CELL_SIZE, height=ROW * CELL_SIZE)
class Cell(Sprite):
def on_create(self):
self.scale = CELL_SIZE - 1
self.color = Color.RED
def set_ij(self, i, j):
self.i = i
self.j = j
def change_color(self):
if self.color == Color.GREEN:
self.color = Color.RED
else:
self.color = Color.GREEN
def change_neighbors(self):
i = self.i
j = self.j
if i > 0:
from pycat.core import Window, Sprite w = Window() s = w.create_sprite(scale=200, position=w.center) w.run()
}
ccolor = {
Color.BLACK,
Color.BLUE,
Color.CYAN,
Color.GREEN,
Color.MAGENTA,
Color.ORANGE,
Color.YELLOW,
Color.RED
}
PIXEL_SIZE = 100
w = Window(width= (len(list0[0])+2)*PIXEL_SIZE,
height= len(list0)*PIXEL_SIZE)
ncolor = Color.WHITE
class PixelR(Sprite):
def on_create(self):
self.scale = PIXEL_SIZE
x0 = PIXEL_SIZE/2
y0 = w.height - PIXEL_SIZE/2
for i in range (len(list0)):
for j in range (len(list0[0])):
p = w.create_sprite(PixelR)
from pycat.core import Window, Sprite, Color
from random import randint
window = Window()
s = window.create_sprite()
class Bat(Sprite):
def on_create(self):
s.image = "bat-b.png"
self.goto_random_position()
s1 = window.create_sprite(Bat)
s2 = window.create_sprite(Bat)
s3 = window.create_sprite(Bat)
for i in range(200):
s = window.create_sprite(Bat)
s.opacity = 200
s.color = Color.random_rgb()
s.rotation = randint(0,360)
s.width = randint(0,10)
s.height = randint(5,10)
window.run()
from pycat.core import Window
from pycat.base import NumpyImage as Image
window = Window()
image_rgb = Image(255, 255, 3)
for i in range(image_rgb.rows):
for j in range(image_rgb.cols):
if j < 85:
image_rgb[i][j] = [255, 0, 0]
elif j < 170:
image_rgb[i][j] = [0, 255, 0]
else:
image_rgb[i][j] = [0, 0, 255]
sprite = window.create_sprite()
sprite.texture = image_rgb.texture
sprite.position = window.center
sprite.x -= sprite.width / 2
image_rgba = Image(255, 255, 4)
for i in range(image_rgba.rows):
for j in range(image_rgba.cols):
if j < 85:
image_rgba[i][j] = [255, 0, 0, i]
elif j < 170:
image_rgba[i][j] = [0, 255, 0, i]
else:
image_rgba[i][j] = [0, 0, 255, i]
sprite = window.create_sprite()
sprite.texture = image_rgba.texture
from pycat.core import Window, Sprite
from pycat.base import NumpyImage
window = Window()
class ImageSprite(Sprite):
def on_create(self):
self.image = "baboon.jpeg"
self.scale = 2
self.y = window.height / 2
input_sprite = window.create_sprite(ImageSprite)
input_sprite.x = (window.width - input_sprite.width) / 2
output_sprite = window.create_sprite(ImageSprite)
output_sprite.x = (window.width + output_sprite.width) / 2
image = NumpyImage.get_array_from_texture(input_sprite.texture)
rows, cols, channels = image.shape
img = NumpyImage(rows, cols)
for i in range(rows):
for j in range(cols):
intensity = (j * 255) // (cols - 1)
img[i, j] = intensity
# for i in range(rows):
# for j in range(cols):
# channel_sum = 0
# # print(image[i][j])
from pycat.core import Window, Point, Color from math import sqrt window = Window() A = Point(600,300) B = Point(800,300) c = A.x - B.x a = c/2 b = sqrt(c**2 - a**2) C = Point((A.x + B.x)/2,A.y + b) window.create_line(A.x, A.y, B.x, B.y, width = 1000, color = Color.CYAN) window.create_line(B.x, B.y, C.x, C.y, width = 1000, color = Color.GREEN) window.create_line(C.x, C.y, A.x, A.y, width = 1000, color = Color.ORANGE) window.run()
from enum import Enum, auto
from pycat.base.color import Color
from pycat.base.event.key_event import KeyCode
from pycat.core import Window, KeyCode
from pycat.sprite import Sprite
from typing import List
from shapes import S, Z, I, O, J, L, T
from random import choice
w = Window()
TOP_Y = 500
GAP = 3
SCALE = 30
ROWS = 15
GROUND_Y = TOP_Y-(ROWS-1)*(GAP+SCALE)
SHAPES = [S, Z, I, O, J, L, T]
class Game(Sprite):
def on_create(self):
self.is_visible = False
self.shape = Shape()
def left(self):
for cell in self.shape.cells:
if cell.state is Cell.State.FALL:
cell.x -= cell.x_speed
def right(self):
for cell in self.shape.cells:
from turtle import position, window_height, window_width
from pycat.base import NumpyImage
from pycat.core import Window
w = Window(width=600, height=400)
oimage = NumpyImage.get_array_from_file("hummmm.png")
print(oimage.shape)
image01 = NumpyImage.get_texture_from_array(oimage[:84, :150:])
image02 = NumpyImage.get_texture_from_array(oimage[:84, 150::])
image03 = NumpyImage.get_texture_from_array(oimage[84:, :150:])
image04 = NumpyImage.get_texture_from_array(oimage[84:, 150::])
x0y0 = w.create_sprite(x=225, y=158)
x1y0 = w.create_sprite(x=375, y=158)
x0y1 = w.create_sprite(x=225, y=242)
x1y1 = w.create_sprite(x=375, y=242)
x0y0.texture = image01
x1y0.texture = image02
x0y1.texture = image03
x1y1.texture = image04
w.run()
from pycat.core import Window, Sprite, KeyCode, RotationMode, Scheduler
from random import random
from pycat.geometry.point import Point
from pyglet.image import create
CELL_SIZE = 48
TREE_PROB = 0.95
window = Window(height=700, width=700, is_sharp_pixel_scaling=True)
class Wall(Sprite):
def on_create(self):
self.scale = 2.8
self.image = 'terrain/wall_1.png'
self.add_tag('wall')
class Grass(Sprite):
def on_create(self):
self.scale = 3
self.image = 'terrain/grass_1.png'
class Tree(Sprite):
def on_create(self):
self.scale = 2.9
self.image = 'terrain/tree.png'
self.layer = 5
self.add_tag("tree")
@cell_gap.setter
def cell_gap(self, val: float):
self.__cell_gap = val
self.__update_cells()
@property
def rows(self):
return self.__rows
@property
def cols(self):
return self.__cols
w = Window(is_sharp_pixel_scaling=True, enforce_window_limits=False)
current_texture: Texture = None
selection_grid = SpriteGrid(rows=7, cols=12, scale=30, cell_cls=SelectionCell)
selection_grid.split_sprite_sheet('pattern.png')
level_grid = SpriteGrid(rows=20,
cols=40,
scale=15,
x=600,
cell_gap=1,
cell_cls=LevelCell)
class GridController(Sprite):
def on_update(self, dt):
if w.is_key_pressed(KeyCode.W):
level_grid.y += 5
import random
from pycat.core import Window, Sprite
w = Window()
rest = 0
class Tur(Sprite):
global rest
def on_create(self):
self.position = w.center
# self.x -= 100
# self.y -= 100
def on_update(self, dt):
pass
def draw_forward(self,res):
rest = res
x1 = self.x
y1 = self.y
self.move_forward(rest)
w.create_line(x1,y1,self.x,self.y)
def draw_rect(self,width,height):
self.draw_forward(width)
self.rotation += 90
self.draw_forward(height)
self.rotation += 90
self.draw_forward(width)
self.rotation += 90
self.opacity *= 0.95
self.move_forward(3)
if self.touching_window_edge() or self.time > 2:
self.delete()
class CreateButton(Sprite):
def on_left_click(self):
for _ in range(10):
window.create_sprite(Particle)
class ExplodeButton(Sprite):
def on_left_click(self):
for p in window.get_sprites_with_tag('particle'):
for r in range(0, 360, 30):
q = window.create_sprite(ExplosionParticle)
q.position = p.position
q.rotation = r
p.delete()
window = Window()
bb = window.create_sprite(CreateButton, x=100, y=100, scale=75)
bb.color = [0, 0, 255]
rb = window.create_sprite(ExplodeButton, x=100, y=200, scale=75)
rb.color = [255, 0, 0]
window.run()
from pycat.base.color import Color
from pycat.base.event.mouse_event import MouseEvent
from pycat.core import Sprite, Window
from enum import Enum, auto
from pyglet.gl.gl import GL_RED
window = Window(background_image="Galaxy.png")
window.background_sprite.scale = 1.5
class PlayerState(Enum):
WAITING_FOR_CLICK = auto()
JUMPING = auto()
RESETTING = auto()
class Player(Sprite):
def on_create(self):
self.image = "frank-a.png"
self.reset()
def reset(self):
self.x = 300
self.y = 300
self.scale = 0.3
self.x_speed = 0
self.y_speed = 0
self.rotation = 0
self.state = PlayerState.JUMPING
PIXEL = 48
color = {
"p":"tiles/tile_000.png",
"w":"tiles/tile_001.png",
"b":"tiles/tile_002.png",
}
my_list = [
"wwwwwww",
"ppppppp",
"pbpppbp",
"ppppppp",
"ppwwwpp",
]
w = Window(width=len(my_list[0])*PIXEL, height=len(my_list)*PIXEL)
class Pixel(Sprite):
def on_create(self):
self.scale = 3
for i in range(len(my_list)):
for j in range(len(my_list[i])):
p = w.create_sprite(Pixel)
p.image = color[my_list[i][j]]
p.scale = 3
p.x = j*(p.width+1) + p.width/2
p.y = w.height - p.height/2 - i*(p.height+1)
# if my_list[i][j] == "p":
# p.color = Color.PURPLE
from pycat.core import Color, KeyCode, Sprite, Window, Scheduler
import random
window = Window()
class Player(Sprite):
def on_create(self):
self.color = Color.AMBER
self.scale = 30
self.speed = 10
self.add_tag("player")
def on_update(self, dt):
if window.get_key(KeyCode.W):
self.y += self.speed
if window.get_key(KeyCode.A):
self.x -= self.speed
if window.get_key(KeyCode.S):
self.y -= self.speed
if window.get_key(KeyCode.D):
self.x += self.speed
def on_left_click_anywhere(self):
window.create_sprite(Bullet)
player = window.create_sprite(Player)
class Bullet(Sprite):
from pycat.core import Window
window = Window()
animal = window.create_sprite()
anwser = input("What animal do you like?")
animal.x = 620
animal.y = 320
if anwser == "pico":
animal.image = "pico-c.png"
if anwser == "squirrel":
animal.image = "squirrel.png"
if anwser == "starfish":
animal.image = "starfish.png"
if anwser == "cat":
animal.image = "Cat.png"
anwser0 = input("Do you want your animal big or small?")
if anwser0 == "big":
animal.scale = 10
if anwser0 == "small":
animal.scale = 0.5
window.run()
