// Called by Unity just before any of the Update methods is called the first time.
    public void Start()
    {
        _sprite           = GetComponent <dfSprite>();
        _sprite.IsVisible = false;

        _label = _sprite.Find <dfLabel>("Count");
    }
    void GenerateList(string filter)
    {
        var children = new List <GameObject>();

        foreach (Transform child in PlayerPanel.transform)
        {
            children.Add(child.gameObject);
        }
        children.ForEach(child => Destroy(child));

        PlayerPanel.Enable();

        IEnumerable <Player> filtered = users.Where(t => t.Username.ToLower().Contains(filter.ToLower()))
                                        .OrderByDescending(t => pinnedPlayers.Any(u => u.ObjectId.Equals(t.ObjectId))).ThenBy(t => t.Username);

        foreach (Player player in filtered)
        {
            // GameObject ListItem = Instantiate(Resources.Load("List Item")) as GameObject;
            dfPanel listItem = PlayerPanel.AddPrefab(ListItem) as dfPanel; // as UserListItem;
            listItem.Width = PlayerPanel.Width - PlayerPanel.FlowPadding.left - PlayerPanel.FlowPadding.right;

            listItem.Click += new MouseEventHandler(listItem_Click);

            ListItemExtras extras = listItem.GetComponent <ListItemExtras>();
            extras.Player = player;


            dfLabel username = listItem.Find("Username Label").GetComponent <dfLabel>();
            username.Text          = player.Username;
            username.DisabledColor = new Color32(100, 100, 100, 255);

            dfSprite onlineSprite = listItem.Find("Online Sprite").GetComponent <dfSprite>();
            if (player.IsOnline)
            {
                onlineSprite.SpriteName = "OUYA_O 24px";
            }
            else
            {
                onlineSprite.SpriteName = "OUYA_A 24px";
            }

            dfButton actionButton = listItem.Find("Action Button").GetComponent <dfButton>();

            bool f = pinnedPlayers.Any(t => t.ObjectId.Equals(player.ObjectId));

            if (f)
            {
                actionButton.Text = "Unpin";
                //  listItem.BackgroundColor = new Color32(200, 255, 200, 255);
                listItem.BackgroundColor = new Color32(255, 255, 255, 255);

                actionButton.Click += new MouseEventHandler(actionButtonUnpin_Click);
            }
            else
            {
                actionButton.Text   = "Pin";
                actionButton.Click += new MouseEventHandler(actionButtonPin_Click);
            }
        }
    }
 void Awake()
 {
     ss = this;
     control = GetComponent<dfControl>();
     sprite = GetComponent<dfSprite>();
     
 }
Exemple #4
0
    // Use this for initialization
    void Start()
    {
        this._panel     = GetComponent <dfPanel>();
        this._indicator = Indicator;
        try
        {
            this._removeButton = transform.Find("Remove").GetComponent <dfButton>();
            if (RemoveRemove)
            {
                this._removeButton.Hide();
            }
            _removeButton.Click += RemoveButton_Click;
        }
        catch (Exception)
        {
        }

        try
        {
            this._indicator = transform.Find("Indicator").GetComponent <dfSprite>();
        }
        catch (Exception)
        {
        }
        this._label = transform.Find("Label").GetComponent <dfLabel>();
        this.name   = gameObject.name;

        color = _panel.BackgroundColor;
        _panel.BackgroundColor = grey;

        // print("Init");
        StartCoroutine(Initialize());
    }
    // Called by Unity just before any of the Update methods is called the first time.
    public void Start()
    {
        _sprite = GetComponent<dfSprite>();
        _sprite.IsVisible = false;

        _label = _sprite.Find<dfLabel>( "Count" );
    }
    private void Refresh()
    {
        _container = GetComponent <dfPanel>();
        _sprite    = _container.Find("Icon") as dfSprite;
        _label     = _container.Find("Count") as dfLabel;

        _sprite.SpriteName = this.Icon;
        _label.Text        = (this.Count > 1) ? Count.ToString() : "";
    }
 void Awake()
 {
     if (sprite == null)
     {
         sprite = GetComponent <dfSprite>();
     }
     ShowBorders       = true;
     this.useGUILayout = false;
 }
	void Awake()
	{
		if( sprite == null )
		{
			sprite = GetComponent<dfSprite>();
		}
		ShowBorders = true;
		this.useGUILayout = false;
	}
    /// <summary>
    /// Displays the drag cursor, which will follow the mouse until hidden
    /// </summary>
    /// <param name="sprite">The sprite to display in the drag cursor</param>
    /// <param name="position">The initial position of the drag cursor</param>
    /// <param name="offset">The mouse offset within the dragged object</param>
    public static void Show( dfSprite sprite, Vector2 position, Vector2 offset )
    {
        _cursorOffset = offset;

        setPosition( position );

        _sprite.Size = sprite.Size;
        _sprite.Atlas = sprite.Atlas;
        _sprite.SpriteName = sprite.SpriteName;
        _sprite.IsVisible = true;
        _sprite.BringToFront();
    }
    public void Start()
    {
        // Obtain a reference to the Sprite that this component is attached to
        _sprite = GetComponent<dfSprite>();

        // We don't want the drag cursor visible unless it is being used
        _sprite.Hide();

        // We don't want the drag cursor to intercept mouse messages
        _sprite.IsInteractive = false;
        _sprite.IsEnabled = false;
    }
Exemple #11
0
    public void Start()
    {
        // Obtain a reference to the Sprite that this component is attached to
        _sprite = GetComponent <dfSprite>();

        // We don't want the drag cursor visible unless it is being used
        _sprite.Hide();

        // We don't want the drag cursor to intercept mouse messages
        _sprite.IsInteractive = false;
        _sprite.IsEnabled     = false;
    }
