Exemple #1
0
    static void Main()
    {
        string[] input = new string[3];

        ObjectInSpace[] stars = new ObjectInSpace[3];
        for (int i = 0; i < stars.Length; i++)
        {
            input = Console.ReadLine().Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

            stars[i].name = input[0];
            stars[i].x = decimal.Parse(input[1]);
            stars[i].y = decimal.Parse(input[2]);
        }

        ObjectInSpace ship = new ObjectInSpace();
        input = Console.ReadLine().Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
        ship.name = "SSVNormandy";
        ship.x = decimal.Parse(input[0]);
        ship.y = decimal.Parse(input[1]);

        decimal movement = 0;
        movement = decimal.Parse(Console.ReadLine());

        for (decimal i = 0; i <= movement; i++)
        {
            printShipLocation(ship, stars, i);
        }
    }
Exemple #2
0
 public void setData(InterfaceScript _master, ObjectInSpace _owner, ObjectInSpace _target, InterfaceOverviewItemScript _interfaceOverviewItem)
 {
     master = _master;
     owner  = _owner;
     target = _target;
     interfaceOverviewItem = _interfaceOverviewItem;
 }
    public DamageReport dealDamage(ObjectInSpace delerOfDamage, float dmgAmount, DamageType dmgType, Vector3 damagePoint)
    {
        DamageReport dmgReport = new DamageReport(this, delerOfDamage, dmgType);
        dmgReport.damagePoint = damagePoint;

        if (dmgAmount > 0f)
        {
            dmgAmount = dealDamageToShield(dmgReport, dmgAmount, dmgType);
            dmgAmount = dealDamageToArmor(dmgReport, dmgAmount, dmgType);
            dmgAmount = dealDamageToHull(dmgReport, dmgAmount, dmgType);

            if (dmgReport.damageSum > 0f)
            {
                damageEffect();
                GameObject.Find("InterfaceGame").GetComponent<InterfaceScript>().createDamageText(dmgReport.damagePoint, "" + Mathf.Ceil(dmgReport.damageSum));
                GameObject.Find("InterfaceGame").GetComponent<InterfaceScript>().addMesage(dmgReport.damageMessage());
            }

            if (dmgReport.remainingHull <= 0f)
            {
                dmgReport.isDestroyed = true;
                destroyByDamage();
            }
        }

        return dmgReport;
    }
    private void refreshOverview()
    {
        overviewListRemoveObjects();

        GameObject[] objectsInSpace = GameObject.FindGameObjectsWithTag("ObjectInSpace");

        ObjectInSpace checkedSpaceObject = null;
        bool          notOwner           = true;
        bool          canBeTargetted     = true;
        bool          inNotOnList        = true;
        bool          isInRange          = true;

        for (int i = 0; i < objectsInSpace.Length; i++)
        {
            notOwner           = false;
            canBeTargetted     = false;
            inNotOnList        = false;
            isInRange          = false;
            checkedSpaceObject = (ObjectInSpace)objectsInSpace[i].GetComponent <ObjectInSpace>();
            if (checkedSpaceObject)
            {
                notOwner       = (owner.GetInstanceID() != checkedSpaceObject.GetInstanceID());
                canBeTargetted = checkedSpaceObject.getCanBeTargetted();
                inNotOnList    = !isThisObjectOnOverviewList(checkedSpaceObject);
                isInRange      = owner.isInTargettingRange(checkedSpaceObject);
                if (notOwner && canBeTargetted && inNotOnList && isInRange)
                {
                    addOverviewItemToOverview(checkedSpaceObject);
                }
            }
        }
    }
 public void equipmentSetTarget(ObjectInSpace target)
 {
     if (uniqueIds.Count > 0)
     {
         owner.addTargetToEquipment(uniqueIds, target);
         clearSelection();
     }
 }
