Properties for spells. Mainly used for projectile spells.
Example #1
0
    public SpellProp spellprop;    //The spell properties of the ward.

    protected override void Start()
    {
        base.Start();
        this.gameObject.layer = LayerMask.NameToLayer("Ward");
        SpellProp_RuneOfWarding spIJ = new SpellProp_RuneOfWarding();                //myObj.AddComponent<SpellProp_RuneOfWarding>();

        spIJ.init(SpellEffect.UW1_Spell_Effect_RuneofWarding, UWCharacter.Instance.gameObject);
        spellprop = spIJ;
    }
    protected override void Start()
    {
        base.Start();
        this.gameObject.layer = LayerMask.NameToLayer("Ward");
        BoxCollider bx = this.gameObject.GetComponent <BoxCollider>();

        if (bx == null)
        {
            bx = this.gameObject.AddComponent <BoxCollider>();
        }
        bx.size      = new Vector3(0.35f, 0.35f, 0.35f);
        bx.center    = new Vector3(0.0f, 0.1f, 0.0f);
        bx.isTrigger = true;
        switch (_RES)
        {
        case GAME_UW2:
        {
            switch (item_id)
            {
            case 414:             //flam trap
            {
                SpellProp_Fireball sppf = new SpellProp_Fireball();
                sppf.init(SpellEffect.UW2_Spell_Effect_Fireball, UWCharacter.Instance.gameObject);
                spellprop = sppf;
                break;
            }

            case 415:            //tym trap
            {
                SpellProp_Tym spty = new SpellProp_Tym();
                spty.init(SpellEffect.UW2_Spell_Effect_Paralyze, UWCharacter.Instance.gameObject);
                spellprop = spty;
                break;
            }

            default:
                Debug.Log("unimplemented ward trap type " + item_id);
                break;
            }
            break;
        }

        default:                                                          //UW1 rune of warding
        {
            SpellProp_RuneOfWarding spIJ = new SpellProp_RuneOfWarding(); //myObj.AddComponent<SpellProp_RuneOfWarding>();
            spIJ.init(SpellEffect.UW1_Spell_Effect_RuneofWarding, UWCharacter.Instance.gameObject);
            spellprop    = spIJ;
            CanHitPlayer = false;
            break;
        }
        }
    }
Example #3
0
    /// <summary>
    /// Creates the magic projectile.
    /// </summary>
    /// <returns>The magic projectile.</returns>
    /// <param name="Location">Location.</param>
    /// <param name="Caster">Caster.</param>
    /// <param name="spellprop">Properties for the projectile.</param>
    GameObject CreateMagicProjectile(Vector3 Location, GameObject Caster, SpellProp spellprop)
    {
        //Creates the projectile.
                GameObject projectile = new GameObject();
                projectile.layer = LayerMask.NameToLayer("MagicProjectile");
                projectile.name = "MagicProjectile_" + SummonCount++;
                projectile.transform.parent=GameWorldController.instance.LevelMarker();
                ObjectInteraction.CreateObjectGraphics(projectile,spellprop.ProjectileSprite,true);
                MagicProjectile mgp = projectile.AddComponent<MagicProjectile>();
                mgp.spellprop=spellprop;

                if (Caster.name=="NPC_Launcher")
                {
                        mgp.caster=Caster.transform.gameObject;
                }
                else
                {
                        mgp.caster=Caster;
                }

                BoxCollider box = projectile.AddComponent<BoxCollider>();
                box.size = new Vector3(0.2f,0.2f,0.2f);
                box.center= new Vector3(0.0f,0.1f,0.0f);
                Rigidbody rgd =projectile.AddComponent<Rigidbody>();
                rgd.freezeRotation =true;
                rgd.useGravity=false;
                rgd.collisionDetectionMode=CollisionDetectionMode.Continuous;
                if (Caster.name!=GameWorldController.instance.playerUW.name)
                {
                        projectile.transform.position=Caster.transform.position;
                        projectile.transform.rotation=Caster.transform.rotation;
                }
                else
                {
                        projectile.transform.position=Location;
                }
                return projectile;
    }
