write() public static méthode

Writes event to log file specified above.
public static write ( string output ) : void
output string
Résultat void
Exemple #1
0
 /// <summary>
 /// Sets the multiplier.
 /// </summary>
 /// <param name="mult">Mult.</param>
 public void SetMultiplier(int mult)
 {
     SystemLogger.write("Score multiplier set");
     this.multi         *= mult;
     this.multiplierText = "x" + multi.ToString();
     Multi.Instance.MultiTxtSet();
 }
Exemple #2
0
 /// <summary>
 /// Decrease the multiplier
 /// </summary>
 /// <param name="mult"></param>
 public void DecreaseMultiplier(int mult)
 {
     SystemLogger.write("Score Multiplier Decreased");
     this.multi          = mult;
     this.multiplierText = "x" + multi.ToString();
     Multi.Instance.MultiTxtSet();
 }
Exemple #3
0
    public void LoadPlanet()
    {
        if (serializedSamplePointsByPlanet.ContainsKey(planetName) && serializedSamplePointsByPlanet[planetName].samplePointKeys != null)
        {
            Vector3[] normals         = mesh.normals;
            int[]     triangleIndices = mesh.GetTriangles(0);
            for (int i = 0; i < triangleIndices.Length - 2; i += 3)
            {
                faceNormals.Add((normals[triangleIndices[i]] + normals[triangleIndices[i + 1]] + normals[triangleIndices[i + 2]]) / 3);
            }
            SystemLogger.write("Loading sample points from save file.");
            samplePoints = new Dictionary <long, List <ProceduralGenerationPoint> >();
            reconstructSamplePoints(planetName);
        }
        else
        {
            samplePoints = generatePoisson(minDistance, newPointsCount);
        }

        if (generateAllAtOnce)
        {
            generateObjectsByName();
            StartCoroutine("generateAll");
        }
        else
        {
            generateInitialObjects();
            serializeSamplePoints();
        }
    }
    /// <summary>
    /// Gets the list of possible grids in which enemies can be spawned.
    /// </summary>
    /// <returns>The spawn cells.</returns>
    /// <param name="playerLoc">Player location.</param>
    /// <param name="maxCellsAway">Max cells away.</param>
    /// <param name="minCellsAway">Minimum cells away.</param>
    /// <param name="direction">Direction.</param>
    public List <long> getSpawnCells(long playerLoc, int maxCellsAway, int minCellsAway)
    {
        SystemLogger.write("Getting cells where enemy can be spawned...");
        List <long> possibleKeys = new List <long> ();

        int y    = (int)(playerLoc / gridOffset);
        int x    = (int)(playerLoc - (y * gridOffset));
        int minX = x - maxCellsAway;
        int maxX = x + maxCellsAway;

        int minY = y - maxCellsAway;
        int maxY = y + maxCellsAway;

        int newX, newY;

        for (int i = minX; i <= maxX; i++)
        {
            for (int j = minY; j < maxY; j++)
            {
                newX = i;
                newY = j;

                if (Mathf.Abs(x - newX) + Mathf.Abs(y - newY) >= minCellsAway)
                {
                    possibleKeys.Add(newX + (newY * gridOffset));
                }
            }
        }

        return(possibleKeys);
    }
    /// <summary>
    /// Update the current plan
    /// </summary>
    /// <returns></returns>
    private void updateCurrentPlan()
    {
        SystemLogger.write("Update current plan");
        base.resetTargetIndex();

        this.getNewPlan(PlanetNavigation.vertices[Random.Range(0, PlanetNavigation.vertices.Length - 1)]);
    }
