#--------------------------------
#--Fliping Blocks version 0.1----
#---Functions page---------------
#--Written from scratch,as first
#--project by Barak Koren-------- 
#---------20\03\2009---------------




import maya.cmds as cmds
import random
import math


#---------Restrat Timeline-----------------------
cmds.playbackOptions(minTime=1)
cmds.playbackOptions(maxTime=1000)
#------End of Timeline---------------------------


#------Start Shaders--------------------------------
#---------------------------------------------------
#-------------RED---------------------
cmds.select(cmds.ls(mat=1))
if cmds.objExists('red'):
	print "Red already exist"
else :
	cmds.shadingNode('lambert',asShader=1,n='red')
	cmds.setAttr('red.color', 1, 0, 0, type="double3")
	cmds.sets (renderable=True ,noSurfaceShader = 1 ,empty=1 ,name='redSG')
	cmds.connectAttr ('red.outColor' ,'redSG.surfaceShader',f=1) 
#-------------End RED---------------------

#----------Green-------
cmds.select(cmds.ls(mat=1))
if cmds.objExists('green'):
	print "Green already exist"
else :
	cmds.shadingNode('lambert',asShader=1,n='green')
	cmds.setAttr('green.color', 0, 1, 0, type="double3")
	cmds.sets (renderable=True ,noSurfaceShader = 1 ,empty=1 ,name='greenSG')
	cmds.connectAttr ('green.outColor' ,'greenSG.surfaceShader',f=1)
#----------End Green-------

#-------Blue------------
cmds.select(cmds.ls(mat=1))
if cmds.objExists('blue'):
	print "Blue already exist"
else :
	cmds.shadingNode('lambert',asShader=1,n='blue')
	cmds.setAttr('blue.color', 0, 0, 1, type="double3")
	cmds.sets (renderable=True ,noSurfaceShader = 1 ,empty=1 ,name='blueSG')
	cmds.connectAttr ('blue.outColor','blueSG.surfaceShader',f=1)
#------- end of Blue------------

#------------------------------------------------------------------
#------End of Shaders--------------------------------

	
#-------Delete All Transforms
#-------Beside the first and last three (cameras)
def delete_all():
	if ((cmds.ls(tr=1))[1:-3]):cmds.delete(cmds.ls(tr=1)[1:-3])
#----------------------------------------------
#-------Delete All Transforms------------------

	
#----Select diffrent Shader-------
#---Input:(Shader name ,name of the object)------------------------------
#-----------------------------------------------------
def chnage_color(x,name):
	cmds.sets (name,e=1, forceElement='%sSG'%x)

#----End of Select diffrent Shader-------


#--- Geting center points from sides of the box---
#-------------------------------------------------
#definition to_be_rotate : 
#Location=The location of edge center point. 
#(Name Of Object,Location1,Location2,Location3,Location4)
            	
#Input: (to_be_rotate)
#Output:(to_be_rotate)

def get_sides (to_be_rotate) :
#---------------  Array ------	
        #print to_be_rotate[0][0]
	victor= cmds.xform ('%s.e[18]'%to_be_rotate[0][0] ,q=1,ws=1,t=1)
	to_be_rotate[1]=((victor[0]+victor[3])/2,(victor[1]+victor[4])/2,(victor[2]+victor[5])/2)

	victor= cmds.xform ('%s.e[19]'%to_be_rotate[0][0] ,q=1,ws=1,t=1)
	to_be_rotate[2]=((victor[0]+victor[3])/2,(victor[1]+victor[4])/2,(victor[2]+victor[5])/2)

	victor= cmds.xform ('%s.e[4]'%to_be_rotate[0][0] ,q=1,ws=1,t=1)
	to_be_rotate[3]=((victor[0]+victor[3])/2,(victor[1]+victor[4])/2,(victor[2]+victor[5])/2)

	victor= cmds.xform ('%s.e[1]'%to_be_rotate[0][0] ,q=1,ws=1,t=1)
	to_be_rotate[4]=((victor[0]+victor[3])/2,(victor[1]+victor[4])/2,(victor[2]+victor[5])/2)
	
	return	to_be_rotate

#--------------------------------------------------------
#--- End of geting center points from sides of the box---



