Example #1
0
 public override void ProjModifyHitPvp(Item item, Player player, Projectile projectile, Player target, ref float damageMultiplier, ref bool crit)
 {
     if (player.HeldItem == item)
     {
         float value = Type1.GetValue();
         damageMultiplier += value * PoMUtil.CountBuffs(target.buffType);
     }
 }
 public static string Method(Type1 a, Type2 b, Type3 c, Type4 d)
 {
     a = a ?? default1;
     b = b ?? default2;
     c = c ?? default3;
     d = d ?? default4;
     //do smth
 }
Example #3
0
        public void Dynamicly_maps_null_to_null()
        {
            Type1 type = null;

            Type3 mappedType = type.DynamicMap <Type3>();

            mappedType.Should().Be.Null();
        }
 void Hit(Item item, Player player, Player target)
 {
     if (item == player.HeldItem && Main.rand.NextFloat(1) < Type1.GetValue())
     {
         int durationTicks = (int)Math.Round(Type2.GetValue() * 60);
         target.AddBuff(BuffID.Confused, durationTicks, false);
     }
 }
 static void Main2()
 {
     Func <Type2, Type1> f1 = MyMethod;
     Type1 t0 = f1(new Type3());
     // Covariant return type and contravariant parameter type.
     Func <Type3, Type1> f2 = f1;
     Type1 t1 = f2(new Type3());
 }
Example #6
0
 public override bool PreHurt(Item item, Player player, bool pvp, bool quiet, ref float damageMultiplier, ref int hitDirection, ref bool crit, ref bool customDamage, ref bool playSound, ref bool genGore, ref PlayerDeathReason damageSource)
 {
     if (AffixItemItem.IsAccessoryEquipped(item, player))
     {
         damageMultiplier += Type1.GetValue();
     }
     return(true);
 }
        public override string GetTolltipText(Item item)
        {
            float value       = Type1.GetValue();
            float valueFormat = Type1.GetValueFormat();
            char  plusMinus   = value < 0 ? '-' : '+';

            return($"{ plusMinus }{ valueFormat }% crit damage");
        }
Example #8
0
 public override string ToString()
 {
     // construct a string to return with the following format
     // Nat,Pokemon,HP,Atk,Def,SpA,SpD,Spe,Total
     // LC: good.
     return(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}", Index, Name, HP, Attack, Defense,
                          SpecialAttack, SpecialDefense, Speed, Total, Type1.ToString(), Type2 == PokemonType.None ? "" : Type2.ToString()));
 }
Example #9
0
 public override void ProjModifyHitNPC(Item item, Player player, Projectile projectile, NPC target, ref float damageMultiplier, ref float knockbackMultiplier, ref bool crit, ref int hitDirection)
 {
     if (player.HeldItem == item)
     {
         float value = Type1.GetValue();
         damageMultiplier += value * PoMUtil.CountBuffs(target.buffType);
     }
 }
Example #10
0
 public void Execute(string xmlData)
 {
     Type1  type1Object = (new Deserializer <Type1>()).XML2Object(XML);
     var    ws          = new WSProxy1();
     string response    = ws.Method1(type1Object);
     //
     // lots of other lines of code that use type1VO, type1Object, the response, etc.
     //
 }
 public override bool PlayerConsumeAmmo(Player player, Item item, Item ammo, ref float chanceToNotConsume)
 {
     if (AffixItemItem.IsArmorEquipped(item, player))
     {
         float value = Type1.GetValue();
         chanceToNotConsume += value;
     }
     return(true);
 }
