Boid's, рдкрдХреНрд╖рд┐рдпреЛрдВ рдФрд░ рдпреВрдирд┐рдЯреА 3 рдбреА



рднрд╛рдЧ рджреЛ: рдПрдХрддрд╛ рдмреЛрд▓рд┐рдпреЛрдВ рдХрд╛ рдЕрдиреБрдХреВрд▓рди рдХрд░реЗрдВ

рдХреНрдпрд╛ рдЖрдкрдиреЗ рдХрднреА рд╕реЛрдЪрд╛ рд╣реИ рдХрд┐ рдмрдбрд╝реЗ рдЭреБрдВрдбреЛрдВ рдореЗрдВ рдЙрдбрд╝рдиреЗ рд╡рд╛рд▓реЗ рдкрдХреНрд╖реА рдХрднреА рднреА рдЯрдХрд░рд╛рддреЗ рдирд╣реАрдВ рд╣реИрдВ рдФрд░ рдПрдХ рдмрд╣реБрдд рдмрдбрд╝реЗ рдкрдВрдЦ рд╡рд╛рд▓реЗ рдЧреЗрдВрдж рд╕реЗ рдЯрдХрд░рд╛ рдЬрд╛рддреЗ рд╣реИрдВ? рд╣рдореНрдо, рдЕрдЧрд░ рдЖрдк рдЗрд╕рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рд╕реЛрдЪрддреЗ рд╣реИрдВ, рддреЛ рдпрд╣ рдЕрдЪреНрдЫрд╛ рд╣реЛрдЧрд╛ред рдХрд┐рд╕реА рднреА рдорд╛рдорд▓реЗ рдореЗрдВ, 1986 рдореЗрдВ рдПрдХ рджрд┐рди рдХреНрд░реЗрдЧ рд░реЗрдиреЙрд▓реНрдбреНрд╕ рдирд╛рдо рдХрд╛ рдПрдХ рд╡реНрдпрдХреНрддрд┐ рдерд╛, рдЬрд┐рд╕рдиреЗ рдЭреБрдВрдб рдореЗрдВ рдкрдХреНрд╖рд┐рдпреЛрдВ рдХреЗ рд╡реНрдпрд╡рд╣рд╛рд░ рдХрд╛ рдПрдХ рд╕рд░рд▓ рдореЙрдбрд▓ рдмрдирд╛рдиреЗ рдХрд╛ рдлреИрд╕рд▓рд╛ рдХрд┐рдпрд╛ рдФрд░ рдЙрд╕реЗ Boids рдХрд╣рд╛ ред рдореЙрдбрд▓ рдореЗрдВ рдкреНрд░рддреНрдпреЗрдХ рдореЙрдбрд▓ рдХреЗ рддреАрди рдмреБрдирд┐рдпрд╛рджреА рдирд┐рдпрдо рд╣реИрдВ: рдкреГрдердХреНрдХрд░рдг, рд╕рдВрд░реЗрдЦрдг рдФрд░ рд╕рд╛рдордВрдЬрд╕реНрдпред рдкрд╣рд▓рд╛ рд╣реИ рдкрдбрд╝реЛрд╕рд┐рдпреЛрдВ рдХреЗ рд╕рд╛рде рдЯрдХрд░рд╛рд╡ рд╕реЗ рдмрдЪрдирд╛, рджреВрд╕рд░рд╛ рдЖрдкрдХреЛ рдкрдбрд╝реЛрд╕рд┐рдпреЛрдВ рдХреЗ рд╕рдорд╛рди рджрд┐рд╢рд╛ рдореЗрдВ рдЙрдбрд╝рдирд╛ рдФрд░ рддреАрд╕рд░рд╛ рдЖрдкрдХреЛ рдЕрдХреЗрд▓реЗ рдирд╣реАрдВ рдЙрдбрд╝рдирд╛ рдФрд░ рд╕рдореВрд╣реЛрдВ рдореЗрдВ рд░рд╣рдирд╛ рдмрддрд╛рддрд╛ рд╣реИред рдпреЗ рд╕рд░рд▓ рдирд┐рдпрдо рдЖрдкрдХреЛ рдкрдХреНрд╖рд┐рдпреЛрдВ, рдордЫрд▓реА рдФрд░ рдЕрдиреНрдп рдЬрд╛рдирд╡рд░реЛрдВ рдХреЗ рд╡рд┐рд╢реНрд╡рд╕рдиреАрдп рдЭреБрдВрдб рдмрдирд╛рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддреЗ рд╣реИрдВ, рдЬреЛ рдлрд┐рд▓реНрдо рдФрд░ рдЧреЗрдорд┐рдВрдЧ рдЙрджреНрдпреЛрдЧреЛрдВ рдореЗрдВ рдЙрдкрдпреЛрдЧ рдХрд┐рдП рдЬрд╛рддреЗ рд╣реИрдВред

рд▓реЗрдЦ рдореЗрдВ рдореИрдВ рдЖрдкрдХреЛ рдмрддрд╛рдКрдВрдЧрд╛ рдХрд┐ рдЗрд╕ рдореЙрдбрд▓ рдХреЛ рд╡реНрдпрд╡рд╣рд╛рд░ рдореЗрдВ рдХреИрд╕реЗ рд▓рд╛рдЧреВ рдХрд┐рдпрд╛ рдЬрд╛рдПред рд╡рд┐рдХрд╛рд╕ рдХреЗ рд▓рд┐рдП, рдореИрдВ рдПрдХрддрд╛ рдФрд░ C # рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реВрдВ, рд▓реЗрдХрд┐рди рдЕрдзрд┐рдХрд╛рдВрд╢ рдЪреАрдЬреЗрдВ рдЕрдиреНрдп рдЗрдВрдЬрдиреЛрдВ рдФрд░ рднрд╛рд╖рд╛рдУрдВ рдХреЗ рд▓рд┐рдП рд╕рд╣реА рд╣реИрдВред рдЗрд╕ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рдореЗрдВ, рдореИрдВ рдпреВрдирд┐рдЯреА рдХреЗ рд╕рд╛рде рдХрд╛рдо рдХрд░рдиреЗ рдХреА рдмреБрдирд┐рдпрд╛рджреА рдмрд╛рддреЛрдВ рдкрд░ рдЬреБрдЧрд╛рд▓реА рдирд╣реАрдВ рдХрд░рддрд╛, рдЗрд╕рдХрд╛ рдорддрд▓рдм рд╣реИ рдХрд┐ рдЖрдк рдордВрдЪ рдкрд░ рд╕рдВрдпреЛрдЬрди Ctrl + Shift + N рдХреЗ рдкреНрд░рднрд╛рд╡ рдХреЛ рдЬрд╛рдирддреЗ рд╣реИрдВ, рдЖрдк рдЬрд╛рдирддреЗ рд╣реИрдВ рдХрд┐ рдирд┐рд░реАрдХреНрд╖рдХ рдХреЗ рд╕рд╛рде рдХреИрд╕реЗ рдХрд╛рдо рдХрд░реЗрдВ, рд╡рд╕реНрддреБрдУрдВ рдХреЛ рдбреБрдкреНрд▓рд┐рдХреЗрдЯ рдХрд░реЗрдВ рдФрд░ рд╕реНрдерд╛рдирд╛рдВрддрд░рд┐рдд рдХрд░реЗрдВред рдпрджрд┐ рдирд╣реАрдВ, рддреЛ рдореИрдВ рдЖрдкрдХреЛ рдЗрд╕ рд▓реЗрдЦ рд╕реЗ рд╢реБрд░реВ рдХрд░рдиреЗ рдХреА рд╕рд▓рд╛рд╣ рджреЗрддрд╛ рд╣реВрдВред рдпрд╛ рдЖрдк рдХреЗрд╡рд▓ рдЪрд┐рддреНрд░реЛрдВ рдХреЛ рджреЗрдЦ рд╕рдХрддреЗ рд╣реИрдВред