Exemple #12
0
    /// <summary>
    /// Displays the drag cursor, which will follow the mouse until hidden
    /// </summary>
    /// <param name="sprite">The sprite to display in the drag cursor</param>
    /// <param name="position">The initial position of the drag cursor</param>
    /// <param name="offset">The mouse offset within the dragged object</param>
    public static void Show(dfSprite sprite, Vector2 position, Vector2 offset)
    {
        _cursorOffset = offset;

        setPosition(position);

        _sprite.Size       = sprite.Size;
        _sprite.Atlas      = sprite.Atlas;
        _sprite.SpriteName = sprite.SpriteName;
        _sprite.IsVisible  = true;
        _sprite.BringToFront();
    }
Exemple #13
0
 internal static new void renderSprite(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     options.baseIndex = renderData.Vertices.Count;
     dfSlicedSprite.rebuildTriangles(renderData, options);
     dfSlicedSprite.rebuildVertices(renderData, options);
     dfSlicedSprite.rebuildUV(renderData, options);
     dfSlicedSprite.rebuildColors(renderData, options);
     if (options.fillAmount < 1f)
     {
         dfSlicedSprite.doFill(renderData, options);
     }
 }
    public void OnEnable()
    {
        if( sprite == null )
            sprite = GetComponent<dfSprite>();

        if( menu == null )
            menu = GetComponent<dfRadialMenu>();

        sprite.SpriteName = menu.IsOpen ? OnSprite : OffSprite;

        menu.MenuOpened += OnMenuOpened;
        menu.MenuClosed += OnMenuClosed;
    }
Exemple #15
0
    // Use this for initialization
    void Start()
    {
        GameDataSingleton gds = GameDataSingleton.Instance;

        if (gds.SDS.Stations.Count == 0)
        {
            //We haven't loaded anything!
            GameObject dfNoDataSprite = GameObject.Find("UI_Sprite_NoData");
            if (dfNoDataSprite != null)
            {
                dfSprite dfs = dfNoDataSprite.GetComponent <dfSprite>();
                dfs.IsVisible = true;
            }
        }
    }
    public void OnEnable()
    {
        if (sprite == null)
        {
            sprite = GetComponent <dfSprite>();
        }

        if (menu == null)
        {
            menu = GetComponent <dfRadialMenu>();
        }

        sprite.SpriteName = menu.IsOpen ? OnSprite : OffSprite;

        menu.MenuOpened += OnMenuOpened;
        menu.MenuClosed += OnMenuClosed;
    }
    void OnEnable()
    {
        Container = GetComponent<dfPanel>();
        if( Container == null )
        {
            this.enabled = false;
        }

        NameLabel = Container.Find<dfLabel>( "Name" );
        DescriptionLabel = Container.Find<dfLabel>( "Description" );
        ProgressLabel = Container.Find<dfLabel>( "ProgressLabel" );
        Icon = Container.Find<dfSprite>( "Icon" );
        ProgressBar = Container.Find<dfProgressBar>( "ProgressBar" );

        Container.BackgroundSprite = "frame-style6";
        NameLabel.BackgroundSprite = null;
        ProgressBar.Opacity = 0.5f;
    }
Exemple #18
0
    private void updateValueIndicators(float rawValue)
    {
        if (this.thumb != null)
        {
            Vector3[] endPoints = this.getEndPoints(true);
            Vector3   vector3   = endPoints[1] - endPoints[0];
            float     single    = this.maxValue - this.minValue;
            float     single1   = (rawValue - this.minValue) / single * vector3.magnitude;
            Vector3   units     = this.thumbOffset * base.PixelsToUnits();
            Vector3   vector31  = (endPoints[0] + (vector3.normalized * single1)) + units;
            if (this.orientation == dfControlOrientation.Vertical || this.rightToLeft)
            {
                vector31 = (endPoints[1] + (-vector3.normalized * single1)) + units;
            }
            this.thumb.Pivot = dfPivotPoint.MiddleCenter;
            this.thumb.transform.position = vector31;
        }
        if (this.fillIndicator == null)
        {
            return;
        }
        RectOffset fillPadding = this.FillPadding;
        float      single2     = (rawValue - this.minValue) / (this.maxValue - this.minValue);
        Vector3    vector32    = new Vector3((float)fillPadding.left, (float)fillPadding.top);
        Vector2    vector2     = this.size - new Vector2((float)fillPadding.horizontal, (float)fillPadding.vertical);
        dfSprite   _dfSprite   = this.fillIndicator as dfSprite;

        if (_dfSprite != null && this.fillMode == dfProgressFillMode.Fill)
        {
            _dfSprite.FillAmount = single2;
        }
        else if (this.orientation != dfControlOrientation.Horizontal)
        {
            vector2.y = base.Height * single2 - (float)fillPadding.vertical;
        }
        else
        {
            vector2.x = base.Width * single2 - (float)fillPadding.horizontal;
        }
        this.fillIndicator.Size             = vector2;
        this.fillIndicator.RelativePosition = vector32;
    }