Exemple #6
0
 void Start()
 {
     owner = GetComponent <ObjectInSpace>();
     if (AIMovement.movementType == AIMovementSettings.MovementType.RandomMovement)
     {
         start_RandomMovement();
     }
 }
 public bool addTarget(ObjectInSpace target)
 {
     if (targets.Count < maxNumberOfTargets && isTargetTargetted(target) == -1)
     {
         targets.Add(target);
         //Debug.Log("ObjectInSpace Added target "+target.getName());
         return true;
     }
     return false;
 }
 private bool isThisObjectOnOverviewList(ObjectInSpace obj)
 {
     for (int i = 0; i < overviewItemList.Count; i++)
     {
         if (overviewItemList[i].getTarget().GetInstanceID() == obj.GetInstanceID())
         {
             return(true);
         }
     }
     return(false);
 }
 public int isOnTargetList(ObjectInSpace target)
 {
     for (int i = 0; i < targetTilesList.Count; i++)
     {
         if (targetTilesList[i].getTarget() == target)
         {
             return(i);
         }
     }
     return(-1);
 }
 public void addTargetToEquipment(List<long> uniqueIds, ObjectInSpace target)
 {
     for (int i = 0; i < equipment.Length; i++)
     {
         if (uniqueIds.Contains(equipment[i].getUniqueId()))
         {
             equipment[i].setTarget(target);
             //Debug.Log("Added target " + target.getName() + " to " + equipment[i].getName() + "(" + equipment[i].getUniqueId() + ")");
         }
     }
 }
    private void addOverviewItemToOverview(ObjectInSpace target)
    {
        GameObject overviewItem = (GameObject)Instantiate(overviewItemPrefab, overviewTransform.position, overviewTransform.rotation, overviewTransform);
        InterfaceOverviewItemScript overviewItemScript = overviewItem.GetComponent <InterfaceOverviewItemScript>();

        if (overviewItemScript)
        {
            overviewItemScript.setData(this, owner, target);
            overviewItemList.Add(overviewItemScript);
        }
    }
 public int isTargetTargetted(ObjectInSpace target)
 {
     for (int i = 0; i < targets.Count; i++)
     {
         //if (targets[i].gameObject.GetInstanceID() == target.gameObject.GetInstanceID())
         if (targets[i] == target)
         {
             return i;
         }
     }
     return -1;
 }
 private void removeTargetFromEquipment(ObjectInSpace target)
 {
     for (int i = 0; i < equipment.Length; i++)
     {
         if (equipment[i].getTarget())
         {
             //if (equipment[i].getTarget().GetInstanceID() == target.GetInstanceID())
             if (equipment[i].getTarget() == target)
             {
                 equipment[i].setTarget(null);
             }
         }
     }
 }
    public void refreshNumbers()
    {
        distance.text = "Distance: " + ObjectInSpace.distanceStr(owner.distanceInMeters(target)) + ", Velocity: " + target.getCurrentVelocityInMetersStr();

        if (target.getMaxShield() > 0f)
        {
            sliderShield.value    = target.getCurrentShield() / target.getMaxShield();
            sliderShieldText.text = "Shield: " + Mathf.Floor(target.getCurrentShield()) + "/" + target.getMaxShield();
            if (target.getShieldBalance() > 0)
            {
                sliderShieldText.text += " (<color=#008000ff>+" + target.getShieldBalance() + "</color>)";
            }
        }
        else
        {
            sliderShield.value    = 0f;
            sliderShieldText.text = "";
        }

        if (target.getMaxArmor() > 0f)
        {
            sliderArmor.value    = target.getCurrentArmor() / target.getMaxArmor();
            sliderArmorText.text = "Armor: " + Mathf.Floor(target.getCurrentArmor()) + "/" + target.getMaxArmor();
            if (target.getArmorBalance() > 0)
            {
                sliderArmorText.text += " (<color=#008000ff>+" + target.getArmorBalance() + "</color>)";
            }
        }
        else
        {
            sliderArmor.value    = 0f;
            sliderArmorText.text = "";
        }

        if (target.getMaxHull() > 0f)
        {
            sliderHull.value    = target.getCurrentHull() / target.getMaxHull();
            sliderHullText.text = "Hull: " + Mathf.Floor(target.getCurrentHull()) + "/" + target.getMaxHull();
            if (target.getHullBalance() > 0)
            {
                sliderHullText.text += " (<color=#008000ff>+" + target.getHullBalance() + "</color>)";
            }
        }
        else
        {
            sliderHull.value    = 0f;
            sliderHullText.text = "";
        }
    }
    public static float getShipPartVolume(ShipPart shipPart)
    {
        List <GameObject> gameObjectList = new List <GameObject>();

        gameObjectList.Add(shipPart.gameObject);
        for (int i = 0; i < shipPart.gameObject.transform.childCount; i++)
        {
            gameObjectList.Add(shipPart.gameObject.transform.GetChild(i).gameObject);
            gameObjectList.AddRange(getChildrenOfThisGameObject(shipPart.gameObject.transform.GetChild(i).gameObject));
        }

        GMS.fileWriteLn("MeshSizes", gameObjectList.Count + "");
        GMS.fileWriteLn("MeshSizes", "Master: " + shipPart.gameObject.name);
        float   volumeOfMesh        = 0;
        float   volumeOfCollider    = 0;
        float   volumeOfColliderSum = 0;
        Vector3 dimensions          = Vector3.zero;

        for (int i = 0; i < gameObjectList.Count; i++)
        {
            volumeOfMesh     = 0;
            volumeOfCollider = 0;
            dimensions       = Vector3.zero;

            if (gameObjectList[i].GetComponent <MeshFilter>())
            {
                volumeOfMesh = GMS.VolumeOfMesh(gameObjectList[i].GetComponent <MeshFilter>().mesh);
                dimensions   = gameObjectList[i].transform.lossyScale * Mathf.Pow(volumeOfMesh, 1f / 3f);
            }

            GMS.fileWrite("MeshSizes", "name: " + gameObjectList[i].name + "; ");
            GMS.fileWrite("MeshSizes", "parents: " + GMS.getParentsOfThisGameObjectStr(gameObjectList[i]) + "; ");
            GMS.fileWrite("MeshSizes", "volumeOfMesh = " + volumeOfMesh + "u; ");
            GMS.fileWrite("MeshSizes", "dimensions = " + dimensions + "u; ");
            GMS.fileWrite("MeshSizes", "dimensionsMeters = " + ObjectInSpace.unitsToMeters(dimensions) + "m; ");
            GMS.fileWrite("MeshSizes", "dimensionsMetersVolume = " + (ObjectInSpace.unitsToMeters(dimensions).x *ObjectInSpace.unitsToMeters(dimensions).y *ObjectInSpace.unitsToMeters(dimensions).z) + "m^3; ");
            GMS.fileWrite("MeshSizes", "volumeOfCollider = " + volumeOfCollider + "u; ");
            GMS.fileWriteLn("MeshSizes", " ");
        }

        volumeOfColliderSum = Mathf.Round(volumeOfColliderSum);

        GMS.fileWrite("MeshSizes", "Master: " + shipPart.gameObject.name + ", ");
        GMS.fileWrite("MeshSizes", "volumeOfColliderSum = " + volumeOfColliderSum + "u; ");
        GMS.fileWrite("MeshSizes", "volumeOfColliderSum = " + ObjectInSpace.unitsToMetersCubic(volumeOfColliderSum) + "m^3; ");
        GMS.fileWriteLn("MeshSizes", " ");

        return(0f);
    }