рдмреБрдирд┐рдпрд╛рджреА рддреИрдпрд╛рд░реА




рд╣рдо рдПрдХрддрд╛ рдореЗрдВ рдПрдХ рдирдИ рдкрд░рд┐рдпреЛрдЬрдирд╛ рдмрдирд╛рдПрдВрдЧреЗ рдФрд░ рднрд╡рд┐рд╖реНрдп рдХреЗ рд▓рд┐рдП рддреБрд░рдВрдд рдХрдИ рдлрд╝реЛрд▓реНрдбрд░реНрд╕ рдмрдирд╛рдПрдВрдЧреЗ: рд╕рд╛рдордЧреНрд░реА, рдкреНрд░реАрдлреИрдм, рджреГрд╢реНрдп, рд▓рд┐рдкрд┐рдпрд╛рдБред
рдордВрдЪ рдкрд░ рджрд┐рд╢рд╛рддреНрдордХ рдкреНрд░рдХрд╛рд╢ рдлреЗрдВрдХреЛ рдФрд░ рдПрдХ рдХреНрд╖реЗрддреНрд░ рдХрд╛ рдирд╛рдо рдмреЛрдЗрджред рд╣рдо рдЧреЛрд▓реЗ рдХреЛ рдкреНрд░реАрдлрд╝реИрдм рдореЗрдВ рдмрджрд▓ рджреЗрддреЗ рд╣реИрдВред рдЙрд╕реА рд╕рдордп, рд╣рдо рддреБрд░рдВрдд рджреГрд╢реНрдп рдХреЛ рд╕рд╣реЗрдЬ рд▓реЗрдВрдЧреЗ, рддрд╛рдХрд┐ рдмрд╛рдж рдореЗрдВ рдЗрд╕рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рди рд╕реЛрдЪреЗрдВред рдЕрдм рд╕реНрдХреНрд░рд┐рдкреНрдЯрд┐рдВрдЧ рд╢реБрд░реВ рдХрд░рддреЗ рд╣реИрдВред

рдореЙрдбрд▓ рдХреЗ рд▓рд┐рдП, рд╣рдореЗрдВ рддреАрди рдорд╛рдкрджрдВрдбреЛрдВ рдХреА рдЧрдгрдирд╛ рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ: рдкреГрдердХреНрдХрд░рдг, рд╕рдВрд░реЗрдЦрдг рдФрд░ рд╕рд╛рдордВрдЬрд╕реНрдпред рдЖрдЗрдП рдмрд╛рдж рд╕реЗ рд╢реБрд░реВ рдХрд░реЗрдВ, рдпрд╣ рд╕рдмрд╕реЗ рд╕рд░рд▓ рд╣реИред рдореБрдЭреЗ рдЖрдкрдХреЛ рдпрд╛рдж рджрд┐рд▓рд╛рдирд╛ рд╣реИ, рдпрд╣ рдПрдХ рд╡реЗрдХреНрдЯрд░ рд╣реИ рдЬреЛ рдЖрд╕рдкрд╛рд╕ рдХреЗ рдмреЙрдпрд┐рдбреНрд╕ рдХреЗ рдХреЗрдВрджреНрд░ рдХреА рдУрд░ рдирд┐рд░реНрджреЗрд╢рд┐рдд рд╣реИред рдЗрд╕реЗ рдЦреЛрдЬрдиреЗ рдХреЗ рд▓рд┐рдП, рдЖрдкрдХреЛ рдмреЙрдпрдб рдХреЗ рдирд┐рд░реНрджреЗрд╢рд╛рдВрдХ рдЬреЛрдбрд╝рдиреЗ рдФрд░ рдЙрдирдХреА рд╕рдВрдЦреНрдпрд╛ рд╕реЗ рд░рд╛рд╢рд┐ рдХреЛ рд╡рд┐рднрд╛рдЬрд┐рдд рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИред рдПрдХ рд▓рдбрд╝рдХрд╛ рдХреИрд╕реЗ рдЬрд╛рдирддрд╛ рд╣реИ рдХрд┐ рдЙрд╕рдХреЗ рдкрд╛рд╕ рдкрдбрд╝реЛрд╕реА рд╣реИрдВ? Physics.OverlapSphere рдЗрд╕рдХреЗ рд▓рд┐рдП рдХрд╛рдо рдЖрддрд╛ рд╣реИред рдпрд╣ рдХрд╛рд░реНрдп рд╣рдорд╛рд░реЗ рдмреЙрдпрдб рд╕рд╣рд┐рдд рд╕рднреА рдХреЛрд▓рд╛рдЗрдбрд░ рдореЗрдВ рд╡рд╛рдкрд╕ рдЖ рдЬрд╛рдПрдЧрд╛, рдЕрдЧрд░ рдпрд╣ рджрд╛рдпрд░реЗ рдореЗрдВ рдЖрддрд╛ рд╣реИ, рддреЛ рд╣рдорд╛рд░реЗ рдмреЙрдпрдб рд╕рд╣рд┐рддред
boids = Physics.OverlapSphere(transform.position, cohesionRadius); 