Exemple #19
0
 private void updateValueIndicators(float rawValue)
 {
     if (this.thumb != null)
     {
         Vector3[] vectorArray = this.getEndPoints(true);
         Vector3   vector      = vectorArray[1] - vectorArray[0];
         float     num         = this.maxValue - this.minValue;
         float     num2        = ((rawValue - this.minValue) / num) * vector.magnitude;
         Vector3   vector2     = (Vector3)(this.thumbOffset * base.PixelsToUnits());
         Vector3   vector3     = (vectorArray[0] + ((Vector3)(vector.normalized * num2))) + vector2;
         if ((this.orientation == dfControlOrientation.Vertical) || this.rightToLeft)
         {
             vector3 = (vectorArray[1] + ((Vector3)(-vector.normalized * num2))) + vector2;
         }
         this.thumb.Pivot = dfPivotPoint.MiddleCenter;
         this.thumb.transform.position = vector3;
     }
     if (this.fillIndicator != null)
     {
         RectOffset fillPadding   = this.FillPadding;
         float      num3          = (rawValue - this.minValue) / (this.maxValue - this.minValue);
         Vector3    vector4       = new Vector3((float)fillPadding.left, (float)fillPadding.top);
         Vector2    vector5       = base.size - new Vector2((float)fillPadding.horizontal, (float)fillPadding.vertical);
         dfSprite   fillIndicator = this.fillIndicator as dfSprite;
         if ((fillIndicator != null) && (this.fillMode == dfProgressFillMode.Fill))
         {
             fillIndicator.FillAmount = num3;
         }
         else if (this.orientation == dfControlOrientation.Horizontal)
         {
             vector5.x = (base.Width * num3) - fillPadding.horizontal;
         }
         else
         {
             vector5.y = (base.Height * num3) - fillPadding.vertical;
         }
         this.fillIndicator.Size             = vector5;
         this.fillIndicator.RelativePosition = vector4;
     }
 }
Exemple #20
0
 private static void rebuildUV(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     dfAtlas dfAtla = options.atlas;
     Vector2 vector2 = new Vector2((float)dfAtla.Texture.width, (float)dfAtla.Texture.height);
     dfAtlas.ItemInfo itemInfo = options.spriteInfo;
     float single = (float)itemInfo.border.top / vector2.y;
     float single1 = (float)itemInfo.border.bottom / vector2.y;
     float single2 = (float)itemInfo.border.left / vector2.x;
     float single3 = (float)itemInfo.border.right / vector2.x;
     Rect rect = itemInfo.region;
     dfSlicedSprite.uv[0] = new Vector2(rect.x, rect.yMax);
     dfSlicedSprite.uv[1] = new Vector2(rect.x + single2, rect.yMax);
     dfSlicedSprite.uv[2] = new Vector2(rect.x + single2, rect.yMax - single);
     dfSlicedSprite.uv[3] = new Vector2(rect.x, rect.yMax - single);
     dfSlicedSprite.uv[4] = new Vector2(rect.xMax - single3, rect.yMax);
     dfSlicedSprite.uv[5] = new Vector2(rect.xMax, rect.yMax);
     dfSlicedSprite.uv[6] = new Vector2(rect.xMax, rect.yMax - single);
     dfSlicedSprite.uv[7] = new Vector2(rect.xMax - single3, rect.yMax - single);
     dfSlicedSprite.uv[8] = new Vector2(rect.x, rect.y + single1);
     dfSlicedSprite.uv[9] = new Vector2(rect.x + single2, rect.y + single1);
     dfSlicedSprite.uv[10] = new Vector2(rect.x + single2, rect.y);
     dfSlicedSprite.uv[11] = new Vector2(rect.x, rect.y);
     dfSlicedSprite.uv[12] = new Vector2(rect.xMax - single3, rect.y + single1);
     dfSlicedSprite.uv[13] = new Vector2(rect.xMax, rect.y + single1);
     dfSlicedSprite.uv[14] = new Vector2(rect.xMax, rect.y);
     dfSlicedSprite.uv[15] = new Vector2(rect.xMax - single3, rect.y);
     if (options.flip != dfSpriteFlip.None)
     {
         for (int i = 0; i < (int)dfSlicedSprite.uv.Length; i = i + 4)
         {
             Vector2 vector21 = Vector2.zero;
             if (options.flip.IsSet(dfSpriteFlip.FlipHorizontal))
             {
                 vector21 = dfSlicedSprite.uv[i];
                 dfSlicedSprite.uv[i] = dfSlicedSprite.uv[i + 1];
                 dfSlicedSprite.uv[i + 1] = vector21;
                 vector21 = dfSlicedSprite.uv[i + 2];
                 dfSlicedSprite.uv[i + 2] = dfSlicedSprite.uv[i + 3];
                 dfSlicedSprite.uv[i + 3] = vector21;
             }
             if (options.flip.IsSet(dfSpriteFlip.FlipVertical))
             {
                 vector21 = dfSlicedSprite.uv[i];
                 dfSlicedSprite.uv[i] = dfSlicedSprite.uv[i + 3];
                 dfSlicedSprite.uv[i + 3] = vector21;
                 vector21 = dfSlicedSprite.uv[i + 1];
                 dfSlicedSprite.uv[i + 1] = dfSlicedSprite.uv[i + 2];
                 dfSlicedSprite.uv[i + 2] = vector21;
             }
         }
         if (options.flip.IsSet(dfSpriteFlip.FlipHorizontal))
         {
             Vector2[] vector2Array = new Vector2[(int)dfSlicedSprite.uv.Length];
             Array.Copy(dfSlicedSprite.uv, vector2Array, (int)dfSlicedSprite.uv.Length);
             Array.Copy(dfSlicedSprite.uv, 0, dfSlicedSprite.uv, 4, 4);
             Array.Copy(vector2Array, 4, dfSlicedSprite.uv, 0, 4);
             Array.Copy(dfSlicedSprite.uv, 8, dfSlicedSprite.uv, 12, 4);
             Array.Copy(vector2Array, 12, dfSlicedSprite.uv, 8, 4);
         }
         if (options.flip.IsSet(dfSpriteFlip.FlipVertical))
         {
             Vector2[] vector2Array1 = new Vector2[(int)dfSlicedSprite.uv.Length];
             Array.Copy(dfSlicedSprite.uv, vector2Array1, (int)dfSlicedSprite.uv.Length);
             Array.Copy(dfSlicedSprite.uv, 0, dfSlicedSprite.uv, 8, 4);
             Array.Copy(vector2Array1, 8, dfSlicedSprite.uv, 0, 4);
             Array.Copy(dfSlicedSprite.uv, 4, dfSlicedSprite.uv, 12, 4);
             Array.Copy(vector2Array1, 12, dfSlicedSprite.uv, 4, 4);
         }
     }
     for (int j = 0; j < (int)dfSlicedSprite.uv.Length; j++)
     {
         renderData.UV.Add(dfSlicedSprite.uv[j]);
     }
 }
