Alice_Assignment01+03

To see the animation :

http://www.vimeo.com/5838178

Assignment 01B, fianl, Liu

#######################################################

# Assignment 01B Recursion

# Editted by Liu, Ko-cheng

# Logic:

#  Step1: Set up initial conditions

#	 setup01): Create Biggest and smallest circles

#    setup02): Make these two circles tangent

#  Step2: Define the principles of how to get the next cirlce tangent with previous two

#  Step3: Start the recursion by the loop

###########################################################







import maya.cmds as cmds



#Step1:Define the biggest and smallest circles

BigRadius=30

SmallRadius=2

Minus= BigRadius-SmallRadius



# Create these two circles which are tangent to each other

cmds.circle(c=(0,0,0),r=30)

cmds.circle(c=(0,-28,0),r=2)



#Step2:Generate two circles which follow the tangent princples

#2.1)r1+r2=D

NextRadius=SmallRadius+1

D= NextRadius+SmallRadius

cmds.circle(n="Mcircle",c=(0,-28,0),r=D)



#2.2)offset the outmost circle based on the radius of next circle 

cmds.circle(n="Moffset",c=(0,0,0), r=BigRadius-NextRadius)

#2.3)Get the intersection point at the right side and as the center point of the new circle

#  which is tangent with previous two circles



inters = cmds.curveIntersect('Mcircle','Moffset')

inters = inters.split()

print inters

inters1 = inters[1:2]

for i in inters1:

	u = float(i)

	pos1=cmds.pointOnCurve("Mcircle", p=1, pr=u)

	myCircle=cmds.circle(c=pos1,r=3)

cmds.delete('Mcircle','Moffset')



#Step3: Loop through it based on previous steps

for i in range(1,BigRadius-3,1):

	cmds.circle(n="myOffset"+str(i),c=(0,0,0),r=Minus-i-1)

	cmds.rotate

	radius=2+i

	r1= radius

	r2= radius+1

	D=r1+r2

	

	cmds.circle(n="mycircle"+str(i),c=pos1,r=D)

	cmds.rotate(0,0,20*i,cp=u)

	myInters= cmds.curveIntersect('mycircle'+str(i),'myOffset'+str(i))

	myInters= myInters.split()

	print myInters

	

	myInters= myInters[0:2]

	for j in myInters:

		u=float(j)

		if 4 < pos2="cmds.pointOnCurve(" p="1,pr="u)" mycircle="cmds.circle(c="pos2,r="i+3)" pos1="pos2">

Assignment 03 Shi xinyu & Liu

There are still some problems among the scripting, we would like to ask how to solve the problems.
1) Since our initial idea is to show the good and bad objects in certain time, and the agent will be attracted. But we couldn't find out how to show the object in some specific times. (Which command we need to use in the scripting?)
2) We can make it work when the agent hits the good angel, but not working in Bad Evil. We still don't know why it doesn't work. We know the "hit" part is among the mel scripting and we couldn't understand the mel code so well.

These are the two main problems we have met so far. We have done our best, and thank you for your teaching in whole semester!

Liu & Shi

Assignment 03 Shi xinyu & Liu

################################################################
## Assignment03 Crowd System
## Professor: Daniel da Rocha
## Students: Liu, ko-cheng & Shi, xinyu
##
## Logic
##   Create 3 kinds of objs
##     1. agent
##       a) active movement
##     2. Good Angel (helps increase the size of agent)
##       a) passive movement
##     3. Bad Evil (shrink the size of agent)
##   a) non-movable
##   When the agents hit the Good Angel, they increase the size.
##   On ther other hand, they shrink when they hit the Bad Evil
##
## Initial Set up:
##   1. Create a cyclinder as wall that holds all the objs inside 
###################################################################

import maya.cmds as cmds
import maya.mel as mel
import random
import math

def hit(hit, agent, GoodAngel, BadEvil):
 ### define what to do when it some collision is detected
 #all transformations are made only on the agent, as the hit object will perform the same queries on this agent
 #if it hit the cube, ignore
 if hit == "wall_rigid":
  return
 agentRole = cmds.getAttr(agent + ".role")
 hitRole = cmds.getAttr(hit + ".role")
 GoodAngelRole= cmds.getAttr(GoodAngel+".role")
 BadEvilRole= cmds.getAttr(BadEvil+".role")
 if hitRole == GoodAngelRole:
  if hitRole== "good":
   cmds.scale(1.1,1.1,1.1, agent, r=1)
 elif hitRole == GoodAngelRole:
  if hitRole == "bad":
   cmds.scale(.1,.1,.1, agent, r=1)
 elif hitRole == agentRole:
  #check if both are bad
  if hitRole == "bad":
   #then shrink
   cmds.scale(.9,.9,.9, agent, r=1)
  else:
   #if good, increase size
   cmds.scale(1.1,1.1,1.1, agent, r=1)
 elif hitRole != agentRole:
  if hitRole == "bad":
   #means agent role is good
   cmds.scale(.90,.90,.90, agent, r=1)
  elif hitRole == "good":
   #means agent was bad
   cmds.scale(1.1,1.1,1.1, agent, r=1)

   
#function to create shader
def createShader(color, transparency=0, type="lambert"):
 #steps to create a new material
 shadingNode1 = cmds.shadingNode(type, asShader=1)
 shadingNode2 = cmds.sets(renderable=1, noSurfaceShader = 1, empty=1, name=shadingNode1+"SG")
 cmds.connectAttr(shadingNode1+".outColor", shadingNode2 + ".surfaceShader", force=1)
 #steps to modify material attributes
 cmds.setAttr(shadingNode1 + ".color", color[0],color[1], color[2]) #color in r g b values
 cmds.setAttr(shadingNode1 + ".transparency", transparency, transparency, transparency)
 
 return shadingNode2
 
def applyShaderOnObject(obj, shader):
 cmds.sets(obj, e=1, forceElement=shader)




class Agent:
 def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
  #set agent atributes
  self.bounciness = bounciness
  self.collide = collide
  self.rigidType = rigidType
  self.solver=solver
  self.role = role
  self.initialScale = size
  #create the agent and scale it
  self.object = cmds.polyCube(ax=(0,0,1))
  cmds.scale(size[0], size[1], size[2])
  #apply a color to the agent
  #set the object color
  sh = createShader(color, transparency=0, type="lambert")
  applyShaderOnObject(self.object[0], sh)
  
  #create the rigid body
  self.rigid = cmds.rigidBody(self.object,
         name=self.object[0] + "_rigid",
         p=position,
         b=self.bounciness,
         impulse=(0,0,0),
         sio=objType, #stand in object
         cc = 1, #contact count
         cp = 1, #contact position
         cn = 1, #contact name
         solver=self.solver)
         
  #add attribute to the rigid body to store the type of agent
  cmds.select(self.rigid, r=1)
  cmds.addAttr(ln="role", dt="string", keyable=1)
  cmds.setAttr(self.rigid + ".role", "good", type="string")

  if self.rigidType == "active":
   cmds.setAttr(self.rigid + ".active", 1)
  else:
   cmds.setAttr(self.rigid + ".active", 0)
   
  #apply the expression
  self.applyExpression()
 
 def applyExpression(self):
  "Function to apply the expression to the agent"
  #first disconnect the rotation attributes because we want to controll it via expressions
  cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
  cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] +  ".rotateX")
  cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")
  # Create expression for VehicleF with a random multiplier added to the expression.
  randX = random.uniform(-3,3)
  randY = random.uniform(3,-3)
  ####COMPOSE THE EXPRESSION STRING
  #this is how it should look like (in MEL)
  '''
  // Set wander motion of vehicle and add random multipliers.
  pCube1_rigid_0.impulseX = sin(time * -2.808801);
  pCube1_rigid_0.impulseY = (noise(time) * -1.041035);

  // Set orientation of Vehicle according to the velocity direction.
  float $fVel[];
  $fVel  = `getAttr pCube1_rigid_0.velocity`;

  pCube1.rotateX = 0;
  pCube1.rotateZ = atan2d( $fVel[0], $fVel[1] );
  pCube1.rotateY = 0;
  
  //checking bumps on other agents
  string $lastHit;
  if (pCube1_rigid_0.contactCount > 0){
   int $contactCount = `getAttr pCube1_rigid_0.contactCount`;
   $lastHit = `getAttr pCube1_rigid_0.contactName[0]`;
   string $rigid = "pCube1_rigid_0";
   string $rigid01 = "pSphere1_rigid_0";
   python("hit('"+$lastHit+"', '"+ $rigid +"','"+rigid01+"')");
  };//endif
  '''
  #now put the text above in a python string
  #the first lines define how the agent will wander
  expString = "// Set wander motion of vehicle and add random multipliers.\n"
  expString += "%s.impulseX" % self.rigid
  expString += " = sin(time * %f);\n" % randX
  expString += "%s.impulseY" % self.rigid
  expString += " = (noise(time) * %f);\n\n" % randY
  #the second part, how it rotates according to the direction it is going (velocity vector)
  expString += "// Set orientation of Vehicle according to the velocity direction.\n"
  expString += "float $fVel[];\n"
  expString += "$fVel  = `getAttr %s.velocity`;\n\n" % (self.rigid)
  expString += "%s.rotateX = 0;\n" % self.object[0]
  expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
  expString += "%s.rotateY = 0;\n\n" % self.object[0]
  #the third part, checking bumps on other agents
  expString += "//checking bumps on other agents\n"
  expString += "string $lastHit;\n"
  expString += "if (%s.contactCount > 0){\n" % self.rigid
  expString += "  int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
  expString += "  $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
  expString += '  string $rigid = "%s";\n' % self.rigid
  expString += '  string $rigid01 = "%s";\n' % self.rigid
  expString += '  string $rigid02 = "%s";\n' % self.rigid
  expString += '  python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\',\'"+ $rigid01 +"\',\'"+ $rigid02 +"\')");\n'
  expString += "};//endif\n"
  
  
  
  self.expString = expString
  cmds.expression(s=expString)  
  