рд╣рдо рд╡реИрд░рд┐рдПрдмрд▓ рдХреЛ рдЬреЛрдбрд╝рддреЗ рд╣реИрдВ, рдкреНрд▓рд╕, рдбрд┐рд╡рд╛рдЗрдб рдХрд░рддреЗ рд╣реИрдВ, рдФрд░ рдлрд┐рд░ рд╕реБрдкрд░ рдЙрдкрдпреЛрдЧреА рдбрд┐рдмрдЧ.рдбреНрд░рд╛рд▓рд╛рдЗрди рдФрд░ Color.magenta рдХреА рдорджрдж рд╕реЗ рдмреЙрдпрдб рдХреЗ рдкрд░рд┐рд╡рд░реНрддрди рд╕реЗ рд╕рдЬрд╛рдП рдЧрдП рдХреЗрдВрджреНрд░ рдХреЛ рдЖрдХрд░реНрд╖рд┐рдд рдХрд░рддреЗ рд╣реИрдВред рдЗрдирдкреБрдЯ Debug.DrawLine рд▓рд╛рдЗрди рдХреА рд╢реБрд░реБрдЖрдд рдФрд░ рдЕрдВрдд рдХреЗ рдирд┐рд░реНрджреЗрд╢рд╛рдВрдХ, рд╕рд╛рде рд╣реА рдПрдХ рд╡реИрдХрд▓реНрдкрд┐рдХ рд▓рд╛рдЗрди рд░рдВрдЧ рдкреИрд░рд╛рдореАрдЯрд░ рдХреЛ рд╕реНрд╡реАрдХрд╛рд░ рдХрд░рддрд╛ рд╣реИред рд╕рднреА рдбреЗрдореЛ рдлрд╝рдВрдХреНрд╢рдВрд╕ рдХреЗ рдкреНрд░рджрд░реНрд╢рди рдХреЗ рдкрд░рд┐рдгрд╛рдо рдХреЗрд╡рд▓ рд╡рд┐рдХрд╛рд╕ рдХреЗ рджреМрд░рд╛рди рджрд┐рдЦрд╛рдИ рджреЗрддреЗ рд╣реИрдВ, рд╡реЗ рдмрд╕ рдирд┐рд░реНрдорд╛рдг рдореЗрдВ рдирд╣реАрдВ рдЖрддреЗ рд╣реИрдВред
 Debug.DrawLine(transform.position, cohesion, Color.magenta); 

Boid.cs рдХреЗрдВрджреНрд░
 using UnityEngine; public class Boid : MonoBehaviour { private Vector3 cohesion; private float cohesionRadius = 10; private Collider[] boids; void Update() { cohesion = Vector3.zero; boids = Physics.OverlapSphere(transform.position, cohesionRadius); foreach (var boid in boids) { cohesion += boid.transform.position; } cohesion = cohesion / boids.Length; Debug.DrawLine(transform.position, cohesion, Color.magenta); } } 

рд╣рдо рд╕реНрдХреНрд░рд┐рдкреНрдЯ рдХреЛ рдкреНрд░реАрдлреИрдм рдкрд░ рдлреЗрдВрдХрддреЗ рд╣реИрдВ, рдмреЙрдпрдб рдХреЛ рдПрдХ-рджреЛ рдмрд╛рд░ рдХреЙрдкреА рдХрд░рддреЗ рд╣реИрдВ рдФрд░ рдкреНрд▓реЗ рдкрд░ рдХреНрд▓рд┐рдХ рдХрд░рддреЗ рд╣реИрдВред рдЧрд┐рдЬрд╝реНрдореЛрд╕ рдбрд┐рд╕реНрдкреНрд▓реЗ рдХреЛ рдЪрд╛рд▓реВ рдХрд░рдирд╛ рди рднреВрд▓реЗрдВ рдЕрдиреНрдпрдерд╛ рдЖрдк рд▓рд╛рдЗрди рдирд╣реАрдВ рджреЗрдЦреЗрдВрдЧреЗред



рд▓рдбрд╝рдХреЛрдВ рдХреЛ рдПрдХ рд╕рд╛рде рд▓рд╛рдирд╛


рддреЛ рдпрд╣ рдХрд╛рдо рдХрд░рдиреЗ рд▓рдЧрддрд╛ рд╣реИред рдЕрдм рд╣рдореЗрдВ рдкрд░рд┐рдгрд╛рдорд╕реНрд╡рд░реВрдк рдмрд┐рдВрджреБ рдХреЛ рдЧрддрд┐ рдореЗрдВ рдмрджрд▓рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИред рд╕рдм рдХреБрдЫ рдПрдХ рд╣реА рдвреЗрд░ рдореЗрдВ рд░рдЦрдирд╛ рдЕрдЪреНрдЫрд╛ рдирд╣реАрдВ рд╣реИ, рдЗрд╕рд▓рд┐рдП рд╣рдо рдкрд┐рдЫрд▓реЗ рдХреЛрдб рдХреЛ рдПрдХ рдЕрд▓рдЧ рдлрд╝рдВрдХреНрд╢рди рдореЗрдВ рд╕реНрдерд╛рдирд╛рдВрддрд░рд┐рдд рдХрд░реЗрдВрдЧреЗред рд╣рдо InvokeRepeating рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдЯрд╛рдЗрдорд░ рджреНрд╡рд╛рд░рд╛ рдлрд╝рдВрдХреНрд╢рди рд╢реБрд░реВ рдХрд░реЗрдВрдЧреЗред рдкрд╣рд▓рд╛ рддрд░реНрдХ рдлрд╝рдВрдХреНрд╢рди рдХрд╛ рдирд╛рдо рд╣реИ, рджреВрд╕рд░рд╛ рдкреНрд░рд╛рд░рдВрдн рд╕рдордп рд╣реИ, рддреАрд╕рд░рд╛ рдкреБрдирд░рд╛рд╡реГрддреНрддрд┐ рдЕрдВрддрд░рд╛рд▓ рд╣реИред рд╡рд┐рднрд┐рдиреНрди рд▓рд┐рдкрд┐рдпреЛрдВ рдХреЗ рд╡рд┐рд▓рдВрдмрд┐рдд рд▓реЙрдиреНрдЪ рдХреЗ рд▓рд┐рдП рдпрд╣ рд╕реБрд╡рд┐рдзрд╛ рдмрд╣реБрдд рдЙрдкрдпреЛрдЧреА рд╣реИред
 InvokeRepeating("CalculateVelocity", 0, 1); 