Exemple #21
0
 private static void doFill(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     int num = options.baseIndex;
     dfList<Vector3> vertices = renderData.Vertices;
     dfList<Vector2> uV = renderData.UV;
     int[][] fillIndices = dfSlicedSprite.getFillIndices(options.fillDirection, num);
     bool flag = options.invertFill;
     if (options.fillDirection == dfFillDirection.Vertical)
     {
         flag = !flag;
     }
     if (flag)
     {
         for (int i = 0; i < (int)fillIndices.Length; i++)
         {
             Array.Reverse(fillIndices[i]);
         }
     }
     int num1 = (options.fillDirection != dfFillDirection.Horizontal ? 1 : 0);
     float item = vertices[fillIndices[0][(flag ? 3 : 0)]][num1];
     float single = vertices[fillIndices[0][(flag ? 0 : 3)]][num1];
     float single1 = Mathf.Abs(single - item);
     float single2 = (flag ? single - options.fillAmount * single1 : item + options.fillAmount * single1);
     for (int j = 0; j < (int)fillIndices.Length; j++)
     {
         if (flag)
         {
             for (int k = 1; k < 4; k++)
             {
                 Vector3 vector3 = vertices[fillIndices[j][k]];
                 float item1 = vector3[num1];
                 if (item1 <= single2)
                 {
                     Vector3 vector31 = vertices[fillIndices[j][k]];
                     vector31[num1] = single2;
                     vertices[fillIndices[j][k]] = vector31;
                     Vector3 item2 = vertices[fillIndices[j][k - 1]];
                     float item3 = item2[num1];
                     if (item3 >= single2)
                     {
                         float single3 = (single2 - item3) / (item1 - item3);
                         Vector2 vector2 = uV[fillIndices[j][k]];
                         float item4 = vector2[num1];
                         Vector2 vector21 = uV[fillIndices[j][k - 1]];
                         float single4 = vector21[num1];
                         Vector2 vector22 = uV[fillIndices[j][k]];
                         vector22[num1] = Mathf.Lerp(single4, item4, single3);
                         uV[fillIndices[j][k]] = vector22;
                     }
                 }
             }
         }
         else
         {
             for (int l = 3; l > 0; l--)
             {
                 Vector3 vector32 = vertices[fillIndices[j][l]];
                 float item5 = vector32[num1];
                 if (item5 >= single2)
                 {
                     Vector3 vector33 = vertices[fillIndices[j][l]];
                     vector33[num1] = single2;
                     vertices[fillIndices[j][l]] = vector33;
                     Vector3 vector34 = vertices[fillIndices[j][l - 1]];
                     float single5 = vector34[num1];
                     if (single5 <= single2)
                     {
                         float single6 = (single2 - single5) / (item5 - single5);
                         Vector2 vector23 = uV[fillIndices[j][l]];
                         float item6 = vector23[num1];
                         Vector2 vector24 = uV[fillIndices[j][l - 1]];
                         float item7 = vector24[num1];
                         Vector2 vector25 = uV[fillIndices[j][l]];
                         vector25[num1] = Mathf.Lerp(item7, item6, single6);
                         uV[fillIndices[j][l]] = vector25;
                     }
                 }
             }
         }
     }
 }
