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;
}
}
protected void ProcessEvent(int index)
{
Event currentEvent = eventList[index];
if (currentEvent is MeterEvent)
{
OnMeter(currentEvent as MeterEvent);
}
else if (currentEvent is BPMEvent)
{
OnBPM(currentEvent as BPMEvent);
}
else if (currentEvent is SoundEvent)
{
SoundEvent soundEvent = currentEvent as SoundEvent;
KeySoundChangeEvent keySoundEvent = soundEvent as KeySoundChangeEvent;
OnSoundObject(soundEvent.sound);
if (keySoundEvent != null)
{
OnPlayerKeyChange(keySoundEvent);
}
else
{
OnBGM(soundEvent);
}
}
else if (currentEvent is NoteEvent)
{
NoteEvent noteEvent = currentEvent as NoteEvent;
LandmineEvent landmineEvent = noteEvent as LandmineEvent;
LongNoteEvent longNoteEvent = noteEvent as LongNoteEvent;
LongNoteEndEvent longNoteEndEvent = noteEvent as LongNoteEndEvent;
foreach (SoundObject sound in noteEvent.sounds)
{
OnSoundObject(sound);
}
if (landmineEvent != null)
{
OnLandmine(noteEvent);
}
else if (longNoteEndEvent != null)
{
OnPlayerKeyLongEnd(longNoteEndEvent);
}
else if (longNoteEvent != null)
{
OnPlayerKeyLong(longNoteEvent);
}
else
{
OnPlayerKey(noteEvent);
}
}
else if (currentEvent is StopEvent)
{
OnStop(currentEvent as StopEvent);
}
else if (currentEvent is BGAEvent)
{
BGAEvent bgaEvent = currentEvent as BGAEvent;
OnBGAObject(bgaEvent);
OnBGA(bgaEvent);
}
else if (currentEvent is MeasureMarkerEvent)
{
OnMeasureChange(currentEvent as MeasureMarkerEvent);
}
}