Example #4
0
 /// <summary>
 /// Casts the projectile along a vector
 /// </summary>
 /// <returns><c>true</c>, if projectile was cast, <c>false</c> otherwise.</returns>
 /// <param name="caster">Caster.</param>
 /// <param name="targetV">Target v.</param>
 /// <param name="spellprop">Properties for the projectile.</param>
 bool CastProjectile(GameObject caster, Vector3 targetV, SpellProp spellprop)
 {
     //Fires off the projectile at a vector3 position.
             //float force = ;//200.0f;
             GameObject projectile = CreateMagicProjectile(caster.transform.position, caster,spellprop);
             //Vector3 direction = (targetV-caster.transform.position);
             //direction.Normalize();
             LaunchProjectile(projectile,spellprop.Force,targetV);
             return true;
 }
Example #5
0
    /// <summary>
    /// Casts the projectile at the target
    /// </summary>
    /// <returns><c>true</c>, if projectile was cast, <c>false</c> otherwise.</returns>
    /// <param name="caster">Caster.</param>
    /// <param name="target">Target.</param>
    /// <param name="spellprop">Properties for the projectile.</param>
    bool CastProjectile(GameObject caster, GameObject target, SpellProp spellprop)
    {
        //Fires off the projectile at a gameobject.
                GameObject projectile = CreateMagicProjectile(caster.transform.position, caster, spellprop);
                Vector3 direction;
                if (spellprop.spread==0)
                {
                        direction = (target.transform.position-caster.transform.position);
                        direction.Normalize();
                        //LaunchProjectile(projectile,spellprop.Force,direction);
                }
                else
                {
                        //From http://answers.unity3d.com/questions/467742/how-can-i-create-raycast-bullet-innaccuracy-as-a-c.html
                        //Start

                        //  Try this one first, before using the second one
                        //  The Ray-hits will form a ring
                        //float randomRadius = spellprop.spread;
                        //  The Ray-hits will be in a circular area
                        float randomRadius = Random.Range( 0, spellprop.spread );

                        float randomAngle = Random.Range ( 0, 2 * Mathf.PI );

                        //Calculating the raycast direction
                        direction = new Vector3(
                                randomRadius * Mathf.Cos( randomAngle ),
                                randomRadius * Mathf.Sin( randomAngle ),
                                10f
                        );

                        //Make the direction match the transform
                        //It is like converting the Vector3.forward to transform.forward
                        direction = projectile.transform.TransformDirection( direction.normalized );
                        //End
                }
                LaunchProjectile(projectile,spellprop.Force,direction);
                return true;
    }
Example #6
0
    /// <summary>
    /// Casts a magic projectile.
    /// </summary>
    /// <returns><c>true</c>, if projectile was cast, <c>false</c> otherwise.</returns>
    /// <param name="caster">Caster.</param>
    /// <param name="spellprop">Properties for the projectile.</param>
    bool CastProjectile(GameObject caster, SpellProp spellprop)
    {
        //Fires off the projectile
                UWCharacter playerUWLocal = caster.GetComponent<UWCharacter>();
                if (playerUWLocal !=null)
                {
                        Ray ray = getRay (caster);
                        RaycastHit hit = new RaycastHit();
                        float dropRange=0.5f;
                        if (!Physics.Raycast(ray,out hit,dropRange))
                        {//No object interferes with the spellcast
                                //float force = 200.0f;
                                ReadiedSpell= "";
                                for (int i=0;i<spellprop.noOfCasts;i++)
                                {
                                        GameObject projectile = CreateMagicProjectile(ray.GetPoint(dropRange/2.0f), caster,spellprop);
                                        projectile.transform.rotation=Quaternion.LookRotation(ray.direction.normalized);
                                        LaunchProjectile(projectile,ray,dropRange,spellprop.Force,spellprop.spread);
                                }

                                UWHUD.instance.CursorIcon=UWHUD.instance.CursorIconDefault;
                                return true;
                        }
                        return false;
                }
                else
                {//Is being cast by an npc or a spell trap
                        //float force = 200.0f;
                        for (int i=0;i<spellprop.noOfCasts;i++)
                        {
                                GameObject projectile = CreateMagicProjectile(caster.GetComponent<ObjectInteraction>().GetImpactPoint(), caster,spellprop);
                                LaunchProjectile(projectile,spellprop.Force);
                        }
                        return true;
                }
    }