Exemple #6
0
    /// <summary>
    /// Generates the objects in the objectsByName pool. To be used during reloading sample points from save file.
    /// </summary>
    public void generateObjectsByName()
    {
        SystemLogger.write("Setting objects by name...");
        Object[] largeObjects  = Resources.LoadAll(folder + "/Large");
        Object[] mediumObjects = Resources.LoadAll(folder + "/Medium");
        Object[] smallObjects  = Resources.LoadAll(folder + "/Small");

        int i;

        objectBySize.Add("Small", new List <GameObject> ());

        for (i = 0; i < smallObjects.Length; i++)
        {
            objectByName.Add(smallObjects[i].name, (GameObject)smallObjects[i]);
        }

        for (i = 0; i < mediumObjects.Length; i++)
        {
            objectByName.Add(mediumObjects[i].name, (GameObject)mediumObjects[i]);
        }

        for (i = 0; i < largeObjects.Length; i++)
        {
            objectByName.Add(largeObjects[i].name, (GameObject)largeObjects[i]);
        }
    }
Exemple #7
0
    /// <summary>
    /// Add the bomb pickup to the pickup array
    /// </summary>
    public void AddBombPickup()
    {
        template bomb = (obj) =>
        {
            if (obj.gameObject.GetComponent <Shooting>() != null)
            {
                Instantiate(bombExplosion, obj.transform.position, obj.transform.rotation);
                // Get all the objects in a <ExplosionRadius> radius from where the bullet collided
                Collider[] hitColliders = Physics.OverlapSphere(
                    transform.position,
                    PowerUpManager.Instance.BombRadius,
                    PowerUpManager.Instance.BombLayer);
                PopUpText.Instance.NewPopUp("Nuke!");
                // For every object in the explosion
                for (int i = 0; i < hitColliders.Length; ++i)
                {
                    if (hitColliders[i])
                    {
                        // Try and find an EnemyHealth script on the gameobject hit.
                        EnemyStats enemyHealth = hitColliders[i].gameObject.GetComponentInParent <EnemyStats>();

                        // If the EnemyHealth component exist...
                        if (enemyHealth != null)
                        {
                            // ... the enemy should take damage.
                            enemyHealth.TakeDamage((int)PowerUpManager.Instance.BombDamage);
                        }
                    }
                }
            }
        };

        this.Type[6] = bomb;
        SystemLogger.write("Bomb Pickup Initialized");
    }
Exemple #8
0
    /// <summary>
    /// Add the shield pickup to the pickup array
    /// </summary>
    public void AddShieldPickup()
    {
        template shieldPickup = (obj) =>
        {
            // If the shield isn't already active
            if (!PowerUpManager.Instance.Powerups["Shield"].IsActive)
            {
                PopUpText.Instance.NewPopUp("Force Field!");
                // Make a shield around the player. This may change from my shitty particle effect
                GameObject shield = Instantiate(PowerUpManager.Instance.ShieldModel, obj.transform.position, obj.transform.rotation) as GameObject;

                // Parent the shield to the player
                shield.transform.parent = obj.transform;

                // Resize the shield to look like it's around the player.
                shield.transform.localScale = new Vector3(
                    PowerUpManager.Instance.ShieldResizer,
                    PowerUpManager.Instance.ShieldResizer,
                    PowerUpManager.Instance.ShieldResizer);

                // Start the particle system
                shield.GetComponent <ParticleSystem>().Play();
            }

            // Activate the shield power up
            PowerUpManager.Instance.Activate("Shield");
        };


        this.Type[7] = shieldPickup;
        SystemLogger.write("Shield Pickup Initialized");
    }
    /// <summary>
    /// Triggered when the bullet collides with anything
    /// </summary>
    /// <param name="col">The object it collides with</param>
    void OnCollisionEnter(Collision col)
    {
        SystemLogger.write("Bullet collision");
        // If it's an enemy
        if (col.gameObject.CompareTag(this.targetTag))
        {
            // Try and find an EnemyHealth script on the gameobject hit.
            EnemyStats enemyHealth = col.gameObject.GetComponentInParent <EnemyStats>();

            // if not in parent
            if (enemyHealth == null)
            {
                enemyHealth = col.gameObject.GetComponent <EnemyStats>();
            }

            // If the EnemyHealth component exists...
            if (enemyHealth != null)
            {
                // ... the enemy should take damage.
                enemyHealth.TakeDamage((int)this.damage);

                if (PowerUpManager.Instance.Powerups["DamageUp"].IsActive)
                {
                    enemyHealth.TakeDamage((int)PowerUpManager.Instance.PowerIncrease);
                }
            }
        }
    }
    /// <summary>
    /// A timer for the power ups
    /// </summary>
    /// <param name="Key">The specific power up key</param>
    /// <returns></returns>
    IEnumerator Timer(string Key)
    {
        // While there's still time left on the timer
        while (Powerups[Key].Timer > 0f)
        {
            // Count down
            this.Powerups[Key].Timer -= Time.deltaTime;
            yield return(null);
        }

        // Deactive power up
        this.Powerups[Key].IsActive = false;
        Powerups[Key].guiIcon.SetActive(false);

        // If the power up was a multishot, set the max laser count back to 1
        if (Key.Equals("Multishot"))
        {
            this.maxLaserCount = 1f;
        }

        // If the power up was a shield, destroy the shield effect
        if (Key.Equals("Shield"))
        {
            Destroy(GameObject.Find("Shield(Clone)"));
        }

        // If the power up was a speed boost, set the speed back to normal
        if (Key.Equals("SpeedBoost"))
        {
            this.CurrentSpeedBoost = 1f;
        }

        SystemLogger.write("Power up time complete");
    }
