protected override IEnumerable <Toil> MakeNewToils()
        {
            yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));

            Toil getInRangeToil = Toils_Combat.GotoCastPosition(TargetIndex.A, false);

            yield return(getInRangeToil);

            Verb_CastWarpPower verb = pawn.CurJob.verbToUse as Verb_CastWarpPower;

            Find.Targeter.targetingVerb = verb;
            yield return(Toils_Combat.CastVerb(TargetIndex.A, false).FailOn(() => !CurToil.actor.Position.InHorDistOf(TargetA.Thing.Position, verb.warpverbprops.range)));

            compPsyker.IsActive = true;
            this.AddFinishAction(() =>
            {
                Log.Message("FinishACtion");
                if (compPsyker.IsActive)
                {
                    //     PsykerUtility.PsykerShockEvents(compPsyker, compPsyker.curPower.PowerLevel);
                }
                compPsyker.IsActive  = false;
                compPsyker.ShotFired = true;
            });
        }
Example #2
0
        public void UpdatePowers()
        {
            PowerVerbs.Clear();
            List <PsykerPower> psylist = new List <PsykerPower>();

            psylist.AddRange(this.Powers);

            psylist.AddRange(this.temporaryWeaponPowers);

            this.allPowers = psylist;

            for (int i = 0; i < allPowers.Count; i++)
            {
                Verb_CastWarpPower newverb = (Verb_CastWarpPower)Activator.CreateInstance(psylist[i].powerdef.MainVerb.verbClass);
                if (!PowerVerbs.Any(item => item.verbProps == newverb.verbProps))
                {
                    newverb.caster    = this.psyker;
                    newverb.verbProps = psylist[i].powerdef.MainVerb;
                    PowerVerbs.Add(newverb);
                }
            }
        }
Example #3
0
        public void UpdatePowers()
        {
            PowerVerbs.Clear();
            List <PsykerPower> psylist = new List <PsykerPower>();

            psylist.AddRange(this.learnedPowers);

            psylist.AddRange(this.temporaryWeaponPowers);
            psylist.AddRange(this.temporaryApparelPowers);

            this.allPowers = psylist;

            for (int i = 0; i < allPowers.Count; i++)
            {
                Verb_CastWarpPower newverb = (Verb_CastWarpPower)Activator.CreateInstance(psylist[i].powerdef.MainVerb.verbClass);
                if (!PowerVerbs.Any(item => item.verbProps == newverb.verbProps))
                {
                    newverb.caster    = this.psyker;
                    newverb.verbProps = psylist[i].powerdef.MainVerb;
                    PowerVerbs.Add(newverb);
                }
            }

            this.psykerPowers.Clear();

            foreach (PsykerPower pow in psylist)
            {
                Verb_CastWarpPower newverb = (Verb_CastWarpPower)Activator.CreateInstance(pow.powerdef.MainVerb.verbClass);
                if (!PowerVerbs.Any(item => item.verbProps == newverb.verbProps))
                {
                    newverb.caster    = this.psyker;
                    newverb.verbProps = pow.powerdef.MainVerb;
                    this.psykerPowers.Add(pow, newverb);
                }
            }
            //       Log.Message(this.psykerPowers.Count.ToString());
        }