Example #12
0
        public override void PostHurt(Item item, Player player, bool pvp, bool quiet, double damage, int hitDirection, bool crit)
        {
            if (AffixItemItem.IsArmorEquipped(item, player) && (Main.GameUpdateCount - lastProcTime) >= (int)Math.Round(Type3.GetValue() * 60))
            {
                player.GetModPlayer <BuffPlayer>().AddGreavesMoveSpeedBuff(player, Type1.GetValue(), (int)Math.Round(Type2.GetValue() * 60), false);

                lastProcTime = Main.GameUpdateCount;
            }
        }
 void GainDodgeChance(Item item, Player player)
 {
     if (AffixItemItem.IsArmorEquipped(item, player) && (Main.GameUpdateCount - lastProcTime) >= (int)Math.Round(Type3.GetValue() * 60))
     {
         int durationTicks = (int)Math.Round((Type2.GetValue() * 60));
         player.GetModPlayer <BuffPlayer>().AddDodgeChanceBuff(player, Type1.GetValue(), durationTicks, false);
         lastProcTime = Main.GameUpdateCount;
     }
 }
Example #14
0
        public override void ProjModifyHitNPC(Item item, Player player, Projectile projectile, NPC target, ref float damageMultiplier, ref float knockbackMultiplier, ref bool crit, ref int hitDirection)
        {
            NPC realTarget = target.realLife >= 0 ? Main.npc[target.realLife] : target;

            if (item == player.HeldItem && (realTarget.life / (float)realTarget.lifeMax) <= PathOfModifiers.lowHPThreshold)
            {
                damageMultiplier += Type1.GetValue();
            }
        }
Example #15
0
    static void Main(string[] args)
    {
        Type1 something1 = new Type1();
        Type2 something2 = new Type2();

        something1.runTest();
        something2.runTest();
        Console.ReadKey();
    }
Example #16
0
 void Hit(Item item, Player player)
 {
     if (player.HeldItem == item)
     {
         int durationTicks = (int)Math.Round(Type1.GetValue() * 60);
         player.AddBuff(BuffID.Flipper, durationTicks);
         player.AddBuff(BuffID.Gills, durationTicks);
         player.AddBuff(BuffID.WaterWalking, durationTicks);
     }
 }
Example #17
0
 void Crit(Player target, ref float damageMultiplier)
 {
     damageMultiplier += Type1.GetValue();
     PoMEffectHelper.Crit(target.position, target.width, target.height, 50);
     if (Main.netMode == NetmodeID.MultiplayerClient)
     {
         EffectPacketHandler.CSyncCrit(target, 50);
     }
     lastProcTime = Main.GameUpdateCount;
 }
Example #18
0
 public ActionResult Edit([Bind(Include = "Id,Name")] Type1 type1)
 {
     if (ModelState.IsValid)
     {
         db.Entry(type1).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(type1));
 }
        public override bool PreHurt(Item item, Player player, bool pvp, bool quiet, ref float damageMultiplier, ref int hitDirection, ref bool crit, ref bool customDamage, ref bool playSound, ref bool genGore, ref PlayerDeathReason damageSource)
        {
            if (AffixItemItem.IsArmorEquipped(item, player) && (Main.GameUpdateCount - lastProcTime) >= (int)Math.Round(Type2.GetValue() * 60))
            {
                damageMultiplier += Type1.GetValue();
                lastProcTime      = Main.GameUpdateCount;
            }

            return(true);
        }
Example #20
0
 void GainBuffs(Item item, Player player)
 {
     if (AffixItemItem.IsArmorEquipped(item, player))
     {
         int durationTicks = (int)Math.Round(Type1.GetValue() * 60);
         player.AddBuff(BuffID.Flipper, durationTicks);
         player.AddBuff(BuffID.Gills, durationTicks);
         player.AddBuff(BuffID.WaterWalking, durationTicks);
     }
 }
Example #21
0
 public override int GetHashCode()
 {
     unchecked
     {
         int hashCode = base.GetHashCode();
         hashCode = (hashCode * 397) ^ (Type1 != null ? Type1.GetHashCode() : 0);
         hashCode = (hashCode * 397) ^ (Type2 != null ? Type2.GetHashCode() : 0);
         return(hashCode);
     }
 }