рд╡реЗрдХреНрдЯрд░ рдХреА рдЧрдгрдирд╛ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП, рд╣рдо рд╕реНрдХреВрд▓ рдЧрдгрд┐рдд рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реИрдВ рдФрд░ рдХреЗрдВрджреНрд░ рдХреЗ рдирд┐рд░реНрджреЗрд╢рд╛рдВрдХ рд╕реЗ рдмреЙрдпрдб рдХреЗ рдирд┐рд░реНрджреЗрд╢рд╛рдВрдХ рдХреЛ рдШрдЯрд╛рддреЗ рд╣реИрдВред рд╕реНрдХреНрд░рд┐рдкреНрдЯ рдХреЛ рд╕рд╛рд░реНрд╡рдЬрдирд┐рдХ рдореЗрдВ рдЬреЛрдбрд╝реЗрдВ (рдореИрдВ рдЖрдкрдХреЛ рдмрд╛рдж рдореЗрдВ рдмрддрд╛рдКрдВрдЧрд╛) рдЪрд░ рд╡реЗрдЧ, рдЗрд╕реЗ рдлрд╝рдВрдХреНрд╢рди рдХреА рд╢реБрд░реБрдЖрдд рдореЗрдВ рд╢реВрдиреНрдп рдкрд░ рд╕реЗрдЯ рдХрд░реЗрдВ, рдФрд░ рдЕрдВрдд рдореЗрдВ рдПрдХ рдирдпрд╛ рд╡реЗрдХреНрдЯрд░ рд╕рд╛рдордВрдЬрд╕реНрдп рдЬреЛрдбрд╝реЗрдВред рдЕрджреНрдпрддрди рдореЗрдВ, рдкрд░рд┐рдгрд╛рдо рдХреЗ рдирд┐рд░реНрджреЗрд╢рд╛рдВрдХ рдкрд░ рдкрд░рд┐рдгрд╛рдо рд▓рд╛рдЧреВ рдХрд░реЗрдВ, рдмреАрддреЗ рд╣реБрдП рд╕рдордп рдХреЛ рдзреНрдпрд╛рди рдореЗрдВ рд░рдЦрддреЗ рд╣реБрдПред Time.deltaTime рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ рддрд╛рдХрд┐ рдЖрдВрджреЛрд▓рди FPS рдкрд░ рдирд┐рд░реНрднрд░ рди рд╣реЛ рдФрд░ рд╕рднреА рдкреНрд░реЛрд╕реЗрд╕рд░реЛрдВ рдкрд░ рд╕рдорд╛рди рдЧрддрд┐ рд╕реЗ рдЪрд▓реЗ ред
 transform.position += velocity * Time.deltaTime; 

рдЗрд╕рдХреЗ рдЕрд▓рд╛рд╡рд╛, рдЪреВрдВрдХрд┐ рд╣рдорд╛рд░рд╛ рдХреЗрдВрджреНрд░ рд╡реЗрдХреНрдЯрд░ рдореЗрдВ рдмрджрд▓ рдЧрдпрд╛ рд╣реИ, рдЗрд╕рд▓рд┐рдП рд╣рдо рдЕрдкрдиреЗ рдбреАрдмрдЧ.рдбреНрд░рд╛рд▓рд╛рдЗрди рдХреЛ рдХрд┐рд╕реА рдЕрдиреНрдп рдХрдо рд╢рд╛рдирджрд╛рд░ рдбреАрдмрдЧ.рдбрд╛рдпрд░реЗрд▓реЗ рдореЗрдВ рдмрджрд▓ рджреЗрдВрдЧреЗ ред рдХреЛрдИ рдЕрдВрддрд░ рдирд╣реАрдВ рд╣реИ, рдмрд╕ рджреВрд╕рд░рд╛ рддрд░реНрдХ рд╣рдорд╛рд░реЗ рдЬреИрд╕реЗ рд░рд┐рд╢реНрддреЗрджрд╛рд░ рд╕рдордиреНрд╡рдп рдореЗрдВ рд╣реЛрдирд╛ рдЪрд╛рд╣рд┐рдПред

Boid.cs рд╕рд╛рдордВрдЬрд╕реНрдп
 using UnityEngine; public class Boid : MonoBehaviour { public Vector3 velocity; private float cohesionRadius = 10; private Collider[] boids; private Vector3 cohesion; private void Start() { InvokeRepeating("CalculateVelocity", 0, 1); } void CalculateVelocity() { velocity = Vector3.zero; cohesion = Vector3.zero; boids = Physics.OverlapSphere(transform.position, cohesionRadius); foreach (var boid in boids) { cohesion += boid.transform.position; } cohesion = cohesion / boids.Length; cohesion = cohesion - transform.position; velocity += cohesion; } void Update() { transform.position += velocity * Time.deltaTime; Debug.DrawRay(transform.position, cohesion, Color.magenta); } } 



рд╣рдо рд╢реЗрдпрд░ рдХрд░рддреЗ рд╣реИрдВ


рдЕрд▓рдЧрд╛рд╡ рдХреА рдЧрдгрдирд╛ рдереЛрдбрд╝реА рдЕрдзрд┐рдХ рдЬрдЯрд┐рд▓ рд╣реИред рдкрдбрд╝реЛрд╕рд┐рдпреЛрдВ рдХреЗ рдвреЗрд░ рд╕реЗ рдмрд╛рд╣рд░ рдирд┐рдХрд▓рдиреЗ рдХреА рд╕рдмрд╕реЗ рдЙрдкрдпреЛрдЧреА рджрд┐рд╢рд╛ рдХреА рдЧрдгрдирд╛ рдХрд░рдирд╛ рдЖрд╡рд╢реНрдпрдХ рд╣реИред рдРрд╕рд╛ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП, рдЖрдк рдкреНрд░рддреНрдпреЗрдХ рдкрдбрд╝реЛрд╕реА рд╕реЗ рд╡реИрдХреНрдЯрд░ рдХреА рднрд╛рд░рд┐рдд рд░рд╛рд╢рд┐ рдкрд╛ рд╕рдХрддреЗ рд╣реИрдВред рд╡реЗрдХреНрдЯрд░ рдХреЛ рдкрдбрд╝реЛрд╕реА рд╕реЗ рдЙрд╕ рддрдХ рджреВрд░реА рд╕реЗ рд╡рд┐рднрд╛рдЬрд┐рдд рдХрд░реЗрдВ, рдЬреЛ рдХрд┐ рд╡реЗрдХреНрдЯрд░ 3 рд╕реБрдмрд╣ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдкреНрд░рд╛рдкреНрдд рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИ ред рдкрд░рд┐рдгрд╛рдореА рд░рд╛рд╢рд┐ рдореЗрдВ, рдирд┐рдХрдЯрддрдо рдкрдбрд╝реЛрд╕рд┐рдпреЛрдВ рдХрд╛ рд╕рдмрд╕реЗ рдмрдбрд╝рд╛ рд╡рдЬрди рд╣реЛрдЧрд╛ред
 separation += (transform.position - boid.transform.position) / (transform.position - boid.transform.position).magnitude; 