class Goodobj:
 def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
  #set Goodobj atributes
  self.bounciness = bounciness
  self.collide = collide
  self.rigidType = rigidType
  self.solver=solver
  self.role = role
  self.initialScale = size
  #create the agent and scale it
  self.object = cmds.polySphere(ax=(0,0,1))
  cmds.scale(size[0], size[1], size[2])
  #apply a color to the agent
  #set the object color
  sh = createShader(color, transparency=0, type="lambert")
  applyShaderOnObject(self.object[0], sh)
  
  #create the rigid body
  self.rigid01 = cmds.rigidBody(self.object,
         name=self.object[0] + "_rigid",
         p=position,
         b=self.bounciness,
         impulse=(0,0,0),
         sio=objType, #stand in object
         cc = 1, #contact count
         cp = 1, #contact position
         cn = 1, #contact name
         solver=self.solver)
         
  #add attribute to the rigid body to store the type of agent
  cmds.select(self.rigid01, r=1)
  cmds.addAttr(ln="role", dt="string", keyable=1)
  cmds.setAttr(self.rigid01 + ".role", "good", type="string")

  if self.rigidType == "active":
   cmds.setAttr(self.rigid01 + ".active", 1)
  else:
   cmds.setAttr(self.rigid01 + ".active", 0)

   
class Badobj:
 def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
  #set Goodobj atributes
  self.bounciness = bounciness
  self.collide = collide
  self.rigidType = rigidType
  self.solver=solver
  self.role = role
  self.initialScale = size
  #create the agent and scale it
  self.object = cmds.polyCone(ax=(0,0,1))
  cmds.scale(size[0], size[1], size[2])
  #apply a color to the agent
  #set the object color
  sh = createShader(color, transparency=0, type="lambert")
  applyShaderOnObject(self.object[0], sh)
  
  #create the rigid body
  self.rigid02 = cmds.rigidBody(self.object,
         name=self.object[0] + "_rigid",
         p=position,
         b=self.bounciness,
         impulse=(0,0,0),
         sio=objType, #stand in object
         cc = 1, #contact count
         cp = 1, #contact position
         cn = 1, #contact name
         solver=self.solver)
         
  #add attribute to the rigid body to store the type of agent
  cmds.select(self.rigid02, r=1)
  cmds.addAttr(ln="role", dt="string", keyable=1)
  cmds.setAttr(self.rigid02 + ".role", "good", type="string")

  if self.rigidType == "active":
   cmds.setAttr(self.rigid02 + ".active", 0)
  else:
   cmds.setAttr(self.rigid02 + ".active", 0)

##############################################
class Crowd:
 def __init__(self, numAgents=20, numGoodobjs=20, numBadobjs=20,minPosition=-70, maxPosition=70, walls=0):
  #set the playback options to increase the time range
  cmds.playbackOptions(min= 1, max=5000)
  self.numAgents = numAgents
  self.numGoodobjs= numGoodobjs
  self.numBadobjs= numBadobjs
  self.minPosition = minPosition
  self.maxPosition = maxPosition
  #get any selected objects
  self.wallObjs = cmds.ls(sl=1)
  #create the rigid solver
  self.solver = self.createSolver()
  #create the agents
  self.createAgents()
  #create the goodobjs
  self.createGoodobj()
  #create the badobjs
  self.createBadobj()
  #create the walls
  if walls: self.makeWalls()
  
 def createSolver(self):
  solver = cmds.rigidSolver( create=1,
            current=1,
            name="crowdSolver",
            velocityVectorScale=0.5,
            displayVelocity=1,
            sc=1, #showcollision
            ctd=1 #contact data
            )
  cmds.setAttr(solver + ".allowDisconnection", 1)
  return solver
  
 def createAgents(self):
  type = ["good", (3,3,3), (1,1,0)] #name, scale, color
  self.goodAgents = []
  for i in range(self.numAgents):
   #get the agent type randomly
   #get random x and y
   x = random.uniform(self.minPosition,self.maxPosition)
   y = random.uniform(self.minPosition,self.maxPosition)
   #create the agents
   a = Agent(self.solver, type[0], color=type[2], size=type[1], position=(x,y,0))

   self.goodAgents.append(a)
 def createGoodobj(self):
   type = ["good", (3,3,3), (1,0,0)] #name, scale, color
   self.goodobjs = []
   for i in range(self.numGoodobjs):
    #get the agent type randomly
    #get random x and y
    x = random.uniform(self.minPosition,self.maxPosition)
    y = random.uniform(self.minPosition,self.maxPosition)
    #create the agents
    a = Goodobj(self.solver, type[0], color=type[2], size=type[1], position=(x,y,0))
 
    self.goodobjs.append(a)

 def createBadobj(self):
   type = ["bad", (2,2,2), (0,0,0)] #name, scale, color
   self.Badobjs = []
   for i in range(self.numBadobjs):
    #get the agent type randomly
    #get random x and y
    x = random.uniform(self.minPosition,self.maxPosition)
    y = random.uniform(self.minPosition,self.maxPosition)
    #create the agents
    a = Badobj(self.solver, type[0], color=type[2], size=type[1], position=(x,y,0))
    self.Badobjs.append(a)


 def makeWalls(self):
  #get selected object,
  #which should be already with its normals facing to the right directions,
  #and convert it to passive rigid bodies
  if len(self.wallObjs) == 0:
   return "No wall objects were selected."
  else:
   for w in self.wallObjs:
    self.wallRigid = cmds.rigidBody(w, passive=1, name= "wall_rigid", bounciness=.8)
########################################
c=Crowd(numAgents=2,numGoodobjs=10,numBadobjs=20,walls=1)

assignment 01B-Shi Xinyu

       ###############################################################
## Assignment 01
## Pof.Daniel da Rocha 
## Student.SHI Xinyu
###############################################################

# logic
# 1) creste an initial square
# 2) find these two points (pocA & pocB) for rotate the square:
#   1) get current line
#  2) use pointOnCurve find the four points of the square
#  3) use the formula to find the pocA or pocB
#   1) if this is even number times, find pocA as rotation piont
#   2) if this is odd number times, find pocB as rotation piont
# 3) select the initail square
# 4) copy & rotate the square by pocA or pocB
# 5) select the last square and run this again

import maya.cmds as cmds

# creating initial square
mySquare = cmds.nurbsSquare(sl1=6,sl2=20)

def realRecursionOpt2(iterations):
 #select mySquare  
 cmds.select( cl=1 ) 
 cmds.select( mySquare )   
 mySquareNew = cmds.duplicate( mySquare )  
 
 sides = cmds.filterExpand( sm=9 )  
   
 #create a list to store the positions  
 positions = []  
 for i in range( len(sides)  ):  
     pos = cmds.pointPosition( sides[i] +".cv[0]" )  
     positions.append(pos)  
 print positions
 
 Xa = ((positions[1][0] + positions[2][0])/2 + positions[0][0])/2
 Ya = ((positions[1][1] + positions[2][1])/2 + positions[0][1])/2
 Za = ((positions[1][2] + positions[2][2])/2 + positions[0][2])/2
 
 Xb = ((positions[1][0] + positions[2][0])/2 + positions[3][0])/2
 Yb = ((positions[1][1] + positions[2][1])/2 + positions[3][1])/2
 Zb = ((positions[1][2] + positions[2][2])/2 + positions[3][2])/2
 
 if iterations/2 ==0:
  cmds.rotate( 0,0,30, pivot=(Xa, Ya, Za) )
 else:
  cmds.rotate( 0,0,30, pivot=(Xb, Yb, Zb) )
  
 mySquare = mySquareNew

 #recursion part
 if iterations ==0:
  return "Done"
 else:
  iterations -=1
  realRecursionOpt2(iterations)

realRecursionOpt2(1)
    

Assignment 03 B - second try

This is what should be our assignment. The error is the same like in the previous script. Here we added more pavilions and a field for each pavilion and we connected the elements.

###############crowd system
###Assignment 03B

#generate random static attractors
#generate random static repulsors
#generate random dynamic principle attractors
#generate random dynamic followers

#


import maya.cmds as cmds
from random import *