Exemple #16
0
    private static void printShipLocation(ObjectInSpace ship, ObjectInSpace[] stars, decimal i)
    {
        string shipLocation = "space";

        foreach (var star in stars)
        {
            if ((ship.x >= star.x - 1 && ship.x <= star.x + 1) &&
                (ship.y + i >= star.y - 1 && ship.y + i <= star.y + 1))
            {
                shipLocation = star.name.ToLower();
            }
        }

        Console.WriteLine(shipLocation);
    }
    public void addTarget(ObjectInSpace target, InterfaceOverviewItemScript interfaceOverviewItem)
    {
        bool addTargetSucess = owner.addTarget(target);

        if (addTargetSucess)
        {
            GameObject targetTile = (GameObject)Instantiate(targetTilePrefab, targetTilesHolder.position, targetTilesHolder.rotation, targetTilesHolder);
            InterfaceTargetTileScript targetTileScript = targetTile.GetComponent <InterfaceTargetTileScript>();
            if (targetTileScript)
            {
                targetTileScript.setData(this, owner, target, interfaceOverviewItem);
                interfaceOverviewItem.setColorTarget();
                targetTilesList.Add(targetTileScript);
                refreshTargetTiles();
            }
        }
    }
 public bool removeTarget(ObjectInSpace target)
 {
     for (int i = 0; i < targets.Count; i++)
     {
         if (targets[i])
         {
             //if (targets[i].gameObject.GetInstanceID() == target.gameObject.GetInstanceID())
             if (targets[i] == target)
             {
                 removeTargetFromEquipment(target);
                 targets.RemoveAt(i);
                 return true;
             }
         }
     }
     return false;
 }