Exemple #11
0
    public void dropBomb(Vector3 target)
    {
        SystemLogger.write("droppin da bomb");
        GameObject bomb = Instantiate(enemyBomb, bombSpawnLocation.position, this.transform.rotation) as GameObject;

        /*
         * // Everything from here down is basically kinematic equations to calculate the necessary forward velocity
         * // for the bomb to hit the player at its current location
         * Vector3 enemyToPlayer = Player.Instance.transform.position - this.transform.position;
         * float angle = Vector3.Angle(this.transform.forward, enemyToPlayer);
         * float horizontalDistanceToPlayer = enemyToPlayer.magnitude * Mathf.Cos(angle);
         *
         * RaycastHit hit;
         * if(Physics.Raycast(this.transform.position, -this.transform.up, out hit, maxDistance, LayerMask.NameToLayer("Planet")))
         * {
         *  float velocityMagnitude = (horizontalDistanceToPlayer / (Mathf.Sqrt((2 * hit.distance) / 9.8f)));
         *
         *  bomb.GetComponent<Rigidbody>().velocity = bomb.transform.forward * velocityMagnitude;
         *
         *  bomb.GetComponent<Rigidbody>().useGravity = true;
         *  bomb.GetComponent<TImedDestroySelf>().lifetime = 25f;
         * }*/

        bomb.GetComponent <Rigidbody>().useGravity = true;
        mover.flyingTowardsPlayer = false;
    }
    /// <summary>
    /// Called when the object is created. Used to
    /// initialize the singleton pattern.
    /// </summary>
    void Start()
    {
        if (Instance == null)
        {
            Instance        = this;
            this.Powerups   = new Dictionary <string, Powerup>();
            this.Multishot  = new Powerup(MultiShotTime, MultiBar, this.MultiBarIcon);
            this.DamageUp   = new Powerup(DamageUpTime, DamageUpBar, this.DamageUpBarIcon);
            this.Shield     = new Powerup(ShieldTime, ShieldBar, this.ShieldBarIcon);
            this.SpeedBoost = new Powerup(SpeedBoostTime, SpeedBar, this.SpeedBarIcon);
            this.Bomb       = new Powerup(0f, null);

            Powerups.Add("Multishot", this.Multishot);
            Powerups.Add("DamageUp", this.DamageUp);
            Powerups.Add("Shield", this.Shield);
            Powerups.Add("SpeedBoost", this.SpeedBoost);
            Powerups.Add("Bomb", this.Bomb);

            SystemLogger.write("Powerup Manager attached to: " + this.gameObject.name);
        }
        else
        {
            Destroy(this.gameObject);
        }
    }