Example #4
0
        public IEnumerable <Command_CastPower> GetPsykerVerbsNew()
        {
            //     Log.Message("Found temp powers: " + this.temporaryPowers.Count.ToString() + " while finding Verbs: " + temporaryPowers.Count.ToString());
            //     Log.Message(this.PowerVerbs.Count.ToString());
            List <Verb_CastWarpPower> temp = new List <Verb_CastWarpPower>();

            temp.AddRange(this.PowerVerbs);
            for (int i = 0; i < temp.Count; i++)
            {
                int j = i;
                Verb_CastWarpPower newverb = temp[j];
                newverb.caster    = this.psyker;
                newverb.verbProps = temp[j].verbProps;

                Command_CastPower command_CastPower = new Command_CastPower(this);
                command_CastPower.verb            = newverb;
                command_CastPower.defaultLabel    = allPowers[j].def.LabelCap;
                command_CastPower.defaultDesc     = allPowers[j].def.description;
                command_CastPower.targetingParams = TargetingParameters.ForAttackAny();
                if (newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetSelf || newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetAoE)
                {
                    command_CastPower.targetingParams = TargetingParameters.ForSelf(this.psyker);
                }
                command_CastPower.icon = allPowers[j].def.uiIcon;
                string str;
                if (FloatMenuUtility.GetAttackAction(this.psyker, TargetInfo.Invalid, out str) == null)
                {
                    command_CastPower.Disable(str.CapitalizeFirst() + ".");
                }
                command_CastPower.action = delegate(Thing target)
                {
                    Action attackAction = CompPsyker.TryCastPowerAction(psyker, target, this, newverb, allPowers[j].def as PsykerPowerDef);
                    if (attackAction != null)
                    {
                        attackAction();
                    }
                };
                if (newverb.caster.Faction != Faction.OfPlayer)
                {
                    command_CastPower.Disable("CannotOrderNonControlled".Translate());
                }
                if (newverb.CasterIsPawn)
                {
                    if (newverb.CasterPawn.story.DisabledWorkTags.Contains(WorkTags.Violent))
                    {
                        command_CastPower.Disable("IsIncapableOfViolence".Translate(new object[]
                        {
                            newverb.CasterPawn.NameStringShort
                        }));
                    }
                    else if (!newverb.CasterPawn.drafter.Drafted)
                    {
                        command_CastPower.Disable("IsNotDrafted".Translate(new object[]
                        {
                            newverb.CasterPawn.NameStringShort
                        }));
                    }
                    else if (!this.IsActive)
                    {
                        command_CastPower.Disable("PsykerPowerRecharging".Translate(new object[]
                        {
                            newverb.CasterPawn.NameStringShort
                        }));
                    }
                }
                yield return(command_CastPower);
            }
            yield break;
        }
Example #5
0
        public static Action TryCastPowerAction(Pawn pawn, TargetInfo target, CompPsyker compPsyker, Verb_CastWarpPower verb, PsykerPowerDef psydef)
        {
            Action act = new Action(delegate
            {
                //            compPsyker.TicksToCast = verb.warpverbprops.TicksToRecharge;
                //            compPsyker.TicksToCastMax = verb.warpverbprops.TicksToRecharge;
                compPsyker.CurTarget   = target;
                compPsyker.curVerb     = verb;
                compPsyker.curPower    = psydef;
                compPsyker.curRotation = target.Thing.Rotation;
                Job job          = CompPsyker.PsykerJob(verb.warpverbprops.PsykerPowerCategory, target);
                job.playerForced = true;
                job.verbToUse    = verb;
                Pawn pawn2       = target.Thing as Pawn;
                if (pawn2 != null)
                {
                    job.killIncappedTarget = pawn2.Downed;
                }
                pawn.drafter.TakeOrderedJob(job);
            });

            return(act);
        }
