void Start()
{
if (instance == null)
{
instance = this;
}
}
// Use this for initialization
void Start()
{
// initiate at 0,0,0
vehiclePos = new Vector3(0, 0, 0);
velocity = Vector3.zero;
acceleration = Vector3.zero;
// set the direction upwards
direction = new Vector3(0, 1, 0);
// set the speed to 1
maxSpeed = 1;
// set rotation to 0
totalRot = 0;
// set the acceleration rate
accelRate = 0.2f;
// zero out cooldown and timer
cooldown = 0f;
timer = 0f;
// find the asteroid manager
man = GameObject.Find("SceneManager").GetComponent <AsteroidManager> ();
// start off with invulnerability
invuln = true;
// start without the powerup
powerUp = false;
// set the timer to 0;
pTimer = 0f;
}
public void LoadAsteroidView()
{
if (asteroidManager != null)
{
asteroidManager.astRepList[selectedAsteroidIndex].GetComponent <astRepControl>().OnDeselect();
}
else
{
asteroidManager = GameObject.Find("GameController").GetComponent <AsteroidManager>();
asteroidManager.astRepList[selectedAsteroidIndex].GetComponent <astRepControl>().OnDeselect();
}
//SceneManager.LoadScene("AsteroidScene");
if (StrategicViewCameraObject == null)
{
StrategicViewCameraObject = GameObject.Find("Main Camera");
}
if (asteroidCameraObject == null)
{
asteroidCameraObject = GameObject.Find("AsteroidCamera");
}
StrategicViewCameraObject.GetComponent <Camera>().enabled = false;
StrategicViewCameraObject.GetComponent <AudioListener>().enabled = false;
asteroidCameraObject.GetComponent <CameraController>().enabled = true;
asteroidCameraObject.GetComponent <CameraController>().SetFocusPlanet(asteroidManager.planets[selectedAsteroidIndex]);
asteroidCameraObject.GetComponent <Camera>().enabled = true;
asteroidCameraObject.GetComponent <AudioListener>().enabled = true;
Debug.Log("Loading asteroid view");
Debug.Log(selectedAsteroidIndex);
}
public Level1Scene(Game game)
: base(game)
{
// Get the current sprite batch
spriteBatch = (SpriteBatch)
Game.Services.GetService(typeof(SpriteBatch));
theCamera = new Camera(1280, 1024);
game.Services.AddService(typeof(Camera), theCamera);
// Get the audio library
audio = (AudioLibrary)
Game.Services.GetService(typeof(AudioLibrary));
player = new GameObject.Player(game, new Vector3(0, 0, 300));
Components.Add(player.Health);
Components.Add(player.Score);
tunnel = new GameObject.Tunnel(game, 200, 200);
skybox = new SkyBox(game);
bulletManager = new BulletManager(game);
asteroidManager = new AsteroidManager(game);
pgen = new ParticleSystem(game, Game1.pe);
game1 = game;
Load();
}
void OnCollisionEnter2D(Collision2D collisionInfo)
{
if (manager == null)
{
manager = gameObject.transform.parent.GetComponent <AsteroidManager>();
}
string name = collisionInfo.gameObject.name;
// Debug.Log("collide with " + name );
// explode on high impacts
float impactSpeed = collisionInfo.relativeVelocity.magnitude;
if (impactSpeed > 2)
{
float factor = 0.9f;
transform.localScale = factor * transform.localScale;
if (transform.localScale.x < 0.2f)
{
manager.RemoveAsteroid(gameObject);
}
}
// spawn dust with size proportional to impactSpeed at every contact point
for (int i = 0; i < collisionInfo.contactCount; i++)
{
Vector2 contact = collisionInfo.GetContact(i).point;
GameObject animObject = Instantiate(dust, new Vector3(contact.x, contact.y, 0f), Quaternion.identity);
animObject.transform.parent = gameObject.transform;
float scaleFactor = 0.4f;
animObject.transform.localScale = scaleFactor * impactSpeed * animObject.transform.localScale;
}
}
void Start()
{
selected = false;
rb = gameObject.GetComponent <Rigidbody> ();
levelManager = FindObjectOfType <BaseLevelManager> ();
asteroidManager = FindObjectOfType <AsteroidManager>();
}
// Update is called once per frame
void Update()
{
if (manager == null)
{
manager = gameObject.transform.parent.GetComponent <AsteroidManager>();
}
}
private void Awake()
{
gameController = GameObject.Find("GameController").GetComponent <GameController>();
navManager = GameObject.Find("NavigationManager").GetComponent <NavManager>();
asteroidManager = GameObject.Find("GameController").GetComponent <AsteroidManager>();
asteroidManager.ShiftAway();
int selectedAstIndex = navManager.selectedAsteroidIndex;
asteroidPreviouslyGenerated = asteroidManager.asteroids[selectedAstIndex].prevgenerated;
if (!asteroidPreviouslyGenerated)
{
seed = asteroidManager.AsteroidSeeds[selectedAstIndex];
planet = Instantiate(planetPrefab);
planet.transform.position = new Vector3(0, 0, 0);
Random.InitState(seed);
/* List of settings to be randomised:
* noise layer 1 centre: Vector3
* noise layer 2 centre: Vector3
* noise layer 3 centre: Vector3
*/
ShapeSettings.NoiseLayer[] noiseLayers = planet.GetComponent <Planet>().shapeSettings.noiseLayers;
foreach (ShapeSettings.NoiseLayer noiseLayer in noiseLayers)
{
noiseLayer.noiseSettings.simpleNoiseSettings.centre = new Vector3(Random.Range(-100f, 100f), Random.Range(-100f, 100f), Random.Range(-100f, 100f));
noiseLayer.noiseSettings.rigidNoiseSettings.centre = new Vector3(Random.Range(-100f, 100f), Random.Range(-100f, 100f), Random.Range(-100f, 100f));
}
planet.transform.SetParent(gameController.transform);
asteroidManager.planets[selectedAstIndex] = planet;
}
else
{
asteroidManager.planets[selectedAstIndex].SetActive(true);
}
}
public override void _Ready()
{
// load in some nodes
asteroidManager = GetNode <AsteroidManager>("AsteroidManager");
endGameDelayTimer = GetNode <Timer>("EndGameDelayTimer");
canvasLayer = GetNode <CanvasLayer>("CanvasLayer");
map = GetNode <Map>("Map");
gui = canvasLayer.GetNode <GUI>("GUI");
techTree = canvasLayer.GetNode <Control>("TechTree");
leaderBoard = canvasLayer.GetNode <Control>("Leaderboard");
quitPopup = canvasLayer.GetNode <ConfirmationDialog>("QuitPopup");
Signals.FinalWaveCompleteEvent += OnFinalWaveComplete;
Signals.TerritoryDestroyedEvent += OnTerritoryDestroyed;
gui.TechTreeButtonPressedEvent += OnTechTreeButtonPressed;
gui.LeaderBoardButtonPressedEvent += OnLeaderBoardButtonPressed;
quitPopup.Connect("confirmed", this, nameof(OnQuitPopupConfirmed));
// setup our list of territories per owner
map.Territories.ForEach(t => numTerritoriesPerPlayer[t.TerritoryOwner - 1]++);
asteroidManager.Territories = map.Territories;
AddPlayersToWorld();
// after the world is setup, tell the server to start the timer and begin the game
Server.Instance.PostBeginGame();
}
// Use this for initialization
void Start()
{
Debug.Log("Starting");
manager = GameObject.Find("Asteroid Manager").GetComponent <AsteroidManager>();
target = GetTarget();
startMove = transform.position;
startTime = Time.time;
audio = GetComponent <AudioSource> ();
if (type == Type.Large)
{
GetComponent <SpriteRenderer>().sprite = manager.largeAsteroids[Random.Range(0, manager.largeAsteroids.Count)];
gameObject.AddComponent <PolygonCollider2D>().isTrigger = true;
explosion = manager.largeExplosion;
audio.clip = manager.lBang;
}
if (type == Type.Medium)
{
explosion = manager.mediumExplosion;
audio.clip = manager.mBang;
}
if (type == Type.Small)
{
explosion = manager.mediumExplosion;
audio.clip = manager.sBang;
}
StartCoroutine(Spin());
}
void Start( )
{
// Grab the AsteroidManager script.
asteroidManager = GetComponent <AsteroidManager>();
// Set the initial position for the asteroid.
transform.position = (transform.position - targetAsteroid.position).normalized * orbitRadius + targetAsteroid.position;
}
public CollisionManager(AsteroidManager asteroidManager,
PlayerManager playerManager, EnemyManager enemyManager,
ExplosionManager explosionManager)
{
this.asteroidManager = asteroidManager;
this.playerManager = playerManager;
this.enemyManager = enemyManager;
this.explosionManager = explosionManager;
}
void Awake()
{
mainCam = Camera.main;
backdrop = mainCam.GetComponent <CameraBehaviour>();
asteroids = GetComponent <AsteroidManager>();
planetManager = GetComponent <PlanetManager>();
systemData = LoadSystemData("Sol");
_minimapManager.GenerateSystemMap();
}
// Use this for initialization
void Start()
{
asteroidManager = GameObject.Find("GameManager").GetComponent <AsteroidManager>();
projectileLayer = LayerMask.NameToLayer("Projectile");
if (big)
{
AddForceTowardsCenter();
}
}
private void Awake()
{
_interfaceManager = Instantiate(_gameData.Managers.InterfaceManagerPrefab, parent: transform);
_wrapManager = Instantiate(_gameData.Managers.WrapManagerPrefab, parent: transform);
_asteroidManager = Instantiate(_gameData.Managers.AsteroidManagerPrefab, parent: transform);
_playerManager = Instantiate(_gameData.Managers.PlayerManagerPrefab, parent: transform);
_bulletManager = Instantiate(_gameData.Managers.BulletManagerPrefab, parent: transform);
Events.OnSessionUpdated.Register(OnSessionUpdated);
}
public GameController(
Hook hook,
AsteroidManager asteroidSpawner,
HookCrashedSignal hookCrashedSignal,
AlienCatchedSignal alienCatchedSignal)
{
_hookCrashedSignal = hookCrashedSignal;
_asteroidSpawner = asteroidSpawner;
_hook = hook;
_alienCatchedSignal = alienCatchedSignal;
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(this);
}
}
//Spawn a random asteroid in a random direction
void Spawn()
{
//Generate random index into asteroid pieces array
int randomIndex = Random.Range(0, asteroidPieces.Length);
//Select random asteroid piece
GameObject astroidPiece = asteroidPieces[randomIndex];
//Ask the Asteroid Manager to spawn a new asteroid piece at a position
AsteroidManager.Spawn(astroidPiece, transform.position);
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
}
// Use this for initialization
void Start()
{
Instance = this;
asteroids = new List <GameObject>();
while (asteroids.Count < Density)
{
RandomlyInstantiateAsteroid(isStart: true);
}
}
internal void Start()
{
Ctx = this;
Saveload = new SaveLoadManager();
Score = GameObject.Find("ScoreText").GetComponent <ScoreManager> ();
Player = GameObject.Find("Player").GetComponent <Player> ();
Asteroids = GameObject.Find("Spawner").GetComponent <AsteroidManager> ();
Bullets = new BulletManager(GameObject.Find("Bullets").transform);
_saveAxis = Platform.GetSaveAxis();
}
int index = 0; //Just one way to change the generation
//Init all variables
protected override void Start()
{
if (asteroidManager != null)
{
Destroy(this);
return;
}
asteroidManager = this;
base.Start();
StartCoroutine(InstantiateBotCoroutine());
index = individualsPerGeneration;
}
public void init(AsteroidManager asteroidManager, Vector3 position, Vector3 direction)
{
this.asteroidManager = asteroidManager;
this.direction = direction;
cachedTransform.position = position;
customParticleEmitter = new CustomParticleEmitter();
warper = new Warper(cachedTransform);
initParams();
}
private void Awake()
{
m_ship = FindObjectOfType <ShipMovement>().transform;
if (AsteroidManager.m_instance != null)
{
Destroy(gameObject);
}
else
{
AsteroidManager.m_instance = this;
}
}
private void Awake()
{
//destroys the gameobject if one already exists
if (asteroidManager == null)
{
asteroidManager = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
void Start()
{
// Declare a new AsteroidManager.
AsteroidManager am = new AsteroidManager();
// Go through all asteroids in the scene.
foreach (GameObject asteroid in GameObject.FindGameObjectsWithTag("Asteroid"))
{
am.SaveAsteroid(asteroid);
}
am.WriteArray();
}
public void DestroyAsteroid()
{
if (big)
{
if (asteroidManager == null)
{
asteroidManager = GameObject.Find("GameManager").GetComponent <AsteroidManager>();
}
asteroidManager.SpawnSmallAsteroids(transform.position);
}
gameObject.SetActive(false);
}
private void Awake()
{
if (main == null)
{
// if there is no main object, this will take its place.
main = this;
}
else
{
// if a main object exists, we'll self-destruct.
DestroyImmediate(this);
}
}
void Start()
{
AsteroidManager am = new AsteroidManager();
AsteroidData[] asteroidDatas = am.ReadAsteroids();
// Instantiate all asteroids from asteroidDatas.
foreach (AsteroidData ad in asteroidDatas)
{
GameObject newAsteroid = GameObject.CreatePrimitive(PrimitiveType.Sphere);
newAsteroid.transform.position = ad.position;
newAsteroid.transform.localScale = ad.scale;
}
}
override protected void initializeRest() {
asm = (AsteroidManager)objectsManager;
canBeMagnetized = false;
minBrokenSpawn = asm.minBrokenSpawn;
maxBrokenSpawn = asm.maxBrokenSpawn;
minBrokenSize = asm.minBrokenSize;
maxBrokenSize = asm.maxBrokenSize;
beatAnimation = GetComponent<Animation>();
beatAnimation.wrapMode = WrapMode.Once;
RhythmManager.rm.registerCallback(GetInstanceID(), () => {
beatAnimation.Play();
});
}
protected override void LoadForeground()
{
var enemyManager = new EnemyManager(TopDown.EnemyName, TopDown.EnemyBulletName, SpaceGraphics.EnemyShipAsset.First(), 100, 1000, ForegroundLayer, 2, SpaceSounds.Sound_Explosion01, 5, 50);
enemyManager.AddObjectEventAction(ObjectEvent.CollisionEnter, EnemyShipDestroyed);
ForegroundLayer.Managers.Add(enemyManager);
var asteroidManager = new AsteroidManager(SpaceGraphics.AsteroidAsset, SpaceGraphics.MiniAsteroidAsset, ForegroundLayer);
ForegroundLayer.Managers.Add(asteroidManager);
CreatePlayer();
CreateScoreDisplay();
}
/// <summary>
/// Resets the game field
/// </summary>
public void ResetGameFull()
{
score = 0;
level = 1;
Random rand = new Random();
player = new Player(GameRef.Content);
asteroids = new AsteroidManager(GameRef.Content);
shots = new List<Shot>();
}
/// <summary>
/// Sets the asteroids parameters
/// </summary>
/// <param name="asteroidManager">The manager for this item</param>
/// <param name="asteroidType">The type of asteroid (size)</param>
/// <param name="rotation">Rotation of the asteroid</param>
/// <param name="velocity">Velocity of the asteroid</param>
/// <param name="position">Position of the asteroid</param>
public void Set(AsteroidManager asteroidManager, ASTEROID_TYPE asteroidType, Vector3 rotation, Vector3 velocity, Vector3 position)
{
_asteroidManager = asteroidManager;
_asteroidType = asteroidType;
_rotation = rotation;
_velocity = velocity;
// We use the Accessor for this member to update the transform position
Position = position;
}
// Use this for initialization
void Start()
{
incol = false;
invis = false;
mainstate = GameObject.FindGameObjectWithTag ("GameController").GetComponent<GameController> ();
curasteroidstate = GetComponentInParent<AsteroidManager> ();
curRig = GetComponent<Rigidbody2D> ();
// Scaling
// Get main camera component
main = Camera.main;
// Main camera height and width
camheight = main.orthographicSize * 2;
camwidth = camheight * main.aspect;
// Set temp to ship sprite
temp = GetComponent<SpriteRenderer> ().sprite;
// How big bg1 is in world units
unitWidth = temp.textureRect.width / temp.pixelsPerUnit;
//unitHeight = temp.textureRect.height / temp.pixelsPerUnit;
// Asteroid Details
randomscale = Random.Range (7, 12);
speed.x = 0;
speed.y = Random.Range (curasteroidstate.speedmin, curasteroidstate.speedmax);
turnspeed = Random.Range (-4, 4);
// Scale ship according to camera size
transform.localScale = new Vector3 (camwidth / (unitWidth * randomscale), camwidth / (unitWidth * randomscale));
//Asteroid Initial speeds
curRig.velocity = speed;
curRig.AddTorque (turnspeed);
}