Exemple #19
0
    void Start()
    {
        ship = shipStatus.GetComponent <ObjectInSpace> ();

        sliderShield               = transform.Find("SliderShield").GetComponent <UnityEngine.UI.Slider> ();
        sliderArmor                = transform.Find("SliderArmor").GetComponent <UnityEngine.UI.Slider> ();
        sliderHull                 = transform.Find("SliderHull").GetComponent <UnityEngine.UI.Slider> ();
        sliderSpeed                = transform.Find("SliderSpeed").GetComponent <UnityEngine.UI.Slider>();
        sliderEnergy               = transform.Find("SliderEnergy").GetComponent <UnityEngine.UI.Slider> ();
        sliderShieldText           = transform.Find("SliderShield/Text").GetComponent <UnityEngine.UI.Text> ();
        sliderArmorText            = transform.Find("SliderArmor/Text").GetComponent <UnityEngine.UI.Text> ();
        sliderHullText             = transform.Find("SliderHull/Text").GetComponent <UnityEngine.UI.Text> ();
        sliderSpeedText            = transform.Find("SliderSpeed/Text").GetComponent <UnityEngine.UI.Text>();
        sliderEnergyText           = transform.Find("SliderEnergy/Text").GetComponent <UnityEngine.UI.Text>();
        sliderEnergyTextPassive    = transform.Find("SliderEnergy/TextPassive").GetComponent <UnityEngine.UI.Text> ();
        sliderEnergyTextActive     = transform.Find("SliderEnergy/TextActive").GetComponent <UnityEngine.UI.Text> ();
        sliderEnergyTextBalance    = transform.Find("SliderEnergy/TextBalance").GetComponent <UnityEngine.UI.Text>();
        sliderEnergyTextEfficiency = transform.Find("SliderEnergy/TextEfficiency").GetComponent <UnityEngine.UI.Text>();

        textMass            = transform.Find("Mass").GetComponent <UnityEngine.UI.Text> ();
        textDrag            = transform.Find("Drag").GetComponent <UnityEngine.UI.Text> ();
        textEngineThrust    = transform.Find("EngineThrust").GetComponent <UnityEngine.UI.Text> ();
        textManouverability = transform.Find("Manouverability").GetComponent <UnityEngine.UI.Text>();
        textVolume          = transform.Find("Volume").GetComponent <UnityEngine.UI.Text>();

        setValues();
        setValues();

        updateSliderShield();
        updateSliderArmor();
        updateSliderHull();
        updateSliderSpeed();
        updateSliderEnergy();

        updateSliderEnergyTextPassive();
        updateSliderEnergyTextActive();
        updateSliderEnergyTextBalance();

        updateShipParameters();

        compare();
    }
    static void Main()
    {
        string[] input = new string[3];

        ObjectInSpace[] stars = new ObjectInSpace[3];
        for (int i = 0; i < stars.Length; i++)
        {
            input = Console.ReadLine().Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

            stars[i].name = input[0];
            stars[i].x = decimal.Parse(input[1]);
            stars[i].y = decimal.Parse(input[2]);
        }

        ObjectInSpace ship = new ObjectInSpace();
        input = Console.ReadLine().Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
        ship.name = "Normandy";
        ship.x = decimal.Parse(input[0]);
        ship.y = decimal.Parse(input[1]);

        decimal movement = 0;
        movement = decimal.Parse(Console.ReadLine());

        for (decimal i = 0; i <= movement; i++)
        {
            string shipLocation = "space";

            foreach (var star in stars)
            {
                if ((ship.x >= star.x - 1 && ship.x <= star.x + 1) &&
                    (ship.y + i >= star.y - 1 && ship.y + i <= star.y + 1))
                {
                    shipLocation = star.name.ToLower();
                }
            }

            Console.WriteLine(shipLocation);
        }
    }
