void UpdateBoidsSettings(BoidSettings settings)
{
foreach (Boid b in boids)
{
b.UpdateSettings(settings);
}
}
//Alle funktionen dienen nur zur Integration in das UI
private void Awake()
{
if (!instance)
{
instance = this;
}
}
public void Init(BoidSettings settings)
{
this.settings = settings;
transform.position = new Vector3((int)Random.Range(-settings.xBound, settings.xBound), (int)Random.Range(-settings.yBound, settings.yBound), (int)Random.Range(-settings.zBound, settings.zBound));
vel = Vector3.zero;
acc = Vector3.zero;
}
void Start()
{
m_depthManager = Application.Instance.KinectDepthManager;
m_beatInfoManager = Application.Instance.BeatInfoManager;
m_videoPlaneManager = Application.Instance.VideoPlaneManager;
m_dataAccessor = Application.Instance.CreatureDataAccessor;
settings = new BoidSettings();
settings.obstacleMask = 1 << LayerMask.NameToLayer("Bounds") | 1 << LayerMask.NameToLayer("ColliderMesh");
settings.layer = Layer;
videoPlayer = gameObject.AddComponent <VideoPlayer>();
videoPlayer.isLooping = true;
videoPlayer.audioOutputMode = VideoAudioOutputMode.None;
videoPlayer.renderMode = VideoRenderMode.RenderTexture;
videoPlayer.clip = m_dataAccessor.GetRandomClip();
RT = new RenderTexture(VIDEO_RT_RES, VIDEO_RT_RES, 0, RenderTextureFormat.ARGB32);
videoPlayer.targetTexture = RT;
videoPlayer.Play();
boids = new Boid[NumBoids];
for (int i = 0; i < NumBoids; i++)
{
GameObject ob = Instantiate(Resources.Load("Prefabs/Boid") as GameObject);
ob.name = $"Boid{i}";
ob.transform.SetParent(Application.Instance.WorldParent);
boids[i] = ob.GetComponent <Boid>();
boids[i].Init(settings);
}
computeShader = Resources.Load("ComputeShaders/Boids") as ComputeShader;
}
public void UpdateBoidSettings(BoidSettings newSettings)
{
managerSettings = newSettings;
for (int i = 0; i < flock.Count; i++)
{
flock[i].UpdateSettings(managerSettings);
}
}
public void Initialize(BoidSettings settings, Transform target)
{
this.settings = settings;
float startSpeed = (settings.minSpeed + settings.maxSpeed) / 2;
velocity = transform.forward * startSpeed;
}
/// <summary>
/// Changement de comportement des boids | Param : BoidSettings Nouveau comportement <> bool poids vers la target supèrieur pour le Koa
/// </summary>
/// <param name="newSettings"></param>
/// <param name="KoaTargetWeight"></param>
public void SetBehavior(BoidSettings newSettings)
{
for (int i = 0; i < _boidsTab.Length; i++)
{
_boidsTab[i].SetNewSettings(newSettings);
curBoidSettings = newSettings;
}
}
public void setSettings(BoidSettings settings)
{
this.settings = settings;
foreach (Boid b in _boids)
{
b.setSettings(this.settings);
}
}
/// <summary>
/// Changement de comportement des boids | Param : BoidSettings Nouveau comportement <> bool poids vers la target supèrieur pour le Koa
/// </summary>
/// <param name="newSettings"></param>
/// <param name="KoaTargetWeight"></param>
public void SetBehavior(BoidSettings newSettings, bool KoaTargetWeight = false)
{
for (int i = 0; i < _boidsTab.Length; i++)
{
_boidsTab[i].SetNewSettings(newSettings);
curBoidSettings = newSettings;;
}
}
public void RegisterUpdateAction(UnityAction action, BoidSettings settings)
{
updateAction = action;
this.settings = settings;
if (spawnOnAwake)
{
InitializeSchool();
}
}
public void Initialize(BoidSettings settings, Transform target)
{
this.target = target;
this.settings = settings;
float startSpeed = (settings.MinSpeed + settings.MaxSpeed) / 2;
//velocity = transform.forward * startSpeed;
velocity = Vector3.zero;
}
void Start()
{
settings = initalSettings;
boids = FindObjectsOfType <Boid> ();
foreach (Boid b in boids)
{
b.Initialize(settings, targets);
agentsPositions.Add(Vector3.zero);
}
}
public void Initialize(BoidSettings settings)
{
this.settings = settings;
position = Random.insideUnitCircle * settings.spawnRadius;
forward = Random.insideUnitCircle;
float startSpeed = (settings.minSpeed + settings.maxSpeed) / 2;
velocity = forward * startSpeed;
}
public void Initialize(BoidSettings settings, Transform target)
{
this.target = target;
this.settings = settings;
position = cachedTransform.position;
forward = cachedTransform.forward;
float startSpeed = (settings.minSpeed + settings.maxSpeed) / 2;
velocity = transform.forward * startSpeed;
}
public Dictionary <BoidSettings, List <BoidData> > RelevantBoidData(BoidData self)
{
Dictionary <BoidSettings, List <BoidData> > relevants = new Dictionary <BoidSettings, List <BoidData> >();
foreach (var pair in _boidDatum)
{
BoidSettings settings = pair.Key;
List <BoidData> datum = pair.Value;
relevants[settings] = RelevantBoidData(self, settings, datum);
}
return(relevants);
}
/// <summary>
/// Changement de comportement des boids | Param : BoidSettings Nouveau comportement <> bool poids vers la target supèrieur pour le Koa
/// </summary>
/// <param name="newSettings"></param>
/// <param name="KoaTargetWeight"></param>
public void SetBehavior(BoidSettings newSettings)
{
curBoidSettings = newSettings;
for (int i = 0; i < _boidsTab.Length; i++)
{
_boidsTab[i].SetNewSettings(curBoidSettings);
}
if (SC_FixedData.Instance.GetBoidIndex(newSettings) != 14)
{
syncVarKoa.SetNewBehavior(SC_FixedData.Instance.GetBoidIndex(newSettings));
}
}
/// <summary>
/// Avant le start, instanciation
/// </summary>
public void Initialize(Transform newGuide, int newSpawnCount, BoidSettings newSettings, FlockSettings flockSettings)
{
regeneration = true;
curRecoveryTimer = 0;
recoveryDuration = 1.5f;
flockManager = newGuide.GetComponent <SC_FlockDisplay>();
curFlockSettings = flockSettings;
spawnCount = newSpawnCount;
Player = GameObject.FindGameObjectWithTag("Player");
switch (flockSettings.attackType)
{
case FlockSettings.AttackType.none:
koaCharID = 'A';
break;
case FlockSettings.AttackType.Bullet:
koaCharID = 'B';
break;
case FlockSettings.AttackType.Laser:
koaCharID = 'C';
break;
}
koaNumID = SC_BoidPool.Instance.GetFlockID();
koaID = koaCharID + "#" + koaNumID;
//Instanciation des list de Boid et de Guide
_boidsTab = SC_BoidPool.Instance.GetBoid(curFlockSettings.maxBoid);
_guideList = new List <Transform>();
//Récupération du comportement initial
curBoidSettings = newSettings;
sensitivity = new Vector3Int(3, 5, 4);
//Ajout du premier guide a la liste
_guideList.Add(newGuide);
respawnTimer = 0;
_koa = Instantiate(_koaPrefab);
_koa.transform.position = transform.position;
Invoke("InitBoids", 1f);
}
public virtual void BoidInitialize(BoidSettings settings, Boid boidTarget)
{
this.boidTarget = boidTarget;
target = boidTarget.transform;
this.settings = settings;
pos = cachedTransform.position;
ahead = cachedTransform.forward;
float startSpeed = Random.Range(settings.minSpeed, settings.maxSpeed);
velocity = transform.forward * startSpeed;
}
public int GetBoidIndex(BoidSettings curboidSettings)
{
int index = 0;
for (int i = 0; i < boidSettings.Length; i++)
{
if (curboidSettings == boidSettings[i])
{
index = i;
}
}
return(index);
}
public void StartNewBehavior(BoidSettings newSettings)
{
transform.rotation = flockInitialRot;
_curBoidSetting = newSettings;
Reassemble();
if (_curBoidSetting.split)
{
SplitDivision(_curBoidSetting.splitNumber);
}
_SCKoaManager.SetBehavior(_curBoidSetting);
bezierWalkerSpeed.speed = _curBoidSetting.speedOnSpline;
}
public void Initialize(BoidSettings settings, Transform[] targets)
{
this.targets = targets;
this.settings = settings;
position = cachedTransform.position;
forward = cachedTransform.forward;
//Two different start speed mode
float startSpeed = (settings.minSpeed + settings.maxSpeed) / 2;
float randomStartSpeed = Random.Range(settings.minSpeed, settings.maxSpeed);
velocity = transform.forward * randomStartSpeed;
}
public void Initialize(BoidSettings settings, Transform target)
{
this.target = target;
this.pathTarget = null;
pathIndex = 0;
this.settings = settings;
position = cachedTransform.position;
forward = cachedTransform.forward;
float startSpeed = settings.maxSpeed / 2;
velocity = transform.forward * startSpeed;
avgAvoidanceHeading = Vector3.zero;
avgFlockHeading = Vector3.zero;
}
// Called by the BoidManager at the beginning of the simulation
public void Initialize(BoidSettings settings, Transform target)
{
// target to follow if not null
this.target = target;
// settings of the boids
this.settings = settings;
position = cachedTransform.position;
forward = cachedTransform.forward;
// set the startSpeed of the boid to the mean of min and max speed
float startSpeed = (settings.minSpeed + settings.maxSpeed) / 2;
velocity = transform.forward * startSpeed;
}
//Inicializamos settings, posicion, direccion, speed, velocidad y region del Boid
public void Inicializar(BoidSettings set, Vector3 pos)
{
settings = set;
this.transform.position = pos;
//Direccion inicial: adelante
direccion = transform.forward;
//Velocidad de movimiento inicial
speed = UnityEngine.Random.Range(settings.maxSpeed, settings.minSpeed);
//Velocidad inicial
velocidad = direccion * speed;
region = RegionManager.EncontrarRegion(transform.position);
regionesAdyacentes = RegionManager.RegionesAdyacentes(region);
regionAnterior = region;
tVuelo = 0f;
}
public void Initialize(BoidSettings settings, List <Target> targets, BoidManager manager)
{
// this.target = target;
this.targets = targets;
this.settings = settings;
position = cachedTransform.position;
forward = cachedTransform.forward;
float startSpeed = (settings.minSpeed + settings.maxSpeed) / 2;
velocity = transform.forward * startSpeed;
this.manager = manager;
SetColour(manager.color);
}
/// <summary>
/// Avant le start, instanciation
/// </summary>
public void Initialize(Transform newGuide, int spawnCount, BoidSettings newSettings)
{
this.spawnCount = spawnCount;
flockManager = SC_UI_Display_Flock.Instance;
//Instanciation des list de Boid et de Guide
_boidsTab = flockManager.GetBoid();
_guideList = new List <Transform>();
//Récupération du comportement initial
curBoidSettings = newSettings;
//Ajout du premier guide a la liste
_guideList.Add(newGuide);
_koa = Instantiate(_koaPrefab);
_koa.transform.position = transform.position;
}
/// <summary>
/// Initialisation
/// </summary>
/// <param name="settings"></param>
/// <param name="target"></param>
public void Initialize(BoidSettings settings, Transform target, Vector3Int sensitivity, SC_KoaManager koaManager, int type)
{
this.koaManager = koaManager;
destructionType = DestructionType.none;
curFlick = 0;
transform.localScale = initScale;
this.target = target; //Peut être null
this.settings = settings; //Scriptable object
this.sensitivity = sensitivity;
position = cachedTransform.position; //Déplacement à la position tampon
forward = cachedTransform.forward; //Direction selon axe X
float startSpeed = (settings.minSpeed + settings.maxSpeed) / 2; //Vitesse d'initialisation
velocity = transform.forward * startSpeed; //Stockage de la vélocité selon la vitesse de départ
destructionTimer = 1f;
curTimer = 0;
meshRenderer.material = baseMat;
isActive = true;
}
IEnumerator SwitchSettings(BoidSettings[] settings)
{
while (true)
{
_curBoidSetting = settings[curSettingsIndex];
int rnd = Random.Range(0, 2);
if (rnd == 0)
{
bezierWalkerSpeed.speed = _curBoidSetting.speedOnSpline;
}
else
{
bezierWalkerSpeed.speed = -_curBoidSetting.speedOnSpline;
}
Reassemble();
if (_curBoidSetting.split)
{
SplitDivision(_curBoidSetting.splitNumber);
}
_SCKoaManager.SetBehavior(_curBoidSetting);
//https://www.youtube.com/watch?v=bOZT-UpRA2Y
if (settings.Length == 1)
{
StopAllCoroutines();
break;
}
yield return(new WaitForSeconds(_curBoidSetting.settingDuration));
curSettingsIndex++;
if (curSettingsIndex >= settings.Length)
{
curSettingsIndex = 0;
}
}
}
private List <BoidData> RelevantBoidData(BoidData self, BoidSettings settings, List <BoidData> boidDatum)
{
// Get those inside range
var relevants = boidDatum.FindAll(x =>
{
float d = Vector3.Distance(x.position, self.position); // d can't be negative
// if x not at self.position and weight at this distance is not null
return(d > 0 && settings.GetWeight(d) != 0);
});
if (settings.m_myBackCulling || settings.m_itsBackCulling)
{
// Back Culling
relevants = relevants.FindAll(x =>
{
Vector3 selfToX = x.position - self.position;
return((!settings.m_myBackCulling || Vector3.Dot(self.forward, selfToX) > 0) && // cull if x is in self's back
(!settings.m_itsBackCulling || Vector3.Dot(x.forward, -selfToX) > 0)); // cull if self is in x's back
});
}
return(relevants);
}
void Start()
{
settings = BoidSettings.instance;
settings.boids.Add(this);
}
