private void onReach(ProgressNode node)
        {
            if (node == null)
            {
                return;
            }

            if (progressParser.isIntervalType(node))
            {
                progressInterval i = progressParser.getIntervalNode(node.Id);

                if (i != null)
                {
                    double nodeRecord = progressParser.getIntervalRecord(node);

                    if (i.getRecord(i.Interval) >= nodeRecord)
                    {
                        return;
                    }

                    if (node.IsReached)
                    {
                        i.calculateRewards(i.Interval);
                        i.Interval += 1;
                    }
                }
            }

            progressParser.updateCompletionRecord();
        }
Example #2
0
        private static void addProgressInterval(ProgressType p, ProgressNode n, string d, string t, string u)
        {
            if (n == null)
            {
                return;
            }

            if (intervalNodes.Contains(n.Id))
            {
                return;
            }

            progressInterval i = null;

            switch (p)
            {
            case ProgressType.ALTITUDERECORD:
                i        = new progressInterval(ProgressType.ALTITUDERECORD, n, ((RecordsAltitude)n).record, getMaxAltitudeRecord, 500, ContractDefs.Progression.RecordSplit, d, t, u);
                altitude = i;
                break;

            case ProgressType.DEPTHRECORD:
                i     = new progressInterval(ProgressType.DEPTHRECORD, n, ((RecordsDepth)n).record, ContractDefs.Progression.MaxDepthRecord, 10, ContractDefs.Progression.RecordSplit, d, t, u);
                depth = i;
                break;

            case ProgressType.DISTANCERECORD:
                i        = new progressInterval(ProgressType.DISTANCERECORD, n, ((RecordsDistance)n).record, ContractDefs.Progression.MaxDistanceRecord, 1000, ContractDefs.Progression.RecordSplit, d, t, u);
                distance = i;
                break;

            case ProgressType.SPEEDRECORD:
                i     = new progressInterval(ProgressType.SPEEDRECORD, n, ((RecordsSpeed)n).record, ContractDefs.Progression.MaxSpeedRecord, 5, ContractDefs.Progression.RecordSplit, d, t, u);
                speed = i;
                break;

            default:
                return;
            }

            if (i == null)
            {
                return;
            }

            intervalNodes.Add(n.Id, i);
        }
        private void onComplete(ProgressNode node)
        {
            if (node == null)
            {
                return;
            }

            if (!node.IsComplete)
            {
                return;
            }

            if (!progressParser.isIntervalType(node))
            {
                if (progressParser.isPOI(node))
                {
                    progressStandard s = progressParser.getPOINode(node.Id);

                    if (s == null)
                    {
                        Debug.Log("[Progress Tracking Parser] POI Progress Node Not Found");
                    }
                    else
                    {
                        s.calculateRewards(null);
                        s.NoteReference = progressParser.vesselNameFromNode(node);

                        try
                        {
                            s.Time = (double)node.GetType().GetField("AchieveDate", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(node);
                        }
                        catch (Exception e)
                        {
                            Debug.LogWarning("[Progress Tracking Parser] Error In Detecting Progress Node Achievement Date\n" + e);
                        }
                    }
                }
                else
                {
                    progressStandard s = progressParser.getStandardNode(node.Id);

                    if (s != null)
                    {
                        s.calculateRewards(null);
                        string note = progressParser.crewNameFromNode(node);

                        if (string.IsNullOrEmpty(note))
                        {
                            note = progressParser.vesselNameFromNode(node);
                        }

                        s.NoteReference = note;

                        try
                        {
                            s.Time = (double)node.GetType().GetField("AchieveDate", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(node);
                        }
                        catch (Exception e)
                        {
                            Debug.LogWarning("[Progress Tracking Parser] Error In Detecting Progress Node Achievement Date\n" + e);
                        }
                    }
                    else
                    {
                        CelestialBody body = progressParser.getBodyFromType(node);

                        if (body == null)
                        {
                            Debug.Log("[Progress Tracking Parser] Body From Progress Node Null...");
                        }
                        else
                        {
                            progressBodyCollection b = progressParser.getProgressBody(body);

                            if (b != null)
                            {
                                progressStandard sb = b.getNode(node.Id);

                                if (sb == null)
                                {
                                    Debug.Log("[Progress Tracking Parser] Body Sub Progress Node Not Found");
                                }
                                else
                                {
                                    sb.calculateRewards(body);
                                    string note = progressParser.crewNameFromNode(node);

                                    if (string.IsNullOrEmpty(note))
                                    {
                                        note = progressParser.vesselNameFromNode(node);
                                    }

                                    sb.NoteReference = note;

                                    try
                                    {
                                        sb.Time = (double)node.GetType().GetField("AchieveDate", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(node);
                                    }
                                    catch (Exception e)
                                    {
                                        Debug.LogWarning("[Progress Tracking Parser] Error In Detecting Progress Node Achievement Date\n" + e);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                progressInterval i = progressParser.getIntervalNode(node.Id);

                if (i == null)
                {
                    Debug.Log("[Progress Tracking Parser] Interval Progress Node Not Found");
                }
                else
                {
                    if (node.IsReached)
                    {
                        i.calculateRewards(i.Interval);
                        i.Interval += 1;
                    }
                }
            }

            progressParser.updateCompletionRecord();
        }
		private static void addProgressInterval(ProgressType p, ProgressNode n, string d = "")
		{
			if (n == null)
				return;

			if (intervalNodes.Contains(n.Id))
				return;

			progressInterval i = null;
			
			switch (p)
			{
				case ProgressType.ALTITUDERECORD:
					i = new progressInterval(ProgressType.ALTITUDERECORD, n, ((RecordsAltitude)n).record, getMaxAltitudeRecord, 500, ContractDefs.Progression.RecordSplit, d);
					altitude = i;
					break;
				case ProgressType.DEPTHRECORD:
					i = new progressInterval(ProgressType.DEPTHRECORD, n, ((RecordsDepth)n).record, ContractDefs.Progression.MaxDepthRecord, 10, ContractDefs.Progression.RecordSplit, d);
					depth = i;
					break;
				case ProgressType.DISTANCERECORD:
					i = new progressInterval(ProgressType.DISTANCERECORD, n, ((RecordsDistance)n).record, ContractDefs.Progression.MaxDistanceRecord, 1000, ContractDefs.Progression.RecordSplit, d);
					distance = i;
					break;
				case ProgressType.SPEEDRECORD:
					i = new progressInterval(ProgressType.SPEEDRECORD, n, ((RecordsSpeed)n).record, ContractDefs.Progression.MaxSpeedRecord, 5, ContractDefs.Progression.RecordSplit, d);
					speed = i;
					break;
				default:
					return;
			}

			if (i == null)
				return;

			intervalNodes.Add(n.Id, i);
		}
        private void buildIntervalNode(int id, progressInterval p, int size, ref Rect r)
        {
            GUILayout.BeginHorizontal();
            GUILayout.Space(20);

            if (popup)
                GUILayout.Label(p.Descriptor, contractSkins.progressBodyTitleBehind, GUILayout.MaxWidth(160 + size * 30));
            else
            {
                if (GUILayout.Button(p.Descriptor, contractSkins.progressBodyTitle, GUILayout.MaxWidth(160 + size * 30)))
                {
                    p.ShowRecords = !p.ShowRecords;
                }
            }
            GUILayout.EndHorizontal();

            if (p.ShowRecords)
            {
                for (int i = 1; i < p.Interval; i++)
                {
                    GUILayout.Label(p.Descriptor + " Record " + i.ToString() + ": " + p.getRecord(i).ToString(), contractSkins.progressNodeTitle, GUILayout.MaxWidth(165 + size * 30));

                    r = GUILayoutUtility.GetLastRect();

                    //Only draw the rewards if they are visible in the window
                    if (r.yMin >= (scroll.y - 20) && r.yMax <= (scroll.y + WindowRect.height - (20 + size * 6)))
                    {
                        Rect rewardsRect = r;
                        rewardsRect.x = 180 + (size * 30);
                        rewardsRect.y += (2 + (size * 2));

                        scaledContent(ref rewardsRect, p.getFundsString(i), "", Currency.Funds, size, true, false);

                        scaledContent(ref rewardsRect, p.getScienceString(i), "", Currency.Science, size, true, false);

                        scaledContent(ref rewardsRect, p.getRepString(i), "", Currency.Reputation, size, true, false);
                    }
                }
            }
        }
Example #6
0
        private void drawIntervalRecords(progressInterval p, int index)
        {
            GUILayout.Label(string.Format(p.Descriptor + " Record {0}: {1}", index, p.getRecord(index)), CapComSkins.parameterText);

            GUILayout.Label("Rewards: ", CapComSkins.headerText, GUILayout.Width(80));

            sizedContent(p.getFundsString(index), p.getScienceString(index), p.getRepString(index), TransactionReasons.ContractReward);
        }