face swirler thing (pygame)

face swirler thing (pygame)

Postby mr ham » Wed Aug 27, 2014 8:46 am

made in python 2.x
save some jpg of a face or whatever (will auto resize 100x100 pixels otherwise slow) called 'face.jpg' in the folder this .py is in.
input:
q/r = rotates/swirls in a square pattern
arrow keys = move while keeping swirl pattern
shift+arrow keys = scroll elsewhere

Roter is an object that rotates in a rectangle pattern defined by xmin/xmax/ymin/ymax (clockwise or counter-cw ('cw' or 'ccw'))
Code: Select all
import pygame,time,copy,random

print 'q/r rotates, arrow keys move keeping swirl pattern, left shift + arrows = move to make another swirl elsewhere'

class Roter(object):
   
   def __init__(ss,xmin,xmax,ymin,ymax,dir,x,y,speed):
      ss.xmin=xmin
      ss.xmax=xmax
      ss.ymin=ymin
      ss.ymax=ymax
      ss.dir=dir
      ss.x=x
      ss.y=y
      ss.speed=speed
   
   def copy(ss):
      return Roter(ss.xmin,ss.xmax,ss.ymin,ss.ymax,ss.dir,ss.x,ss.y,ss.speed)
   
   def tick(ss):
      if ss.dir=='cw':
         #top 4 ifs handle if its exactly in corner
         if ss.y==ss.ymax and ss.x==ss.xmin:
            ss.y-=ss.speed
         elif ss.y==ss.ymin and ss.x==ss.xmin:
            ss.x+=ss.speed
         elif ss.y==ss.ymin and ss.x==ss.xmax:
            ss.y+=ss.speed
         elif ss.y==ss.ymax and ss.x==ss.xmax:
            ss.x-=ss.speed
         elif ss.y==ss.ymax:
            ss.x-=ss.speed
            if ss.x<ss.xmin:
               extra=ss.xmin-ss.x
               ss.x=ss.xmin
               ss.y-=extra
         elif ss.y==ss.ymin:
            ss.x+=ss.speed
            if ss.x>ss.xmax:
               extra=ss.x-ss.xmax
               ss.x=ss.xmax
               ss.y+=extra
         elif ss.x==ss.xmax:
            ss.y+=ss.speed
            if ss.y>ss.ymax:
               extra=ss.y-ss.ymax
               ss.y=ss.ymax
               ss.x-=extra
         elif ss.x==ss.xmin:
            ss.y-=ss.speed
            if ss.y<ss.ymin:
               extra=ss.ymin-ss.y
               ss.y=ss.ymin
               ss.x+=extra
      elif ss.dir=='ccw':
         #top 4 ifs handle if its exactly in corner
         if ss.y==ss.ymax and ss.x==ss.xmin:
            ss.x+=ss.speed
         elif ss.y==ss.ymin and ss.x==ss.xmin:
            ss.y+=ss.speed
         elif ss.y==ss.ymin and ss.x==ss.xmax:
            ss.x-=ss.speed
         elif ss.y==ss.ymax and ss.x==ss.xmax:
            ss.y-=ss.speed
         elif ss.y==ss.ymax:
            ss.x+=ss.speed
            if ss.x>ss.xmax:
               extra=ss.x-ss.xmax
               ss.x=ss.ymax
               ss.y-=extra
         elif ss.y==ss.ymin:
            ss.x-=ss.speed
            if ss.x<ss.xmin:
               extra=ss.xmin-ss.x
               ss.x=ss.xmin
               ss.y+=extra
         elif ss.x==ss.xmax:
            ss.y-=ss.speed
            if ss.y<ss.ymin:
               extra=ss.ymin-ss.y
               ss.y=ss.ymin
               ss.x-=extra
         elif ss.x==ss.xmin:
            ss.y+=ss.speed
            if ss.y>ss.ymax:
               extra=ss.y-ss.ymax
               ss.y=ss.ymax
               ss.x+=extra