Exemple #22
0
        // Token: 0x060001DA RID: 474 RVA: 0x000110B4 File Offset: 0x0000F2B4
        public static void TriggerReloadHook(MultiActiveReloadManager.Action <GameUIReloadBarController, PlayerController, Vector3, float, float, int> orig, GameUIReloadBarController self, PlayerController attachParent, Vector3 offset, float duration, float activeReloadStartPercent, int pixelWidth)
        {
            bool flag = MultiActiveReloadManager.tempraryActiveReloads.ContainsKey(self);

            if (flag)
            {
                foreach (MultiActiveReload multiActiveReload in MultiActiveReloadManager.tempraryActiveReloads[self])
                {
                    bool flag2 = multiActiveReload.sprite != null && multiActiveReload.sprite.gameObject != null;
                    if (flag2)
                    {
                        UnityEngine.Object.Destroy(multiActiveReload.sprite.gameObject);
                    }
                    bool flag3 = multiActiveReload.celebrationSprite != null && multiActiveReload.celebrationSprite.gameObject != null;
                    if (flag3)
                    {
                        UnityEngine.Object.Destroy(multiActiveReload.celebrationSprite.gameObject);
                    }
                }
                MultiActiveReloadManager.tempraryActiveReloads[self].Clear();
            }
            orig(self, attachParent, offset, duration, activeReloadStartPercent, pixelWidth);
            bool flag4 = attachParent != null && attachParent.CurrentGun != null && attachParent.CurrentGun.GetComponent <MultiActiveReloadController>() != null;

            if (flag4)
            {
                foreach (MultiActiveReloadData multiActiveReloadData in attachParent.CurrentGun.GetComponent <MultiActiveReloadController>().reloads)
                {
                    dfSprite dfSprite = UnityEngine.Object.Instantiate <dfSprite>(self.activeReloadSprite);
                    self.activeReloadSprite.Parent.AddControl(dfSprite);
                    dfSprite.enabled = true;
                    float width    = self.progressSlider.Width;
                    float maxValue = self.progressSlider.MaxValue;
                    float num      = (float)multiActiveReloadData.startValue / maxValue * width;
                    float num2     = (float)multiActiveReloadData.endValue / maxValue * width;
                    float x        = num + (num2 - num) * multiActiveReloadData.activeReloadStartPercentage;
                    float width2   = (float)pixelWidth * Pixelator.Instance.CurrentTileScale;
                    dfSprite.RelativePosition = self.activeReloadSprite.RelativePosition;
                    dfSprite.RelativePosition = GameUIUtility.QuantizeUIPosition(dfSprite.RelativePosition.WithX(x));
                    dfSprite.Width            = width2;
                    dfSprite.IsVisible        = true;
                    dfSprite dfSprite2 = UnityEngine.Object.Instantiate <dfSprite>(self.celebrationSprite);
                    self.activeReloadSprite.Parent.AddControl(dfSprite2);
                    dfSprite2.enabled = true;
                    dfSpriteAnimation component = dfSprite2.GetComponent <dfSpriteAnimation>();
                    component.Stop();
                    component.SetFrameExternal(0);
                    dfSprite2.enabled          = false;
                    dfSprite2.RelativePosition = dfSprite.RelativePosition + new Vector3(Pixelator.Instance.CurrentTileScale * -1f, Pixelator.Instance.CurrentTileScale * -2f, 0f);
                    int num3 = Mathf.RoundToInt((float)(multiActiveReloadData.endValue - multiActiveReloadData.startValue) * multiActiveReloadData.activeReloadStartPercentage) + multiActiveReloadData.startValue - multiActiveReloadData.activeReloadLastTime / 2;
                    MultiActiveReload item = new MultiActiveReload
                    {
                        sprite            = dfSprite,
                        celebrationSprite = dfSprite2,
                        startValue        = num3,
                        endValue          = num3 + multiActiveReloadData.activeReloadLastTime,
                        stopsReload       = multiActiveReloadData.stopsReload,
                        canAttemptActiveReloadAfterwards = multiActiveReloadData.canAttemptActiveReloadAfterwards,
                        reloadData           = multiActiveReloadData.reloadData,
                        usesActiveReloadData = multiActiveReloadData.usesActiveReloadData,
                        Name = multiActiveReloadData.Name
                    };
                    bool flag5 = MultiActiveReloadManager.tempraryActiveReloads.ContainsKey(self);
                    if (flag5)
                    {
                        MultiActiveReloadManager.tempraryActiveReloads[self].Add(item);
                    }
                    else
                    {
                        MultiActiveReloadManager.tempraryActiveReloads.Add(self, new List <MultiActiveReload>
                        {
                            item
                        });
                    }
                }
            }
        }
    private void Refresh()
    {
        _container = GetComponent<dfPanel>();
        _sprite = _container.Find( "Icon" ) as dfSprite;
        _label = _container.Find( "Count" ) as dfLabel;

        _sprite.SpriteName = this.Icon;
        _label.Text = ( this.Count > 1 ) ? Count.ToString() : "";
    }