#--------------------------------------------------------
#----------Make List of Cubes 
#Making the Cubes list to be used in animation
#Input :(Number of Cubes wanted)
#Output:List of keyframed in the begining visibility off boxes.
#I will have to make option for location chnage (the deafult is (0.5,0,0.5)
def make_list_cube(number_of_cube,x,y,z,width,height,depth):
	boxes=[]
	for i in range(0,number_of_cube+2):
    		boxes.append(cmds.polyCube( sy=2,w=width,d=depth,h=height ))
    		cmds.move(x,y,z)
    		cmds.setAttr ("%s.visibility" %boxes[i][0], 0)	
    		cmds.setKeyframe (t=1)
	return boxes

#--------------------------------------------------------------------
#----------End of Make List of Cubes 


#--------Choose Direction--------------------------------------------
#Input:(To_be_rotate,side)
#Output:[point,speed vector,direction]

def choose_direction (to_be_rotate,direction) :
#---------------------Array---------String
	
	
	if (direction=='right') :
		chosen=to_be_rotate[1] #choosing point who represnt side from the list to_be_rotate[1]-to_be_rotate[4]
		max_v=to_be_rotate[1][0] # in this case of right side checking saveing the x value.
		for i in range(2,5) :
			if (to_be_rotate[i][0]>max_v ): # checking each x value from every point.
				chosen=to_be_rotate[i]
				max_v=to_be_rotate[i][0]
		return [chosen,(0,0,-6),direction] # after checking it will returen the point who contain the max x value . 
	
	if (direction=='down') :
		chosen=to_be_rotate[1]
		max_v=to_be_rotate[1][2]
		for i in range(2,5) :
			if (to_be_rotate[i][2]>max_v ):
				chosen=to_be_rotate[i]
				max_v=to_be_rotate[i][2]
		return [chosen,(6,0,0),direction]
	
	if (direction=='forward') :
		chosen=to_be_rotate[1]
		max_v=to_be_rotate[1][2]
		for i in range(2,5) :
			if (to_be_rotate[i][2]<max_v ):
				chosen=to_be_rotate[i]
				max_v=to_be_rotate[i][2]
		return [chosen,(-6,0,0),direction]
	
	if (direction=='left') :
		chosen=to_be_rotate[1]
		max_v=to_be_rotate[1][0]
		for i in range(2,5) :
			if (to_be_rotate[i][0]<max_v ):
				chosen=to_be_rotate[i]
				max_v=to_be_rotate[i][0]
		return [chosen,(0,0,6),direction]

#---------------point=[side center point,axis for rottation,speed,direction]
#--------End of Choose Direction--------------------------------------------
#---------------------------------------------------------------------------
	
	
#-----------Rotation with Animation-----------------------------------------
#-----------Rotate the cube while counting frames---------------------------
#Input: (to_be_rotate,point,number of box flip,the invisiable boxes list)
#Output:(to_be_rotate)
	
def rotocube(to_be_rotate,point,turn_number,boxes):
	
	
	#example for "point" [(0.5, 0.0, 1.0), (6, 0, 0), 'down']
	
	Cframe=(cmds.currentTime( query=True ))
	for i in range(0,turn_number) :
	
		cmds.move (point[0][0],point[0][1],point[0][2],'%s.scalePivot' %to_be_rotate[0][0], '%s.rotatePivot' %to_be_rotate[0][0])
	
		count=0
		turn_speed=point[1][0]+point[1][1]+point[1][2]
		while count < 180 :
			
			count+=math.sqrt(turn_speed*turn_speed)
			
			cmds.setKeyframe(to_be_rotate[0][0],t= (cmds.currentTime( query=True )-1))
			
			
			cmds.rotate(point[1][0],point[1][1],point[1][2],r=1,os=1)
			
			
			cmds.setKeyframe(to_be_rotate[0][0])
				
			
			cmds.currentTime(Cframe)
			Cframe+=1
			
		#"Duplictae" last box
		#-------------------------------------------------
		to_be_rotate=demidupi(to_be_rotate,point[2],boxes)
		to_be_rotate=get_sides (to_be_rotate)
		point=choose_direction(to_be_rotate,point[2])
		#End of "Duplictae" last box
	return to_be_rotate