рдпрд╣ рдПрдХ рдирд┐рд╢реНрдЪрд┐рдд рджреВрд░реА рддрдХ рдЦрд╛рддреЗ рдореЗрдВ рд▓реЗ рдЬрд╛рдиреЗ рд╡рд╛рд▓реЗ рдкрдбрд╝реЛрд╕рд┐рдпреЛрдВ рдХреА рд╕рдВрдЦреНрдпрд╛ рдХреЛ рд╕реАрдорд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рд╕рдордЭ рдореЗрдВ рдЖрддрд╛ рд╣реИ, рдЗрд╕рдХреЗ рд▓рд┐рдП рд╣рдо рдХрд╛рдЙрдВрдЯрд░ рдХреЗ рд▓рд┐рдП рдПрдХ рдЪрд░ рдФрд░ рдкреГрдердХреНрдХрд░рдг рддреНрд░рд┐рдЬреНрдпрд╛ рдХреЗ рд▓рд┐рдП рдПрдХ рдЬреЛрдбрд╝рддреЗ рд╣реИрдВред
 if ((transform.position - boid.transform.position).magnitude < separationDistance) 

рдЗрд╕рдХреЗ рдЕрд▓рд╛рд╡рд╛, рд╣рдореЗрдВ рдмреЙрдпрдб рдХреЗ рдХреЛрд▓рд╛рдЗрдбрд░ рдХреЗ рдХрд╛рд░рдг рд╢реВрдиреНрдп рд╡реЗрдХреНрдЯрд░ рдХреЛ рд╣рд┐рдЯ рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рдирд╣реАрдВ рд╣реИред рдпрд╣ рдордд рднреВрд▓реЛ рдХрд┐ Physics.OverlapSphere рд╕рднреА рдХреЛрд▓рд╛рдЗрдбрд░ рдХреЛ рдХрд╡рд░ рдХрд░рддрд╛ рд╣реИ, рдЬрд┐рд╕рдореЗрдВ рдмреЙрдпрд░ рдХреЛрд▓рд╛рдЗрдбрд░ рднреА рд╢рд╛рдорд┐рд▓ рд╣реИред рдЗрд╕рд▓рд┐рдП, рд╣рдо рд╕реНрдерд┐рддрд┐ рдХреЛ рдереЛрдбрд╝рд╛ рдмрджрд▓ рджреЗрдВрдЧреЗред
 if (boid != collider && (transform.position - boid.transform.position).magnitude < separationDistance) 

Boid.cs рдЕрд▓рдЧ рд╣реЛрдирд╛
 using UnityEngine; public class Boid : MonoBehaviour { public Vector3 velocity; private float cohesionRadius = 10; private float separationDistance = 5; private Collider[] boids; private Vector3 cohesion; private Vector3 separation; private int separationCount; private void Start() { InvokeRepeating("CalculateVelocity", 0, 1); } void CalculateVelocity() { velocity = Vector3.zero; cohesion = Vector3.zero; separation = Vector3.zero; separationCount = 0; boids = Physics.OverlapSphere(transform.position, cohesionRadius); foreach (var boid in boids) { cohesion += boid.transform.position; if (boid != collider && (transform.position - boid.transform.position).magnitude < separationDistance) { separation += (transform.position - boid.transform.position) / (transform.position - boid.transform.position).magnitude; separationCount++; } } cohesion = cohesion / boids.Length; cohesion = cohesion - transform.position; if (separationCount > 0) { separation = separation / separationCount; } velocity += cohesion + separation; } void Update() { transform.position += velocity * Time.deltaTime; Debug.DrawRay(transform.position, separation, Color.green); Debug.DrawRay(transform.position, cohesion, Color.magenta); } } 



рд╣рдо рд▓рдбрд╝рдХреЛрдВ рдХреЛ рд╕рдВрдЧрдард┐рдд рдХрд░рддреЗ рд╣реИрдВ


рдмреЙрдпрдбреНрд╕ рдХреЗ рд▓рд┐рдП рди рдХреЗрд╡рд▓ рд╕реЛрдЪ-рд╕рдордЭрдХрд░ рдвреЗрд░ рдореЗрдВ рдЗрдХрдЯреНрдард╛ рд╣реЛрдиреЗ рдХреЗ рд▓рд┐рдП, рд╣рдореЗрдВ рдЙрдиреНрд╣реЗрдВ рдЕрдкрдиреЗ рдкрдбрд╝реЛрд╕рд┐рдпреЛрдВ рдХреЗ рд╡реНрдпрд╡рд╣рд╛рд░ рдХреЛ рджреЛрд╣рд░рд╛рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИред рд╕рдВрд░реЗрдЦрдг рдЧрдгрдирд╛ рдмрд╣реБрдд рд╕рд░рд▓ рд╣реИ, рд╣рдо рдкреНрд░рддреНрдпреЗрдХ рдкрдбрд╝реЛрд╕реА рд╕реЗ рд╕рд╛рд░реНрд╡рдЬрдирд┐рдХ рд╡реЗрдЧ рдЪрд░ (рд╣рд╛рдБ!) рдХреЛ рд╕рд╛рд░рд╛рдВрд╢рд┐рдд рдХрд░рддреЗ рд╣реИрдВ рдФрд░ рдЙрдирдХреА рд╕рдВрдЦреНрдпрд╛ рд╕реЗ рд╡рд┐рднрд╛рдЬрд┐рдд рдХрд░рддреЗ рд╣реИрдВред рд╕рдВрд▓рдЧреНрди рд╕реНрдХреНрд░рд┐рдкреНрдЯ GameObject.GetComponent рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдкрд╣реБрдБрдЪрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред рдпрд╣ рди рдХреЗрд╡рд▓ рд╕реНрдХреНрд░рд┐рдкреНрдЯ, рдмрд▓реНрдХрд┐ рдЖрдо рддреМрд░ рдкрд░ рдХрд┐рд╕реА рднреА рдШрдЯрдХ рдХреЛ рдкрд╛ рд╕рдХрддрд╛ рд╣реИред рдХрдорд╛рд▓ рдХреА рдмрд╛рдд рд╣реИред
 alignment += boid.GetComponent<Boid>().velocity; 

Boid.cs рд╕рдВрд░реЗрдЦрдг
 using UnityEngine; public class Boid : MonoBehaviour { public Vector3 velocity; private float cohesionRadius = 10; private float separationDistance = 5; private Collider[] boids; private Vector3 cohesion; private Vector3 separation; private int separationCount; private Vector3 alignment; private void Start() { InvokeRepeating("CalculateVelocity", 0, 1); } void CalculateVelocity() { velocity = Vector3.zero; cohesion = Vector3.zero; separation = Vector3.zero; separationCount = 0; alignment = Vector3.zero; boids = Physics.OverlapSphere(transform.position, cohesionRadius); foreach (var boid in boids) { cohesion += boid.transform.position; alignment += boid.GetComponent<Boid>().velocity; if (boid != collider && (transform.position - boid.transform.position).magnitude < separationDistance) { separation += (transform.position - boid.transform.position) / (transform.position - boid.transform.position).magnitude; separationCount++; } } cohesion = cohesion / boids.Length; cohesion = cohesion - transform.position; if (separationCount > 0) { separation = separation / separationCount; } alignment = alignment / boids.Length; velocity += cohesion + separation + alignment; } void Update() { transform.position += velocity * Time.deltaTime; Debug.DrawRay(transform.position, separation, Color.green); Debug.DrawRay(transform.position, cohesion, Color.magenta); Debug.DrawRay(transform.position, alignment, Color.blue); } } 