Exemple #24
0
 private static void rebuildVertices(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     float single = 0f;
     float single1 = 0f;
     float single2 = Mathf.Ceil(options.size.x);
     float single3 = Mathf.Ceil(-options.size.y);
     dfAtlas.ItemInfo itemInfo = options.spriteInfo;
     float single4 = (float)itemInfo.border.left;
     float single5 = (float)itemInfo.border.top;
     float single6 = (float)itemInfo.border.right;
     float single7 = (float)itemInfo.border.bottom;
     if (options.flip.IsSet(dfSpriteFlip.FlipHorizontal))
     {
         float single8 = single6;
         single6 = single4;
         single4 = single8;
     }
     if (options.flip.IsSet(dfSpriteFlip.FlipVertical))
     {
         float single9 = single7;
         single7 = single5;
         single5 = single9;
     }
     dfSlicedSprite.verts[0] = new Vector3(single, single1, 0f) + options.offset;
     dfSlicedSprite.verts[1] = dfSlicedSprite.verts[0] + new Vector3(single4, 0f, 0f);
     dfSlicedSprite.verts[2] = dfSlicedSprite.verts[0] + new Vector3(single4, -single5, 0f);
     dfSlicedSprite.verts[3] = dfSlicedSprite.verts[0] + new Vector3(0f, -single5, 0f);
     dfSlicedSprite.verts[4] = new Vector3(single2 - single6, single1, 0f) + options.offset;
     dfSlicedSprite.verts[5] = dfSlicedSprite.verts[4] + new Vector3(single6, 0f, 0f);
     dfSlicedSprite.verts[6] = dfSlicedSprite.verts[4] + new Vector3(single6, -single5, 0f);
     dfSlicedSprite.verts[7] = dfSlicedSprite.verts[4] + new Vector3(0f, -single5, 0f);
     dfSlicedSprite.verts[8] = new Vector3(single, single3 + single7, 0f) + options.offset;
     dfSlicedSprite.verts[9] = dfSlicedSprite.verts[8] + new Vector3(single4, 0f, 0f);
     dfSlicedSprite.verts[10] = dfSlicedSprite.verts[8] + new Vector3(single4, -single7, 0f);
     dfSlicedSprite.verts[11] = dfSlicedSprite.verts[8] + new Vector3(0f, -single7, 0f);
     dfSlicedSprite.verts[12] = new Vector3(single2 - single6, single3 + single7, 0f) + options.offset;
     dfSlicedSprite.verts[13] = dfSlicedSprite.verts[12] + new Vector3(single6, 0f, 0f);
     dfSlicedSprite.verts[14] = dfSlicedSprite.verts[12] + new Vector3(single6, -single7, 0f);
     dfSlicedSprite.verts[15] = dfSlicedSprite.verts[12] + new Vector3(0f, -single7, 0f);
     for (int i = 0; i < (int)dfSlicedSprite.verts.Length; i++)
     {
         renderData.Vertices.Add((dfSlicedSprite.verts[i] * options.pixelsToUnits).Quantize(options.pixelsToUnits));
     }
 }
    void GenerateList2(string filter)
    {
        var children = new List <GameObject>();

        foreach (Transform child in UserPanel.transform)
        {
            children.Add(child.gameObject);
        }
        children.ForEach(child => Destroy(child));


        IEnumerable <Player> filtered = users.Where(t => t.Username.ToLower().Contains(filter.ToLower()));

        foreach (Player player in filtered)
        {
            ParseObject friend = null;
            if (friends != null)
            {
                friend = friends.Where(t => ((Player)t[REQUEST_FROM]).ObjectId.Equals(player.ObjectId) || ((Player)t[REQUEST_TO]).ObjectId.Equals(player.ObjectId)).FirstOrDefault();

                //    friend = friends.FirstOrDefault();
                //   print("Friend: " + ((Player)friend[REQUEST_TO]).ObjectId);
                //    print("Player: " + player.ObjectId);
            }

            var panel = UserPanel.AddControl <UserListItem>();
            panel.BackgroundSprite = "BLANK_TEXTURE";
            if (friend != null)
            {
                panel.BackgroundColor = new Color32(255, 229, 255, 255);
            }
            else
            {
                panel.BackgroundColor = new Color32(213, 229, 255, 255);
            }
            panel.Height = 50;
            panel.Width  = UserPanel.Width - UserPanel.FlowPadding.left - UserPanel.FlowPadding.right;
            panel.User   = player;

            dfLabel nameLabel = panel.AddControl <dfLabel>();
            nameLabel.Text             = player.Username;
            nameLabel.AutoSize         = true;
            nameLabel.RelativePosition = new Vector3(50, 12);
            nameLabel.Color            = new Color32(0, 0, 0, 255);

            dfSprite onlineSprite = panel.AddControl <dfSprite>();
            if (player.IsOnline)
            {
                onlineSprite.SpriteName = "OUYA_O 24px";
            }
            else
            {
                onlineSprite.SpriteName = "OUYA_A 24px";
            }
            onlineSprite.RelativePosition = new Vector3(13, 13);

            if (!player.Username.Equals(Player.CurrentUser.Username))
            {
                var addButton = panel.AddControl <dfButton>();
                addButton.BackgroundSprite = "button-normal";
                addButton.HoverSprite      = "button-hilite";
                addButton.PressedSprite    = "button-normal";
                addButton.FocusSprite      = "button-hilite";
                addButton.DisabledSprite   = "button-disabled";
                addButton.Text             = "Add";
                addButton.Width            = 50;
                addButton.Height           = 30;
                addButton.RelativePosition = new Vector3(panel.Width - addButton.Width - 5, 10);

                addButton.Click += new MouseEventHandler(actionClick_add);
            }
        }
    }
Exemple #26
0
 private static void rebuildVertices(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     dfList<Vector3> vertices = renderData.Vertices;
     int num = options.baseIndex;
     float single = 0f;
     float single1 = 0f;
     float single2 = Mathf.Ceil(options.size.x);
     float single3 = Mathf.Ceil(-options.size.y);
     vertices.Add(new Vector3(single, single1, 0f) * options.pixelsToUnits);
     vertices.Add(new Vector3(single2, single1, 0f) * options.pixelsToUnits);
     vertices.Add(new Vector3(single2, single3, 0f) * options.pixelsToUnits);
     vertices.Add(new Vector3(single, single3, 0f) * options.pixelsToUnits);
     Vector3 vector3 = options.offset.RoundToInt() * options.pixelsToUnits;
     for (int i = 0; i < 4; i++)
     {
         vertices[num + i] = (vertices[num + i] + vector3).Quantize(options.pixelsToUnits);
     }
 }
Exemple #27
0
 private static void rebuildTriangles(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     int num = options.baseIndex;
     dfList<int> triangles = renderData.Triangles;
     for (int i = 0; i < (int)dfSlicedSprite.triangleIndices.Length; i++)
     {
         triangles.Add(num + dfSlicedSprite.triangleIndices[i]);
     }
 }