class Crowd:
 def __init__(self):
  "Initialize attributes"
  #objects for obstacles
  self.collectObjects = []
  #number of vehicles
  self.vNumber = 0
  #boolean for obstacles
  self.obst = 0
  #boolean for global forces
  self.gforces = 0
  #dictionary for UI elements
  self.UIelements = {}
  #set timeline
  cmds.playbackOptions(min= 1, max=1000)
  #get selected objects
  self.collectObjects = cmds.ls(sl=1)
  #start UI
  self.crowdSystemUI()

 def crowdSystemUI(self):
  "Assembles and displays the UI for the Crowd System"
  self.UIelements["window"] = cmds.window(title="Crowd System",
            widthHeight=(300, 200)
            )
  
  self.UIelements["form"] = cmds.formLayout()
  txt = cmds.text(label="Number of Vehicles")
  collection = cmds.radioCollection()
  radiob1 = cmds.radioButton(label="10", data=1, changeCommand=self.changeVnumber)
  radiob2 = cmds.radioButton(label="20", onCommand="vNumber = 20")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  txtOB = cmds.text(label="Obstacles")
  collection2 = cmds.radioCollection()
  radiob3 = cmds.radioButton(label="On", changeCommand=self.changeObst)
  radiob4 = cmds.radioButton(label="Off")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  txtGF = cmds.text( label = "Global Forces")
  collection3 = cmds.radioCollection()
  radiob5 = cmds.radioButton(label= "On" ,changeCommand =self.changeGforces)
  radiob6 = cmds.radioButton(label="Off")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  cmds.radioCollection(collection, edit=1, select=radiob1)
  cmds.radioCollection(collection2, edit=1, select=radiob4)
  cmds.radioCollection(collection3, edit=1, select=radiob6)

  # Place Vehicle options
  form = self.UIelements["form"]
  cmds.formLayout(form,
      edit=1,
      attachForm= [
         ( txt, "top", 20),
         (txt ,"left", 70),
         (radiob1,"top", 10),
         (radiob1,"left", 20),
         (radiob2,"top", 30),
         (radiob2,"left", 20)
         ]
      )
  # Place environment options
  cmds.formLayout(form,
      edit=1,
      attachForm= [
         (txtOB, "top", 80),
         (txtOB, "left", 80),
         (radiob3, "top", 80),
         (radiob3, "left", 150),
         (radiob4 ,"top", 80),
         (radiob4, "left", 190),
         (txtGF, "top", 110),
         (txtGF, "left", 63),
         (radiob5, "top", 110),
         (radiob5, "left", 150),
         (radiob6, "top", 110),
         (radiob6, "left", 190)
         ]
      )
  # Create buttons
  button1 = cmds.button(label = "Create")
  button2 = cmds.button(label = "Cancel")

  # Place buttons in the window
  cmds.formLayout(form,
      edit=1,
      attachForm =[
         (button1, "bottom", 10),
         (button1, "left", 185),
         (button2, "bottom", 10),
         (button2, "right", 10)
         ]
      )
  # Add the commands to the buttons.
  cmds.button(button1, edit=1, command=self.createCrowd )
  cmds.button(button2, edit=1, command=self.deleteUI )
  
  cmds.showWindow(self.UIelements["window"])
 ## UI help functions
 def changeVnumber(self, *args):
  if args[0] == "true":
   self.vNumber = 10
  else:
   self.vNumber = 20
  print "vNumber:",self.vNumber 
 def changeObst(self, *args):
  if args[0] == "true":
   self.obst = 1
  else:
   self.obst = 0
  print "Obst:", self.obst
 def changeGforces(self, *args):
  if args[0] == "true":
   self.gforces = 1
  else:
   self.gforces = 0
  print "gforces:", self.gforces
 def deleteUI(self, *args):
  cmds.deleteUI(self.UIelements["window"])
  self.UIelements["window"] = ""

 ## MAIN METHODS
 def createCrowdSolver(self):
  "Creates the main rigidSolver for the elements in the Crowd System"
  self.crowdSolver = cmds.rigidSolver( create=1, 
            current=1,
            name="crowdSolver",
            velocityVectorScale=0.5,
            displayVelocity=1
            )
  cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)
  
 def createVehicle(self, vType, N):
  "Creates one vehicle and add fields and expressions to it."
  #first verify if the vehicle is of type follower (F) or leader (L)
  #and set the size of the cube according to the type (leaders are bigger! :)
  if vType == "P1":
   w = 70  #width
   h = 70#height
   d = 70  #depth
  if vType == "P2":
   w = 100 #width
   h = 100 #height
   d = 100 #depth
  
  
  if vType == "F1":
   w = 2  #width
   h = 2 #height
   d = 2  #depth
  if vType == "F2":
   w = 2  #width
   h = 4   #height
   d = 2  #depth
  if vType == "F3":
   w = 2  #width
   h = 6   #height
   d = 2  #depth
   
  if vType == "L1":
   w = 5  #width
   h = 3  #height
   d = 5  #depth
  if vType == "L2":
   w = 5  #width
   h = 5   #height
   d = 5  #depth  
  else:
   w = 5
   h = 7
   d = 5
  
  #creates the basic cube
  vehicle = cmds.polyCube(w=w,d=d,h=h)
  
  #creates the pavilion
  pavilion1 = cmds.polyCube(w=w,d=d,h=h)
  pavilion2 = cmds.polyCube(w=w,d=d,h=h)
  
  #create a vehicule force to the agent - force 1
  field1=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field1[0], vehicle[0])
  cmds.hide(field1)
  
  if vType=="L1":
   Lfield1 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=50
         )
         
   cmds.parent(Lfield1[0], vehicle[0])
   cmds.hide(Lfield1)
   
  #create a vehicule force to the agent - force 2
  field2=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field2[0], vehicle[0])
  cmds.hide(field2)
  
  if vType=="L2":
   Lfield2 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=50
         )
         
   cmds.parent(Lfield2[0], vehicle[0])
   cmds.hide(Lfield2)
   
  #create a vehicule force to the agent - force 3
  field3=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field3[0], vehicle[0])
  cmds.hide(field3)
  
  if vType=="L3":
   Lfield3 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=50
         )
         
   cmds.parent(Lfield3[0], vehicle[0])
   cmds.hide(Lfield3)
  
  #create a static force to the agent - force 4
  field4=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field4[0], pavilion1[0])
  cmds.hide(field4)
  
  if vType=="P1":
   Lfield4 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=70
         )
         
   cmds.parent(Lfield4[0], pavilion1[0])
   cmds.hide(Lfield4)
 
  #create a static force to the agent - force 5
  field5=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field5[0], pavilion2[0])
  cmds.hide(field5)
  
  if vType=="P2":
   Lfield5 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=100
         )
         
   cmds.parent(Lfield5[0], pavilion2[0])
   cmds.hide(Lfield5)
 
   
  #convert vehicle to a rigid body with random placement 
  rigid = cmds.rigidBody(
     vehicle[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=1,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
     
  #convert pavillion1 to a passive rigid body with random placement
  rigid = cmds.rigidBody(
     pavilion1[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=0,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
     
  #convert pavillion2 to a passive rigid body with random placement
  rigid = cmds.rigidBody(
     pavilion2[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=0,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
     
  #disconnect the rotation attributes of the vehicle
  cmds.disconnectAttr(rigid + "rx.output", vehicle[0]+".rx")
  cmds.disconnectAttr(rigid + "ry.output", vehicle[0]+".ry")
  cmds.disconnectAttr(rigid + "rz.output", vehicle[0]+".rz")
  
  #add expression for movement
  randX = uniform(-3,3)
  randY = uniform(-3,3)
  
  expString = "%s.impulseX = sin(time * %f);" % (rigid, randX)
  expString += "%s.impulseY = (noise(time)*%f);" % (rigid, randY)
  expString += "float $Vel[] = `getAttr %s.velocity`;" % rigid
  expString += "%s.rotateX = 0;" % vehicle[0]
  expString += "%s.rotateY = 0;" % vehicle[0]
  expString += "%s.rotateZ = atan2d( $Vel[0], $Vel[2] );" % vehicle[0]
  
  cmds.expression(s=expString)
  
  if vType == "F1":
   return [rigid, field] #returns the name of the function
   
  else:
   return[rigid, field, Lfield1]
  
  if vType == "F2":
   return [rigid, field] #returns the name of the function
   
  else:
   return[rigid, field, Lfield2] 
   
  if vType == "F3":
   return [rigid, field] #returns the name of the function
   
  else:
   return[rigid, field, Lfield3]
   
 def createCrowd(self, *args):
  "Method to assemble the whole system"
  #creates a rigidSolver to add the vehicle to
  self.createCrowdSolver()
  #turn on the velocity arrow   
  cmds.setAttr(self.crowdSolver + ".displayVelocity", 1)
  cmds.setAttr(self.crowdSolver + ".scaleVelocity", .5)
  
  #allow disconnections on the rigidSolver
  cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)
  
  ###create amount of agents
  if self.vNumber == 10:
   FNumber = 8
   LNumber = 2
  elif self.vNumber == 20:
   FNumber=18
   Lnumber=2
   
  
  #create empty lists to store followers and leaders
  followers1=[]
  leaders1=[]
  followers2=[]
  leaders2=[]
  followers3=[]
  leaders3=[]
  pavilions1=[]
  pavilions2=[]
  
  #create the followers
  for i in range(FNumber):
   if i%3 == 0:
    v=self.createVehicle("F1",i)
    followers1.append(v)

   if i%3 == 1:
    v=self.createVehicle("F2",i)
    followers2.append(v)

   if i%3 == 2:
    v=self.createVehicle("F3",i)
    followers3.append(v)
    
  #create the leaders
  for i in range(LNumber):
   if i%3 == 0:
    v=self.createVehicle("L1",i)
    leaders1.append(v)

   if i%3 == 1:
    v=self.createVehicle("L2",i)
    leaders2.append(v)

   if i%3 == 2:
    v=self.createVehicle("L3",i)
    leaders3.append(v)

  #create static attractor
  for i in range(2):
   if i%2 == 0:
    v=self.createVehicle("P1",i)
    pavilions1.append(v)

   if i%2 == 1:
    v=self.createVehicle("P2",i)
    pavilions2.append(v)


  
  cmds.polyCube( sx=10, sy=15, sz=5, h=20 )
  #result is a 20 units height rectangular box
  #with 10 subdivisions along X, 15 along Y and 20 along Z.


      
   
     
  #CONNECT THE FIELDS TO THE RIGID BODIES(AGENTS)
  #1) Connect the leaders with the followers 1-1
  
  for i in range(LNumber):
   if i%3 == 0:
    Lfield1=leaders1[i][2]
    lfield1=leaders1[i][1]
    for j in range (FNumber):
     if j%3 == 0:
      Frigid1 = followers1[j][0]
      #connect the fields
      cmds.connectDynamic(Frigid1, fields=Lfields)
      cmds.connectDynamic(Frigid1, fields=lfields)
     
   if i%3 == 1:
    Lfield2=leaders2[i][2]
    lfield2=leaders2[i][1]
    for j in range (FNumber):
     if j%3 == 1:
      Frigid1 = followers2[j][0]
      #connect the fields
      cmds.connectDynamic(Frigid2, fields=Lfields)
      cmds.connectDynamic(Frigid2, fields=lfields)
     
   else:
    Lfield3=leaders3[i][2]
    lfield3=leaders3[i][1]
    for j in range (FNumber):
     if j%3 == 2:
      Frigid3 = followers3[j][0]
      #connect the fields
      cmds.connectDynamic(Frigid3, fields=Lfields)
      cmds.connectDynamic(Frigid3, fields=lfields)
     
    
    
    
  #2) Connect followers to leaders
  for i in range(FNumber):
   if i%3 == 0:
    Ffield1 = followers1[i][1]
    for j in range(LNumber):
     if j%3 == 0:
      Lrigid1 = leaders1[j][0]
      cmds.connectDynamic(Lrigid1, fields=Ffield)
      
  
   if i%3 == 1:
    Ffield2 = followers2[i][1]
    for j in range(LNumber):
     if j%3 == 1:
      Lrigid2 = leaders2[j][0]
      cmds.connectDynamic(Lrigid2, fields=Ffield)
    
     else:
     Ffield3 = followers3[i][1]
     for j in range(LNumber):
      if j%3 == 2:
       Lrigid3 = leaders3[j][0]
       cmds.connectDynamic(Lrigid3, fields=Ffield)
     
    
    
    
  #3) Connect leaders to leaders
  for i in range (LNumber):
   if i%3 == 0:
    Lrigid1 = leaders1[i][0]
    Lfield1 = leaders1[i][1]
    for j in range(LNumber):
     if i == f: continue
     if j%3 == 0:
      L1rigid = leaders1[j][0]
      #l1field = leaders1[j][1]
      cmds.connectDynamic(L1rigid, fields=Lfield)
     
   if i%3 == 1:
    Lrigid2 = leaders2[i][0]
    Lfield2 = leaders2[i][1]
    for j in range(LNumber):
     if i == f: continue
     if j%3 == 1:
      L1rigid = leaders2[j][0]
      #l1field = leaders1[j][1]
      cmds.connectDynamic(L1rigid, fields=Lfield)
  
   if i%3 == 2:
    Lrigid3 = leaders3[i][0]
    Lfield3 = leaders3[i][1]
    for j in range(LNumber):
     if i == f: continue
     if j%3 == 2:
      L1rigid = leaders3[j][0]
      #l1field = leaders1[j][1]
      cmds.connectDynamic(L1rigid, fields=Lfield)
    
  #4) Connect followers to followers
  for i in range(FNumber):
   if i%3 == 0:
    Ffield1=followers1[i][1]
    for j in range(FNumber):
     if i==j: continue
     if j%3 == 0:
      Frigid1 = followers1[j][0]
      
      cmds.connectDynamics(Frigid1, fields=Ffield)
   if i%3 == 1:
    Ffield2=followers2[i][1]
    for j in range(FNumber):
     if i==j: continue
     if j%3 == 1:
      Frigid2 = followers2[j][0]
      
      cmds.connectDynamics(Frigid2, fields=Ffield)
   else:
    Ffield3=followers3[i][1]
    for j in range(FNumber):
     if i==j: continue
     if j%3 == 2:
      Frigid3 = followers3[j][0]
      
      cmds.connectDynamics(Frigid3, fields=Ffield)
    
  
    
    
    
  #create obstacles if i want
  if self.obst:self.collectObstacles()
 
  
  
  
  #disable solver warnings
  cmds.cycleCheck(e=0)  
      
  #disable solver warnings
  cmds.cycleCheck(e=0)
  
 def collectObstacles(self):
  "Collects all obstacles"
  if len(self.collectObjects) == 0:
   #there is nothing selected
   return "There is nothing selected!"
   
  for o in self.collectObjects:
   cmds.rigidBody( o,
       passive = 1,
       name=o+"_rb",
       bounciness=2.0)
       
#craete an instance for this class
c=Crowd()
 

Assignment 03B - first try

In this script we tried to add pavilions(by script) and obstacles(manually in maya). It seams to be something wrong when we define the pavilions. Pavilions are static rigid bodies. The only difference between vehicles and pavilions is the varriable active, which is 0 for pavilions. It is a wrong way to define pavilions like that?

#######################################################################################################
##
## CROWD SYSTEM
## Adapted from original idea by Mark R. Wilkins and Chris Kazmier
##
## Modified: 22.06.09 by Daniel da Rocha
##
## Last Modified: 21.07.09 by  Alexandra Virlan and Mircea Mogan
##
#######################################################################################################


import maya.cmds as cmds
from random import *


class Crowd:
 def __init__(self):
  "Initialize attributes"
  #objects for obstacles
  self.collectObjects = []
  #number of vehicles
  self.vNumber = 0
  #boolean for obstacles
  self.obst = 0
  #boolean for global forces
  self.gforces = 0
  #dictionary for UI elements
  self.UIelements = {}
  #set timeline
  cmds.playbackOptions(min= 1, max=1000)
  #get selected objects
  self.collectObjects = cmds.ls(sl=1)
  #start UI
  self.crowdSystemUI()

 def crowdSystemUI(self):
  "Assembles and displays the UI for the Crowd System"
  self.UIelements["window"] = cmds.window(title="Crowd System",
            widthHeight=(300, 200)
            )

  self.UIelements["form"] = cmds.formLayout()
  txt = cmds.text(label="Number of Vehicles")
  collection = cmds.radioCollection()
  radiob1 = cmds.radioButton(label="10", data=1, changeCommand=self.changeVnumber)
  radiob2 = cmds.radioButton(label="20", onCommand="vNumber = 20")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  txtOB = cmds.text(label="Obstacles")
  collection2 = cmds.radioCollection()
  radiob3 = cmds.radioButton(label="On", changeCommand=self.changeObst)
  radiob4 = cmds.radioButton(label="Off")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  txtGF = cmds.text( label = "Global Forces")
  collection3 = cmds.radioCollection()
  radiob5 = cmds.radioButton(label= "On" ,changeCommand =self.changeGforces)
  radiob6 = cmds.radioButton(label="Off")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  cmds.radioCollection(collection, edit=1, select=radiob1)
  cmds.radioCollection(collection2, edit=1, select=radiob4)
  cmds.radioCollection(collection3, edit=1, select=radiob6)

  # Place Vehicle options
  form = self.UIelements["form"]
  cmds.formLayout(form,
      edit=1,
      attachForm= [
         ( txt, "top", 20),
         (txt ,"left", 70),
         (radiob1,"top", 10),
         (radiob1,"left", 20),
         (radiob2,"top", 30),
         (radiob2,"left", 20)
         ]
      )
  # Place environment options
  cmds.formLayout(form,
      edit=1,
      attachForm= [
         (txtOB, "top", 80),
         (txtOB, "left", 80),
         (radiob3, "top", 80),
         (radiob3, "left", 150),
         (radiob4 ,"top", 80),
         (radiob4, "left", 190),
         (txtGF, "top", 110),
         (txtGF, "left", 63),
         (radiob5, "top", 110),
         (radiob5, "left", 150),
         (radiob6, "top", 110),
         (radiob6, "left", 190)
         ]
      )
  # Create buttons
  button1 = cmds.button(label = "Create")
  button2 = cmds.button(label = "Cancel")

  # Place buttons in the window
  cmds.formLayout(form,
      edit=1,
      attachForm =[
         (button1, "bottom", 10),
         (button1, "left", 185),
         (button2, "bottom", 10),
         (button2, "right", 10)
         ]
      )
  # Add the commands to the buttons.
  cmds.button(button1, edit=1, command=self.createCrowd )
  cmds.button(button2, edit=1, command=self.deleteUI )

  cmds.showWindow(self.UIelements["window"])
 ## UI help functions
 def changeVnumber(self, *args):
  if args[0] == "true":
   self.vNumber = 10
  else:
   self.vNumber = 20
  print "vNumber:",self.vNumber
 def changeObst(self, *args):
  if args[0] == "true":
   self.obst = 1
  else:
   self.obst = 0
  print "Obst:", self.obst
 def changeGforces(self, *args):
  if args[0] == "true":
   self.gforces = 1
  else:
   self.gforces = 0
  print "gforces:", self.gforces
 def deleteUI(self, *args):
  cmds.deleteUI(self.UIelements["window"])
  self.UIelements["window"] = ""

 ## MAIN METHODS
 def createCrowdSolver(self):
  "Creates the main rigidSolver for the elements in the Crowd System"
  self.crowdSolver = cmds.rigidSolver( create=1,
            current=1,
            name="crowdSolver",
            velocityVectorScale=0.5,
            displayVelocity=1
            )
  cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)

 def createVehicle(self, vType, N):
  "Creates one vehicle and add fields and expressions to it."
  #first verify if the vehicle is of type follower (F) or leader (L)
  #and set the size of the cube according to the type (leaders are bigger! :)
  if vType == "F":
   w = 2  #width
   h = 2.5 #height
   d = 2  #depth

  if vType == "P":
   w = 100 #width
   h = 100 #height
   d = 100 #depth

  else:
   w = 5
   h = 3.5
   d = 5

  #creates the basic cube
  vehicle = cmds.polyCube(w=w,d=d,h=h)
  pavilion = cmds.polyCube(w=w,d=d,h=h)

  #create a vehicule force to the agent
  field=cmds.radial(position=[0,0,0],
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
       
  cmds.parent(field[0], vehicle[0])
  cmds.parent(field[0], pavilion[0])
  cmds.hide(field)

  if vType=="L":
   Lfield = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=50
         )
       
   cmds.parent(Lfield[0], vehicle[0])
   cmds.hide(Lfield)

  #convert it to a rigid body with random placement
  rigid = cmds.rigidBody(
     vehicle[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=1,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
   
  rigid = cmds.rigidBody(
     pavilion[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=0,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
   
  #disconnect the rotation attributes of the vehicle   ??)?)?)?)
  cmds.disconnectAttr(rigid + "rx.output", vehicle[0]+".rx")
  cmds.disconnectAttr(rigid + "ry.output", vehicle[0]+".ry")
  cmds.disconnectAttr(rigid + "rz.output", vehicle[0]+".rz")

  #add expression for movement
  randX = uniform(-3,3)
  randY = uniform(-3,3)

  expString = "%s.impulseX = sin(time * %f);" % (rigid, randX)
  expString += "%s.impulseY = (noise(time)*%f);" % (rigid, randY)
  expString += "float $Vel[] = `getAttr %s.velocity`;" % rigid
  expString += "%s.rotateX = 0;" % vehicle[0]
  expString += "%s.rotateY = 0;" % vehicle[0]
  expString += "%s.rotateZ = atan2d( $Vel[0], $Vel[2] );" % vehicle[0]

  cmds.expression(s=expString)

  if vType == "F":
   return [rigid, field] #returns the name of the function
 
  if vType == "L":
   return[rigid, field, Lfield]
 
  else:
   return[rigid, field, Pfield]

 def createCrowd(self, *args):
  "Method to assemble the whole system"
  #creates a rigidSolver to add the vehicle to
  self.createCrowdSolver()
  #turn on the velocity arrow 
  cmds.setAttr(self.crowdSolver + ".displayVelocity", 1)
  cmds.setAttr(self.crowdSolver + ".scaleVelocity", .5)

  #allow disconnections on the rigidSolver
  cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)

  ###create amount of agents
  if self.vNumber == 10:
   FNumber = 8
   LNumber = 2
  elif self.vNumber == 20:
   FNumber=18
   Lnumber=2
 
  #create empty lists to store followers and leaders
  followers=[]
  leaders=[]
  pavilions=[]
  #create the followers
  for i in range(FNumber):
     v=self.createVehicle("F",i)
     followers.append(v)

  #create the leaders
  for i in range(LNumber):
     v=self.createVehicle("L",i)
     leaders.append(v)
   
  create pavilion
  for i in range(1):
     v=self.createVehicle("P",i)
     pavilions.append(v)
   
   

  #CONNECT THE FIELDS TO THE RIGID BODIES(AGENTS)
  #1) Connect the leaders with the followers

  for i in range(LNumber):
   Lfield=leaders[i][2]
   lfield=leaders[i][1]
   for j in range (FNumber):
    Frigid = followers[j][0]
    #connect the fields
    cmds.connectDynamic(Frigid, fields=Lfields)
    cmds.connectDynamic(Frigid, fields=lfields)
  

  #2) Connect followers to leaders
  for i in range(FNumber):
   Ffield = followers[i][1]
   for j in range(LNumber):
    Lrigid = leaders[j][0]
    cmds.connectDynamic(Lrigid, fields=Ffield)
  
  #3) Connect leaders to leaders
  for i in range (LNumber):
   Lrigid = leaders[i][0]
   Lfield = leaders[i][1]
   for j in range(LNumber):
    if i == f: continue
    L1rigid = leaders[j][0]
    #l1field = leaders[j][1]
    cmds.connectDynamic(L1rigid, fields=Lfield)
  
  #4) Connect followers to followers
  for i in range(FNumber):
   Ffield=followers[i][1]
   for j in range(FNumber):
    if i==j: continue
    Frigid = followers[j][0]
  
    cmds.connectDynamics(Frigid, fields=Ffield)
  
  #5) Connect the pavilion with the leaders

  for i in range(1):
   Pfield=pavilions[i][2]
   Lfield=pavilions[i][1]
 
   for j in range (LNumber):
    Frigid = leaders[j][0]
    #connect the fields
    cmds.connectDynamic(Frigid, fields=Pfields)
    cmds.connectDynamic(Frigid, fields=Lfields)
  

  #6) Connect leaders to pavilions
  for i in range(LNumber):
   Lfield = leaders[i][1]
   for j in range(1):
    Frigid = pavilions[j][0]
    cmds.connectDynamic(Prigid, fields=Lfield)

  #create obstacles if i want
  if self.obst:self.collectObstacles()

  #disable solver warnings
  cmds.cycleCheck(e=0)
    
  #disable solver warnings
  cmds.cycleCheck(e=0)

 def collectObstacles(self):
  "Collects all obstacles"
  if len(self.collectObjects) == 0:
   #there is nothing selected
   return "There is nothing selected!"
 
  for o in self.collectObjects:
   cmds.rigidBody( o,
       passive = 1,
       name=o+"_rb",
       bounciness=2.0)
     
#craete an instance for this class
c=Crowd()

Chinese whispers

::: SYNOPSIS :::
My idea is to have 1EMITER, 1RECEPTOR, and n number of TRANSMITOR!
The aim of this script is to bring the information from the EMITER, to the RECEPTOR by the TRANSMITOR!
The information is symbolized by the red color, the white color symbolized the un-information ...
The EMITER and the RECEPTOR doesn't move, only theTRANSMITOR can move!...

When a TRANSMITOR hit the EMITER, the TRANSMITOR become red, the EMITER become white!
Then when this red-TRANSMITOR hit another black-TRANSMITOR, the red become black again, and the black become red!
The Information is transmitted! ... When finally the RECEPTOR is hitting by a red TRANSMITOR, the script stop! ...

::: AUTO-COMMENTS :::
- Does this script too simple?
- I will try to clean a little bit the hit part! It's a little bit messy, and I found a new way to do it!
- I also want to script another scenerio based on the same principe

####################################
## INFORMATIONS DIFFUSION
## Chinese whispers
####################################

import maya.cmds as cmds
import maya.mel as mel
import random
import math


# Function to create shader
def createShader(color, transparency=0, type="lambert", name="shader"):
#steps to create a new material
shadingNode1 = cmds.shadingNode(type, asShader=1, name=name)
shadingNode2 = cmds.sets(renderable=1, noSurfaceShader = 1, empty=1, name=name)
cmds.connectAttr(shadingNode1+".outColor", shadingNode2 + ".surfaceShader", force=1)
#steps to modify material attributes
cmds.setAttr(shadingNode1 + ".color", color[0],color[1], color[2]) #color in r g b values
cmds.setAttr(shadingNode1 + ".transparency", transparency, transparency, transparency)

return shadingNode2


# Function to create shader I need
def myshaders():
# Create the transmitter shader => no information
if cmds.objExists('noir'):
# stupid line just to say to python to do nothing!
nothing = 0
else:
noir = createShader((0,0,0), transparency=0, type="lambert", name="noir")

# Create the Receptor shader => awaiting the information
if cmds.objExists('blanc'):
# stupid line just to say to python to do nothing!
nothing = 0
else:
blanc = createShader((255,255,255), transparency=0, type="lambert", name="blanc")

# Create the transmitter shader => information
if cmds.objExists('rouge'):
# stupid line just to say to python to do nothing!
nothing = 0
else:
rouge = createShader((255,0,0), transparency=0, type="lambert", name="rouge")

# Create the box shader, transparent to see what's happen inside! =)
if cmds.objExists('transparent'):
# stupid line just to say to python to do nothing!
nothing = 0
else:
transparent = createShader((0,0,0), transparency=.9, type="lambert", name="transparent")

# Function to apply the shader
def applyShaderOnObject(obj, shader):
cmds.sets(obj, e=1, forceElement=shader)

# SYNOPSIS :::
# My idea is to have 1EMITER, 1RECEPTOR, and n number of TRANSMITOR!
# The aim of this script is to bring the information from the EMITER, to the RECEPTOR by the TRANSMITOR!
# The information is symbolized by the red color, the white color symbolized the un-information ...
# The EMITER and the RECEPTOR doesn't move, only the TRANSMITOR can move!...

# When a TRANSMITOR hit the EMITER, the TRANSMITOR become red, the EMITER become white!
# Then when this red-TRANSMITOR hit another black-TRANSMITOR, the red become black again, and the black become red!
# The Information is transmitted! ... When finally the RECEPTOR is hitting by a red TRANSMITOR, the script stop! ...

def hit(hit, agent):
### define what to do when it some collision is detected
if hit == "wall_rigid":
return

agentRole = cmds.getAttr(agent + ".role")
hitRole = cmds.getAttr(hit + ".role")
agentShader = cmds.getAttr(agent + ".shader")
hitShader = cmds.getAttr(hit + ".shader")

# If the emitter hit a transmitter
if agentRole == "emitter":
if hitRole == "transmitters":
#print agentRole # = emitter
#print hitRole # = transmitter

if agentShader == 'rouge1':
# change the color of the transmitter from black to red
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(hit+".shader", 'rouge1', type="string")

# change the color of the emitter from red to black
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(agent+".shader", 'noir1', type="string")


# If a transmiter hit a emitter
if agentRole == "transmitters":
if hitRole == "emitter":
#print agentRole # = trans
#print hitRole # = emit

if hitShader == 'rouge1':
# change the color of the emitter from red to black
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(hit+".shader", 'noir1', type="string")

# change the color of the transmitter from black to red
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(agent+".shader", 'rouge1', type="string")


# If a transmitter hit another transmitter
if agentRole == "transmitters":
if hitRole == "transmitters":

if agentShader == 'rouge1':
# change the color of the frist transmitter from black to red
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(hit+".shader", 'rouge1', type="string")

# change the color of the second transmitter from red to black
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(agent+".shader", 'noir1', type="string")


if hitShader == 'rouge1':
# change the color of the frist transmitter from red to black
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(hit+".shader", 'noir1', type="string")

# change the color of the second transmitter from black to red
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(agent+".shader", 'rouge1', type="string")


# And Finally, if an emitter hit the receptor!
if agentRole == "receptor":
if hitRole == "transmitters":
#print agentRole # = receptor
#print hitRole # = emitter

if hitShader == 'rouge1':
# change the color of the transmitter from red to black
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(hit+".shader", 'noir1', type="string")

# change the color of the receptor form white to red
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(agent+".shader", 'rouge1', type="string")

# means that the information is propely transmitted
# so, stop the animation, and print a feedback
cmds.play( state=False )
frame = cmds.currentTime( query=True )
print "INFORMATION TRANSMITED IN", frame, "FRAMES"


# if an emitter hit the receptor!
if agentRole == "transmitters":
if hitRole == "receptor":
#print agentRole # = emit
#print hitRole # = trans

if agentShader == 'rouge1':
# change the color of the receptor form white to red
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(hit+".shader", 'rouge1', type="string")

# change the color of the transmitter from red to black
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(agent+".shader", 'noir1', type="string")

# means that the information is propely transmitted
# so, stop the animation, and print a feedback
cmds.play( state=False )
frame = cmds.currentTime( query=True )
print "INFORMATION TRANSMITED IN", frame, "FRAMES"



class Agent:
def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="sphere", rigidType="active", bounciness=.6, collide=1, mass=1, speed=5):
#set agent atributes
self.bounciness = bounciness
self.collide = collide
self.rigidType = rigidType
self.solver=solver
self.role = role
self.initialScale = size
self.mass=mass
self.speed = speed

#create the agent and scale it
self.object = cmds.polySphere(ax=(0,0,1))
cmds.scale(size[0], size[1], size[2])
#apply a color to the agent
#set the object color

applyShaderOnObject(self.object[0], color)

#create the rigid body
self.rigid = cmds.rigidBody(self.object,
    name=self.object[0] + "_rigid",
    p=position,
    b=self.bounciness,
    impulse=(0,0,0),
    sio=objType, #stand in object
    cc = 1, #contact count
    cp = 1, #contact position
    cn = 1, #contact name
    si = (190,190,190),
    m=mass,
    solver=self.solver)

#add attribute to the rigid body to store the type of agent
cmds.select(self.rigid, r=1)
cmds.addAttr(ln="role", dt="string", keyable=1, w=1)
cmds.setAttr(self.rigid + ".role", self.role, type="string")

cmds.addAttr(ln="obj", dt="string", keyable=1, w=1)
cmds.setAttr(self.rigid + ".obj", self.object[0] , type="string")

cmds.addAttr(ln="shader", dt="string", keyable=1, w=1)
cmds.setAttr(self.rigid + ".shader", color , type="string")

self.applyExpression(speed)

def applyExpression(self, speed):
"Function to apply the expression to the agent"
#first disconnect the rotation attributes because we want to controll it via expressions
cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] +  ".rotateX")
cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")

# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-speed,speed)
randY = random.uniform(speed,-speed)

expString = "// Set wander motion of vehicle and add random multipliers.\n"

if self.role == "transmitters":
####COMPOSE THE EXPRESSION STRING
#now put the text above in a python string
#the first lines define how the agent will wander

expString += "%s.impulseX" % self.rigid
expString += " = (cos(time*%f));\n" % randX
expString += "%s.impulseY" % self.rigid
expString += " = ((noise(time) * %f));\n\n" % randY


#the second part, how it rotates according to the direction it is going (velocity vector)
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel[];\n"
expString += "$fVel  = `getAttr %s.velocity`;\n\n" % (self.rigid)
expString += "%s.rotateX = 0;\n" % self.object[0]
expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
expString += "%s.rotateY = 0;\n\n" % self.object[0]


#the third part, checking bumps on other agents
expString += "//checking bumps on other agents\n"
expString += "string $lastHit;\n"
expString += "if (%s.contactCount > 0){\n" % self.rigid
expString += "  int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
expString += "  $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
expString += '  string $rigid = "%s";\n' % self.rigid
expString += '  python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\')");\n'
expString += "};//endif\n"

self.expString = expString
cmds.expression(s=expString)







##############################################
class Crowd:
def __init__(self, numAgents=20, scaleRecept=2.5, scaleTrans=2, minPosition=-70, maxPosition=70, walls=1, speed=5):
#set the playback options to increase the time range
cmds.playbackOptions(min= 1, max=5000)
self.numAgents = numAgents
self.minPosition = minPosition
self.maxPosition = maxPosition
self.scaleRecept = scaleRecept
self.scaleTrans = scaleTrans
self.speed = speed

#get any selected objects
self.createBorders(scaleRecept,maxPosition)
self.wallObjs = cmds.ls(sl=1)

#create the rigid solver
self.solver = self.createSolver()
#create the agents
self.createAgents(scaleRecept, scaleTrans, speed)
#create the walls
if walls: self.makeWalls()


# Create a box to contain the balls
def createBorders(self, scaleRecept,maxPosition):
cmds.polyCube(n="border", ax=(0,0,0), w=((maxPosition*2)+(scaleRecept*2)), h=((maxPosition*2)+(scaleRecept*2)), d=(scaleRecept*2))
cmds.polyNormal( nm=0 )
myshaders()
applyShaderOnObject("border", 'transparent1')

cmds.select("border")


# Create Solver
def createSolver(self):
solver = cmds.rigidSolver(create=1, current=1, name="crowdSolver", velocityVectorScale=0.1, displayVelocity=1, sc=1, ctd=1)
cmds.setAttr(solver + ".allowDisconnection", 1)
return solver

# Create x numbers of transmittors
def createAgents(self, scaleRecept, scaleTrans, speed):
myshaders()
self.speed = speed
transmitters = ['transmitters', (scaleTrans,scaleTrans,scaleTrans), 1, 'noir1'] #name, scale, mass, color
emitter = ['emitter', (scaleRecept,scaleRecept,scaleRecept), 1000, 'rouge1'] #name, scale, mass, color
receptor = ['receptor', (scaleRecept,scaleRecept,scaleRecept), 1000, 'blanc1'] #name, scale, mass, color

self.transmitlist = []
self.emitlist = []
self.receptlist = []


# Create the emeter
x = float(random.uniform(self.minPosition,self.maxPosition))
y = float(random.uniform(self.minPosition,self.maxPosition))
z = 0

emitagent = Agent(self.solver, emitter[0], size=emitter[1], color=emitter[3], position=(x,y,z), bounciness=0, mass=emitter[2], speed=speed)
liste = (self.solver, emitagent)
self.emitlist.append(liste)

# Create the receptor
x = float(random.uniform(self.minPosition,self.maxPosition))
y = float(random.uniform(self.minPosition,self.maxPosition))
z = 0

receptagent = Agent(self.solver, receptor[0], size=receptor[1], color=receptor[3], position=(x,y,z), bounciness=0, mass=receptor[2], speed=speed)
liste = (self.solver, receptagent)
self.receptlist.append(liste)


# Create n transmiters
for i in range(self.numAgents):
#get random x and y
x = random.uniform(self.minPosition,self.maxPosition)
y = random.uniform(self.minPosition,self.maxPosition)
z = 0

#create the agents
transagent = Agent(self.solver, transmitters[0], position=(x,y,z), size=transmitters[1], color=transmitters[3], mass=transmitters[2], speed=speed)
liste = (self.solver, transagent)
self.transmitlist.append(liste)


def makeWalls(self):
#get selected object,
#which should be already with its normals facing to the right directions,
#and convert it to passive rigid bodies
if len(self.wallObjs) == 0:
return "No wall objects were selected."
else:
for w in self.wallObjs:
self.wallRigid = cmds.rigidBody(w, passive=1, name= "wall_rigid", bounciness=.8)

########################################


c=Crowd(numAgents=50, walls=1, speed=5)

Predator-Prey crowd system

The goal of the script was to create a primary state of equality and to add some fields which would tarnsform(change) the boids behaviour. Therefore from simple wanderers (with no leaders) some boids would become either preys or predators.

If a predator would hit a wanderer, the number of predators would increase by one. If the predator would hit a prey, the number of preys would decrease by one and the number of predators would be the same. If a predator would enter the "force" field which changes the boids behaviour to preys, it would become a prey. If a prey would enter the "force" field which changes the boids behaviour to predators, it would become a predator.




import maya.cmds as cmds
import random


# Main
# ____
class Crowd:
def __init__(self):
#def crowdMain():
self.vNumber = 10
self.obst = 0
self.gforces = 0
self.UIelements = {}
cmds.playbackOptions(min= 1, max=500)
self.crowdSystemUI()
#end if
#end def __init__


def crowdSystemUI(self):
self.UIelements["window"] = cmds.window(title="Crowd System",
widthHeight=(300, 200)
)

self.UIelements["form"] = cmds.formLayout()
txt = cmds.text(label="Number of Vehicles")
collection = cmds.radioCollection()
radiob1 = cmds.radioButton(label="10", data=1, changeCommand=self.changeVnumber)
radiob2 = cmds.radioButton(label="20", onCommand="vNumber = 20")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

txtOB = cmds.text(label="Obstacles")
collection2 = cmds.radioCollection()
radiob3 = cmds.radioButton(label="On", changeCommand=self.changeObst)
radiob4 = cmds.radioButton(label="Off")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

txtGF = cmds.text( label = "Global Forces")
collection3 = cmds.radioCollection()
radiob5 = cmds.radioButton(label= "On" ,changeCommand =self.changeGforces)
radiob6 = cmds.radioButton(label="Off")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

cmds.radioCollection(collection, edit=1, select=radiob1)
cmds.radioCollection(collection2, edit=1, select=radiob4)
cmds.radioCollection(collection3, edit=1, select=radiob6)

# Place Vehicle options
form = self.UIelements["form"]
cmds.formLayout(form,
edit=1,
attachForm= [
( txt, "top", 20),
(txt ,"left", 70),
(radiob1,"top", 10),
(radiob1,"left", 20),
(radiob2,"top", 30),
(radiob2,"left", 20)
]
)

# Place environment options
cmds.formLayout(form,
edit=1,
attachForm= [
(txtOB, "top", 80),
(txtOB, "left", 80),
(radiob3, "top", 80),
(radiob3, "left", 150),
(radiob4 ,"top", 80),
(radiob4, "left", 190),
(txtGF, "top", 110),
(txtGF, "left", 63),
(radiob5, "top", 110),
(radiob5, "left", 150),
(radiob6, "top", 110),
(radiob6, "left", 190)
]
)

# Create buttons
button1 = cmds.button(label = "Create")
button2 = cmds.button(label = "Cancel")

# Place buttons in the window
cmds.formLayout(form,
edit=1,
attachForm =[
(button1, "bottom", 10),
(button1, "left", 185),
(button2, "bottom", 10),
(button2, "right", 10)
]
)

# Add the commands to the buttons.

cmds.button(button1, edit=1, command=self.createCrowd )
cmds.button(button2, edit=1, command=self.deleteUI )

cmds.showWindow(self.UIelements["window"])

##############################################################
def createCrowdSolver(self):
self.crowdSolver = cmds.rigidSolver( create=1,
current=1,
name="crowdSolver",
velocityVectorScale=0.5,
displayVelocity=1,
sc=1
)
cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)

def createVehicle(self, i, vType):
"Creates a Vehicle"
if vType == "F":
w = 2
h = 2.5
d = 2
else:
w=5
h=3.5
d=5
v = cmds.polyCube(name="vehicle%s_%d" % (vType, i), width = w, height = h, depth = d)
#Add a Vehicle force field for follower.
field = cmds.radial( position=(0, 0, 0),
name = "vehicle%sForce_%d" % (vType, i),
magnitude=50,
attenuation=0.3,
maxDistance = 8.0
)
cmds.parent(field[0], v[0])
cmds.hide (field)
'''
if vType == "L":
# Add leader field
lRadial = cmds.radial( position = (0, 0, 0),
name = "vehicleGlobalLeadForce_%d" % i,
magnitude = -1,
attenuation = 0.2,
maxDistance = 50
)
cmds.parent (lRadial[0], v[0])
cmds.hide (lRadial)
'''
# Make the Vehicle a Rigid Body with random placement.
rigid = cmds.rigidBody(v[0],
name="rigidVehicle%s_%d" % (vType, i),
active=1,
mass=1,
bounciness=0,
damping= 1.5 ,
position = (random.uniform(-70,70), random.uniform(-70,70), 0),
impulse =( 0, 0, 0),
standInObject="cube",
solver= self.crowdSolver
)

cmds.disconnectAttr (rigid + "ry.output", v[0] + ".rotateY")
cmds.disconnectAttr (rigid + "rx.output", v[0] + ".rotateX")
cmds.disconnectAttr (rigid + "rz.output", v[0] + ".rotateZ")

# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-3,3)
randY = random.uniform(3,-3)
expString = "// Set wander motion of vehicle and add random multipliers.\n"
expString += "%s.impulseX" % rigid
expString += " = sin(time * %f);\n" % randX
expString += "%s.impulseY" % rigid
expString += " = (noise(time) * %f);\n\n" % randY
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel%d[];\n" % i
expString += "$fVel%d = `getAttr %s.velocity`;\n\n" % (i,rigid)
expString += "%s.rotateX = 0;\n" % v[0]
expString += "%s.rotateY = atan2d( $fVel%d[0], $fVel%d[2] );\n" % (v[0],i,i)
expString += "%s.rotateZ = 0;\n" % v[0]
expString += "string $ContactNames = `getAttr %s.cnn`;\n" % rigid
expString += "print($ContactNames);\n"

#print expString
exp = cmds.expression(s=expString )
######################################################################### start w08
if vType == "F":
return [rigid, field]
else:
return [rigid, field, lRadial]

def createCrowd(self, *args) :

self.collectObjects = cmds.ls(sl=1) ###################################### get selected objects

# Bring in ints and string from interface.
# Vehicle creation for crowd system.
# Create a master crowdSolver for all Vehicles.
self.createCrowdSolver()

# Get total number of Vehicles from interface options.
if self.vNumber == 10:
FvNumber = 10 # Followers
#LvNumber = 2 # Leaders
elif self.vNumber == 20:
FvNumber = 20 # Followers
#LvNumber = 2 # Leaders

#if (self.gforces == 1): self.makeGforces() # Check Global Forces option.


# Basic Vehicle model type: follower
#____________________________
followers = []
for i in range(FvNumber):
v = self.createVehicle(i, "F")
followers.append(v)

# Basic Vehicle model type: Leader
#_________________________________
#leaders = []
#for i in range(LvNumber):
# v = self.createVehicle(i, "L")
# leaders.append(v)
##########################
# Connect the fields nested loops.
# ________________________________
'''
for i in range(LvNumber): # Connect Leaders to Followers both fields.
fieldL = leaders[i][1]
fieldLG = leaders[i][2]
for j in range(FvNumber):
rigidF = followers[j][0]
cmds.connectDynamic(rigidF, fields=fieldL)
cmds.connectDynamic(rigidF, fields=fieldLG)





for i in range(FvNumber): # Connect Followers to Leaders
fieldF = followers[i][1]
for j in range(LvNumber):
rigidL = leaders[j][0]
cmds.connectDynamic(rigidL, fields=fieldF)


# Connect same type Vehicles to each other. Disconnect Vehicle from itself.

for i in range(LvNumber): # Connect Leaders to Leaders
rigidL1 = leaders[i][0]
fieldL1 = leaders[i][1]
for j in range(LvNumber):
rigidL2 = leaders[j][0]
fieldL2 = leaders[j][1]
cmds.connectDynamic(rigidL2, fields=fieldL1)

cmds.connectDynamic(rigidL1, delete=1, fields=fieldL1)
'''
for i in range(FvNumber): # Connect Follower to Followers
rigidF1 = followers[i][0]
fieldF1 = followers[i][1]
for j in range(FvNumber):
rigidF2 = followers[j][0]
fieldF2 = followers[j][1]
cmds.connectDynamic(rigidF2, fields=fieldF1)

cmds.connectDynamic(rigidF1, delete=1, fields=fieldF1)

######################################################################################## skip this global forces thing
# Connect the Global Forces to both types of Vehicles if option is on.

if self.gforces:
self.makeGforces()

compass = [ "N", "S", "E", "W" ]
for i in range(LvNumber):
for c in range(len(compass)):
cmds.connectDynamic(leaders[i][0], fields = "Gforce" + compass[c])

for i in range(FvNumber):
for c in range(len(compass)):
cmds.connectDynamic(followers[i][0], fields = "Gforce" + compass[c])


# Build Obstacles if option is selected.
if self.obst: self.collectObstacles()

# Disable warning.

cmds.cycleCheck(e=0)

# End of createCrowd def

def collectObstacles(self):
print "collecting obstacles!!"
if len(self.collectObjects) == 0: ### show on __init__ def
return "No obstacle objects were selected."
else:
print "elseeeee"
for ob in self.collectObjects:
print ob
cmds.rigidBody(ob, passive=1, name= ob + "_RigidB", bounciness=2.0)

#end def collectObstacles


# Make Global Forces with an interface.
#______________________________________


########################################### UI functions (for radio buttons)
def changeVnumber(self, *args):
if args[0] == "true":
self.vNumber = 10
else:
self.vNumber = 20
print "vNumber:",self.vNumber
def changeObst(self, *args):
if args[0] == "true":
self.obst = 1
else:
self.obst = 0
print "Obst:", self.obst
def changeGforces(self, *args):
if args[0] == "true":
self.gforces = 1
else:
self.gforces = 0
print "gforces:", self.gforces
def deleteUI(self, *args):
cmds.deleteUI(self.UIelements["window"])
self.UIelements = {}

############### call the class
c = Crowd()

And part of the second attempt:

import maya.cmds as cmds
import maya.mel as mel
import random
import math

def hit(hit, agent):
### define what to do when it some collision is detected
#all transformations are made only on the agent, as the hit object will perform the same queries on this agent
#if it hit the cube, ignore
if hit == "wall_rigid":
return
agentRole = cmds.getAttr(agent + ".role")
hitRole = cmds.getAttr(hit + ".role")
if hitRole == agentRole:
#check if both are bad
if hitRole == "bad":
#then shrink
cmds.scale(.9,.9,.9, agent, r=1)
else:
#if good, increase size
cmds.scale(1.1,1.1,1.1, agent, r=1)
elif hitRole != agentRole:
if hitRole == "bad":
#means agent role is good
cmds.scale(.90,.90,.90, agent, r=1)
elif hitRole == "good":
#means agent was bad
cmds.scale(1.1,1.1,1.1, agent, r=1)


#function to create shader
def createShader(color, transparency=0, type="lambert"):
#steps to create a new material
shadingNode1 = cmds.shadingNode(type, asShader=1)
shadingNode2 = cmds.sets(renderable=1, noSurfaceShader = 1, empty=1, name=shadingNode1+"SG")
cmds.connectAttr(shadingNode1+".outColor", shadingNode2 + ".surfaceShader", force=1)
#steps to modify material attributes
cmds.setAttr(shadingNode1 + ".color", color[0],color[1], color[2]) #color in r g b values
cmds.setAttr(shadingNode1 + ".transparency", transparency, transparency, transparency)

return shadingNode2

def applyShaderOnObject(obj, shader):
cmds.sets(obj, e=1, forceElement=shader)




class Agent:
def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
#set agent atributes
self.bounciness = bounciness
self.collide = collide
self.rigidType = rigidType
self.solver=solver
self.role = role
self.initialScale = size
#create the agent and scale it
self.object = cmds.polySphere(ax=(0,0,1))
cmds.scale(size[0], size[1], size[2])
#apply a color to the agent
#set the object color
sh = createShader(color, transparency=0, type="lambert")
applyShaderOnObject(self.object[0], sh)

#create the rigid body
self.rigid = cmds.rigidBody(self.object,
name=self.object[0] + "_rigid",
p=position,
b=self.bounciness,
impulse=(0,0,0),
sio=objType, #stand in object
cc = 1, #contact count
cp = 1, #contact position
cn = 1, #contact name
solver=self.solver)

#add attribute to the rigid body to store the type of agent
cmds.select(self.rigid, r=1)
cmds.addAttr(ln="role", dt="string", keyable=1)
cmds.setAttr(self.rigid + ".role", "good", type="string")

if self.rigidType == "active":
cmds.setAttr(self.rigid + ".active", 1)
else:
cmds.setAttr(self.rigid + ".active", 0)

#apply the expression
self.applyExpression()

def applyExpression(self):
"Function to apply the expression to the agent"
#first disconnect the rotation attributes because we want to controll it via expressions
cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] + ".rotateX")
cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")
# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-3,3)
randY = random.uniform(3,-3)
####COMPOSE THE EXPRESSION STRING
#this is how it should look like (in MEL)
'''
// Set wander motion of vehicle and add random multipliers.
pCube1_rigid_0.impulseX = sin(time * -2.808801);
pCube1_rigid_0.impulseY = (noise(time) * -1.041035);

// Set orientation of Vehicle according to the velocity direction.
float $fVel[];
$fVel = `getAttr pCube1_rigid_0.velocity`;

pCube1.rotateX = 0;
pCube1.rotateZ = atan2d( $fVel[0], $fVel[1] );
pCube1.rotateY = 0;

//checking bumps on other agents
string $lastHit;
if (pCube1_rigid_0.contactCount > 0){
int $contactCount = `getAttr pCube1_rigid_0.contactCount`;
$lastHit = `getAttr pCube1_rigid_0.contactName[0]`;
string $rigid = "pCube1_rigid_0";
python("hit('"+$lastHit+"', '"+ $rigid +"')");
};//endif
'''
#now put the text above in a python string
#the first lines define how the agent will wander
expString = "// Set wander motion of vehicle and add random multipliers.\n"
expString += "%s.impulseX" % self.rigid
expString += " = sin(time * %f);\n" % randX
expString += "%s.impulseY" % self.rigid
expString += " = (noise(time) * %f);\n\n" % randY
#the second part, how it rotates according to the direction it is going (velocity vector)
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel[];\n"
expString += "$fVel = `getAttr %s.velocity`;\n\n" % (self.rigid)
expString += "%s.rotateX = 0;\n" % self.object[0]
expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
expString += "%s.rotateY = 0;\n\n" % self.object[0]
#the third part, checking bumps on other agents
expString += "//checking bumps on other agents\n"
expString += "string $lastHit;\n"
expString += "if (%s.contactCount > 0){\n" % self.rigid
expString += " int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
expString += " $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
expString += ' string $rigid = "%s";\n' % self.rigid
expString += ' python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\')");\n'
expString += "};//endif\n"

self.expString = expString
cmds.expression(s=expString)


##############################################
class Crowd:
def __init__(self, numAgents=20, minPosition=-70, maxPosition=70, walls=0):
#set the playback options to increase the time range
cmds.playbackOptions(min= 1, max=5000)
self.numAgents = numAgents
self.minPosition = minPosition
self.maxPosition = maxPosition
#get any selected objects
self.wallObjs = cmds.ls(sl=1)
#create the rigid solver
self.solver = self.createSolver()
#create the agents
self.createAgents()
#create the walls
if walls: self.makeWalls()

def createSolver(self):
solver = cmds.rigidSolver( create=1,
current=1,
name="crowdSolver",
velocityVectorScale=0.5,
displayVelocity=1,
sc=1, #showcollision
ctd=1 #contact data
)
cmds.setAttr(solver + ".allowDisconnection", 1)
return solver

def createAgents(self):
type1 = ["good", (3,3,3), (250,100,0)] #name, scale, color
type2 = ["bad", (5,5,5), (100,100,100)]
types = [type1, type2]
self.badAgents = []
self.goodAgents = []
for i in range(self.numAgents):
#get the agent type randomly
at = random.choice(types)
#get random x and y
x = random.uniform(self.minPosition,self.maxPosition)
y = random.uniform(self.minPosition,self.maxPosition)
#create the agents
a = Agent(self.solver, at[0], color=at[2], size=at[1], position=(x,y,0))
if at[0] == "good":
self.goodAgents.append(a)
else:
self.badAgents.append(a)

def makeWalls(self):
#get selected object,
#which should be already with its normals facing to the right directions,
#and convert it to passive rigid bodies
if len(self.wallObjs) == 0:
return "No wall objects were selected."
else:
for w in self.wallObjs:
self.wallRigid = cmds.rigidBody(w, passive=1, name= "wall_rigid", bounciness=.8)

########################################
c=Crowd(numAgents=30, walls=1)

##### Bacteria War _ crowd systems
#### started 20:21 08.07.09


### import all possibly needed


### Super Plan
###Passive agents:
## BODY (obstacles__rigid body)
## BRAIN (finish area__rigid body)
##Active agents:
## BACTERIUM (agent type1)
## DRUG (agent type2)


#####################################TRANSLATING into script
####create "BODY" and Agent 3d(small - Bacterium, big - Drug)
#### have them on stage
### rename 3d objects
### run script

import maya.cmds as cmds
import maya.mel as mel
import random
import math

def hit(hit, agent):
### define what to do when it some collision is detected
#if it hit the body, ignore
if hit == "wall_rigid":
return
agentRole = cmds.getAttr(agent + ".role")
hitRole = cmds.getAttr(hit + ".role")
if hitRole == agentRole:
#check if both are Drugs
if hitRole == "Drug":
#then rotate
cmds.rotate(90,90,0)
else:
#if Bacteria, delete Bacteria
cmds.delete('agent')
elif hitRole != agentRole:
if hitRole == "Drug":
#means agent role is Bacteria
cmds.duplicate('agent')
cmds.move(0,0,0)
elif hitRole == "Bacteria":
#means agent was Drug
cmds.delete('agent')




class Agent:
def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="agent", rigidType="active", bounciness=.6, collide=1):
#set agent atributes
self.bounciness = bounciness
self.collide = collide
self.rigidType = rigidType
self.solver=solver
self.role = role
self.initialScale = size
#create the agent and scale it
NameDubObj1 = []
myDubObj1 = cmds.duplicate( 'agent' )# creation ( dublication) of the elements (bacteria/drug)
self.object = myDubObj1
cmds.scale(size[0], size[1], size[2])

