public AddControllersModifier(IEnumerable <DanmakuController> controllers)
{
this.controllers = null;
if (controllers == null)
{
return;
}
var colList = controllers as IList <DanmakuController>;
if (colList != null)
{
for (int i = 0; i < colList.Count; i++)
{
controllerAggregate += colList[i];
}
}
else
{
foreach (var controller in controllers)
{
controllerAggregate += controller;
}
}
}
public override Scenario GetScenario(DanmakuController parent)
{
var scenario = ScriptableObject.CreateInstance <Scenario>();
scenario.Init(parent);
var scene = new Scene {
EnterFrame = 0, MaxDuration = 80 * 60, MinDuration = 1 * 60, CoolingTime = 4 * 60
};
new Stage2Scene0().AddActions(scene);
scenario.AddScene(scene);
scene = new Scene {
EnterFrame = 1, MaxDuration = 240 * 60, MinDuration = 1 * 60, CoolingTime = 4 * 60
};
new Stage2Scene1().AddActions(scene);
scenario.AddScene(scene);
scene = new Scene {
EnterFrame = 1, MaxDuration = 240 * 60, MinDuration = 1 * 60, CoolingTime = 4 * 60
};
new Stage2Boss().AddActions(scene);
scenario.AddScene(scene);
scenario.SortScenes();
return(scenario);
}
public static DanmakuController Compress(this IEnumerable <IDanmakuController> controllers)
{
if (controllers == null)
{
throw new System.NullReferenceException();
}
DanmakuController controller = null;
var list = controllers as IList <IDanmakuController>;
if (list != null)
{
int count = list.Count;
for (int i = 0; i < count; i++)
{
IDanmakuController current = list[i];
if (current != null)
{
controller += current.Update;
}
}
}
else
{
foreach (var current in controllers)
{
if (current != null)
{
controller += current.Update;
}
}
}
return(controller);
}
public static T AddController <T> (this T danmakus, DanmakuController controller) where T : class, IEnumerable <Danmaku>
{
if (danmakus == null)
{
return(null);
}
var arrayTest = danmakus as Danmaku[];
if (arrayTest != null)
{
for (int i = 0; i < arrayTest.Length; i++)
{
Danmaku danmaku = arrayTest[i];
if (danmaku != null)
{
danmaku.AddController(controller);
}
}
}
else
{
foreach (var danmaku in danmakus)
{
if (danmaku != null)
{
danmaku.AddController(controller);
}
}
}
return(danmakus);
}
public void Copy(FireData other)
{
Prefab = other.Prefab;
Field = other.Field;
Position = other.Position;
Rotation = other.Rotation;
Speed = other.Speed;
AngularSpeed = other.AngularSpeed;
Controller = other.Controller;
Damage = other.Damage;
Group = other.Group;
}
/// <summary>
/// Called on Component instantiation
/// </summary>
public override void Awake()
{
base.Awake();
affected = new DanmakuSet();
if (controllers == null)
{
return;
}
for (int i = 0; i < controllers.Length; i++)
{
controllerAggregate += controllers[i].Update;
}
}
public override void OnFire(Vector2 position, DynamicFloat rotation)
{
DanmakuController temp = controllerAggregate;
if (controllers != null)
{
for (int i = 0; i < controllers.Length; i++)
{
temp += controllers[i].Update;
}
}
Controller += temp;
FireSingle(position, rotation);
Controller -= temp;
}
public void RemoveController(DanmakuController controller)
{
ControllerUpdate -= controller;
controllerCheck = ControllerUpdate != null;
}
public void AddController(DanmakuController controller)
{
ControllerUpdate += controller;
controllerCheck = ControllerUpdate != null;
}
public FireBuilder WithController(DanmakuController controller)
{
Controller += controller;
return(this);
}
public void RemoveController(IDanmakuController controller)
{
controllerAggregate -= controller.Update;
}
public void Awake()
{
//mpb = new MaterialPropertyBlock();
Vector3[] vertexes;
Renderer singleRenderer = GetComponent <Renderer> ();
SpriteRenderer spriteRenderer = singleRenderer as SpriteRenderer;
MeshRenderer meshRenderer = singleRenderer as MeshRenderer;
if (singleRenderer == null || (spriteRenderer == null && meshRenderer == null))
{
Debug.LogError("Danmaku Prefab (" + name + ") has neither SpriteRenderer or MeshRenderer. Attach one or the other to it.");
Destroy(this);
return;
}
singleRenderer.enabled = false;
foreach (Component otherComponent in GetComponentsInChildren <Component>())
{
if (otherComponent != this && !(otherComponent is Transform))
{
Destroy(otherComponent);
}
}
foreach (Transform child in transform)
{
Destroy(child.gameObject);
}
cachedScale = transform.localScale;
cachedTag = gameObject.tag;
cachedLayer = gameObject.layer;
if (danmakuSystemPrefab != null)
{
runtimeSystem = Instantiate(danmakuSystemPrefab);
}
if (runtimeSystem == null)
{
GameObject runtimeObject = Instantiate(Resources.Load("Danmaku Particle System")) as GameObject;
if (runtimeObject == null)
{
runtimeObject = new GameObject(name);
}
if (runtimeSystem == null)
{
runtimeSystem = runtimeObject.GetComponent <ParticleSystem>();
}
if (runtimeSystem == null)
{
runtimeSystem = runtimeObject.AddComponent <ParticleSystem> ();
}
}
Transform runtimeTransform = runtimeSystem.transform;
//runtimeTransform.parent = null;
runtimeTransform.localPosition = Vector3.zero;
runtimeRenderer = runtimeSystem.GetComponent <ParticleSystemRenderer> ();
renderMesh = new Mesh();
if (meshRenderer == null)
{
renderingType = RenderingType.Sprite;
singleRenderer = spriteRenderer;
cachedSprite = spriteRenderer.sprite;
cachedColor = spriteRenderer.color;
cachedMaterial = spriteRenderer.sharedMaterial;
cachedSortingLayer = spriteRenderer.sortingLayerID;
cachedSortingOrder = spriteRenderer.sortingOrder;
//renderMaterial = cachedMaterial;
renderMaterial = new Material(cachedMaterial);
renderMaterial.mainTexture = Sprite.texture;
if (cachedSprite == null)
{
runtimeRenderer.mesh = null;
}
else
{
var verts = cachedSprite.vertices;
var tris = cachedSprite.triangles;
vertexes = new Vector3[verts.Length];
int[] triangles = new int[tris.Length];
for (int i = 0; i < verts.Length; i++)
{
vertexes [i] = (Vector3)verts [i];
}
for (int i = 0; i < tris.Length; i++)
{
triangles [i] = (int)tris [i];
}
renderMesh.vertices = vertexes;
renderMesh.uv = cachedSprite.uv;
renderMesh.triangles = triangles;
}
}
else
{
renderingType = RenderingType.Mesh;
singleRenderer = meshRenderer;
cachedSprite = null;
cachedColor = Color.white;
cachedMaterial = meshRenderer.sharedMaterial;
cachedSortingLayer = meshRenderer.sortingLayerID;
cachedSortingOrder = meshRenderer.sortingOrder;
renderMaterial = meshRenderer.sharedMaterial;
MeshFilter filter = meshRenderer.GetComponent <MeshFilter>();
if (filter == null)
{
Debug.LogError("Danmaku Prefab (" + name + ") is trying to use a MeshRenderer as a base, but no MeshFilter is found. Please add one.");
}
else
{
Mesh filterMesh = filter.mesh;
renderMesh.vertices = filterMesh.vertices;
renderMesh.uv = filterMesh.uv;
renderMesh.triangles = filterMesh.triangles;
renderMesh.colors = filterMesh.colors;
renderMesh.normals = filterMesh.normals;
renderMesh.tangents = filterMesh.tangents;
}
}
if (renderMesh != null)
{
Matrix4x4 transformMatrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, transform.localScale);
vertexes = renderMesh.vertices;
for (int i = 0; i < vertexes.Length; i++)
{
vertexes[i] = transformMatrix * vertexes[i];
}
renderMesh.vertices = vertexes;
renderMesh.Optimize();
}
runtimeRenderer.mesh = renderMesh;
foreach (Behaviour comp in GetComponentsInChildren <Behaviour>())
{
if (comp != this)
{
comp.enabled = false;
}
}
runtimeSystem.simulationSpace = ParticleSystemSimulationSpace.World;
runtimeSystem.startColor = cachedColor;
runtimeSystem.startSize = 1;
runtimeSystem.startLifetime = float.PositiveInfinity;
runtimeSystem.gravityModifier = 0f;
runtimeSystem.startSpeed = 0f;
runtimeSystem.enableEmission = false;
currentDanmaku = new HashSet <Danmaku> ();
particles = new ParticleSystem.Particle[runtimeSystem.particleCount];
for (int i = 0; i < extraControllers.Length; i++)
{
controllerAggregate += extraControllers[i].Update;
}
runtimeRenderer.mesh = renderMesh;
runtimeRenderer.renderMode = ParticleSystemRenderMode.Mesh;
runtimeRenderer.sharedMaterial = renderMaterial;
runtimeRenderer.sortingLayerID = cachedSortingLayer;
runtimeRenderer.sortingOrder = cachedSortingOrder;
runtimeRenderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
runtimeRenderer.receiveShadows = false;
runtimeRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
runtimeRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
gameObject.hideFlags = HideFlags.HideInHierarchy;
runtimeSystem.gameObject.hideFlags = HideFlags.HideInHierarchy;
}
public AddControllersModifier(DanmakuController controller)
{
controllerAggregate = controller;
}
public AddControllersModifier(IDanmakuController controller)
{
controllers = null;
controllerAggregate = controller.Update;
}
public void ClearControllers()
{
controllerAggregate = null;
controllers = new IDanmakuController[0];
}
public void RemoveController(DanmakuController controller)
{
controllerAggregate -= controller;
}
public void AddController(DanmakuController controller)
{
controllerAggregate += controller;
}
public void AddController(IDanmakuController controller)
{
controllerAggregate += controller.Update;
}
/// <summary>
/// Clears the controllers.
/// All of the currently included contrrollers are removed.
/// </summary>
public void ClearControllers()
{
controllerAggregate = null;
}