Exemple #13
0
    /// <summary>
    /// Drop a mine onto the planet
    /// </summary>
    private void dropMine()
    {
        SystemLogger.write("instantiating new mine");
        GameObject newMine = (GameObject)Instantiate(this.mine, this.mineSpawnLocation.position, this.mineSpawnLocation.rotation);

        // Add self to observable
        newMine.GetComponent <Obesrvable>().Instantiate(this);
    }
Exemple #14
0
    /// <summary>
    /// Called every frame. Checks to see if a weapon switch has occured
    /// </summary>
    void Update()
    {
        // If player 2 pushes up on the dpad, or presses '1' on the keyboard, switch to the default laser
        if (InputManager.Player2VerticalInput > 0 || Input.GetKeyDown(KeyCode.Alpha1))
        {
            SystemLogger.write("Weapon Switch: Default Laser");
            //Set Gui to current weapon
            WeaponDisplayController.Instance.AllOff();
            WeaponDisplayController.Instance.dLaserOn.enabled = true;
            WeaponDisplayController.Instance.ChangeCursor("laser");
            GetComponent <Shooting>().bullet = cache.Laser;
        }

        // If player 2 pushes left on the dpad, or presses '2' on the keyboard, switch to the rocket
        if (InputManager.Player2HorizontalInput < 0 || Input.GetKeyDown(KeyCode.Alpha2))
        {
            // If there's ammo
            if (cache.Rocket.GetComponent <Weapon>().ammo > 0)
            {
                SystemLogger.write("Weapon Switch: Rocket");
                // Set Gui to current weapon
                WeaponDisplayController.Instance.AllOff();
                WeaponDisplayController.Instance.rocketsOn.enabled = true;
                WeaponDisplayController.Instance.ChangeCursor("rocket");
                GetComponent <Shooting>().bullet = cache.Rocket;
            }
        }

        // If player 2 pushes right on the dpad, or presses '3' on the keyboard, switch to the laser beam
        if (InputManager.Player2HorizontalInput > 0 || Input.GetKeyDown(KeyCode.Alpha3))
        {
            // If there's ammo
            if (cache.LaserBeam.GetComponent <Weapon>().ammo > 0)
            {
                SystemLogger.write("Weapon Switch: Laser Beam");
                // Set Gui to current weapon
                WeaponDisplayController.Instance.AllOff();
                WeaponDisplayController.Instance.beamOn.enabled = true;
                WeaponDisplayController.Instance.ChangeCursor("beam");
                GetComponent <Shooting>().bullet = cache.LaserBeam;
            }
        }

        // If player 2 pushes down on the dpad, or presses '4' on the keyboard, switch to the mine
        if (InputManager.Player2VerticalInput < 0 || Input.GetKeyDown(KeyCode.Alpha4))
        {
            // If there's ammo
            if (cache.Mine.GetComponent <Weapon>().ammo > 0)
            {
                SystemLogger.write("Weapon Switch: Mine");
                // Set Gui to current weapon
                WeaponDisplayController.Instance.AllOff();
                WeaponDisplayController.Instance.mineOn.enabled = true;
                WeaponDisplayController.Instance.ChangeCursor("mine");
                GetComponent <Shooting>().bullet = cache.Mine;
            }
        }
    }