рд╣рдо рд╢реБрд░реВ рдХрд░рддреЗ рд╣реИрдВ рдФрд░ ... рд╢реВрдиреНрдп рдкреНрд░рддрд┐рдХреНрд░рд┐рдпрд╛, рд╕рдм рдХреБрдЫ рдЕрднреА рднреА рд╣реИред рд╡реЗрдЧ рдХреЗ рд╕реВрддреНрд░ рдореЗрдВ рдПрдХ рдЯреНрд░рд┐рдХ рдЬреЛрдбрд╝реЗрдВред
 velocity += cohesion + separation + alignment*2; 

рдФрд░ рдлрд┐рд░ ...



рд╣рдордиреЗ рд╡реИрдХреНрдЯрд░ рдХрд╛рдЯ рджрд┐рдП


Vzhuuum! рд╡реИрд╕реЗ, рдХрд╛рдлреА рдкреНрд░реЗрдбрд┐рдХреНрдЯреЗрдмрд▓ рд╣реИред рд╣рдордиреЗ рд╕рдВрд░реЗрдЦрдг рд╡реЗрдХреНрдЯрд░ рдореЗрдВ рд╡реГрджреНрдзрд┐ рдХреА, рдЬрд┐рд╕рд╕реЗ рд╡реЗрдЧ рд╡реЗрдХреНрдЯрд░ рдореЗрдВ рд╡реГрджреНрдзрд┐ рд╣реБрдИ, рдЬрд┐рд╕рдиреЗ рд╕рдВрд░реЗрдЦрдг рд╡реЗрдХреНрдЯрд░ рдореЗрдВ рд╡реГрджреНрдзрд┐ рдХреА, рдЬреЛ ... рдареАрдХ рд╣реИ, рдЖрдк рд╕рдордЭрддреЗ рд╣реИрдВред рд╣рдореЗрдВ рдЕрдзрд┐рдХрддрдо рдЧрддрд┐ рд╕реАрдорд╛ рдмрдирд╛рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИред рдЗрд╕рдХреЗ рдЕрд▓рд╛рд╡рд╛, рдкреНрд░рддрд┐рдмрдВрдз рдХреЛ рд╡реЗрдХреНрдЯрд░ рдХреЗ рд╕рднреА рдШрдЯрдХреЛрдВ рдкрд░ рднреА рд░рдЦрд╛ рдЬрд╛рдирд╛ рдЪрд╛рд╣рд┐рдП, рдЕрдиреНрдпрдерд╛ рдХреБрдЫ рд╕реНрдерд┐рддрд┐рдпреЛрдВ рдореЗрдВ рдкреНрд░реЗрдореА рдХрд╛ рд╡реНрдпрд╡рд╣рд╛рд░ рдХреБрдЫ рдЕрдЬреАрдм рд╣реЛ рдЬрд╛рддрд╛ рд╣реИред рдЖрдк рдЗрд╕реЗ рд╕реНрд╡рдпрдВ рдЖрдЬрдорд╛ рд╕рдХрддреЗ рд╣реИрдВред

рдПрдХрддрд╛ рдореЗрдВ рд╡реИрдХреНрдЯрд░ рдХреЛ рдЯреНрд░рд┐рдо рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдПрдХ рд╡реЗрдХреНрдЯрд░ 3 рд╣реИред рдХреНрд▓реИрдореНрдкрдореИрдЧреНрдирд┐рдЯреНрдпреВрдб рдлрд╝рдВрдХреНрд╢рдиред рдкреНрд░рддреНрдпреЗрдХ рд╡реИрдХреНрдЯрд░ рдХреА рдЧрдгрдирд╛ рдХреЗ рдмрд╛рдж, рд╣рдо рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдирд┐рд░реНрдорд╛рдг рдХреЛ рдЬреЛрдбрд╝рддреЗ рд╣реИрдВ:
 velocity = Vector3.ClampMagnitude(velocity, maxSpeed); 

Boid.cs рдХреНрд▓реИрдВрдк
 using UnityEngine; public class Boid : MonoBehaviour { public Vector3 velocity; private float cohesionRadius = 10; private float separationDistance = 5; private Collider[] boids; private Vector3 cohesion; private Vector3 separation; private int separationCount; private Vector3 alignment; private float maxSpeed = 15; private void Start() { InvokeRepeating("CalculateVelocity", 0, 1f); } void CalculateVelocity() { velocity = Vector3.zero; cohesion = Vector3.zero; separation = Vector3.zero; separationCount = 0; alignment = Vector3.zero; boids = Physics.OverlapSphere(transform.position, cohesionRadius); foreach (var boid in boids) { cohesion += boid.transform.position; alignment += boid.GetComponent<Boid>().velocity; if (boid != collider && (transform.position - boid.transform.position).magnitude < separationDistance) { separation += (transform.position - boid.transform.position) / (transform.position - boid.transform.position).magnitude; separationCount++; } } cohesion = cohesion / boids.Length; cohesion = cohesion - transform.position; cohesion = Vector3.ClampMagnitude(cohesion, maxSpeed); if (separationCount > 0) { separation = separation / separationCount; separation = Vector3.ClampMagnitude(separation, maxSpeed); } alignment = alignment / boids.Length; alignment = Vector3.ClampMagnitude(alignment, maxSpeed); velocity += cohesion + separation * 10 + alignment * 1.5f; velocity = Vector3.ClampMagnitude(velocity, maxSpeed); } void Update() { if (transform.position.magnitude > 25) { velocity += -transform.position.normalized; } transform.position += velocity * Time.deltaTime; Debug.DrawRay(transform.position, separation, Color.green); Debug.DrawRay(transform.position, cohesion, Color.magenta); Debug.DrawRay(transform.position, alignment, Color.blue); } } 

рджрдмрд╛рдП рдЧрдП рд╡реИрдХреНрдЯрд░ рдХреЗ рд╕рдВрдЪрд╛рд▓рди рдХреА рдЬрд╛рдВрдЪ рдХрд░реЗрдВред



