private Task<CreateServiceBindingResponse> CustomServiceBinding(CloudController.V2.Client.Base.AbstractServiceBindingsEndpoint arg1, CreateServiceBindingRequest arg2)
{
return Task.Factory.StartNew<CreateServiceBindingResponse>(() =>
{
return new CreateServiceBindingResponse() { EntityMetadata = new Metadata() };
});
}
internal static Task<CreateServiceInstanceResponse> CustomCreateServiceInstance(CloudController.V2.Client.Base.AbstractServiceInstancesEndpoint arg1, CreateServiceInstanceRequest arg2)
{
return Task.Factory.StartNew<CreateServiceInstanceResponse>(() =>
{
return new CreateServiceInstanceResponse() { EntityMetadata = new Metadata() };
});
}
public float boostAmount = 2f; // 1-10000
void Start()
{
cloudController = GetComponent <CloudController>();
catsAndDogsAmount = PlayerPrefs.GetFloat(catsAndDogsAmountSave);
uiController.UpdateCatsAndDogsSliders(catsAndDogsAmount / 100);
}
public static void Main(string[] args)
{
string username = "******";
string password = "******";
var baseUrl = "https://api.particle.io";
var accessTokenController = new AccessTokenController(baseUrl);
// Login, if a token exists and it's not expired use it.
var accessTokens = accessTokenController.ListTokensAsync(username, password).Result;
var userToken = accessTokens.FirstOrDefault(t => t.Client == "user");
if (userToken == null)
{
var authResponse = accessTokenController.GenerateAccessTokenAsync(username, password).Result;
userToken = new AccessToken {
Token = authResponse.Access_Token,
Expires_At = DateTime.UtcNow.AddSeconds(authResponse.Expires_In).ToString("o"),
Client = "user"
};
}
// var sseManager = new SSECore (baseUrl,userToken.Token);
// sseManager.SSEPublished += (eve) => {
// Console.WriteLine (eve.Info.Data);
// };
//
// Task.Run (() => {
// sseManager.GetStreamOfEvents ("Dummy");
// });
var deviceController = new DeviceController(baseUrl);
var devices = deviceController.ListDevicesAsync(userToken.Token).Result;
var device = devices.FirstOrDefault();
if (device != null && device.Connected)
{
var cloudController = new CloudController(baseUrl, userToken, device);
Task.Run(async() => {
var deviceInfo = await deviceController.GetDeviceInfoByIdAsync(userToken.Token, device.Id);
// var testVariable = deviceInfo.VariableList.FirstOrDefault ();
//
// var vResp = await cloudController.GetVariableAsync (testVariable.Name);
//
// if(vResp != null)
// Console.WriteLine (vResp.Result);
var testFunction = deviceInfo.Functions.FirstOrDefault();
var fResp = await cloudController.CallFunctionAsync(testFunction, "test");
if (fResp != null)
{
Console.WriteLine(fResp.Return_Value);
}
}).Wait();
}
}
internal static Task<CreateAppResponse> CustomCreateApp(CloudController.V2.Client.Base.AbstractAppsEndpoint arg1, CreateAppRequest arg2)
{
return Task.Factory.StartNew<CreateAppResponse>(() =>
{
return new CreateAppResponse() { EntityMetadata = new Metadata(), Name = "testApp" };
});
}
void CreateCloud()
{
float RandHeight = Random.Range(-HeightRange, HeightRange);
Transform tCloud = Instantiate(CloudPrefab, new Vector3(transform.position.x, transform.position.y + RandHeight, transform.position.z), transform.rotation) as Transform;
CloudController tcCloud = tCloud.GetComponent <CloudController>();
tcCloud.Dino = Dino;
tcCloud.Point2Destroy = Point2Destroy;
tcCloud.score = score;
}
void Awake()
{
#region Singleton
if (instance != null)
{
Debug.LogError("Multiple instances of " + this + " found");
}
instance = this;
#endregion
}
private IEnumerator DestroyCloudInCo(CloudController newCloud, float time)
{
yield return(new WaitForSeconds(time));
LeanTween.alpha(newCloud.GetComponentInChildren <SpriteRenderer>().gameObject, 0, _alphaAnimTime);
newCloud.IsBeingDestroyed = true;
yield return(new WaitForSeconds(_alphaAnimTime));
Destroy(newCloud.gameObject);
}
void CreateCloud(Cloud3D cloud)
{
UnityEngine.Object obj = Resources.Load("Prefab/Cloud/" + cloud.mPerfabName);
GameObject gobj = Instantiate(obj) as GameObject;
CloudController AddItem = gobj.GetComponent <CloudController>(); //;Instantiate(Resources.Load("Prefab/Cloud/" + cloud.mPerfabName)) as CloudController;
AddItem.transform.parent = transform;
AddItem.InitCloud(mSun, cloud);
mClouds.Add(AddItem);
}
static void Main(string[] args)
{
IView v = new CloudCLI();
IModel m = new CloudModel();
CloudController c = new CloudController(v, m);
v.SetController(c);
m.SetController(c);
v.Start();
}
// Start is called before the first frame update
void Start()
{
meteorController = GameObject.FindGameObjectWithTag("MeteorController").GetComponent <MeteorController>();
meteorController.ControllerStart();
hexController = GameObject.FindGameObjectWithTag("HexController").GetComponent <HexController>();
hexController.ControllerStart();
planetController = GameObject.FindGameObjectWithTag("Planet").GetComponent <PlanetController>();
planetController.ControllerStart();
cloudController = GameObject.FindGameObjectWithTag("CloudController").GetComponent <CloudController>();
cloudController.ControllerStart();
}
static void Main(string[] args)
{
IView v = new CloudCLI();
IModel m = new CloudModel();
CloudController c = new CloudController(v, m);
v.SetController(c);
m.SetController(c);
v.Start();
}
private void Awake()
{
DontDestroyOnLoad(this);
DontDestroyOnLoad(endPosition);
if (instance == null)
{
instance = this;
}
else
{
Destroy(this.gameObject);
}
}
public void SpawnCloud()
{
Vector3 nextPos;
bool contactFlag = false;
if (clouds.Count == 0)
{
nextPos = new Vector3(0, GameManager.Instance.cloudInititalPosY, 0);
sign = 0;
contactFlag = true;
}
else
{
Vector3 lastPos = clouds[clouds.Count - 1].transform.position;
nextPos = new Vector3(0, lastPos.y - GameManager.Instance.cloudVerticleOffset, 0);
if (sign == -1 || sign == 1)
{
sign = 0;
}
else
{
sign = Mathf.Sign(Random.Range(-10, 10));
}
}
GameObject g = Instantiate(GameManager.Instance.cloudPrefab.gameObject, nextPos, Quaternion.identity) as GameObject;
g.transform.GetChild(0).Translate(new Vector3(sign * GameManager.Instance.cloudHorizontalOffset, 0, 0));
CloudController controller = g.GetComponentInChildren <CloudController>();
controller.contactFlag = contactFlag;
bool hasCoin = Random.Range(0f, 1f) < GameManager.Instance.coinFrequency && !contactFlag ? true : false;
controller.SetActiveCoin(hasCoin);
if (clouds.Count == 0)
{
controller.noObstacle = true;
}
if (sign == 0)
{
Vector3 translation = new Vector3(Mathf.Sign(Random.Range(-10, 10)) * GameManager.Instance.cloudHorizontalOffset, 0, 0);
controller.obstacle.transform.Translate(translation);
}
clouds.Add(g);
if (clouds.Count == 2)
{
GameManager.Instance.firstRotationDirection = -sign;
}
GameManager.Instance.playerDeathPlane.MoveDown();
}
private void OnTriggerStay2D(Collider2D collision)
{
CloudController cloud = collision.GetComponentInParent <CloudController>();
if (cloud.IsBeingDestroyed)
{
return;
}
if (cloud.IsAngry && !_pegi.IsInShock)
{
_pegi.OnEnterInAngryCloud();
}
}
public IEnumerator SpawnAndWait()
{
Vector3 startingPos = transform.position + new Vector3(0, Random.Range(minVertical, maxVertical), 0);
GameObject newCloud = Instantiate(cloudPrefab, startingPos, Quaternion.identity);
newCloud.transform.localScale /= transform.position.z;
CloudController controller = newCloud.GetComponent <CloudController>();
controller.speed = 2 / transform.position.z;
controller.SetKillPos(-transform.position.x);
newCloud.transform.parent = holder.transform;
yield return(new WaitForSeconds(Random.Range(minWaitTime, maxWaitTime)));
StartCoroutine(SpawnAndWait());
}
private IEnumerator GenerateClouds()
{
for (; ;)
{
Vector2 offset = new Vector2(0f, Random.Range(-2f, 2.5f));
GameObject newCloud = CNExtensions.GetPooledObject(clouds, cloud, uiLayer, cloudGeneratorT, offset, Quaternion.identity, false);
newCloud.GetComponent <SpriteRenderer>().sprite = cloudSprites[Random.Range(0, cloudSprites.Length)];
CloudController cloudController = newCloud.GetComponent <CloudController>();
cloudController.passingCloud = true;
cloudController.cloudSpeed = Random.Range(-0.5f, -0.2f);
yield return(new WaitForSeconds(2f));
}
}
void Update()
{
if (Input.GetButton("Horizontal"))
{
stopMovement = false;
movement = Vector2.right * Input.GetAxis("Horizontal");
}
else
{
stopMovement = true;
}
if (Input.GetButtonDown("Jump"))
{
JumpCount++;
}
else if (!jump.getInAir())
{
JumpCount = 0;
}
if (JumpCount == 2 && Input.GetButtonDown("Jump") && powerUp == null && powerViewer.power > 0)
{
Debug.Log("GO!");
powerUp = Instantiate(CyclonePowerUp);
powerUp.transform.position = feet.position;
powerUp.GetComponent <Rigidbody2D>().velocity = rb.velocity / 4;
rb.velocity = Vector2.zero;
rb.isKinematic = true;
transform.parent = powerUp.transform;
CloudController cc = powerUp.GetComponent <CloudController>();
cc.player = transform;
cc.powerViewer = powerViewer;
animator.SetFloat("Speed", 0);
DisableAll();
}
if (!jump.getInAir())
{
animator.SetFloat("Speed", Mathf.Abs(rb.velocity.x));
}
else
{
// animator.SetFloat("Speed",0);
}
}
public bool levelGenerating; // used to ensure that two levels aren't made at the same time
void Start()
{
audioManager = AudioManager.instance;
cameraController = CameraController.instance;
cannonController = CannonController.instance;
cloudController = CloudController.instance;
inputManager = InputManager.instance;
prefabPlacer = PrefabPlacer.instance; // set up all pathways
target = Target.instance;
terrainGenerator = TerrainGenerator.instance;
UIManager = UIManager.instance;
windController = WindController.instance;
cloudController.StartCoroutine(cloudController.CloudSpammer()); // start the cloudSpammer coroutine
StartGame();
}
// Start is called before the first frame update
void Start()
{
if (!(meteorController = GameObject.FindGameObjectWithTag("MeteorController").GetComponent<MeteorController>()))
meteorController.ControllerStart();
if (!(hexController = GameObject.FindGameObjectWithTag("HexController").GetComponent<HexController>()))
hexController.ControllerStart();
if (!(planetController = GameObject.FindGameObjectWithTag("Planet").GetComponent<PlanetController>()))
planetController.ControllerStart();
if (!(cloudController = GameObject.FindGameObjectWithTag("CloudController").GetComponent<CloudController>()))
cloudController.ControllerStart();
if (!(hexViewController = GameObject.FindGameObjectWithTag("HexViewController").GetComponent<HexViewController>()))
hexViewController.ControllerStart();
if (!(sunController = GameObject.FindGameObjectWithTag("SunController").GetComponent<SunController>()))
sunController.ControllerStart();
Debug.Log(sunController.name);
}
// Start is called before the first frame update
void Awake()
{
gameManager = GameObject.Find("GameManager").GetComponent <GameManager>();
globalPostProcessing = GameObject.Find("PostProcessingLayer").GetComponent <PostProcessVolume>();
gameWorld = transform.parent.gameObject.GetComponent <GameWorld>();
globalPostProcessing.profile.TryGetSettings(out grading);
globalPostProcessing.profile.TryGetSettings(out vignete);
temperatur = grading.temperature;
tint = grading.tint;
startVignete = vignete.intensity.value;
cloudController = GameObject.Find("cloudMask").GetComponent <CloudController>();
if (timeOfDay > 0 && timeOfDay < 3)
{
startVignete = timeOfDay / 3.0f * 0.119f + 0.382f;
}
}
void Start()
{
Screen.orientation = ScreenOrientation.LandscapeLeft;
_currentSceneState = SceneState.Unfavorable;
_dayNightCycleController = new DayNightCycleController();
_windController = new WindController();
_cloudController = new CloudController(StartCoroutine);
_rainController = new RainController();
_temperatureController = new TemperatureController(StartCoroutine, _dayNightCycleController);
_waterController = new WaterController();
_terrainController = new TerrainController(StartCoroutine);
_snowController = new SnowController();
_treeGrowthStateController = new TreeGrowthStateController(StartCoroutine, _windController.UpdateTreeWindForceOnGrow);
_sceneRestarted = false;
}
private void OnTriggerEnter2D(Collider2D collision)
{
CloudController cloud = collision.GetComponentInParent <CloudController>();
if (cloud.IsBeingDestroyed)
{
return;
}
if (!cloud.IsAngry)
{
_pegi.OnEnterInNormalCloud();
}
else
{
_pegi.OnEnterInAngryCloud();
}
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.tag.Equals("Cloud"))
{
CloudController a = other.GetComponent <CloudController>();
if (a != null)
{
if (a.direction == 1 && !onLeft)
{
Destroy(other.gameObject);
}
else if (a.direction == -1 && onLeft)
{
Destroy(other.gameObject);
}
}
}
}
private void FixedUpdate()
{
if (Time.timeSinceLevelLoad >= (timeSinceLastSpawn + spawnTimer))
{
Bounds spawnBounds = cd.bounds;
Vector3 min = spawnBounds.min;
Vector3 max = spawnBounds.max;
float x = Random.Range(min.x, max.x);
float y = Random.Range(min.y, max.y);
Vector2 spawnLocation = new Vector3(x, y, 0);
GameObject o = Instantiate(cloud, spawnLocation, Quaternion.identity);
CloudController tmp = o.GetComponent <CloudController>();
tmp.direction = onLeft ? 1 : -1;
timeSinceLastSpawn = Time.timeSinceLevelLoad;
RandomizeSpawnTime();
}
}
private CloudController GenerateRandomCloud()
{
CloudController newCloud = Instantiate <CloudController>(_cloudPrefab, transform);
int orbit = UnityEngine.Random.Range(1, 4);
int cloudID = UnityEngine.Random.Range(1, 4);
float timeNormal = UnityEngine.Random.Range(_minTimeNewCloudNormal, _maxTimeNewCloudNormal);
float timeAngry = UnityEngine.Random.Range(_minxTimeNewCloudAngry, _maxTimeNewCloudAngry);
float speed = UnityEngine.Random.Range(_minSpeed, _maxSpeed);
newCloud.Init(orbit, cloudID, timeNormal, timeAngry, speed);
Vector2 point = UnityEngine.Random.insideUnitCircle;
newCloud.transform.position = point;
newCloud.GetComponentInChildren <SpriteRenderer>().color = new Color(1, 1, 1, 0);
StartCoroutine(DestroyCloudInCo(newCloud, timeNormal + timeAngry + 1));
return(newCloud);
}
internal static Task<GetAppSummaryResponse> CustomGetAppSummary(CloudController.V2.Client.Base.AbstractAppsEndpoint arg1, Guid? arg2)
{
return Task.Factory.StartNew<GetAppSummaryResponse>(() => {
switch (callNumber)
{
case 0:
{
callNumber += 1;
return new GetAppSummaryResponse() { State = "PENDING", RunningInstances = 0 };
}
case 1:
{
callNumber += 1;
return new GetAppSummaryResponse() { State = "STAGED", RunningInstances = 0 };
}
case 2:
{
return new GetAppSummaryResponse() { State = "STARTED", RunningInstances = 1 };
}
default: { return new GetAppSummaryResponse(); }
}
});
}
internal static Task CustomDeleteApp(CloudController.V2.Client.Base.AbstractAppsEndpoint arg1, Guid? arg2)
{
var task = Task.Run(() => { });
return task;
}
internal static Task<UpdateAppResponse> CustomUpdateApp(CloudController.V2.Client.Base.AbstractAppsEndpoint arg1, Guid? arg2, UpdateAppRequest arg3)
{
return Task.Factory.StartNew<UpdateAppResponse>(() =>
{
return new UpdateAppResponse() { Name = "TestApp" };
});
}
internal static Task<PagedResponseCollection<ListAllServiceInstancesResponse>> CustomListAllServiceInstancesPlain(CloudController.V2.Client.Base.AbstractServiceInstancesEndpoint arg1)
{
return Task.Factory.StartNew<PagedResponseCollection<ListAllServiceInstancesResponse>>(() => { return new PagedResponseCollection<ListAllServiceInstancesResponse>(); });
}
internal static Task<RemoveAppFromRouteResponse> CustomRemoveAppFromRoute(CloudController.V2.Client.Base.AbstractRoutesEndpoint arg1, Guid? arg2, Guid? arg3)
{
return Task.Factory.StartNew(() => { return new RemoveAppFromRouteResponse(); });
}
internal static Task<PagedResponseCollection<ListAllRoutesResponse>> CustomListAllRoutes(CloudController.V2.Client.Base.AbstractRoutesEndpoint arg1, RequestOptions arg2)
{
return Task.Factory.StartNew<PagedResponseCollection<ListAllRoutesResponse>>(() =>
{
return new PagedResponseCollection<ListAllRoutesResponse>();
});
}
void Apps_PushProgress(object sender, CloudController.V2.Client.PushProgressEventArgs e)
{
logger.LogMessage("Received from push job:{0} - {1}%", e.Message, e.Percent);
}
private Task<AssociateRouteWithAppResponse> CustomAssociate(CloudController.V2.Client.Base.AbstractAppsEndpoint arg1, Guid? arg2, Guid? arg3)
{
var task = Task.Run(() => { return new AssociateRouteWithAppResponse(); });
return task;
}
private bool CloudIsActive(CloudController cloud)
{
return(cloud != null && cloud.isActiveAndEnabled && cloud.cloudPS.particleCount > 0);
}
// { Token = new UAA.Authentication.Token() { RefreshToken = "mytoken" } } - Token is read-only and cannot be assigned to from shim context without fakeing uaa
internal static Task<AuthenticationContext> CustomLogin(CloudController.V2.Client.CloudFoundryClient arg1, CloudCredentials arg2)
{
return Task.Factory.StartNew<AuthenticationContext>(() => { return new AuthenticationContext(); });
}
public void SetController(CloudController controller)
{
this.Controller = controller;
}
void Awake()
{
Instance = this;
cloudPanel.SetActive(true);
}
internal static Task<PagedResponseCollection<ListAllServicePlansForServiceResponse>> CustomListServicePlans(CloudController.V2.Client.Base.AbstractServicesEndpoint arg1, Guid? arg2)
{
return Task.Factory.StartNew<PagedResponseCollection<ListAllServicePlansForServiceResponse>>(new Func<PagedResponseCollection<ListAllServicePlansForServiceResponse>>(() =>
{
return new PagedResponseCollection<ListAllServicePlansForServiceResponse>();
}));
}
internal static Task<PagedResponseCollection<ListAllServiceInstancesForSpaceResponse>> CustomListAllServiceInstances(CloudController.V2.Client.Base.AbstractSpacesEndpoint arg1, Guid? arg2, RequestOptions arg3)
{
return Task.Factory.StartNew<PagedResponseCollection<ListAllServiceInstancesForSpaceResponse>>(() =>
{
return new PagedResponseCollection<ListAllServiceInstancesForSpaceResponse>();
});
}
internal static Task<PagedResponseCollection<ListAllStacksResponse>> CustomListAllStacks(CloudController.V2.Client.Base.AbstractStacksEndpoint arg1)
{
return Task.Factory.StartNew<PagedResponseCollection<ListAllStacksResponse>>(new Func<PagedResponseCollection<ListAllStacksResponse>>(
() =>
{
PagedResponseCollection<ListAllStacksResponse> collection = new PagedResponseCollection<ListAllStacksResponse>();
return collection;
}
));
}
internal static Task<PagedResponseCollection<ListAllServiceBindingsForAppResponse>> CustomListAllServiceBindingsForApp(CloudController.V2.Client.Base.AbstractAppsEndpoint arg1, Guid? arg2)
{
return Task.Factory.StartNew<PagedResponseCollection<ListAllServiceBindingsForAppResponse>>(() =>
{
return new PagedResponseCollection<ListAllServiceBindingsForAppResponse>();
});
}
internal static Task<PagedResponseCollection<ListAllSpacesForOrganizationResponse>> CustomListAllSpacesForOrganization(CloudController.V2.Client.Base.AbstractOrganizationsEndpoint arg1, Guid? arg2, RequestOptions arg3)
{
return Task.Factory.StartNew(() => { return new PagedResponseCollection<ListAllSpacesForOrganizationResponse>(); });
}
internal static Task<PagedResponseCollection<ListAllDomainsDeprecatedResponse>> CustomListAllDomains(CloudController.V2.Client.Base.AbstractDomainsDeprecatedEndpoint arg1)
{
return Task.Factory.StartNew<PagedResponseCollection<ListAllDomainsDeprecatedResponse>>(new Func<PagedResponseCollection<ListAllDomainsDeprecatedResponse>>(() =>
{
return new PagedResponseCollection<ListAllDomainsDeprecatedResponse>();
}));
}
void Start()
{
AudioClip lightningSoundLoad = Resources.Load("Foley/Lightning", typeof(AudioClip)) as AudioClip;
LightningFoley = lightningSoundLoad;
GameObject lightningLoad = Resources.Load("Mesh/Lightning", typeof(GameObject)) as GameObject;
lightningObject = lightningLoad;
GameObject cloudLoad = Resources.Load("Mesh/Cloud", typeof(GameObject)) as GameObject;
cloud = cloudLoad;
cloudController = GameObject.FindGameObjectWithTag ("GameController").GetComponent<CloudController> ();
player = CustomExtensions.GetPlayer();
CreateClouds();
Debug.Log(cloudVectorList.Count);
Debug.Log(particleCount);
cloadBaseColor = CloudColor;
}
public void SetController(CloudController controller)
{
this.Controller = controller;
}
internal static Task CustomDeleteServiceInstance(CloudController.V2.Client.Base.AbstractServiceInstancesEndpoint arg1, Guid? arg2)
{
return Task.Factory.StartNew(() => { });
}
private System.Threading.Tasks.Task CustomPushJob(CloudController.V2.Client.AppsEndpoint arg1, Guid arg2, string arg3, bool arg4)
{
var task = Task.Run(() => { });
return task;
}
public void BeforeTest()
{
cloudMovementController = GetCloudMovementControllerMock();
controller = new CloudController();
controller.SetCloudMovementController(cloudMovementController);
}
public void GenerateClouds()
{
GameObject cloudManager = GameObject.Find("CloudManager");
if (!cloudManager)
{
cloudManager = new GameObject();
cloudManager.name = "CloudManager";
cloudManager.AddComponent <CloudManager>();
cloudManager.transform.position = this.transform.position;
}
GameObject[] allClouds = GameObject.FindGameObjectsWithTag("Cloud");
for (int i = 0; i < allClouds.Length; i++)
{
DestroyImmediate(allClouds[i]);
}
for (int c = 0; c < numClouds; c++)
{
GameObject cloudGO = new GameObject();
ParticleSystem cloudSystem = cloudGO.AddComponent <ParticleSystem>();
CloudController cc = cloudGO.AddComponent <CloudController>();
ParticleSystem.MainModule main = cloudSystem.main;
Renderer cloudRend = cloudGO.GetComponent <Renderer>();
cloudGO.name = "Cloud" + c;
cloudGO.tag = "Cloud";
cloudGO.transform.rotation = cloudManager.transform.rotation;
cloudGO.transform.position = cloudManager.transform.position;
cloudGO.transform.parent = cloudManager.transform;
cloudGO.transform.localScale = new Vector3(1.0f, 1.0f, 1.0f);
cloudGO.layer = LayerMask.NameToLayer("Sky");
cc.color = cloudColor;
cc.lining = cloudLining;
cc.numOfParticles = particlesPerCloud;
cc.minSpeed = cloudMinSpeed;
cc.maxSpeed = cloudMaxSpeed;
cc.dst = cloudRange;
cloudRend.material = cloudMat;
cloudRend.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
cloudRend.receiveShadows = false;
main.loop = false;
main.startLifetime = Mathf.Infinity;
main.startSpeed = 0;
main.startSize = cloudStartSize;
main.startColor = Color.white;
var emission = cloudSystem.emission;
emission.rateOverTime = 0;
emission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0.0f, (short)particlesPerCloud) });
var shape = cloudSystem.shape;
shape.shapeType = ParticleSystemShapeType.Sphere;
shape.scale = new Vector3(UnityEngine.Random.Range(cloudScaleMin.x, cloudScaleMax.x), UnityEngine.Random.Range(cloudScaleMin.y, cloudScaleMax.y), UnityEngine.Random.Range(cloudScaleMin.z, cloudScaleMax.z));
if (UnityEngine.Random.Range(0, 10) < 7.5)
{
GameObject cloudProjector = new GameObject();
Projector cp = cloudProjector.AddComponent <Projector>();
int skyLayerMask = 1 << LayerMask.NameToLayer("Sky");
int waterLayerMask = 1 << LayerMask.NameToLayer("Water");
cloudProjector.name = "Shadow";
cloudProjector.transform.position = cloudGO.transform.position;
cloudProjector.transform.forward = Vector3.down;
cloudProjector.transform.parent = cloudGO.transform;
cp.material = cloudShadowMat;
cp.material.mainTextureScale = new Vector2(shape.scale.x, shape.scale.z);
cp.farClipPlane = terrainData.size.y;
cp.ignoreLayers = skyLayerMask | waterLayerMask;
cp.fieldOfView = 20.0f;
}
}
}
private void Awake()
{
cloudControllerScript = FindObjectOfType <CloudController>();
Debug.Log(cloudControllerScript);
}