Exemple #28
0
 public static void TriggerReloadHook(Action <GameUIReloadBarController, PlayerController, Vector3, float, float, int> orig, GameUIReloadBarController self, PlayerController attachParent, Vector3 offset, float duration, float activeReloadStartPercent,
                                      int pixelWidth)
 {
     if (tempraryActiveReloads.ContainsKey(self))
     {
         foreach (MultiActiveReload multiactivereload in tempraryActiveReloads[self])
         {
             if (multiactivereload.sprite != null && multiactivereload.sprite.gameObject != null)
             {
                 UnityEngine.Object.Destroy(multiactivereload.sprite.gameObject);
             }
             if (multiactivereload.celebrationSprite != null && multiactivereload.celebrationSprite.gameObject != null)
             {
                 UnityEngine.Object.Destroy(multiactivereload.celebrationSprite.gameObject);
             }
         }
         tempraryActiveReloads[self].Clear();
     }
     orig(self, attachParent, offset, duration, activeReloadStartPercent, pixelWidth);
     if (attachParent != null && attachParent.CurrentGun != null && attachParent.CurrentGun.GetComponent <MultiActiveReloadController>() != null)
     {
         foreach (MultiActiveReloadData data in attachParent.CurrentGun.GetComponent <MultiActiveReloadController>().reloads)
         {
             dfSprite sprite = UnityEngine.Object.Instantiate(self.activeReloadSprite);
             self.activeReloadSprite.Parent.AddControl(sprite);
             sprite.enabled = true;
             float width    = self.progressSlider.Width;
             float maxValue = self.progressSlider.MaxValue;
             float num      = data.startValue / maxValue * width;
             float num2     = data.endValue / maxValue * width;
             float x        = num + (num2 - num) * data.activeReloadStartPercentage;
             float width2   = (float)pixelWidth * Pixelator.Instance.CurrentTileScale;
             sprite.RelativePosition = self.activeReloadSprite.RelativePosition;
             sprite.RelativePosition = GameUIUtility.QuantizeUIPosition(sprite.RelativePosition.WithX(x));
             sprite.Width            = width2;
             sprite.IsVisible        = true;
             dfSprite celebrationSprite = UnityEngine.Object.Instantiate(self.celebrationSprite);
             self.activeReloadSprite.Parent.AddControl(celebrationSprite);
             celebrationSprite.enabled = true;
             dfSpriteAnimation component = celebrationSprite.GetComponent <dfSpriteAnimation>();
             component.Stop();
             component.SetFrameExternal(0);
             celebrationSprite.enabled          = false;
             celebrationSprite.RelativePosition = sprite.RelativePosition + new Vector3(Pixelator.Instance.CurrentTileScale * -1f, Pixelator.Instance.CurrentTileScale * -2f, 0f);
             int activeReloadStartValue = Mathf.RoundToInt((float)(data.endValue - data.startValue) * data.activeReloadStartPercentage) + data.startValue - data.activeReloadLastTime / 2;
             MultiActiveReload reload   = new MultiActiveReload
             {
                 sprite            = sprite,
                 celebrationSprite = celebrationSprite,
                 startValue        = activeReloadStartValue,
                 endValue          = activeReloadStartValue + data.activeReloadLastTime,
                 stopsReload       = data.stopsReload,
                 canAttemptActiveReloadAfterwards = data.canAttemptActiveReloadAfterwards,
                 reloadData           = data.reloadData,
                 usesActiveReloadData = data.usesActiveReloadData
             };
             if (tempraryActiveReloads.ContainsKey(self))
             {
                 tempraryActiveReloads[self].Add(reload);
             }
             else
             {
                 tempraryActiveReloads.Add(self, new List <MultiActiveReload> {
                     reload
                 });
             }
         }
     }
 }
Exemple #29
0
 internal static void renderSprite(dfRenderData data, dfSprite.RenderOptions options)
 {
     options.baseIndex = data.Vertices.Count;
     dfSprite.rebuildTriangles(data, options);
     dfSprite.rebuildVertices(data, options);
     dfSprite.rebuildUV(data, options);
     dfSprite.rebuildColors(data, options);
     if (options.fillAmount > -1f && options.fillAmount < 1f)
     {
         dfSprite.doFill(data, options);
     }
 }
    void GenerateList(string filter)
    {
        //Player current = Player.CurrentUser as Player;

        //current.Get<string>("email");

        //IList<Player> players = null;

        //try
        //{
        //    players = current.Get<IList<Player>>("pinnedPlayers");
        //}
        //catch (Exception e)
        //{

        //}
        //if (players == null)
        //{
        //    print("players is null");
        //    players = new List<Player>() { users.LastOrDefault() };
        //}
        //print("count " + players.Count);
        //players.Add(users.FirstOrDefault());
        //current["pinnedPlayers"] = players;
        //current.SaveAsync();

        //current.PinnedPlayers.FetchAllAsync().ContinueWith(t =>
        //{
        //    if (current.PinnedPlayers != null)
        //    {
        //        foreach (Player p in current.PinnedPlayers)
        //        {
        //            print("Player: " + p.Username);
        //        }
        //    }



        //    current.PinnedPlayers.Add(users.LastOrDefault());
        //    current.SaveAsync();
        //    print("Saving pinnedPlayers");
        //});


        var children = new List <GameObject>();

        foreach (Transform child in UserPanel.transform)
        {
            children.Add(child.gameObject);
        }
        children.ForEach(child => Destroy(child));

        UserPanel.Enable();

        IEnumerable <Player> filtered = users.Where(t => t.Username.ToLower().Contains(filter.ToLower())).OrderByDescending(t => t.ObjectId.Equals(Player.CurrentUser.ObjectId))
                                        .ThenByDescending(t => friendList.Contains(t.ObjectId));

        foreach (Player player in filtered)
        {
            ParseObject friend = null;
            if (friends != null)
            {
                friend = friends.Where(t => ((Player)t[REQUEST_FROM]).ObjectId.Equals(player.ObjectId) || ((Player)t[REQUEST_TO]).ObjectId.Equals(player.ObjectId)).FirstOrDefault();

                //    friend = friends.FirstOrDefault();
                //   print("Friend: " + ((Player)friend[REQUEST_TO]).ObjectId);
                //    print("Player: " + player.ObjectId);
            }

            // GameObject ListItem = Instantiate(Resources.Load("List Item")) as GameObject;
            dfPanel listItem = UserPanel.AddPrefab(ListItem) as dfPanel; // as UserListItem;
            listItem.Width = UserPanel.Width - UserPanel.FlowPadding.left - UserPanel.FlowPadding.right;

            ListItemExtras extras = listItem.GetComponent <ListItemExtras>();
            extras.Player        = player;
            extras.FriendRequest = friend;

            dfLabel username = listItem.Find("Username Label").GetComponent <dfLabel>();
            username.Text          = player.Username;
            username.DisabledColor = new Color32(100, 100, 100, 255);

            dfLabel email = listItem.Find("Email label").GetComponent <dfLabel>();
            email.Text          = player.Email;
            email.DisabledColor = new Color32(100, 100, 100, 255);

            dfSprite onlineSprite = listItem.Find("Online Sprite").GetComponent <dfSprite>();
            if (player.IsOnline)
            {
                onlineSprite.SpriteName = "OUYA_O 24px";
            }
            else
            {
                onlineSprite.SpriteName = "OUYA_A 24px";
            }

            dfButton actionButton = listItem.Find("Action Button").GetComponent <dfButton>();
            if (friend == null)
            {
                actionButton.Text   = "Add";
                actionButton.Click += new MouseEventHandler(actionClick_add);
            }
            else
            {
                string status = friend[STATUS] as string;
                Player from   = friend[REQUEST_FROM] as Player;
                if (Player.CurrentUser.ObjectId.Equals(from.ObjectId))
                {
                    switch (status)
                    {
                    case S_ACCEPTED:
                        actionButton.Text        = "Remove";
                        actionButton.Click      += new MouseEventHandler(actionClick_remove);
                        listItem.BackgroundColor = new Color32(200, 255, 200, 255);
                        break;

                    case S_REJECTED:
                        actionButton.Text = "Sorry";
                        break;

                    case S_PENDING:
                        actionButton.Text = "Pending";
                        actionButton.Disable();
                        break;
                    }
                }
                else
                {
                    switch (status)
                    {
                    case S_ACCEPTED:
                        actionButton.Text        = "Remove";
                        actionButton.Click      += new MouseEventHandler(actionClick_remove);
                        listItem.BackgroundColor = new Color32(200, 255, 200, 255);
                        break;

                    case S_REJECTED:
                        actionButton.Text = "Rejected";
                        break;

                    case S_PENDING:
                        actionButton.Text   = "Accept";
                        actionButton.Click += new MouseEventHandler(actionClick_accept);
                        break;
                    }
                }
            }

            if (player.Username.Equals(Player.CurrentUser.Username))
            {
                actionButton.Hide();
            }
        }
    }