Exemple #15
0
 /// <summary>
 /// Resets the bolt count. Should be used when
 /// a new planet is traveled to.
 /// </summary>
 public void resetBoltCount()
 {
     SystemLogger.write("Bolts Reset");
     this.BoltCount = 0f;
     warpTextActive = false;
     BoltTxt.text   = "Bolt: " + (int)((this.BoltCount / this.BoltGoal) * 100) + "%";
     // Call deactivate event
     PlayerTeleported();
 }
 /// <summary>
 /// Called when the laser is destroyed to decrease the laser count by 1
 /// </summary>
 void OnDestroy()
 {
     SystemLogger.write("Laser beam destruction");
     if (this.Target == "Enemy")
     {
         // Decrease the laser count by 1
         --PowerUpManager.Instance.CurrentLaserCount;
     }
 }
 /// <summary>
 /// Checks if the plan needs to be updated
 /// </summary>
 public override void checkPlan()
 {
     SystemLogger.write("checking plan");
     // Check if plan should be updated
     if (shouldUpdatePlan())
     {
         this.updateCurrentPlan();
     }
 }
 /// <summary>
 /// Start this instance.
 /// </summary>
 void Start()
 {
     SystemLogger.write("Initializing Patrolling behavior");
     base.init();
     base.targetLocation = Player.Instance.getClosestVertice();
     base.setMovementScript(this.GetComponent <AStar>());
     base.moveTowardsPlayerAtEndOfPath = false;
     this.updateCurrentPlan();
 }
Exemple #19
0
    /// <summary>
    /// Initialize necessary variables
    /// </summary>
    void Start()
    {
        SystemLogger.write("Instantiating Mine Dropper");

        base.init();

        // Begin Dropping MInes
        StartCoroutine(this.dropMines());
    }
Exemple #20
0
 /// <summary>
 /// Decreases the score.
 /// </summary>
 /// <param name="decreaseAmount">Decrease amount.</param>
 public void DecreaseScore(int decreaseAmount)
 {
     if (!PowerUpManager.Instance.Powerups["Shield"].IsActive)
     {
         score -= decreaseAmount;
         PlayerHitImage.Instance.playerHit();
         SystemLogger.write("Score Decreased by: " + decreaseAmount);
     }
 }
Exemple #21
0
    /// <summary>
    /// Waits for loading of the save file so that on continue,
    /// it will wait until the file has been loaded before the
    /// procedural generation will be set off.
    /// </summary>
    /// <returns>The for load.</returns>
    public IEnumerator waitForLoad()
    {
        while (!SaveSystem.Instance.getLoaded())
        {
            yield return(null);
        }

        SystemLogger.write("Finished loading save file!");
        LoadPlanet();
    }
Exemple #22
0
    /// <summary>
    /// Initialize components
    /// </summary>
    void Start()
    {
        SystemLogger.write("Init Astar");

        // Divide by 2 to get radius not diameter
        this.radius = this.body.GetComponent <Collider>().bounds.size.magnitude *this.multiplier / 2;

        // Get planets navigation
        this.planetVertexNavigation = Player.Instance.getPlanetNavigation();
    }
Exemple #23
0
    /// <summary>
    /// What happens when this object collides with something
    /// </summary>
    /// <param name="obj">The object it collided with</param>
    void OnTriggerEnter(Collider obj)
    {
        if (obj.gameObject.tag == "Player")
        {
            SystemLogger.write("Player Picked Up Bolt");
            Destroy(this.gameObject);

            // Activate the pickup type
            this.Type[this.PickupType](obj.gameObject);
        }
    }
    /// <summary>
    /// Move Towards the given target
    /// </summary>
    /// <param name="targ"></param>
    public virtual void move(Vector3 targ)
    {
        SystemLogger.write("Moving towards target");

        // Set rotation
        Quaternion destRotation = Quaternion.LookRotation(targ - transform.position, transform.up);

        transform.rotation = Quaternion.RotateTowards(transform.rotation, destRotation, rotationMaxDegrees * Time.deltaTime);

        // Move forward
        this.transform.position = Vector3.MoveTowards(this.transform.position, targ, this.moveSpeed * Time.deltaTime);
    }
