Blender script which clones and places objects according to pattern specified by array of object names, i.e. [wall1, wall2, wall3]

blender_clone_by_pattern.py

import math
import bpy

def delete(prefix):
    for obj in bpy.context.scene.objects: 
        if obj.name.startswith(prefix):
            objs = bpy.data.objects
            objs.remove(objs[obj.name], True)

def max_len(objects, dimension):
    result = 0
    for o in objects:
        if o.dimensions[dimension] > result:
            result = o.dimensions[dimension]
    return result

def get_objects(names):
    objects = []
    for n in names:
        o = bpy.data.objects.get(n, None)
        if o != None:
            objects.append(o)
    return objects

scene = bpy.context.scene
PREFIX = 'instance_'
recipe = ['wall1', 'rotate 90', 'wall2', 'wall3' ]

z_cnt = 20
z_offset = 0
z_max_len = max_len(get_objects(set(recipe)), 2)

delete(PREFIX)

for i in range(z_cnt):

    z_angle = 0.0
    z_angle_deg = 0
    old_loc_x = 0
    old_loc_y = 0
    old_dim_x = 0
    old_dim_y = 0
    rotation = False
    
    for r in recipe:

        if r.startswith('rotate'):
            z_angle_deg += float(r.split()[1])
            z_angle = math.radians(z_angle_deg % 360)
            rotation = True
            continue

        prefab = bpy.data.objects.get(r, None)
        if prefab == None:
            print('prefab %s not found' % r)
            continue
                
        # create new object
        new_obj = prefab.copy()
        new_obj.name = PREFIX+r
        new_obj.data = prefab.data.copy()
        new_obj.animation_data_clear()
        
        # add to scene
        scene.objects.link(new_obj)
                
        # apply rotation
        new_obj.rotation_euler = (0, 0, z_angle)
        new_obj.select = True
        scene.objects.active = new_obj
        bpy.ops.object.transform_apply( rotation = True )
        scene.objects.active = None
        new_obj.select = False
        
        # calculate location
        new_loc_x = old_loc_x + (old_dim_x / 2.0 + new_obj.dimensions[0] / 2.0) * math.cos(z_angle)
        new_loc_y = old_loc_y + (old_dim_y / 2.0 + new_obj.dimensions[1] / 2.0) * math.sin(z_angle)
        
        # handle rotation
        if rotation:
            rotation = False

            if math.degrees(z_angle) >= 0:
                new_loc_x = old_loc_x + new_obj.dimensions[0]/2.0 - old_dim_x
                new_loc_y = old_loc_y - old_dim_y / 2.0
                
            if math.degrees(z_angle) >= 90:        
                new_loc_x = old_loc_x + old_dim_x / 2.0
                new_loc_y = old_loc_y + new_obj.dimensions[1]/2.0 - old_dim_y
    
            if math.degrees(z_angle) >= 180:
                new_loc_x = old_loc_x - new_obj.dimensions[0]/2.0 + old_dim_x
                new_loc_y = old_loc_y + old_dim_y / 2.0
            
            if math.degrees(z_angle) >= 270:
                new_loc_x = old_loc_x - old_dim_x / 2.0 
                new_loc_y = old_loc_y - new_obj.dimensions[1]/2.0 + old_dim_y
            
        new_obj.location = (new_loc_x, new_loc_y, z_offset)
        
        old_loc_x = new_loc_x
        old_loc_y = new_loc_y
        old_dim_x = new_obj.dimensions[0]
        old_dim_y = new_obj.dimensions[1]
    
    z_offset += z_max_len