static ActionHistory.Action[] CapPrevAndNextPreInsert(Starpower sp, Chart chart)
    {
        List <ActionHistory.Action> record = new List <ActionHistory.Action>();
        int arrayPos = SongObjectHelper.FindClosestPosition(sp, chart.starPower);

        if (arrayPos != SongObjectHelper.NOTFOUND)       // Found an object that matches
        {
            if (chart.starPower[arrayPos] < sp)
            {
                ++arrayPos;
            }

            if (arrayPos > 0 && chart.starPower[arrayPos - 1].tick < sp.tick)
            {
                Starpower prevSp = chart.starPower[arrayPos - 1];
                // Cap previous sp
                if (prevSp.tick + prevSp.length > sp.tick)
                {
                    Starpower originalPrev = (Starpower)prevSp.Clone();

                    prevSp.length = sp.tick - prevSp.tick;
                    record.Add(new ActionHistory.Modify(originalPrev, prevSp));
                }
            }

            if (arrayPos < chart.starPower.Count && chart.starPower[arrayPos].tick > sp.tick)
            {
                Starpower nextSp = chart.starPower[arrayPos];

                // Cap self
                if (sp.tick + sp.length > nextSp.tick)
                {
                    Starpower originalNext = (Starpower)nextSp.Clone();
                    sp.length = nextSp.tick - sp.tick;
                    record.Add(new ActionHistory.Modify(originalNext, nextSp));
                }
            }
        }

        return(record.ToArray());
    }
Exemplo n.º 2
0
    static void CapPrevAndNextPreInsert(Starpower sp, Chart chart, IList <SongObject> overwrittenList, IList <SongObject> validatedList)
    {
        int arrayPos = SongObjectHelper.FindClosestPosition(sp, chart.chartObjects);

        if (arrayPos != SongObjectHelper.NOTFOUND)       // Found an object that matches
        {
            Starpower previousSp = null;
            Starpower nextSp     = null;

            bool currentArrayPosIsStarpower = chart.chartObjects[arrayPos] as Starpower == null;

            // Find the previous starpower
            {
                int previousSpIndex = currentArrayPosIsStarpower ? arrayPos - 1 : arrayPos;
                while (previousSpIndex >= 0 && chart.chartObjects[previousSpIndex].tick < sp.tick)
                {
                    Starpower maybeSp = chart.chartObjects[previousSpIndex] as Starpower;
                    if (maybeSp == null)
                    {
                        --previousSpIndex;
                    }
                    else
                    {
                        previousSp = maybeSp;
                        break;
                    }
                }
            }

            // Find the next starpower
            {
                int nextSpIndex = currentArrayPosIsStarpower ? arrayPos + 1 : arrayPos;
                while (nextSpIndex < chart.chartObjects.Count && chart.chartObjects[nextSpIndex].tick > sp.tick)
                {
                    Starpower maybeSp = chart.chartObjects[nextSpIndex] as Starpower;
                    if (maybeSp == null)
                    {
                        ++nextSpIndex;
                    }
                    else
                    {
                        nextSp = maybeSp;
                        break;
                    }
                }
            }

            if (previousSp != null)
            {
                // Cap previous sp
                if (previousSp.tick + previousSp.length > sp.tick)
                {
                    previousSp.Delete();
                    overwrittenList.Add(previousSp.Clone());

                    uint      newLength = sp.tick - previousSp.tick;
                    Starpower newSp     = new Starpower(previousSp.tick, newLength);
                    chart.Add(newSp);
                    validatedList.Add(newSp);
                }
            }

            if (nextSp != null)
            {
                // Cap self
                if (sp.tick + sp.length > nextSp.tick)
                {
                    sp.length = nextSp.tick - sp.tick;
                }
            }
        }
    }