Exemple #25
0
 void Awake()
 {
     if (Instance == null)
     {
         Instance = this;
         SystemLogger.write("Pickup Cache Instantiated On: " + this.gameObject.name);
     }
     else
     {
         Destroy(this);
     }
 }
Exemple #26
0
    private IEnumerator dropMines()
    {
        SystemLogger.write("Beginning to drop more mines");
        this.shouldDropMines = true;

        // Will drop mines until max reached
        while (shouldDropMines)
        {
            this.dropMine();
            yield return(new WaitForSeconds(this.timeBetweenEachMineDrop));
        }
    }
Exemple #27
0
    /// <summary>
    /// Add the score multiplier to the pickup array
    /// </summary>
    public void AddScoreMultiplierPickup()
    {
        template pickupThree = (obj) =>
        {
            GameObject multi = new GameObject();
            multi.AddComponent <ScoreMulti>();
            PopUpText.Instance.NewPopUp("Multiplier!");
        };

        this.Type[2] = pickupThree;
        SystemLogger.write("Score Multiplier Pickup Initialized");
    }
Exemple #28
0
 /// <summary>
 /// Sets the name.
 /// </summary>
 /// <param name="PlayerName">Player name.</param>
 public void SetName()
 {
     if (SaveSystem.Instance == null)
     {
         PlayerName = "LumpyLabs";
     }
     else
     {
         PlayerName = SaveSystem.Instance.PlayerID;
         SystemLogger.write("Player Name Set to: " + PlayerName);
     }
 }
    public IEnumerator waitForPlanet()
    {
        while (Player.instance == null || Player.instance.getPlanetNavigation().gameObject == null)
        {
            yield return(null);
        }

        SystemLogger.write("The planet has been loaded!");
        SystemLogger.write(Player.instance.getPlanetNavigation().gameObject.name);
        planetName = Player.instance.getPlanetNavigation().gameObject.name;
        CreateGrid(planetName);
    }
Exemple #30
0
    /// <summary>
    /// Triggered when the bullet collides with anything
    /// </summary>
    /// <param name="obj"></param>
    void OnCollisionEnter(Collision obj)
    {
        SystemLogger.write("Rocket collision");
        // Get all the objects in a <ExplosionRadius> radius from where the bullet collided
        Collider[] hitColliders = Physics.OverlapSphere(transform.position, ExplosionRadius);

        // Create Explosion object
        Instantiate(Explosion, transform.position, transform.rotation);

        // For every object in the explosion
        for (int i = 0; i < hitColliders.Length; ++i)
        {
            if (hitColliders[i])
            {
                // Add an explosion force of <ExplosionForce> to them
                Rigidbody rb = hitColliders[i].gameObject.GetComponent <Rigidbody>();

                if (rb)
                {
                    rb.AddExplosionForce(ExplosionForce, transform.position, this.ExplosionRadius);
                }

                // Try and find an EnemyHealth script on the gameobject hit.
                EnemyStats enemyHealth = hitColliders[i].gameObject.GetComponentInParent <EnemyStats>();

                if (hitColliders[i].CompareTag("Player"))
                {
                    ScoreManager.Instance.DecreaseScore((int)this.GetComponent <Weapon>().damage);
                }
                else if (hitColliders[i].CompareTag("DestructableEnvironment"))
                {
                    Destroy(hitColliders[i].gameObject);
                }

                // If the EnemyHealth component exist...
                if (enemyHealth != null)
                {
                    // ... the enemy should take damage.
                    enemyHealth.TakeDamage((int)this.GetComponent <Weapon>().damage);

                    // If the damage up power up is active, do extra damage
                    if (PowerUpManager.Instance.Powerups["DamageUp"].IsActive)
                    {
                        enemyHealth.TakeDamage((int)PowerUpManager.Instance.PowerIncrease);
                    }
                }
            }
        }

        // Destroy the rocket
        Destroy(this.gameObject);
    }