def grease_pencil_frame_handler(scene, flock: Flock, context):
frame = scene.frame_current
if frame == 0:
for i, unit in enumerate(flock.units):
gp_layer = init_grease_pencil(
gpencil_layer_name="unit_{}".format(i), clear_layer=True)
gp_layer.frames.new(0)
# When reaching final frame, clear handlers
if frame >= context.scene.NUM_FRAMES:
bpy.app.handlers.frame_change_pre.clear()
elif (frame % context.scene.NUM_FRAMES_CHANGE) == 0:
flock.update()
move_target(flock.attractor_obj, frame)
flock.attractor_pos = np.array(flock.attractor_obj.location)
for i, unit in enumerate(flock.units):
gp_layer = init_grease_pencil(
gpencil_layer_name="unit_{}".format(i), clear_layer=False)
gp_frame = gp_layer.frames.copy(gp_layer.frames[-1])
gp_frame.frame_number = frame
p0 = unit.pos
p1 = unit.pos + unit.vel
draw_line(gp_frame, p0, p1, i)
def showCarpetBombing(self, equipmentID, pos, direction, time):
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('===== showCarpetBombing =====')
LOG_DEBUG(equipmentID)
LOG_DEBUG(pos, direction, time)
bombEquipment = vehicles.g_cache.equipments()[equipmentID]
shellDescr = vehicles.getItemByCompactDescr(bombEquipment.shellCompactDescr)
shotEffect = vehicles.g_cache.shotEffects[shellDescr.effectsIndex]
airstrikeID = shotEffect.get('airstrikeID')
if airstrikeID is None:
LOG_ERROR('EquipmentID %s has no airstrike shot effect settings' % equipmentID)
return
else:
areaWidth, areaLength = bombEquipment.areaWidth, bombEquipment.areaLength
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('Ideal', areaWidth, areaLength)
beginExplosionPos = BigWorld.wg_collideSegment(BigWorld.player().spaceID, pos, pos + direction * 1000.0, 18)
if beginExplosionPos is None:
return
beginExplosionPos = beginExplosionPos.closestPoint
flatDir = Vector3(direction)
flatDir.y = 0.0
flatDir.normalise()
endDropPoint = pos + flatDir * (areaLength * bombEquipment.waveFraction)
endExplosionPos = BigWorld.wg_collideSegment(BigWorld.player().spaceID, endDropPoint, endDropPoint + direction * 1000.0, 18)
if endExplosionPos is None:
endExplosionPos = beginExplosionPos + flatDir * (areaLength * bombEquipment.waveFraction)
else:
endExplosionPos = endExplosionPos.closestPoint
areaLength = beginExplosionPos.flatDistTo(endExplosionPos)
averageBombCount = bombEquipment.bombsNumber
bombsPerWidth, bombsPerLength = CombatEquipmentManager.__calcBombsDistribution(averageBombCount, areaWidth, areaLength)
delay = time - BigWorld.serverTime()
explosionVelocity = flatDir * bombEquipment.speed
partialAirstrikeFunc = functools.partial(BigWorld.PyGroundEffectManager().playAirstrike, airstrikeID, beginExplosionPos, explosionVelocity, areaWidth, areaLength, math.ceil(bombsPerWidth), math.ceil(bombsPerLength))
if _ENABLE_DEBUG_LOG:
LOG_DEBUG('delta', delay)
LOG_DEBUG('pos, dir', pos, direction)
LOG_DEBUG('Params for artyStrike effect', airstrikeID, beginExplosionPos, flatDir, areaWidth, areaLength, bombsPerWidth, bombsPerLength)
if delay < 0.0:
partialAirstrikeFunc()
else:
self.__callbackDelayer.delayCallback(delay, partialAirstrikeFunc)
if _ENABLE_DEBUG_DRAW:
self.debugStartLine = Flock.DebugLine(pos, beginExplosionPos)
self.debugEndLine = Flock.DebugLine(endDropPoint, endExplosionPos)
self.__callbackDelayer.delayCallback(delay, functools.partial(_DebugFrontLine.launch, beginExplosionPos, endExplosionPos, areaWidth, explosionVelocity))
return
def __init__(self):
self.__callbackDelayer = CallbackDelayer()
self.__selectedAreas = {}
self.__wings = {}
if _ENABLE_DEBUG_DRAW:
self.debugPolyLine = Flock.DebugPolyLine()
self.debugPoints = []
self.debugDirs = []
def init_flock(size: int,
sphere_size: float,
seed: int = None,
volume_size: int = 1):
ATTRACTOR_POS = (0, 0, 30)
flock = Flock(size,
canvas_size=volume_size,
canvas_shift=(-volume_size // 2, -volume_size // 2,
ATTRACTOR_POS[2] - volume_size // 2),
seed=seed)
# Add object for attractor
bpy.ops.object.empty_add(type='PLAIN_AXES', location=ATTRACTOR_POS)
flock.attractor_obj = bpy.context.view_layer.objects.active
flock.attractor_pos = np.array(flock.attractor_obj.location)
if not use_grease_pencil:
# Create basic sphere from which we will copy the mesh
bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=sphere_subdivisions,
radius=sphere_size,
location=(0, 0, 0))
base_obj = bpy.context.view_layer.objects.active
scene = bpy.context.scene
for unit in flock.units:
# add blender object to unit attributes
unit.obj = base_obj.copy()
unit.obj.location = unit.pos
scene.collection.objects.link(unit.obj)
# add visibility border
if DRAW_VISIBILITY:
unit.visibility = create_circle()
unit.visibility.location = unit.pos
# add velocity line
if DRAW_VELOCITY:
unit.vel_obj = create_line()
unit.vel_obj.data.vertices[0].co = unit.pos
unit.vel_obj.data.vertices[1].co = unit.pos + unit.vel * 4
# delete original
objs = bpy.data.objects
objs.remove(base_obj)
return flock
def frame_handler(scene, flock: Flock, context):
frame = scene.frame_current
# When reaching final frame, clear handlers
if frame >= context.scene.NUM_FRAMES:
bpy.app.handlers.frame_change_pre.clear()
elif (frame % context.scene.NUM_FRAMES_CHANGE) == 0:
flock.update()
flock.attractor_pos = np.array(flock.attractor_obj.location)
for unit in flock.units:
# update and keyframe location
unit.obj.location = unit.pos
unit.obj.keyframe_insert("location")
# update visibility position
if DRAW_VISIBILITY:
unit.visibility.location = unit.pos
unit.visibility.keyframe_insert("location")
# update velocity line
if DRAW_VELOCITY:
unit.vel_obj.data.vertices[0].co = unit.pos
unit.vel_obj.data.vertices[1].co = unit.pos + unit.vel * 4
def __init__(self):
self.__callbackDelayer = CallbackDelayer()
self.__selectedAreas = {}
self.__wings = {}
self.__isGUIVisible = True
if _ENABLE_DEBUG_DRAW:
self.debugPolyLine = Flock.DebugPolyLine()
self.debugPoints = []
self.debugDirs = []
self.__lastSmokeInfos = None
self.__onCombatEquipmentShotCB = None
return
def __init__(self,
mapSettings=None,
startTime=None,
gasAttackSettings=None,
cloudModel=None):
if mapSettings is None:
mapSettings = _getDefaultMapSettings()
if gasAttackSettings is None or startTime is None:
startTime, gasAttackSettings = _getDefaultScenario()
if not isinstance(mapSettings, GasAttackMapSettings):
raise AssertionError
soundSettings = mapSettings.soundSettings
soundSettings = soundSettings is None and _getSoundSettings(
)['soundSettings']
gasCloudSettings = (
gasAttackSettings.position, startTime,
mapSettings.cameraProximityDist, gasAttackSettings.compressionTime,
gasAttackSettings.startRadius, gasAttackSettings.endRadius,
mapSettings.cloudClimbTime, mapSettings.cloudStartHeight,
mapSettings.cloudEndHeight, mapSettings.edgeToCenterAngle,
mapSettings.edgeToCenterAngleDelta,
mapSettings.edgeToCenterDistance,
mapSettings.centerSunIntensityDef,
mapSettings.centerSunIntensityFwd, mapSettings.edgeSunIntensityDef,
mapSettings.edgeSunIntensityFwd, mapSettings.shimmerSettings,
mapSettings.centerFogSettings, mapSettings.edgeFogSettings,
mapSettings.edgeToCenterFogSettings, soundSettings)
self.__cloud = BattlegroundElements.GasCloud(gasCloudSettings)
self.__cloud.start()
self.__model = None
self.model = cloudModel
weather = BigWorld.weather(BigWorld.player().spaceID)
weather.windAverage(*mapSettings.windSpeed.tuple())
weather.windGustiness(mapSettings.windGustiness)
self.__cloud.setProximityCallback(self.__onProximity)
self.__started = False
self.__gasAttackEffects = GasAttackEffects(mapSettings.vehicleGAEffect,
mapSettings.cameraGAEffect,
gasAttackSettings.position)
if _ENABLE_DEBUG_DRAW:
import Flock
d = Flock.DebugGizmo(BigWorld.player().spaceID,
'helpers/models/unit_cube.model')
d.motor.signal = self.__cloud.cloudMatrixProvider
ctrlName = BigWorld.player().inputHandler.ctrlModeName
self.__cloud.enableEdgeFogEffects = ctrlName != CTRL_MODE_NAME.POSTMORTEM or BigWorld.player(
).vehicle is not None
BigWorld.player(
).inputHandler.onPostmortemVehicleChanged += self.__onPostmortemVehicleChanged
return
def __drawDebugOutput(self, matrixProvider):
self.__resetDebugOutput()
if matrixProvider is None:
return
else:
matrixProvider = Matrix(matrixProvider)
pos = matrixProvider.translation
endPos = matrixProvider.translation
endPos.y += 70.0
self.__debugLine = Flock.DebugLine(pos, endPos)
self.__debugLine.thickness = 1.0
matrixProvider.translation = pos
self.__debugGizmo.setMatrix(matrixProvider)
self.__callbackDelayer.delayCallback(4.0, self.__resetDebugOutput)
return
def __init__(self, settings, gui):
if isinstance(settings, Config.Config_World):
self.settings = settings
self.gui = gui
if isinstance(settings.screen, Config.Config_Screen):
render.start(self.settings.screen.x_pos,
self.settings.screen.y_pos,
self.settings.screen.x_size,
self.settings.screen.y_size, 1000)
# creating city grid
for b in range(2):
self.x_location += 100
self.y_location = 90
for z in range(3):
self.y_location -= 20
# self.x_location += 20
for i in range(2):
self.y_location -= 10
self.x_location -= 20
self.c = random.randint(0, 1)
for t in range(2):
self.c2 = random.randint(0, 1)
b_location = P3.P3(self.x_location, self.y_location, 0)
# print(b_location)
buildings.extend([
Building.Building(b_location, 10,
random.randrange(20, 65), 10,
(self.c, 0, self.c2))
])
self.x_location += 10
if isinstance(settings, Config.Config_World):
flock = settings.flocks[0]
if isinstance(flock, Config.Config_Flock):
self.F1 = Flock.Flock(flock.count,
World.make_force_field(buildings),
flock.center, flock.radius)
self.render = render.Render(self.F1)
gui.set_tick_method(self.tick)
ground(10)
for building in World.buildings:
Building.Building.draw_building(building)
for b in self.flock.boids:
v = make_bird_vertices(b)
draw_bird(v)
pygame.display.flip()
def dispose(self):
pygame.quit()
if __name__ == "__main__":
flock = Flock.Flock(100, P3.P3(-75, -75, 0), 10)
f = Render(flock)
start(0, 0, 800, 600, 1000)
while 1:
f.draw()
for b in flock.boids:
b.move_Boid(.1)