#----------------------------------------------
#-----------End of Rotation with Animation-----------------------------------------


#------------------Simple 180 angle function-----------------------------------
#--------------Really duplicate and after Rotate the box for future colosion checking.
#---Input:(to_be_rotate,wanted point to rotate on ("point"))
#---Output:(Retrive the name of the last original box)
#-------------------------------------------------------------------------------
def rotosimple(to_be_rotate,point):
	original_box=to_be_rotate[0][0] #keeping the original box,for returning after the checking.
	to_be_rotate[0]=cmds.duplicate() # duplicating the box and save it in the main variy
	cmds.move (point[0][0],point[0][1],point[0][2],'%s.scalePivot' %to_be_rotate[0][0], '%s.rotatePivot' %to_be_rotate[0][0]) #moving pivot point to the wanted side
	x=point[1][0] #saving the value of the "speed" in x y z becuase we cant change list eith "=" oportain from iiner function 
	y=point[1][1]
	z=point[1][2]
	
	if (point[1][0]) : x=180*(x/(math.sqrt(x*x)))
	if (point[1][1]) : y=180*(y/(math.sqrt(y*y)))
	if (point[1][2]) : z=180*(z/(math.sqrt(z*z)))#didnt really need it but maybe for future use.
		
	cmds.rotate(x,y,z,r=1,os=1)
	
	return original_box

#------------------End of Simple 180 angle function-----------------------------------
#-----------------------------------------------------------------------------------


#---------------------------------------------------------------
#-------------- Exectuting the roto_cube function (animation rotation)----  
#------Input: (to_be_rotate,direction,how many flips (keep it 1),boxes list)

def roto (to_be_rotate,direction,steps,boxes) :

	#----strong the name of the selected object if needed. 
	#if needed so it also will "Duplicate"(demidupi) the object
	
	if ((cmds.ls(sl=1))!=to_be_rotate[0]) :
		
		to_be_rotate[0]=(cmds.ls(sl=1))
		
		
		to_be_rotate=demidupi(to_be_rotate,direction,boxes)
	
	#----End of strong the name of the selected object if needed.
	
	to_be_rotate=get_sides (to_be_rotate)
	to_be_rotate=rotocube(to_be_rotate,choose_direction(to_be_rotate,direction),steps,boxes)

#----------End Of Exectuting the roto_cube function (animation rotation)----	
#-------------------------------------------------------------------------

	
	
#---------------"demidupi: "A" and "B" boxes  prepretion Function----------------
#--------------- meant to mimic the duplicate function.
#1.Taking B changeing Pivot point acordingly to rotation side  
#2.moving B onto A position acording pivot points.	
#----------------------------------------------------	

def demidupi(to_be_rotate,side,boxes):
	
	#arrange A and B cubes. : A is the last\sleceted cube,B is the cube took out from the stack.(boxes)	
	
	#-----Arrange B------------------------------------------------
         
	original=to_be_rotate[0] #we save the nmae of the last cube (A)
	
		
	to_be_rotate[0]=[boxes.pop(0)[0]] #taking out first cube from the cubes list (B)
	box_temp=to_be_rotate[0] #saving the name of the box we took out from the list (B)
	
	to_be_rotate=get_sides(to_be_rotate) #getting sides for box we took from the list.
	 
	side_point=choose_direction(to_be_rotate,side) #saving the side point (B)
	
	cmds.setKeyframe(to_be_rotate[0],t= (cmds.currentTime( query=True )-1)) # keyframing before the real move.
		 
	cmds.move(side_point[0][0],side_point[0][1],side_point[0][2],'%s.scalePivot' %to_be_rotate[0][0], '%s.rotatePivot' %to_be_rotate[0][0])# moving pivot point of (B) to the wanted side 
	cmds.setAttr('%s.visibility' %to_be_rotate[0][0],1) # Unhidden (B)
#------end of Arrange B---------------------------------------------------	