Exemple #21
0
    public void  OnTriggerEnter(Collider c)
    {
        if (isLaunched)
        {
            GameObject    g = c.gameObject;
            ObjectInSpace targetOfCollision = g.GetComponent <ObjectInSpace>();

            while (g.transform.parent && !targetOfCollision)
            {
                g = g.transform.parent.gameObject;
                targetOfCollision = g.GetComponent <ObjectInSpace>();
            }

            if (targetOfCollision)
            {
                if (!(getOwner() != null && targetOfCollision.getOwner() != null && getOwner() == targetOfCollision.getOwner()))
                {
                    ObjectInSpace.DamageReport dmgReport = targetOfCollision.dealDamage(getOwner(), damageDealt, damageType, transform.position);
                    explode();
                }
            }
        }
    }
        public float remainingShield; //currentShield - damageShield

        public DamageReport(ObjectInSpace _recepientOfDamage, ObjectInSpace _dealerOfDamage, DamageType _dmgType)
        {
            recepientOfDamage = _recepientOfDamage;
            dealerOfDamage = _dealerOfDamage;
            damagePoint = recepientOfDamage.gameObject.transform.position;
            dmgType = _dmgType;
            maxShield = recepientOfDamage.maxShield;
            maxArmor = recepientOfDamage.maxArmor;
            maxHull = recepientOfDamage.maxHull;
            currentShield = recepientOfDamage.currentShield;
            currentArmor = recepientOfDamage.currentArmor;
            currentHull = recepientOfDamage.currentHull;
            damageShield = 0f;
            damageArmor = 0f;
            damageHull = 0f;
            damageSum = 0f;
            damageOverkill = 0f;
            remainingShield = recepientOfDamage.currentShield;
            remainingArmor = recepientOfDamage.currentArmor;
            remainingHull = recepientOfDamage.currentHull;
            isDestroyed = false;
            overkill = 0f;
        }
 public void alignTowardsTarget(ObjectInSpace target)
 {
     alignTarget = target;
 }
 public void setData(InterfaceScript _master, ObjectInSpace _owner, ObjectInSpace _target)
 {
     master = _master;
     owner  = _owner;
     target = _target;
 }
 public void alignTowardsTargetStop()
 {
     alignTarget = null;
 }
Exemple #26
0
 public void setTarget(ObjectInSpace _target)
 {
     target = _target;
 }
 public void clickedOnInterfaceTargetTile(ObjectInSpace target)
 {
     equipmentSetTarget(target);
     //Debug.Log("clickedOnInterfaceTargetTile");
 }
 public void setOwner(ObjectInSpace _owner)
 {
     owner = _owner;
 }
 public float distance(ObjectInSpace target)
 {
     return Mathf.Max(0f, Vector3.Distance(transform.position, target.gameObject.transform.position) - getDistanceOffset() - target.getDistanceOffset());
 }
 //public float distance(ObjectInSpace target) { return Vector3.Distance(transform.position, target.gameObject.transform.position); }
 public float distanceInMeters(ObjectInSpace target)
 {
     return distance(target) * oneUnitIsThisMeters;
 }
 public string distanceInMetersStr(ObjectInSpace target)
 {
     return distanceStr(distanceInMeters(target));
 }
 public bool isInTargettingRange(ObjectInSpace target)
 {
     return distanceInMeters(target) <= getShipProperty(Equipment.PropertyName.TargetingRange);
 }
 public bool isTargetted(ObjectInSpace target)
 {
     return isTargetTargetted(target) >= 0;
 }