class Rotpix(object):
   
   def __init__(ss,roter,pix):
      ss.roter=roter
      ss.pix=pix
   
   def draw(ss,surf):
      surf.blit(ss.pix,(ss.roter.x,ss.roter.y))

def normalmove(rps,surf,xmov,ymov):
   blitsurf=surf.copy()
   if xmov==1:
      surf.blit(blitsurf,(-1,0))
      surf.blit(blitsurf,(blitsurf.get_width()-1,0))
   elif xmov==-1:
      surf.blit(blitsurf,(1,0))
      surf.blit(blitsurf,(1-blitsurf.get_width(),0))
   if ymov==1:
      surf.blit(blitsurf,(0,-1))
      surf.blit(blitsurf,(0,blitsurf.get_height()-1))
   elif ymov==-1:
      surf.blit(blitsurf,(0,1))
      surf.blit(blitsurf,(0,1-blitsurf.get_height()))
   for y in range(len(rps)):
      for x in range(len(rps[0])):
         rps[y][x].pix.fill(surf.get_at((rps[y][x].roter.x,rps[y][x].roter.y)))

def move(rps,xmov,ymov):
   if xmov==1:
      #shift every rp's pixel 1 grid left... but each is really 'located' at roter x y... confusing not sure why this works, made on accident
      for y in range(len(rps)):
         lpix=pygame.Surface((1,1))
         lpix.blit(rps[y][0].pix,(0,0))
         for x in range(1,len(rps[0]),1):
            rps[y][x-1].pix.blit(rps[y][x].pix,(0,0))
         rps[y][-1].pix.blit(lpix,(0,0))
   elif xmov==-1:
      for y in range(len(rps)):
         rpix=pygame.Surface((1,1))
         rpix.blit(rps[y][-1].pix,(0,0))
         for x in range(len(rps[0])-2,-1,-1):
            rps[y][x+1].pix.blit(rps[y][x].pix,(0,0))
         rps[y][0].pix.blit(rpix,(0,0))
   if ymov==1:
      for x in range(len(rps[0])):
         tpix=pygame.Surface((1,1))
         tpix.blit(rps[0][x].pix,(0,0))
         for y in range(1,len(rps),1):
            rps[y-1][x].pix.blit(rps[y][x].pix,(0,0))
         rps[-1][x].pix.blit(tpix,(0,0))
   elif ymov==-1:
      for x in range(len(rps[0])):
         bpix=pygame.Surface((1,1))
         bpix.blit(rps[-1][x].pix,(0,0))
         for y in range(len(rps)-2,-1,-1):
            rps[y+1][x].pix.blit(rps[y][x].pix,(0,0))
         rps[0][x].pix.blit(bpix,(0,0))


face=pygame.image.load('face.jpg')
#face=pygame.transform.scale(face,(face.get_width()/2,face.get_height()/2))
face=pygame.transform.scale(face,(100,100))
w=face.get_width()
h=face.get_height()
screen=pygame.display.set_mode((w,h))

def getrps(pic):
   rps=[]
   for y in range(h):
      row=[]
      for x in range(w):
         ldist=x
         rdist=w-1-x
         tdist=y
         bdist=h-1-y
         d=min(ldist,rdist,tdist,bdist)
         r=Roter(d,w-1-d,d,h-1-d,'cw',x,y,1)
         col=pic.get_at((x,y))
         pix=pygame.Surface((1,1))
         pix.fill(col)
         rp=Rotpix(r,pix)
         row.append(rp)
      rps.append(row)
   return rps