#-----Arrange A------------------------------------------------
	to_be_rotate[0]=original # getting the name of (A)
	 
	to_be_rotate=get_sides(to_be_rotate) #getting sides from (A).
	
	side_point=choose_direction(to_be_rotate,side) # #saving the side point (A)
	#---------End of Arrange A------------------------------------------------

	cmds.move(side_point[0][0],side_point[0][1],side_point[0][2],box_temp,rpr=1) #moving (B) acording to pivot to (A) pivot location 
	cmds.setKeyframe(box_temp) # keyframe (B)
	cmds.select(box_temp) #selecting (B)
	to_be_rotate[0]=box_temp # making (B) the "last box created"
	
	return to_be_rotate

#---------------End Of "demidupi: "A" and "B" boxes  prepretion Function----------------
#--------------------------------------------------------------------------------


#------------------"The checking" function ----------------------------------------------
#-----"The checking" function check if we can rotate object to the requested side--------------------
#---Input:  (To_be_rotate,side for checking)
#---Output: True or False

def check_side_ok (to_be_rotate,side,min_border,maxborder): 
	cmds.ls (sl=1) #selecting objects
	to_be_rotate=get_sides (to_be_rotate) #getting sides from objects
	to_be_rotate[0][0]=rotosimple(to_be_rotate,choose_direction(to_be_rotate,side)) #genereating box for checking


	Bbox_simple_roto=cmds.exactWorldBoundingBox() #geting bbox from the box we made for check 
	Bbox_original=cmds.exactWorldBoundingBox(to_be_rotate[0][0]) #geting bbox from the box we made for check 
	cmds.delete() #we delete the box we made for check 
	#---if go behiand borders or hit other object
	#bbox values of checking box
	xmin = Bbox_simple_roto[0]
	ymin = Bbox_simple_roto[1]
	zmin = Bbox_simple_roto[2]
	xmax = Bbox_simple_roto[3]
	ymax = Bbox_simple_roto[4]
	zmax = Bbox_simple_roto[5]
	#------averaging min max points for another point refernce-------------------
	Ax_check=(xmin+xmax)/2
	Ay_check=(ymin+ymax)/2
	Az_check=(zmin+zmax)/2
	
	#----------------------------------
	#check borders
	if ((xmin>maxborder) or (ymin>maxborder) or (zmin>maxborder)) or ((xmax>maxborder) or (ymax>maxborder) or (zmax>maxborder)):
		cmds.select(to_be_rotate[0][0])
		return 0

	if ((xmin<min_border) or (ymin<(min_border)) or (zmin<min_border)) or ((xmax<min_border) or (ymax<(min_border)) or (zmax<min_border)):
		cmds.select(to_be_rotate[0][0])
		return 0
	#End Of check borders
#------------------------------------------------------------------------------------
#--------If there is cross section between BBOXs  
	bbox_list=(cmds.ls( tr=1))[1:-3] #getting all transforms for bbox not include first and last three. 

	# checking if there is point from all object that inside the BBox simple roto ( the checking box)
	# if point between A and B.
	for i in bbox_list :
	
		temp_bbox = cmds.exactWorldBoundingBox(i) 
				
		
		Txmin = temp_bbox[0] # "T" means temporal.
		Tymin = temp_bbox[1]
		Tzmin = temp_bbox[2]
		Txmax = temp_bbox[3]
		Tymax = temp_bbox[4]
		Tzmax = temp_bbox[5]
				
		Ax_temp=(Txmin+Txmax)/2
		Ay_temp=(Tymin+Tymax)/2
		Az_temp=(Tzmin+Tzmax)/2
		check1=0
		check2=0
		
		#made this round to cover my ass on the BBOX command
		if (((round(Bbox_original[0],4))==(round(temp_bbox[0],4)))and((round(Bbox_original[1],4))==(round(temp_bbox[1],4)))and((round(Bbox_original[2],4))==(round(temp_bbox[2],4)))) : 	
			check1=(-3)
			check2=(-3)
				
		#-------- if some point from object in space, inside bbox check	
		if ((Txmin > xmin ) and (Txmin < xmax )) or ((Txmax > xmin ) and (Txmax < xmax ) )or((Ax_temp >= xmin ) and (Ax_temp <= xmax ) ):
			
			check1+=1
		if ((Tymin > ymin ) and (Tymin < ymax )) or ((Tymax > ymin ) and (Tymax < ymax )) or ((Ay_temp >= ymin ) and (Ay_temp <= ymax )):
			
			check1+=1
		if ((Tzmin > zmin ) and (Tzmin < zmax )) or ((Tzmax > zmin ) and (Tzmax < zmax )) or ((Az_temp >= zmin ) and (Az_temp <= zmax )):
			
			check1+=1
							
		#---------------- if some point of bbox check inside some object in space		
		if ((xmin > Txmin ) and (xmin < Txmax )) or ((xmax > Txmin ) and (xmax < Txmax )) or ((Ax_check >= Txmin ) and (Ax_check <= Txmax )):
			
			check2+=1
		if ((ymin > Tymin ) and (ymin < Tymax )) or ((ymax > Tymin ) and (ymax < Tymax )) or ((Ay_check >= Tymin ) and (Ay_check <= Tymax )):
			
			check2+=1
		if ((zmin > Tzmin ) and (zmin < Tzmax )) or ((zmax > Tzmin ) and (zmax < Tzmax )) or ((Az_check >= Tzmin ) and (Az_check <= Tzmax )):
			
			check2+=1
										
										
		if ((check1 == 3 ) or (check2 == 3 )) : 
			cmds.select(to_be_rotate[0][0])
			return 0
				
	cmds.select(to_be_rotate[0][0])
	return 1