рд╕реНрд╡рдЪрд╛рд▓рд┐рдд


рдореИрдиреНрдпреБрдЕрд▓ рд░реВрдк рд╕реЗ рдмреЙрдпрд▓рд░ рдХреА рд╡реНрдпрд╡рд╕реНрдерд╛ рдХрд░рдирд╛ рдмрд┐рд▓реНрдХреБрд▓ рднреА рджрд┐рд▓рдЪрд╕реНрдк рдирд╣реАрдВ рд╣реИред рд╕реЙрдлреНрдЯрд╡реЗрдпрд░ рдХреЗ рд▓рд┐рдП, рдПрдХ рддреНрд╡рд░рд┐рдд рдХрд╛рд░реНрдп рд╣реИред рдкреНрд░рд╡реЗрд╢ рджреНрд╡рд╛рд░ рдкрд░, рдЙрд╕реЗ рдХреЙрдкреА рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдСрдмреНрдЬреЗрдХреНрдЯ рдХрд╛ рд▓рд┐рдВрдХ рд╕рдмрдорд┐рдЯ рдХрд░рдирд╛ рд╣реЛрдЧрд╛, рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЗ рдирдП рдирд┐рд░реНрджреЗрд╢рд╛рдВрдХ рдФрд░ рдЙрд╕рдХреЗ рд░реЛрдЯреЗрд╢рдиред рдкреНрд░реАрдлрд╝реИрдм рдХреА рдкреНрд░рддрд┐рд▓рд┐рдкрд┐ рдмрдирд╛рдиреЗ рдХреЗ рд▓рд┐рдП, рд╣рдо рдПрдХ рдЕрд▓рдЧ рд╕рд╛рд░реНрд╡рдЬрдирд┐рдХ рдЪрд░ рдмрдирд╛рддреЗ рд╣реИрдВ, рдЬрд┐рд╕реЗ рд╣рдо рдирд┐рд░реАрдХреНрд╖рдХ рдореЗрдВ рднрд░реЗрдВрдЧреЗред рдпрд╣ random.insideUnitSphere рд╕реЗ рдпрд╛рджреГрдЪреНрдЫрд┐рдХ рдирд┐рд░реНрджреЗрд╢рд╛рдВрдХ рд▓реЗрдиреЗ рдХреЗ рд▓рд┐рдП рд╕реБрд╡рд┐рдзрд╛рдЬрдирдХ рд╣реИ, рдмрд╕ рдЗрд╕реЗ рдЖрд╡рд╢реНрдпрдХ рдХреНрд╖реЗрддреНрд░ рдХреЗ рддреНрд░рд┐рдЬреНрдпрд╛ рд╕реЗ рдЧреБрдгрд╛ рдХрд░реЗрдВред рд╣рдорд╛рд░реЗ Boids рдХреЛ рдЬрд┐рддрдирд╛ рдЪрд╛рд╣реЗрдВ рдШреБрдорд╛рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ, рдкрд░рд┐рдгрд╛рдо рдПрдХ рд╣реЛрдЧрд╛, рдЗрд╕рд▓рд┐рдП рд╣рдо Quaternion.identity рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реЗрдВрдЧреЗ, рдЬрд┐рд╕рдХрд╛ рдЕрд░реНрде рд╣реИ рдХрд┐ рдХреЛрдИ рд░реЛрдЯреЗрд╢рди рдирд╣реАрдВред
 Instantiate(boidPrefab, Random.insideUnitSphere * 25, Quaternion.identity); 

рд▓реВрдк рдореЗрдВ, рдКрдкрд░ рдХреА рдХрд╛рд░реНрд░рд╡рд╛рдИ рдХреЛ рджреЛрд╣рд░рд╛рдПрдВ рдФрд░ рдХрд┐рд╕реА рднреА рд╡рд╛рдВрдЫрд┐рдд рд╕рдВрдЦреНрдпрд╛ рдореЗрдВ рдмреЙрдпрд▓рд░ рдкреНрд░рд╛рдкреНрдд рдХрд░реЗрдВред рд╣рдо рджреГрд╢реНрдп рдХреЗ рдХреЗрдВрджреНрд░ рдореЗрдВ рдПрдХ рдЦрд╛рд▓реА рд╡рд╕реНрддреБ рдкрд░ рдПрдХ рдирдИ рд╕реНрдХреНрд░рд┐рдкреНрдЯ рдлреЗрдВрдХрддреЗ рд╣реИрдВ рдФрд░ рдкреНрд░реАрдлреИрдм рд▓рд┐рдВрдХ рдХреЛ рднрд░рддреЗ рд╣реИрдВред

HeartOfTheSwarm.cs
 using UnityEngine; public class HeartOfTheSwarm : MonoBehaviour { public Transform boidPrefab; public int swarmCount = 100; void Start() { for (var i = 0; i < swarmCount; i++) { Instantiate(boidPrefab, Random.insideUnitSphere * 25, Quaternion.identity); } } } 

рддреЗрдЬреА рд╕реЗ рдЙрдбрд╝рддреЗ рд╣реБрдП рдЭреБрдВрдбреЛрдВ рдХреЛ рджреЗрдЦрдирд╛ рдмрд╣реБрдд рд╕реБрд╡рд┐рдзрд╛рдЬрдирдХ рдирд╣реАрдВ рд╣реИ, рдЙрдиреНрд╣реЗрдВ рдЪреЗрди рдкрд░ рд░рдЦрдирд╛ рдЕрдЪреНрдЫрд╛ рд╣реЛрдЧрд╛ред рдРрд╕рд╛ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП, рдЕрджреНрдпрддрди рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдПрдХ рдЫреЛрдЯреА рд╢рд░реНрдд рдЬреЛрдбрд╝реЗрдВ:
 if (transform.position.magnitude > 25) { velocity += -transform.position.normalized; } 

рдЗрд╕рдХреА рдорджрдж рд╕реЗ, рдмреЙрдпрдбреНрд╕, рдЬрд┐рдирдХреЗ рдирд┐рд░реНрджреЗрд╢рд╛рдВрдХ рдЖрднрд╛рд╕реА рдХреНрд╖реЗрддреНрд░ рдХреЗ рдмрд╛рд╣рд░ рд╣реИрдВ, рдХреЗрдВрджреНрд░ рдХреА рдУрд░ рдореБрдбрд╝ рдЬрд╛рдПрдВрдЧреЗред рдЕрдВрдд рдореЗрдВ, рдЖрдЗрдП рд╡реЗрдХреНрдЯрд░ рдХрд╛рд░рдХреЛрдВ рдФрд░ рдЕрдиреНрдп рдорд╛рдкрджрдВрдбреЛрдВ рдХреЗ рд╕рд╛рде рдереЛрдбрд╝рд╛ рдЦреЗрд▓реЗрдВ, рдЕрдиреНрдпрдерд╛ рд╡рд╛рдВрдЫрд┐рдд рдкреНрд░рднрд╛рд╡ рдХрд╛рдо рдирд╣реАрдВ рдХрд░реЗрдЧрд╛ред рдиреАрдЪреЗ рджрд┐рдП рдЧрдП рд╕реНрдкреЙрдЗрд▓рд░ рдХреЗ рдиреАрдЪреЗ рдЕрдВрддрд┐рдо рдХреЛрдб рджреЗрдЦреЗрдВред
 velocity += cohesion + separation * 10 + alignment * 1.5f; 