Example #22
0
 private static void Demo1()
 {
     Console.WriteLine("In Demo1");
     try {
         Console.WriteLine("In try");
     }
     finally {
         // Type1’s static constructor is implicitly called in here
         Type1.M();
     }
 }
Example #23
0
        private static async Task <Type1> Method1Async()
        {
            Type1 t = null;
            await Task.Run(new Action(() =>
            {
                t = new Type1();
                Thread.Sleep(1000);
            }));

            return(t);
        }
Example #24
0
        public void PoolSizeTest()
        {
            int defaultPoolSize = ObjectPool <Type1> .DEFAULT_POOL_SIZE;

            Assert.AreEqual(defaultPoolSize, _type1Pool.PoolSize);
            Type1 acquiredObject = _type1Pool.AcquireObject();

            Assert.AreEqual(defaultPoolSize - 1, _type1Pool.PoolSize);
            _type1Pool.ReleaseObject(acquiredObject);
            Assert.AreEqual(defaultPoolSize, _type1Pool.PoolSize);
        }
Example #25
0
        public ActionResult Create([Bind(Include = "Id,Name")] Type1 type1)
        {
            if (ModelState.IsValid)
            {
                db.Type1s.Add(type1);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(type1));
        }
Example #26
0
 public void Test2()
 {
     unsafe
     {
         IntPtr iptr  = Marshal.AllocHGlobal(1024);
         Type1  type1 = Marshal.PtrToStructure <Type1>(iptr);
         //void* ptr = iptr.ToPointer();
         //*((Type1*)ptr) = new Type();
         Assert.IsFalse(new Type1().Equals(type1));
     }
 }
Example #27
0
    private void Awake()
    {
        if (gameObject.CompareTag(_PROJECTILE1_TAG))
        {
            _type1 = gameObject.GetComponent <Type1>();
        }

        if (gameObject.CompareTag(_PROJECTILE2_TAG))
        {
            _type2 = gameObject.GetComponent <Type2>();
        }
    }
        public void DoesNotEnforceUniquenessAcrossTypes ()
        {
            var sagaStorage = new InMemorySagaStorage();

            var recycledId = "recycled-id";

            var instanceOfType1 = new Type1 {Id = Guid.NewGuid(), Revision = 0, CorrelationId = recycledId};
            var instanceOfType2 = new Type2 { Id = Guid.NewGuid(), Revision = 0, CorrelationId = recycledId };

            sagaStorage.Insert(instanceOfType1, For(typeof(Type1))).Wait();
            sagaStorage.Insert(instanceOfType2, For(typeof(Type2))).Wait();
        }
Example #29
0
 void GainBuffs(Item item, Player player)
 {
     if (AffixItemItem.IsArmorEquipped(item, player))
     {
         int durationTicks = (int)Math.Round(Type1.GetValue() * 60);
         player.AddBuff(BuffID.Dangersense, durationTicks);
         player.AddBuff(BuffID.Featherfall, durationTicks);
         player.AddBuff(BuffID.Gravitation, durationTicks);
         player.AddBuff(BuffID.Hunter, durationTicks);
         player.AddBuff(BuffID.ObsidianSkin, durationTicks);
     }
 }
 void Heal(Item item, Player player)
 {
     if (AffixItemItem.IsAccessoryEquipped(item, player))
     {
         int amount = (int)MathHelper.Clamp(player.statManaMax2 * Type1.GetValue(), 1, 9999999);
         if (amount > 0)
         {
             player.statMana += amount;
             PoMEffectHelper.HealMana(player, amount);
         }
     }
 }
Example #31
0
        public Dictionary <string, float> GetWeakness()
        {
            Dictionary <string, float> type1Weakness = Type1.GetWeaknesses();
            Dictionary <string, float> type2Weakness = Type2.GetWeaknesses();
            Dictionary <string, float> result        = new Dictionary <string, float>();

            foreach (KeyValuePair <string, float> modifier in type1Weakness)
            {
                result.Add(modifier.Key, type1Weakness[modifier.Key] * type2Weakness[modifier.Key]);
            }
            return(result);
        }
 public Type3(Type1 type)
 {
     a1 = type;
 }
