public static bool Prefix(Thing t, OverlayTypes overlayType)
            {
                if (!(t is Pawn pawn))
                {
                    return(true);
                }
                var tryingToDrawQuestionMarkOnGuest = overlayType == OverlayTypes.QuestionMark && pawn.IsGuest();

                return(!tryingToDrawQuestionMarkOnGuest);
            }
Esempio n. 2
0
 public void DrawOverlay(Thing t, OverlayTypes overlayType)
 {
     if (overlaysToDraw.ContainsKey(t))
     {
         overlaysToDraw[t] |= overlayType;
     }
     else
     {
         overlaysToDraw.Add(t, overlayType);
     }
 }
 public void DrawOverlay(Thing t, OverlayTypes overlayType)
 {
     if (this.overlaysToDraw.ContainsKey(t))
     {
         Dictionary <Thing, OverlayTypes> dictionary;
         (dictionary = this.overlaysToDraw)[t] = (dictionary[t] | overlayType);
     }
     else
     {
         this.overlaysToDraw.Add(t, overlayType);
     }
 }
Esempio n. 4
0
 public void DrawOverlay(Thing t, OverlayTypes overlayType)
 {
     if (overlaysToDraw.ContainsKey(t))
     {
         Dictionary <Thing, OverlayTypes> dictionary;
         Thing key;
         (dictionary = overlaysToDraw)[key = t] = (dictionary[key] | overlayType);
     }
     else
     {
         overlaysToDraw.Add(t, overlayType);
     }
 }
Esempio n. 5
0
        public override void Draw()
        {
            base.Draw();

            OverlayTypes overlay = OverlayTypes.Forbidden;

            if (Broken)
            {
                overlay = OverlayTypes.BrokenDown;
            }
            else if (charger != null && CurJobDef == Globals.AutocleanerCharge)
            {
                overlay = OverlayTypes.NeedsPower;
            }
            else if (LowPower)
            {
                overlay = OverlayTypes.PowerOff;
            }

            if (overlay != OverlayTypes.Forbidden)
            {
                Map.overlayDrawer.DrawOverlay(this, overlay);
            }
        }
 public void DrawAllOverlays()
 {
     foreach (KeyValuePair <Thing, OverlayTypes> keyValuePair in this.overlaysToDraw)
     {
         this.curOffset = Vector3.zero;
         Thing        key   = keyValuePair.Key;
         OverlayTypes value = keyValuePair.Value;
         if ((value & OverlayTypes.BurningWick) != (OverlayTypes)0)
         {
             this.RenderBurningWick(key);
         }
         else
         {
             OverlayTypes overlayTypes = OverlayTypes.NeedsPower | OverlayTypes.PowerOff;
             int          bitCountOf   = Gen.GetBitCountOf((long)(value & overlayTypes));
             float        num          = this.StackOffsetFor(keyValuePair.Key);
             if (bitCountOf != 1)
             {
                 if (bitCountOf != 2)
                 {
                     if (bitCountOf == 3)
                     {
                         this.curOffset = new Vector3(-1.5f * num, 0f, 0f);
                     }
                 }
                 else
                 {
                     this.curOffset = new Vector3(-0.5f * num, 0f, 0f);
                 }
             }
             else
             {
                 this.curOffset = Vector3.zero;
             }
             if ((value & OverlayTypes.NeedsPower) != (OverlayTypes)0)
             {
                 this.RenderNeedsPowerOverlay(key);
             }
             if ((value & OverlayTypes.PowerOff) != (OverlayTypes)0)
             {
                 this.RenderPowerOffOverlay(key);
             }
             if ((value & OverlayTypes.BrokenDown) != (OverlayTypes)0)
             {
                 this.RenderBrokenDownOverlay(key);
             }
             if ((value & OverlayTypes.OutOfFuel) != (OverlayTypes)0)
             {
                 this.RenderOutOfFuelOverlay(key);
             }
         }
         if ((value & OverlayTypes.ForbiddenBig) != (OverlayTypes)0)
         {
             this.RenderForbiddenBigOverlay(key);
         }
         if ((value & OverlayTypes.Forbidden) != (OverlayTypes)0)
         {
             this.RenderForbiddenOverlay(key);
         }
         if ((value & OverlayTypes.QuestionMark) != (OverlayTypes)0)
         {
             this.RenderQuestionMarkOverlay(key);
         }
     }
     this.overlaysToDraw.Clear();
 }
        public void DrawAllOverlays()
        {
            foreach (KeyValuePair <Thing, OverlayTypes> item in this.overlaysToDraw)
            {
                this.curOffset = Vector3.zero;
                Thing        key   = item.Key;
                OverlayTypes value = item.Value;
                if ((value & OverlayTypes.BurningWick) != 0)
                {
                    this.RenderBurningWick(key);
                }
                else
                {
                    OverlayTypes overlayTypes = OverlayTypes.NeedsPower | OverlayTypes.PowerOff;
                    int          bitCountOf   = Gen.GetBitCountOf((long)(value & overlayTypes));
                    float        num          = this.StackOffsetFor(item.Key);
                    switch (bitCountOf)
                    {
                    case 1:
                        this.curOffset = Vector3.zero;
                        break;

                    case 2:
                        this.curOffset = new Vector3((float)(-0.5 * num), 0f, 0f);
                        break;

                    case 3:
                        this.curOffset = new Vector3((float)(-1.5 * num), 0f, 0f);
                        break;
                    }
                    if ((value & OverlayTypes.NeedsPower) != 0)
                    {
                        this.RenderNeedsPowerOverlay(key);
                    }
                    if ((value & OverlayTypes.PowerOff) != 0)
                    {
                        this.RenderPowerOffOverlay(key);
                    }
                    if ((value & OverlayTypes.BrokenDown) != 0)
                    {
                        this.RenderBrokenDownOverlay(key);
                    }
                    if ((value & OverlayTypes.OutOfFuel) != 0)
                    {
                        this.RenderOutOfFuelOverlay(key);
                    }
                }
                if ((value & OverlayTypes.ForbiddenBig) != 0)
                {
                    this.RenderForbiddenBigOverlay(key);
                }
                if ((value & OverlayTypes.Forbidden) != 0)
                {
                    this.RenderForbiddenOverlay(key);
                }
                if ((value & OverlayTypes.QuestionMark) != 0)
                {
                    this.RenderQuestionMarkOverlay(key);
                }
            }
            this.overlaysToDraw.Clear();
        }
Esempio n. 8
0
 public void showOverlay(OverlayTypes overlayId)
 {
 }