Exemple #31
0
 private static void doFill(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     int num = options.baseIndex;
     dfList<Vector3> vertices = renderData.Vertices;
     dfList<Vector2> uV = renderData.UV;
     int num1 = num;
     int num2 = num + 1;
     int num3 = num + 3;
     int num4 = num + 2;
     if (options.invertFill)
     {
         if (options.fillDirection != dfFillDirection.Horizontal)
         {
             num1 = num + 3;
             num2 = num + 2;
             num3 = num;
             num4 = num + 1;
         }
         else
         {
             num1 = num + 1;
             num2 = num;
             num3 = num + 2;
             num4 = num + 3;
         }
     }
     if (options.fillDirection != dfFillDirection.Horizontal)
     {
         vertices[num3] = Vector3.Lerp(vertices[num3], vertices[num1], 1f - options.fillAmount);
         vertices[num4] = Vector3.Lerp(vertices[num4], vertices[num2], 1f - options.fillAmount);
         uV[num3] = Vector2.Lerp(uV[num3], uV[num1], 1f - options.fillAmount);
         uV[num4] = Vector2.Lerp(uV[num4], uV[num2], 1f - options.fillAmount);
     }
     else
     {
         vertices[num2] = Vector3.Lerp(vertices[num2], vertices[num1], 1f - options.fillAmount);
         vertices[num4] = Vector3.Lerp(vertices[num4], vertices[num3], 1f - options.fillAmount);
         uV[num2] = Vector2.Lerp(uV[num2], uV[num1], 1f - options.fillAmount);
         uV[num4] = Vector2.Lerp(uV[num4], uV[num3], 1f - options.fillAmount);
     }
 }
 void Awake()
 {
     if( sprite == null )
     {
         sprite = GetComponent<dfSprite>();
     }
     ShowBorders = true;
 }
Exemple #33
0
 private static void rebuildColors(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     dfList<Color32> colors = renderData.Colors;
     colors.Add(options.color);
     colors.Add(options.color);
     colors.Add(options.color);
     colors.Add(options.color);
 }
Exemple #34
0
 private static void rebuildTriangles(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     int num = options.baseIndex;
     dfList<int> triangles = renderData.Triangles;
     triangles.EnsureCapacity(triangles.Count + (int)dfSprite.TRIANGLE_INDICES.Length);
     for (int i = 0; i < (int)dfSprite.TRIANGLE_INDICES.Length; i++)
     {
         triangles.Add(num + dfSprite.TRIANGLE_INDICES[i]);
     }
 }
Exemple #35
0
 private static void rebuildUV(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     Rect rect = options.spriteInfo.region;
     dfList<Vector2> uV = renderData.UV;
     uV.Add(new Vector2(rect.x, rect.yMax));
     uV.Add(new Vector2(rect.xMax, rect.yMax));
     uV.Add(new Vector2(rect.xMax, rect.y));
     uV.Add(new Vector2(rect.x, rect.y));
     Vector2 item = Vector2.zero;
     if (options.flip.IsSet(dfSpriteFlip.FlipHorizontal))
     {
         item = uV[1];
         uV[1] = uV[0];
         uV[0] = item;
         item = uV[3];
         uV[3] = uV[2];
         uV[2] = item;
     }
     if (options.flip.IsSet(dfSpriteFlip.FlipVertical))
     {
         item = uV[0];
         uV[0] = uV[3];
         uV[3] = item;
         item = uV[1];
         uV[1] = uV[2];
         uV[2] = item;
     }
 }
	// Use this for initialization
	void Start () {
        gc = this;
        Icon = GetComponent<dfSprite>();
        Label = GetComponentInChildren<dfLabel>();
	}
Exemple #37
0
 private static void rebuildColors(dfRenderData renderData, dfSprite.RenderOptions options)
 {
     for (int i = 0; i < 16; i++)
     {
         renderData.Colors.Add(options.color);
     }
 }