#-------------------------------------------------------------------------------
#------------------End Of "The checking" function ------------------------------------------
#..............................................................................


#------------------Cheking all sides Function---------------------
#------------------Retrive object and check where it can be rotate---- 
#input: (To_be_rotate)		
#output:(List of sides available to flip)

def check_all_sides (to_be_rotate,min_border,maxborder):
	temp=to_be_rotate[0]
	if ((cmds.ls(sl=1))!=to_be_rotate[0]) :
		
		to_be_rotate[0]=(cmds.ls(sl=1))
		#cmds.makeIdentity( apply=True, t=0, r=1, s=1, n=0 )
		
	sides=['left','right','forward','down']
	side_options=[]
	for i in sides :
		if (check_side_ok(to_be_rotate,i,min_border,maxborder)): 
			side_options.append(i)
	to_be_rotate[0]=temp	
	return side_options
#-----------------------------------------------------------
#------------------Cheking all sides Function---------------------
#..................................................................


#--------------------------------------------------------------------------
#------------Checking which objects can be rotating or in other words
#----in other words wich objects pass the check all sides function 
#---input(To_Be_rotate)
#---Output(List of objects that can be rotate)
#--------------------------------------------------------------------------
def free_way_list(to_be_rotate,min_border,maxborder):# return list of aviable object for rotate
	temp=to_be_rotate[0]
	list_next_obj=((cmds.ls(tr=1,v=1)))
	
	x=[]
	for i in list_next_obj:
		cmds.select(i)
		if (check_all_sides(to_be_rotate,min_border,maxborder)):
			
			x.append(i)
	to_be_rotate[0]=temp
	cmds.select (to_be_rotate[0])
	return (x)

#------------End of Checking which objects can be rotating or in other words


#----------Arrange function---------------
# Arrange the list of boxes acording standart way of countring from 
# left to right and then down , left to right and so on.....
#--Input(scaning area(border range),the smallest edege in the sence)
#--Output(clean list after delete all duplicates in sence)

def minmax_clean (border_range,smallest_edge) :
# i wish i heard more about list commands before i wrote this script! dammm me.	
	line=0
	w=smallest_edge #search area
		
	sort_list=[]
	new_list=[]
	big_list=[]
	
	while (line <= border_range):
		list_next_obj=((cmds.ls(tr=1,v=1)))
		num_list=len(list_next_obj)
		sort_list=[]
		for i in list_next_obj:
		
			point=cmds.exactWorldBoundingBox(i)
			if (point[5] <= (line+(w/10))) and (point[5] >=( line-(w/10))):
				
				sort_list.append(i)
				
	
		while (sort_list) :
			place=0
	
			smallX=(cmds.exactWorldBoundingBox(sort_list[0]))[3]
			for i in range(0,len(sort_list)):
				smallX_temp=(cmds.exactWorldBoundingBox(sort_list[i]))[3]
				if (smallX > smallX_temp):
					smallX=smallX_temp
							
					place=i
							
			new_list.append(sort_list.pop(place))
		new_list = clean_list(new_list)
		big_list=big_list+new_list
		new_list=[]	
		line+=w
		 
		

	return(big_list)