Example #33
0
 public void Method(Type1 item)
 {
     Console.WriteLine("Type1");
 }
Example #34
0
   // This is the state machine method itself
   void IAsyncStateMachine.MoveNext() {
      String result = null;   // Task's result value

      // Compiler-inserted try block ensures the state machine's task completes
      try {
         Boolean executeFinally = true;   // Assume we're logically leaving the 'try' block
         if (m_state == -1) {             // If 1st time in state machine method,
            m_local = m_argument;         // execute start of original method
         }

         // Try block that we had in our original code
         try {
            TaskAwaiter<Type1> awaiterType1;
            TaskAwaiter<Type2> awaiterType2;

            switch (m_state) {
               case -1: // Start execution of code in 'try'
                  // Call Method1Async and get its awaiter
                  awaiterType1 = Method1Async().GetAwaiter();
                  if (!awaiterType1.IsCompleted) {
                     m_state = 0;                   // 'Method1Async' is completing
                                                    // asynchronously
                     m_awaiterType1 = awaiterType1; // Save the awaiter for when we come back

                     // Tell awaiter to call MoveNext when operation completes
                     m_builder.AwaitUnsafeOnCompleted(ref awaiterType1, ref this);
                     // The line above invokes awaiterType1's OnCompleted which approximately
                     // calls ContinueWith(t => MoveNext()) on the Task being awaited.
                     // When the Task completes, the ContinueWith task calls MoveNext

                     executeFinally = false;        // We're not logically leaving the 'try'
                                                    // block
                     return;                        // Thread returns to caller
                  }
                  // 'Method1Async' completed synchronously
                  break;

               case 0:  // 'Method1Async' completed asynchronously
                  awaiterType1 = m_awaiterType1;  // Restore most-recent awaiter
                  break;

               case 1:  // 'Method2Async' completed asynchronously
                  awaiterType2 = m_awaiterType2;  // Restore most-recent awaiter
                  goto ForLoopEpilog;
            }

            // After the first await, we capture the result & start the 'for' loop
            m_resultType1 = awaiterType1.GetResult(); // Get awaiter's result

         ForLoopPrologue:
            m_x = 0;          // 'for' loop initialization
            goto ForLoopBody; // Skip to 'for' loop body

         ForLoopEpilog:
            m_resultType2 = awaiterType2.GetResult();
            m_x++;            // Increment x after each loop iteration
            // Fall into the 'for' loop's body

         ForLoopBody:
            if (m_x < 3) {  // 'for' loop test
               // Call Method2Async and get its awaiter
               awaiterType2 = Method2Async().GetAwaiter();
               if (!awaiterType2.IsCompleted) {
                  m_state = 1;                   // 'Method2Async' is completing asynchronously
                  m_awaiterType2 = awaiterType2; // Save the awaiter for when we come back

                  // Tell awaiter to call MoveNext when operation completes
                  m_builder.AwaitUnsafeOnCompleted(ref awaiterType2, ref this);
                  executeFinally = false;        // We're not logically leaving the 'try' block
                  return;                        // Thread returns to caller
               }
               // 'Method2Async' completed synchronously
               goto ForLoopEpilog;  // Completed synchronously, loop around
            }
         }
         catch (Exception) {
            Console.WriteLine("Catch");
         }
         finally {
            // Whenever a thread physically leaves a 'try', the 'finally' executes
            // We only want to execute this code when the thread logically leaves the 'try
'
            if (executeFinally) {
               Console.WriteLine("Finally");
            }
         }
         result = "Done"; // What we ultimately want to return from the async function
      }
      catch (Exception exception) {
         // Unhandled exception: complete state machine's Task with exception
         m_builder.SetException(exception);
         return;
      }
      // No exception: complete state machine's Task with result
      m_builder.SetResult(result);
   }