public override void GenerateEvents()
{
eventList = new List <Event>(eventCount);
int longNoteType = GetHeader <int>("LNTYPE");
Dictionary <int, LongNoteEvent> lastLNEvent = new Dictionary <int, LongNoteEvent>();
Dictionary <int, LongNoteEvent> startLNEvent = new Dictionary <int, LongNoteEvent>();
Dictionary <int, NoteEvent> lastPlayerEvent = new Dictionary <int, NoteEvent>();
long pulse = 0;
double currentBpm = bpmObjects[0];
double meter = 1.0;
if (longNoteType == 2)
{
// insert empty measure at the end to close longnotes ending at last beat (#LNTYPE 2)
int measureIndex = 0;
if (measureList.Count > 0)
{
measureIndex = measureList[measureList.Count - 1].index + 1;
}
BMSMeasure measure = new BMSMeasure(measureIndex);
measureList.Add(measure);
}
foreach (BMSMeasure measure in measureList)
{
List <Event> measureEvents = new List <Event>();
// check if long notes should be ended at previous measure (#LNTYPE 2)
if (longNoteType == 2 && lastLNEvent.Count > 0)
{
List <int> keys = lastLNEvent.Keys.ToList();
foreach (var lnChannel in keys)
{
bool breakNote = true;
for (int i = 0; i < measure.channelList.Count; i++)
{
if (measure.channelList[i].index != lnChannel)
{
continue;
}
else if (measure.channelList[i].values.Count > 0 &&
measure.channelList[i].values[0] != 0)
{
breakNote = false;
break;
}
}
if (breakNote)
{
// LN section ended at the last note in previous measure,
// and does not continue in next measure, so restore the
// last skipped event, and end the long note there.
LongNoteEvent lastEvent = lastLNEvent[lnChannel];
LongNoteEvent startEvent = startLNEvent[lnChannel];
LongNoteEndEvent endEvent = new LongNoteEndEvent(pulse, lastEvent.sound, lastEvent.lane, startEvent);
startEvent.endNote = endEvent;
eventList.Add(endEvent);
lastLNEvent.Remove(lnChannel);
startLNEvent.Remove(lnChannel);
}
}
}
// reset meter back to 1.0
if (meter != measure.meter)
{
MeterEvent measureEvent = new MeterEvent(pulse, measure.meter);
eventList.Add(measureEvent);
timeEventList.Add(measureEvent);
}
meter = measure.meter;
// mark measure position
measureCount++;
measurePositions.Add(new Tuple <int, long>(measure.index, pulse));
MeasureMarkerEvent measureMarker = new MeasureMarkerEvent(pulse);
eventList.Add(measureMarker);
double nextBpm = 0.0;
Dictionary <long, double> bpmExValues = new Dictionary <long, double>();
foreach (BMSChannel channel in measure.channelList)
{
long channelPulse = pulse;
long beatPulse = (resolution * 4) / channel.values.Count;
int lane = BMSChannel.GetLaneIndex(channel.index, playerChannels, players);
bool isLongChannel = BMSChannel.IsLong(channel.index);
for (int i = 0; i < channel.values.Count; i++, channelPulse += beatPulse)
{
int value = channel.values[i];
if (value == 0 && !isLongChannel)
{
continue;
}
Event bmsEvent = null;
if (BMSChannel.IsSound(channel.index))
{
SoundObject sound = null;
soundObjects.TryGetValue(value, out sound);
if (channel.index == (int)BMSChannel.Type.BGM)
{
bmsEvent = new SoundEvent(channelPulse, sound);
}
else if (BMSChannel.IsInvisible(channel.index))
{
bmsEvent = new KeySoundChangeEvent(channelPulse, sound, lane);
}
else if (BMSChannel.IsLandmine(channel.index))
{
// landmine does damage based on the object value itself,
// and plays the hit sound from WAV00.
int damage = value;
soundObjects.TryGetValue(0, out sound);
bmsEvent = new LandmineEvent(channelPulse, sound, lane, damage);
}
else
{
NoteEvent noteEvent = null;
bool isLnObj = lnObjects.Contains(value);
if (isLongChannel || isLnObj)
{
LongNoteEvent longNoteEvent = new LongNoteEvent(channelPulse, sound, lane, null);
if (longNoteType == 2)
{
// ignore section filler events with #LNTYPE 2
// skip all the events except the first one, and restore the last
// skipped event at the end of long note.
if (lastLNEvent.ContainsKey(channel.index))
{
if (value != 0)
{
lastLNEvent[channel.index] = longNoteEvent;
continue;
}
else
{
// long note breaks here,
// replace current event with last skipped LN event.
LongNoteEvent startEvent = startLNEvent[channel.index];
LongNoteEndEvent endEvent = new LongNoteEndEvent(channelPulse, sound, lane, startEvent);
startEvent.endNote = endEvent;
lastLNEvent.Remove(channel.index);
startLNEvent.Remove(channel.index);
noteEvent = endEvent;
}
}
else if (value != 0)
{
lastLNEvent.Add(channel.index, longNoteEvent);
startLNEvent.Add(channel.index, longNoteEvent);
noteEvent = longNoteEvent;
}
}
else if (longNoteType == 1 && value != 0)
{
LongNoteEvent lastLongNote = null;
if (isLnObj)
{
NoteEvent lastEvent = lastPlayerEvent[lane];
if (lastEvent != null)
{
lastPlayerEvent[lane] = null;
lastLongNote = new LongNoteEvent(lastEvent.pulse, lastEvent.sound, lastEvent.lane, null);
bool foundNote = false;
for (int j = measureEvents.Count - 1; j >= 0; j--)
{
if (measureEvents[j] != lastEvent)
{
continue;
}
measureEvents[j] = lastLongNote;
foundNote = true;
break;
}
if (!foundNote)
{
for (int j = eventList.Count - 1; j >= 0; j--)
{
if (eventList[j] != lastEvent)
{
continue;
}
eventList[j] = lastLongNote;
foundNote = true;
break;
}
}
if (!foundNote)
{
throw new ApplicationException("Could not find long note starting point");
}
}
else
{
noteEvent = new NoteEvent(channelPulse, sound, lane);
}
}
else
{
lastLNEvent.TryGetValue(channel.index, out lastLongNote);
}
if (lastLongNote != null)
{
LongNoteEvent startEvent = lastLongNote;
LongNoteEndEvent endEvent = new LongNoteEndEvent(channelPulse, sound, lane, startEvent);
startEvent.endNote = endEvent;
lastLNEvent.Remove(channel.index);
SoundObject releaseSound = null;
if (startEvent.sound != sound && sound != null)
{
// play sound on release
releaseSound = sound;
}
noteEvent = endEvent;
}
else if (isLongChannel)
{
lastLNEvent.Add(channel.index, longNoteEvent);
noteEvent = longNoteEvent;
}
}
}
else
{
noteEvent = new NoteEvent(channelPulse, sound, lane);
lastPlayerEvent[lane] = noteEvent;
}
bmsEvent = noteEvent;
}
}
else if (channel.index == (int)BMSChannel.Type.BPM)
{
bmsEvent = new BPMEvent(channelPulse, value);
nextBpm = value;
}
else if (channel.index == (int)BMSChannel.Type.BPMExtended)
{
double bpmValue = 0.0;
if (bpmObjects.TryGetValue(value, out bpmValue) && bpmValue != 0.0)
{
bmsEvent = new BPMEvent(channelPulse, bpmValue);
nextBpm = bpmValue;
bpmExValues.Add(channelPulse, bpmValue);
}
}
else if (channel.index == (int)BMSChannel.Type.Stop)
{
double stopValue = 0;
stopObjects.TryGetValue(value, out stopValue);
long stopTime = (long)(stopValue / 192.0 * resolution * 4);
bmsEvent = new StopEvent(channelPulse, stopTime);
}
else if (channel.index == (int)BMSChannel.Type.BGA ||
channel.index == (int)BMSChannel.Type.BGALayer ||
channel.index == (int)BMSChannel.Type.BGAPoor)
{
BGAObject bga = null;
bgaObjects.TryGetValue(value, out bga);
BGAEvent.BGAType type = BGAEvent.BGAType.BGA;
if (channel.index == (int)BMSChannel.Type.BGALayer)
{
type = BGAEvent.BGAType.LayerTransparentBlack;
}
else if (channel.index == (int)BMSChannel.Type.BGAPoor)
{
type = BGAEvent.BGAType.Poor;
}
bmsEvent = new BGAEvent(channelPulse, bga, type);
}
else
{
Log.Warning("Unsupported BMS channel: " + channel.index.ToString("X2"));
}
if (bmsEvent == null)
{
continue;
}
measureEvents.Add(bmsEvent);
}
}
pulse += resolution * 4;
measureEvents.Sort(new Comparison <Event>((e1, e2) =>
{
return(e1.pulse > e2.pulse ? 1 : (e1.pulse < e2.pulse ? -1 :
e1 is StopEvent ? 1 : (e2 is StopEvent ? -1 :
e1 is BPMEvent ? 1 : (e2 is BPMEvent ? -1 : 0))));
}));
foreach (Event bmsEvent in measureEvents)
{
NoteEvent noteEvent = bmsEvent as NoteEvent;
if (noteEvent != null)
{
playerEventCount++;
if (noteEvent is LandmineEvent)
{
landmineCount++;
}
else
{
noteCount++;
if (noteEvent is LongNoteEvent)
{
longNoteCount++;
}
}
}
else if (bmsEvent is BPMEvent)
{
// on overlap, prefer extended BPM (xxx08) changes over basic (xxx03) values
double otherBpm;
if (bpmExValues.TryGetValue(bmsEvent.pulse, out otherBpm))
{
if (otherBpm != (bmsEvent as BPMEvent).bpm)
{
continue;
}
}
timeEventList.Add(bmsEvent);
}
else if (bmsEvent is StopEvent)
{
timeEventList.Add(bmsEvent);
}
eventList.Add(bmsEvent);
}
}
GenerateTimestamps();
if (eventList.Count > 0)
{
songLength = eventList[eventList.Count - 1].timestamp;
}
}
private void OnChannel(BMSChart data, string line, ref BMSMeasure lastMeasure)
{
// channel sentences
// # <measure:3> <channel:2> : <object data>
// for object data, 00 = musical rest
if (headerOnly)
{
return;
}
int measureIndex;
int channelIndex;
string channelValue;
if (!ParseChannelLine(line, out measureIndex, out channelIndex, out channelValue))
{
Log.Error("Invalid channel line");
return;
}
if (channelRefs.ContainsKey(channelIndex))
{
channelRefs[channelIndex]++;
}
else
{
channelRefs.Add(channelIndex, 1);
}
if (!BMSChannel.IsSupported(channelIndex))
{
Log.Error("Unsupported channel type " + line.Substring(4, 2));
return;
}
bool isSoundChannel = BMSChannel.IsSound(channelIndex);
bool isPlayerChannel = BMSChannel.IsPlayer(channelIndex);
BMSMeasure measure = null;
if (lastMeasure != null && lastMeasure.index == measureIndex)
{
measure = lastMeasure;
}
else
{
measure = data.GetMeasure(measureIndex);
if (measure == null)
{
measure = new BMSMeasure(measureIndex);
data.measureList.Add(measure);
}
}
lastMeasure = measure;
int channelLength = 1;
if (channelIndex == (int)BMSChannel.Type.Meter)
{
double meter = 1.0;
if (!double.TryParse(channelValue,
NumberStyles.Float, CultureInfo.InvariantCulture, out meter))
{
channelValue = channelValue.Replace(",", ".");
if (!double.TryParse(channelValue,
NumberStyles.Float, CultureInfo.InvariantCulture, out meter))
{
Log.Error("Unable to parse meter value: " + channelValue.ToString());
}
}
measure.meter = meter;
}
else
{
channelLength = channelValue.Length / 2;
if (channelValue.Length % 2 != 0)
{
Log.Warning("Channel data length not divisible by 2");
}
List <int> objects = new List <int>(channelLength);
for (int i = 0; i < channelValue.Length; i += 2)
{
int value;
if (channelIndex == (int)BMSChannel.Type.BPM)
{
string bpmStr = channelValue.Substring(i, 2);
if (!int.TryParse(bpmStr, NumberStyles.HexNumber,
CultureInfo.InvariantCulture, out value))
{
Log.Warning("Invalid BPM value in channel line: " + bpmStr);
channelLength = objects.Count;
break;
}
}
else
{
if (!Utility.TryFromBase36(channelValue[i], channelValue[i + 1], out value))
{
Log.Warning("Invalid value in channel line: " + channelValue.Substring(i, 2));
channelLength = objects.Count;
break;
}
}
objects.Add(value);
if (value != 0)
{
data.eventCount++;
}
}
// new channel data is applied to existing channel data (excluding BGM channel)
if (channelIndex != (int)BMSChannel.Type.BGM && !BMSChannel.IsLong(channelIndex) &&
measure.HasChannel(channelIndex))
{
int longNoteType = data.GetHeader <int>("LNTYPE");
foreach (BMSChannel channel in measure.channelList)
{
if (channel.index != channelIndex)
{
continue;
}
// when merging data with LNTYPE 2, section filler must not be
// filled with 0's in order to not close the long notes at wrong times.
bool lnWorkaround = longNoteType == 2 && BMSChannel.IsLong(channel.index);
BMSChannel.MergeChannels(channel, objects, lnWorkaround);
channelLength = channel.values.Count;
break;
}
}
else if (objects.Count > 0)
{
measure.Add(channelIndex, objects);
}
}
if (channelLength > measure.maxLength)
{
measure.maxLength = channelLength;
}
}