#create the rigid body
self.rigid = cmds.rigidBody(self.object,
name=self.object[0] + "_rigid",
p=position,
b=self.bounciness,
impulse=(0,0,0),
sio=objType, #stand in object
cc = 1, #contact count
cp = 1, #contact position
cn = 1, #contact name
solver=self.solver)

#add attribute to the rigid body to store the type of agent
cmds.select(self.rigid, r=1)
cmds.addAttr(ln="role", dt="string", keyable=1)
cmds.setAttr(self.rigid + ".role", "Bacteria", type="string")

if self.rigidType == "active":
cmds.setAttr(self.rigid + ".active", 1)
else:
cmds.setAttr(self.rigid + ".active", 0)

#apply the expression
self.applyExpression()

def applyExpression(self):
"Function to apply the expression to the agent"
#first disconnect the rotation attributes because we want to controll it via expressions
cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] + ".rotateX")
cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")
# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-1,1)
randY = random.uniform(1,-1)

#the first lines define how the agent will wander
expString = "// Set wander motion of vehicle and add random multipliers.\n"
expString += "%s.impulseX" % self.rigid
expString += " = sin(time * %f);\n" % randX
expString += "%s.impulseY" % self.rigid
expString += " = (noise(time) * %f);\n\n" % randY
#the second part, how it rotates according to the direction it is going (velocity vector)
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel[];\n"
expString += "$fVel = `getAttr %s.velocity`;\n\n" % (self.rigid)
expString += "%s.rotateX = 0;\n" % self.object[0]
expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
expString += "%s.rotateY = 0;\n\n" % self.object[0]
#the third part, checking bumps on other agents
expString += "//checking bumps on other agents\n"
expString += "string $lastHit;\n"
expString += "if (%s.contactCount > 0){\n" % self.rigid
expString += " int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
expString += " $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
expString += ' string $rigid = "%s";\n' % self.rigid
expString += ' python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\')");\n'
expString += "};//endif\n"