рд╣рдо рд╢реБрд░реВ рдХрд░рддреЗ рд╣реИрдВ, рд╣рдо рдкреНрд░рд╢рдВрд╕рд╛ рдХрд░рддреЗ рд╣реИрдВред

Boid.cs
 using UnityEngine; public class Boid : MonoBehaviour { public Vector3 velocity; private float cohesionRadius = 10; private float separationDistance = 5; private Collider[] boids; private Vector3 cohesion; private Vector3 separation; private int separationCount; private Vector3 alignment; private float maxSpeed = 15; private void Start() { InvokeRepeating("CalculateVelocity", 0, 0.1f); } void CalculateVelocity() { velocity = Vector3.zero; cohesion = Vector3.zero; separation = Vector3.zero; separationCount = 0; alignment = Vector3.zero; boids = Physics.OverlapSphere(transform.position, cohesionRadius); foreach (var boid in boids) { cohesion += boid.transform.position; alignment += boid.GetComponent<Boid>().velocity; if (boid != collider && (transform.position - boid.transform.position).magnitude < separationDistance) { separation += (transform.position - boid.transform.position) / (transform.position - boid.transform.position).magnitude; separationCount++; } } cohesion = cohesion / boids.Length; cohesion = cohesion - transform.position; cohesion = Vector3.ClampMagnitude(cohesion, maxSpeed); if (separationCount > 0) { separation = separation / separationCount; separation = Vector3.ClampMagnitude(separation, maxSpeed); } alignment = alignment / boids.Length; alignment = Vector3.ClampMagnitude(alignment, maxSpeed); velocity += cohesion + separation * 10 + alignment * 1.5f; velocity = Vector3.ClampMagnitude(velocity, maxSpeed); } void Update() { if (transform.position.magnitude > 25) { velocity += -transform.position.normalized; } transform.position += velocity * Time.deltaTime; Debug.DrawRay(transform.position, separation, Color.green); Debug.DrawRay(transform.position, cohesion, Color.magenta); Debug.DrawRay(transform.position, alignment, Color.blue); } } 



рдпрд╣ рд╕рдм, рдмреЙрдпрдЬ рдЕрдкрдиреЗ рдкрд┐рдВрдЬрд░реЗ рдореЗрдВ рдЙрдбрд╝рддреЗ рд╣реИрдВред рд╣рд╛рд▓рд╛рдБрдХрд┐, рдЙрдирдореЗрдВ рд╕реЗ рдмрд╣реБрдд рдХрдо рд╣реИрдВ! рд╕реМ рд╕реЗ рдЕрдзрд┐рдХ рдХреА рд░рд╛рд╢рд┐ рдХреЗ рд╕рд╛рде, рд╕рдм рдХреБрдЫ рдХрд╛рдлреА рдзреАрдореА рдЧрддрд┐ рд╕реЗ рд╢реБрд░реВ рд╣реЛрддрд╛ рд╣реИред рдХреЛрдИ рдЖрд╢реНрдЪрд░реНрдп рдирд╣реАрдВ, рдХреНрдпреЛрдВрдХрд┐ рд╣рдордиреЗ рдПрдХ рднреА рдЕрдиреБрдХреВрд▓рди рдирд╣реАрдВ рдХрд┐рдпрд╛ред рдЕрдЧрд▓реЗ рднрд╛рдЧ рдореЗрдВ рдореИрдВ рдЗрд╕ рдмрд╛рд░реЗ рдореЗрдВ рдмрд╛рдд рдХрд░реВрдБрдЧрд╛ рдХрд┐ рдЖрдк рд╣рдорд╛рд░реЗ рдХреЛрдб рдХреЛ рдХреИрд╕реЗ рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рддрд╛рдХрд┐ рдпрд╣ 60 рдПрдлрдкреАрдПрд╕ рдХреЛ рдЕрдзрд┐рдХ рд╕рдВрдЦреНрдпрд╛ рдореЗрдВ рдмреЛрд▓рд┐рдпреЛрдВ рдкрд░ рдкрдХрдбрд╝ рд╕рдХреЗред рдЗрд╕ рдмреАрдЪ, рдЖрдк рдЯрд┐рдкреНрдкрдгрд┐рдпреЛрдВ рдореЗрдВ рдЕрдкрдиреЗ рд╡рд┐рдХрд▓реНрдкреЛрдВ рдХрд╛ рд╕реБрдЭрд╛рд╡ рджреЗ рд╕рдХрддреЗ рд╣реИрдВред

рднрд╛рдЧ рджреЛ: рдПрдХрддрд╛ рдмреЛрд▓рд┐рдпреЛрдВ рдХрд╛ рдЕрдиреБрдХреВрд▓рди рдХрд░реЗрдВ

рдЧрд┐рдЯрд╣рдм рдкрд░ рд╕реВрддреНрд░ | рдПрдХрддрд╛ рд╡реЗрдм рдкреНрд▓реЗрдпрд░ рдХреЗ рдорд╛рд▓рд┐рдХреЛрдВ рдХреЗ рд▓рд┐рдП рдСрдирд▓рд╛рдЗрди рд╕рдВрд╕реНрдХрд░рдг

рдЙрди рд▓реЛрдЧреЛрдВ рдХреЗ рд▓рд┐рдП рдПрдХ рдорд┐рдиреА рдмреЛрдирд╕ рдЬреЛ рдореИрдВ рдПрдирд┐рдореЗрд╢рди рдХреИрд╕реЗ рдмрдирд╛рдпрд╛ рдореЗрдВ рд░реБрдЪрд┐ рд░рдЦрддреЗ рд╣реИрдВред
Screenshot.cs
 using UnityEngine; public class Screenshot : MonoBehaviour { private int count; void Update() { if (Input.GetButtonDown("Jump")) { InvokeRepeating("Capture", 0.1f, 0.3f); } } void Capture() { Application.CaptureScreenshot(Application.dataPath + "/Screenshot" + count + ".png"); count++; } } 

Source: https://habr.com/ru/post/In182382/


All Articles