'''
for ringdist in range(0,w/2,1):
   roting=True
   iterroter=Roter(ringdist,w-1-ringdist,ringdist,h-1-ringdist,'cw',ringdist,ringdist,1)
   ringtl=[iterroter.x,iterroter.y]
   while roting:
      r=iterroter.copy()
      col=face.get_at((r.x,r.y))
      pix=pygame.Surface((1,1))
      pix.fill(col)
      rp=Rotpix(r,pix)
      rps.append(rp)
      iterroter.tick()
      if [iterroter.x,iterroter.y]==ringtl:
         roting=False
'''
'''
def normalizespiral(rps):
   global face,screen
   for y in range(len(rps)):
      for x in range(len(rps[0])):
         face.blit(rps[y][x].pix,(rps[y][x].roter.x,rps[y][x].roter.y))
   rps=getrps(face)
   #screen.blit(face,(10,10))
   #pygame.display.flip()
   #print 'hi'
   #time.sleep(100)
'''

rps=getrps(face)
gonnadraw=True
xmov=0
ymov=0
roting=False
shiftdown=False
while 1:
   ##better if event stuff just change shiftdown==True etc variables?
   for e in pygame.event.get():
      if e.type==pygame.QUIT or (e.type == pygame.KEYDOWN and e.key == pygame.K_ESCAPE):
         running=False
      elif e.type==pygame.KEYDOWN and e.key == pygame.K_w:
         for y in range(len(rps)):
            for x in range(len(rps[0])):
               rps[y][x].roter.dir='cw'
         #for rp in rps:
         #   rp.roter.dir='cw'
         roting=True
      elif e.type==pygame.KEYUP and e.key == pygame.K_w:
         roting=False
      elif e.type==pygame.KEYDOWN and e.key == pygame.K_q:
         for y in range(len(rps)):
            for x in range(len(rps[0])):
               rps[y][x].roter.dir='ccw'
            #rp.roter.dir='ccw'
         roting=True
      elif e.type==pygame.KEYUP and e.key == pygame.K_q:
         roting=False
      
      elif e.type==pygame.KEYDOWN and e.key == pygame.K_RIGHT:
         xmov=1
      elif e.type==pygame.KEYUP and e.key == pygame.K_RIGHT and xmov==1:
         xmov=0
      elif e.type==pygame.KEYDOWN and e.key == pygame.K_LEFT:
         xmov=-1
      elif e.type==pygame.KEYUP and e.key == pygame.K_LEFT and xmov==-1:
         xmov=0
      
      elif e.type==pygame.KEYDOWN and e.key == pygame.K_DOWN:
         ymov=1
      elif e.type==pygame.KEYUP and e.key == pygame.K_DOWN and ymov==1:
         ymov=0
      elif e.type==pygame.KEYDOWN and e.key == pygame.K_UP:
         ymov=-1
      elif e.type==pygame.KEYUP and e.key == pygame.K_UP and ymov==-1:
         ymov=0
      
      elif e.type==pygame.KEYDOWN and e.key==pygame.K_LSHIFT:
         shiftdown=True
      elif e.type==pygame.KEYUP and e.key==pygame.K_LSHIFT:
         shiftdown=False
      
      #elif e.type==pygame.KEYDOWN and e.key==pygame.K_SPACE:
      #   normalizespiral(rps)
   
   if gonnadraw:
      for y in range(len(rps)):
         for x in range(len(rps[0])):
            rps[y][x].draw(screen)
      #for rp in rps:
      #   rp.draw(screen)
      gonnadraw=False
   pygame.display.flip()
   time.sleep(.01)
   
   if xmov!=0 or ymov!=0:
      #move(rps,xmov,ymov)
      if shiftdown:
         normalmove(rps,screen,xmov,ymov)
      else:
         move(rps,xmov,ymov)
      gonnadraw=True
   
   if roting:
      for y in range(len(rps)):
         for x in range(len(rps[0])):
            rps[y][x].roter.tick()
         #rp.roter.tick()
      gonnadraw=True
mr ham
 
Posts: 21
Joined: Wed Aug 27, 2014 3:36 am

Return to Game Development

Who is online

Users browsing this forum: No registered users and 2 guests