#-----------------------------------------
#----------End Of Arrange function---------------
#-----------------------------------------



#-----------------------------------------
#----------Clean Function-----------------
#--Clean copies of objects which exist in the same place.

def clean_list (new_list) :
	list01=[] #making same size list as mew_list but with "1" 
	for i in new_list:
		list01.append(1)

	for i in range (0,(len(new_list))): # check if there are duplictions and where there are puting "0" in list01
		flag=0
		for j in range (0,(len(new_list))):
			bboxI=(cmds.exactWorldBoundingBox(new_list[i]))[3]
			bboxJ=(cmds.exactWorldBoundingBox(new_list[j]))[3]
			if (flag) and ((round(bboxI,4))==(round(bboxJ,4))):list01[j]=0
			if new_list[i]==new_list[j]:flag=1
	del_list=[]
	temp_list=[]
	for i in range (0,(len(new_list))):
		if (list01[i]): temp_list.append(new_list[i])
		
	not_list=filter(lambda x:x not in temp_list,new_list)
	if (not_list): cmds.delete(not_list)
	
	return temp_list
	
#-----------------------------------------
#----------End of Clean Function----------
#-----------------------------------------



def start_software (number_box,x,y,z,width,height,depth,min_border,maxborder,side):
	#delete_all()
	to_be_rotate=[1,2,3,4,5]
	boxes=[]
	boxes=make_list_cube(number_box,x,y,z,width,height,depth)

	#making the first frame!
	#----------------The first box-----------
	to_be_rotate[0]=([boxes.pop(0)[0]])

	cmds.select(to_be_rotate[0])
	if ((cmds.currentTime(q=1))>2) : #this made in case we want to start animation after number of frame
		cmds.setKeyframe(t=cmds.currentTime(q=1)-1) 
	cmds.setAttr ("%s.visibility" %to_be_rotate[0][0],1)

	cmds.setKeyframe()
	to_be_rotate=get_sides(to_be_rotate)


	#----------------The second box that will be turned-----------
	to_be_rotate[0]=[boxes.pop(0)[0]]
	cmds.select(to_be_rotate[0])
	if ((cmds.currentTime(q=1))>2) : #this made in case we want to start animation after number of frame
		cmds.setKeyframe(t=cmds.currentTime(q=1)-1)
	
	cmds.setAttr ("%s.visibility" %to_be_rotate[0][0],1)
	cmds.setKeyframe()
	#----------------end of The second box that will be turned-----------

	cmds.currentTime(cmds.currentTime(q=1)+2,e=1) # we moving 2 frame forward so the everything will start move only from frame 2


	sides=['left','right','forward','down']


	for i in range(0,number_box) :
		option_list=check_all_sides(to_be_rotate,min_border,maxborder)
		directions=len(option_list)
	
	
	
		if (directions):
			roto(to_be_rotate,side,1,boxes)

#option_list[random.randint(0,directions-1)]

	
#SPACE ENGINES 10 pm ET/PT
start_software(25,0.5,0,10,1,0.1,1.75,-1,15,'right')
#start_software(10,0.5,0,6.5,1,0.1,1.75,-1,15,'right')

#-(number flip,(xyz) start position,width,height,depth,min_border,maxborder,side)	

blocks_rgb=(minmax_clean(7,1))




#general functain
rgb=['red','green','blue']

#random color funcation
for i in blocks_rgb:
	
	chnage_color(rgb[random.randint(0,2)],i)


#rgb pattern
color='red'

for i in blocks_rgb:
	flag=1
	if (color=='red') and (flag):
		chnage_color(color,i)
		color='green'
		flag=0
	if (color=='green') and (flag):
		chnage_color(color,i)
		color='blue'
		flag=0
	if (color=='blue') and (flag):
		chnage_color(color,i)
		color='red'
		flag=0