self.expString = expString
cmds.expression(s=expString)


##############################################
class Crowd:
def __init__(self, numAgents=4, minPosition=-20, maxPosition=20, walls=0):
#set the playback options to increase the time range
cmds.playbackOptions(min= 1, max=5000)
self.numAgents = numAgents
self.minPosition = minPosition
self.maxPosition = maxPosition
#get any selected objects
self.wallObjs = cmds.ls(sl=1)
#create the rigid solver
self.solver = self.createSolver()
#create the agents
self.createAgents()
#create the walls
if walls: self.makeWalls()

def createSolver(self):
solver = cmds.rigidSolver( create=1,
current=1,
name="crowdSolver",
velocityVectorScale=0.5,
displayVelocity=1,
sc=1, #showcollision
ctd=1 #contact data
)
cmds.setAttr(solver + ".allowDisconnection", 1)
return solver

def createAgents(self):
type1 = ["Bacteria", (1,1,1), (1,1,0)] #name, scale, color
type2 = ["Drug", (5,5,5), (.6,.6,.6)]
types = [type1, type2]
self.DrugAgents = []
self.BacteriaAgents = []
for i in range(self.numAgents):
#get the agent type randomly
at = random.choice(types)
#get random x and y
x = random.uniform(self.minPosition,self.maxPosition)
y = random.uniform(self.minPosition,self.maxPosition)
#create the agents
a = Agent(self.solver, at[0], color=at[2], size=at[1], position=(x,y,0))
if at[0] == "Bacteria":
self.BacteriaAgents.append(a)
else:
self.DrugAgents.append(a)

def makeWalls(self):
#get selected object,
#which should be already with its normals facing to the right directions,
#and convert it to passive rigid bodies
if len(self.wallObjs) == 0:
return "No wall objects were selected."
else:
for w in self.wallObjs:
self.wallRigid = cmds.rigidBody(w, passive=1, name= "wall_rigid", bounciness=.8)

########################################
c=Crowd(numAgents=4, walls=1)