Example #6
0
        public IEnumerable <Command_CastPower> GetPsykerVerbsNewV3()
        {
            //   Log.Message("INIT");
            foreach (PsykerPowerEntry current in this.allpsykerPowers)
            {
                //      Log.Message("A");
                if (PsykerHasEquipment(current))
                {
                    Verb_CastWarpPower newverb = (Verb_CastWarpPower)Activator.CreateInstance(current.psykerPowerDef.MainVerb.verbClass);
                    newverb.caster    = this.psyker;
                    newverb.verbProps = current.psykerPowerDef.MainVerb;
                    //      Log.Message("B");

                    Command_CastPower command_CastPower = new Command_CastPower(this);
                    command_CastPower.verb         = newverb;
                    command_CastPower.defaultLabel = current.psykerPowerDef.LabelCap;
                    command_CastPower.defaultDesc  = current.psykerPowerDef.description;
                    //         Log.Message("C");
                    command_CastPower.targetingParams = TargetingParameters.ForAttackAny();
                    if (newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetSelf || newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetAoE)
                    {
                        command_CastPower.targetingParams = TargetingParameters.ForSelf(this.psyker);
                    }
                    // Log.Message("C2");
                    command_CastPower.icon = current.psykerPowerDef.uiIcon;
                    //         Log.Message("D1");
                    string str;
                    if (FloatMenuUtility.GetAttackAction(this.psyker, LocalTargetInfo.Invalid, out str) == null)
                    {
                        command_CastPower.Disable(str.CapitalizeFirst() + ".");
                    }
                    //         Log.Message("D");
                    command_CastPower.action = delegate(Thing target)
                    {
                        CompPsyker.TryCastPowerAction(psyker, target, this, newverb, current.psykerPowerDef as PsykerPowerDef)?.Invoke();
                    };
                    if (newverb.caster.Faction != Faction.OfPlayer)
                    {
                        command_CastPower.Disable("CannotOrderNonControlled".Translate());
                    }
                    if (newverb.CasterIsPawn)
                    {
                        if (newverb.CasterPawn.story.DisabledWorkTags.Contains(WorkTags.Violent))
                        {
                            command_CastPower.Disable("IsIncapableOfViolence".Translate(new object[]
                            {
                                newverb.CasterPawn.NameStringShort
                            }));
                        }
                        else if (!newverb.CasterPawn.drafter.Drafted)
                        {
                            command_CastPower.Disable("IsNotDrafted".Translate(new object[]
                            {
                                newverb.CasterPawn.NameStringShort
                            }));
                        }
                        else if (!this.IsActive)
                        {
                            command_CastPower.Disable("PsykerPowerRecharging".Translate(new object[]
                            {
                                newverb.CasterPawn.NameStringShort
                            }));
                        }
                    }
                    yield return(command_CastPower);
                }
            }
            yield break;
        }
Example #7
0
        public IEnumerable <Command_CastPower> GetPsykerVerbsNew()
        {
            foreach (KeyValuePair <PsykerPower, Verb_CastWarpPower> entry in this.psykerPowers)
            {
                Verb_CastWarpPower newverb = entry.Value;
                newverb.caster    = this.psyker;
                newverb.verbProps = entry.Value.verbProps;

                Command_CastPower command_CastPower = new Command_CastPower(this);
                command_CastPower.verb            = newverb;
                command_CastPower.defaultLabel    = entry.Key.def.LabelCap;
                command_CastPower.defaultDesc     = entry.Key.def.description;
                command_CastPower.targetingParams = TargetingParameters.ForAttackAny();
                if (newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetSelf || newverb.warpverbprops.PsykerPowerCategory == PsykerPowerTargetCategory.TargetAoE)
                {
                    command_CastPower.targetingParams = TargetingParameters.ForSelf(this.psyker);
                }
                command_CastPower.icon = entry.Key.def.uiIcon;
                string str;
                if (FloatMenuUtility.GetAttackAction(this.psyker, LocalTargetInfo.Invalid, out str) == null)
                {
                    command_CastPower.Disable(str.CapitalizeFirst() + ".");
                }
                command_CastPower.action = delegate(Thing target)
                {
                    Action attackAction = CompPsyker.TryCastPowerAction(psyker, target, this, newverb, entry.Key.def as PsykerPowerDef);
                    if (attackAction != null)
                    {
                        attackAction();
                    }
                };
                if (newverb.caster.Faction != Faction.OfPlayer)
                {
                    command_CastPower.Disable("CannotOrderNonControlled".Translate());
                }
                if (newverb.CasterIsPawn)
                {
                    if (newverb.CasterPawn.story.DisabledWorkTags.Contains(WorkTags.Violent))
                    {
                        command_CastPower.Disable("IsIncapableOfViolence".Translate(new object[]
                        {
                            newverb.CasterPawn.NameStringShort
                        }));
                    }
                    else if (!newverb.CasterPawn.drafter.Drafted)
                    {
                        command_CastPower.Disable("IsNotDrafted".Translate(new object[]
                        {
                            newverb.CasterPawn.NameStringShort
                        }));
                    }
                    else if (!this.IsActive)
                    {
                        command_CastPower.Disable("PsykerPowerRecharging".Translate(new object[]
                        {
                            newverb.CasterPawn.NameStringShort
                        }));
                    }
                }
                yield return(command_CastPower);
            }
            yield break;
        }