/// <summary>
/// 设置容器单元格
/// </summary>
/// <param name="cellWidth">单元格宽</param>
/// <param name="cellHeight">单元格高</param>
/// <param name="arrangement">单元格滑动方向 [水平 or 垂直]</param>
/// <param name="upperLimitIndex">超过最大上限，进行垃圾回收</param>
/// <param name="lowerLimitIndex">超过最大下限，进行资源加载</param>
/// <param name="cellHeightSpace">单元格与单元格之间的高度</param>
/// <param name="cellWidthSpace">单元格与单元格之间的宽度</param>
/// <param name="maxPerLine">这个根据 单元格滑动方向来定， 垂直 ，就是每行最多有多少个单元格 水平表示每列最多有多少单元格</param>
protected void SetData(int cellWidth, int cellHeight, Arrangement arrangement, int upperLimitIndex = 0, int lowerLimitIndex = 0,
int cellHeightSpace = 0, int cellWidthSpace = 0, int maxPerLine = 1)
{
this.CellWidth = cellWidth;
this.CellHeight = cellHeight;
this.CellWidthSpace = cellWidthSpace;
this.CellHeightSpace = cellHeightSpace;
this.MaxPerLine = maxPerLine;
this._Arranement = arrangement;
switch (arrangement)
{
case Arrangement.Horizontal:
scroRect.vertical = false;
break;
case Arrangement.Vertical:
scroRect.horizontal = false;
break;
default:
scroRect.horizontal = true;
scroRect.vertical = true;
break;
}
}
public ActionResult Create(Arrangement item)
{
ArrangementStatus status;
IQueryable <int> qry;
if (!ModelState.IsValid)
{
return(View(item));
}
qry = from x in db.Arrangements
where x.Year == item.Year
orderby x.Serial descending
select x.Serial;
item.Status = (int)StatusEnum.Status01;
item.Year = DateTime.Today.Year;
item.Serial = qry.FirstOrDefault() + 1;
status = new ArrangementStatus
{
ArrangementYear = item.Year,
ArrangementSerial = item.Serial,
CreatorId = User.Identity.Name,
Date = DateTime.Now,
Status = item.Status,
Comment = Mictlanix.Iam.Properties.Resources.NewStatusComment
};
db.Arrangements.Add(item);
db.Statuses.Add(status);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public LegendItemBlockContainer(Arrangement arrangement, Dataset dataset, IComparable seriesKey)
: base(arrangement)
{
LegendItemBlockContainer itemBlockContainer = this;
this.dataset = dataset;
this.seriesKey = seriesKey;
}
public void player_transcribes_arrangement_correctly_and_in_time()
{
var kickPattern = new Pattern("|X|_|_|_|X|_|_|_|X|_|_|_|X|_|_|_|");
var snarePattern = new Pattern("|_|_|_|_|X|_|_|_|_|_|_|_|X|_|_|_|");
var hiHatPattern = new Pattern("|_|_|X|_|_|_|X|_|_|_|X|_|_|_|X|_|");
var kickTrack = new Track(kickPattern, new Sound("Kick"));
var snareTrack = new Track(snarePattern, new Sound("Snare"));
var hiHatTrack = new Track(hiHatPattern, new Sound("HiHat"));
var arrangementTracks = new List <Track>
{
kickTrack,
snareTrack,
hiHatTrack
};
var arrangement = new Arrangement(arrangementTracks);
var player = new Player(arrangement, 120);
var writer = new StringWriter();
Stopwatch sw = new Stopwatch();
sw.Start();
player.TranscribeArrangement(writer);
sw.Stop();
Assert.AreEqual(sw.ElapsedMilliseconds < 2100, true);
Assert.AreEqual(sw.ElapsedMilliseconds > 1800, true);
Assert.AreEqual(writer.GetCurrentString(), "|Kick|_|HiHat|_|Kick+Snare|_|HiHat|_|Kick|_|HiHat|_|Kick+Snare|_|HiHat|_|\r\n");
}
public void ExportFile_WithCrawlResultsModel_ShouldSaveFile()
{
// Act
var filename = "testFile";
var arrangement = new Arrangement();
var links = new List <string>();
var models = new List <CrawlModel>();
links.Add("testpage1.com");
var model = new CrawlModel()
{
Page = "testpage.com",
Links = links
};
models.Add(model);
var crawlResults = new CrawlResultModel()
{
FileName = filename,
CrawlModels = models
};
// Arrange
arrangement.SUT.ExportFile(crawlResults);
// Assert
File.Exists(filename + ".json").Should().BeTrue();
}
private List <PriceZone> GeneratePriceZones(Arrangement arrangement, List <Seat> allSeats)
{
var priceZones = new List <PriceZone>();
foreach (var sector in arrangement.Sectors)
{
Price regularPrice = GetRegularPriceLevels()[sector.DataQuality];
var discoundedPrice = GetDiscoundedPriceLevels()[sector.DataQuality];
var priceZone = new PriceZone
{
ScenePriceZoneId = sector.PriceZoneId,
Name = sector.Name,
Seats = allSeats.Where(x => sector.Seats.Any(s => s.Id == x.SceneSeatId)).ToList(),
Options = new List <PriceOption>
{
new PriceOption {
Name = "Regular", Price = regularPrice
},
new PriceOption {
Name = "Discounted", Price = discoundedPrice
},
}
};
priceZones.Add(priceZone);
}
return(priceZones);
}
private static void CalculateArrangements(List <string[]> permutations)
{
var arrangements = new List <Arrangement>();
foreach (var permutation in permutations)
{
var arrangement = new Arrangement();
foreach (var guest in permutation)
{
arrangement.Guests.Add(guest);
}
for (int i = 0; i < _totalGuests; i++)
{
var guest = permutation[i];
var toLeft = permutation[i - 1 < 0 ? _totalGuests - 1 : i - 1];
var toLeftHappiness = _guests.First(x => x.Name == guest && x.NextTo == toLeft).Happiness;
arrangement.TotalHappiness += toLeftHappiness;
var toRight = permutation[i + 1 > _totalGuests - 1 ? 0 : i + 1];
var toRightHappiness = _guests.First(x => x.Name == guest && x.NextTo == toRight).Happiness;
arrangement.TotalHappiness += toRightHappiness;
}
arrangements.Add(arrangement);
}
CustomConsoleColour.SetAnswerColour();
Console.WriteLine($"{arrangements.Max(x => x.TotalHappiness)}");
Console.ResetColor();
}
public LegendItemBlockContainer(Arrangement arrangement, int datasetIndex, int series)
: base(arrangement)
{
LegendItemBlockContainer itemBlockContainer = this;
this.datasetIndex = datasetIndex;
this.series = series;
}
public ActionResult ChangeStatus(ArrangementStatus item)
{
if (ModelState.IsValid)
{
// guardar ArrangementStatus en la db
// cambiar estado al Arrangement
Arrangement arrangement = db.Arrangements.Find(item.ArrangementYear, item.ArrangementSerial);
//DateTime date = DateTime.Parse(Request.Params["SessionDate"]);
if (item.StatusEnum == StatusEnum.Status09)
{
arrangement.SessionDate = item.SessionDate;
}
if (item.StatusEnum == StatusEnum.Status10)
{
arrangement.Session = item.Session;
}
arrangement.Status = item.Status;
item.Arrangement = arrangement;
item.Date = DateTime.Now;
item.CreatorId = User.Identity.Name;
db.Statuses.Add(item);
db.Configuration.ValidateOnSaveEnabled = false;
db.SaveChanges();
db.Configuration.ValidateOnSaveEnabled = true;
return(RedirectToAction("Index"));
}
return(View(item));
}
public static void UpdateXml(Arrangement arr, DLCPackageData info)
{
arr.SongFile = new RocksmithToolkitLib.DLCPackage.AggregateGraph.SongFile {
File = ""
};
arr.Id = IdGenerator.Guid();
arr.MasterId = RandomGenerator.NextInt();
// update xml with user modified DLCPackageData info
var songXml = Song2014.LoadFromFile(arr.SongXml.File);
songXml.AlbumName = info.SongInfo.Album;
songXml.AlbumYear = info.SongInfo.SongYear.ToString();
songXml.ArtistName = info.SongInfo.Artist;
songXml.ArtistNameSort = info.SongInfo.ArtistSort;
songXml.AverageTempo = info.SongInfo.AverageTempo;
songXml.Title = info.SongInfo.SongDisplayName;
songXml.ToneBase = arr.ToneBase;
songXml.ToneA = arr.ToneA;
songXml.ToneB = arr.ToneB;
songXml.ToneC = arr.ToneC;
songXml.ToneD = arr.ToneD;
using (var stream = File.Open(arr.SongXml.File, FileMode.Create))
songXml.Serialize(stream, true);
}
public void ArrangeSelectedImages(Arrangement arrangement, int spacing, int margin)
{
using (new OperationWrapper(this))
{
_positionManager.DoPositionSelectedImages(arrangement, spacing, margin);
}
}
private void Form1_Load(object sender, EventArgs e)
{
int left = 30; int top = 30;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
arrArray[total] = new Arrangement();
arrArray[total].left = left;
arrArray[total].top = top;
arrArray[total].location = -1;
if (total != 8)
{
Button btn = new Button();
btn.Left = left;
btn.Top = top;
btn.Width = 50;
btn.Height = 50;
btn.Text = (total + 1).ToString();
buttons[total] = btn;
arrArray[total].location = total;
this.Controls.Add(btn);
}
total += 1;
left += 50;
}
left = 30;
top += 50;
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
ReservationManager rm = new ReservationManager(new UnitOfWork(new ReservationContextTest()));
Client client = new Client(999, "Alice", "Cards", ClientCategory.Vip, new Address());
rm.AddClient(client);
Location start = Location.Antwerpen;
Location stop = Location.Brussel;
List <Price> prices = new List <Price>();
prices.Add(new Price(Arrangement.Airport, 100m));
prices.Add(new Price(Arrangement.Business, 100m));
prices.Add(new Price(Arrangement.NightLife, 900m));
prices.Add(new Price(Arrangement.Wedding, 800m));
prices.Add(new Price(Arrangement.Wellness, 750m));
Car car = new Car("RabbitHole", "Delux", "Brown", prices);
DeliveryAddress address = new DeliveryAddress("Teaparty", "1", "Wonderland");
rm.AddCar(car);
DateTime startTime = new DateTime(2020, 12, 12, 13, 0, 0);
Arrangement arrangement = Arrangement.Wedding;
DateTime endTime = new DateTime(2020, 12, 13, 0, 0, 0);
ReservationOverview reservationOverview = rm.CreateOverview(rm.CreateReservation(client, start, stop, car, startTime, arrangement, endTime, address));
// FileReader.AddClients();
// FileReader.AddCars();
Console.ReadKey();
}
/// <summary>
/// Preferred Write method
/// <para>Detects the Arrangment Tuning correctly</para>
/// </summary>
/// <param name="arr"></param>
/// <param name="outputFile"></param>
/// <param name="platform"></param>
public static void Write(Arrangement arr, string outputFile, Platform platform)
{
using (var reader = new StreamReader(arr.SongXml.File))
{
var bitConverter = platform.GetBitConverter;
if (arr.ArrangementType == ArrangementType.Vocal)
{
var serializer = new XmlSerializer(typeof(Vocals));
var vocals = (Vocals)serializer.Deserialize(reader);
WriteVocalsFile(vocals, outputFile, bitConverter);
}
else
{
var serializer = new XmlSerializer(typeof(Song));
var song = (Song)serializer.Deserialize(reader);
// apply proper fix for null tuning
var tuning = new Int16[] { 0, 0, 0, 0, 0, 0 };
if (arr.TuningStrings != null)
{
tuning = arr.TuningStrings.ToArray();
}
WriteSngFile(song, InstrumentTuningExtensions.GetTuningByOffsets(tuning), arr.ArrangementType, outputFile, bitConverter);
}
}
}
private void OnZoekBeschikbareLimosClick(object sender, RoutedEventArgs e)
{
//DateTime? startDatum = StartDatumDatePicker.SelectedDate;
//DateTime? eindDatum = EindDatumDatePicker.SelectedDate;
DateTime startDatum;
DateTime eindDatum;
if (StartDatumDatePicker.SelectedDate == null)
{
startDatum = DateTime.MinValue;
}
else
{
startDatum = (DateTime)StartDatumDatePicker.SelectedDate;
}
if (EindDatumDatePicker.SelectedDate == null)
{
eindDatum = DateTime.MaxValue;
}
else
{
eindDatum = (DateTime)EindDatumDatePicker.SelectedDate;
}
Locatie startLocatie = (Locatie)StartLocatieComboBox.SelectionBoxItem;
Arrangement arrangement = (Arrangement)ArrangementComboBox.SelectionBoxItem;
BeschikbareLimosListView.ItemsSource = _repo.OphalenLimosMetFilters(startDatum, eindDatum, startLocatie, arrangement);
}
/// <summary>
/// Constructs a new instance of the StyleEntry class.
/// </summary>
/// <param name="Arrange">The arrangement</param>
/// <param name="Part">The style part</param>
/// <param name="Instrument">The instrument</param>
/// <param name="ChordType">The chord family</param>
/// <param name="Message">The message</param>
public StyleEntry(Arrangement Arrange, StylePart Part, Instrument Instrument, ChordType ChordType, MidiMessage Message)
{
this.arrangement = Arrange;
this.part = Part;
this.instrument = Instrument;
this.chordType = ChordType;
this.message = Message;
}
public ResultWindow(Arrangement arrangement)
{
InitializeComponent();
var viewModel = new ViewModelResultWindow(arrangement);
DataContext = viewModel;
viewModel.CloseWindow += (sender, e) => { Close(); };
}
public Task RemoveAsync(Arrangement arrangement)
{
var intendedToDelete = _context.TagArrangement.Where(e => e.ArrangementId == arrangement.Id).ToList();
_context.TagArrangement.RemoveRange(intendedToDelete);
return(_context.SaveChangesAsync());
}
//GET: /Arrangement/Assign
public ViewResult Assign(int year, int serial)
{
Arrangement arrangement = db.Arrangements.Find(year, serial);
return(View("Assign", new Assignment {
Arrangement = arrangement, ArrangementYear = year, ArrangementSerial = serial
}));
}
//
// GET: /Arrangements/ChangeStatus/2011/1
public ActionResult ChangeStatus(int year, int serial)
{
Arrangement arrangement = db.Arrangements.Find(year, serial);
return(View(new ArrangementStatus {
ArrangementYear = year, ArrangementSerial = serial, Status = arrangement.Status
}));
}
public PriceCalculation(Arrangement arrangement, Limousine limousine, Client client, DateTime reservationDateStart, DateTime reservationDateEnd)
{
Hours = arrangement.GetHours(reservationDateStart, reservationDateEnd, limousine.FirstHourPrice);
Subtotal = (int)arrangement.Price;
ChargedDiscounts = CalculateChargedDiscounts(Subtotal, client);
TotalExclusiveVAT = Subtotal - ChargedDiscounts;
VATAmount = TotalExclusiveVAT * (Decimal)vatPercentage;
Total = TotalExclusiveVAT + VATAmount;
}
/// <summary>
/// Loads all the chords and notes for the arrangement
/// </summary>
public ArrangementObject LoadArrangement(Arrangement arrangment)
{
XmlDocument document = new XmlDocument();
using (var inputStream = File.OpenRead(source))
{
var psarc = new PlayStationArchive();
psarc.Read(inputStream, true);
try
{
foreach (var entry in psarc.TOC)
{
if (entry.Name.Contains("songs") && entry.Name.Contains("arr") && entry.Name.EndsWith("_" + arrangment.ToString() + ".xml"))
{
psarc.InflateEntry(entry);
using (var reader = new StreamReader(entry.Data, Encoding.UTF8))
{
document.LoadXml(reader.ReadToEnd());
}
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
if (psarc != null)
{
psarc.Dispose();
psarc = null;
}
}
}
float averageTempo = float.Parse(document.GetElementsByTagName("averageTempo")[0].InnerText, CultureInfo.InvariantCulture);
XmlNode node = document.GetElementsByTagName("transcriptionTrack")[0];
int noteCount = int.Parse(node["notes"].GetAttribute("count"));
int chordCount = int.Parse(node["chords"].GetAttribute("count"));
if (noteCount <= 0 && chordCount <= 0)
{
node = document.GetElementsByTagName("level")[0];
noteCount = int.Parse(node["notes"].GetAttribute("count"));
chordCount = int.Parse(node["chords"].GetAttribute("count"));
}
ArrangementObject newArrangement = new ArrangementObject(averageTempo,
noteCount, node["notes"].GetElementsByTagName("note"),
chordCount, node["chords"].GetElementsByTagName("chord"));
return(newArrangement);
}
public static bool ValidateExpiryDate(Arrangement item, int days)
{
if (item.ExpiryDate == null)
{
return(true);
}
return((item.ExpiryDate.Value - DateTime.Now).Days <= days);
}
private Yaku Toitoi(Arrangement arrangement)
{
if (arrangement.IsChiitoitsu || arrangement.IsKokushi || _melds.Any(m => m.MeldType == MeldType.Shuntsu) || arrangement.Shuntsus.Any())
{
return(Yaku.None);
}
return(Yaku.Toitoi);
}
public usrc_Item()
{
InitializeComponent();
//Item = new TangentaTableClass.Item();
m_Arrangement = new Arrangement();
m_Arrangement.Define(0, btn_Stock, nmUpDn_StockQuantity);
m_Arrangement.Define(1, btn_NoStock, nmUpDn_FactoryQuantity);
DefaultColor = BackColor;
}
private Yaku Kokushi(Arrangement arrangement)
{
if (arrangement.IsKokushi)
{
return(arrangement.Pair == _winningTile ? Yaku.KokushiMusouJuusanmen : Yaku.KokushiMusou);
}
return(Yaku.None);
}
public PrijsBerekening(Limo limo, Arrangement arr, EventingKorting evtKorting, int aantalReserveringen,
DateTime startTijd, DateTime eindTijd)
{
Limo = limo;
Arrangement = arr;
EventingKorting = evtKorting;
AantalReserveringen = aantalReserveringen;
Periode = new Periode(startTijd, eindTijd);
BerekenKostPrijs();
}
public MainWindow()
{
InitializeComponent();
SettingManager.Init();
arrangement = new Arrangement(this);
unarranged = new ObservableCollection <Item>();
waitingList.ItemsSource = unarranged;
PipeManager = new PipeManager(this);
PipeManager.Initialize();
}
public ActionResult Edit(Arrangement datosconvenio)
{
if (ModelState.IsValid)
{
db.Entry(datosconvenio).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(datosconvenio));
}
public IActionResult Update(Arrangement model)
{
if (model == null)
{
return(BadRequest($"{nameof(model)} is null."));
}
var result = m_ArrangementService.Update(model);
return(Json(result));
}
//schrappen?
public bool BevatOverUren(Arrangement arr)
{
bool bevatOveruren = false;
if (arr == Arrangement.NightLife || arr == Arrangement.Wedding)
{
bevatOveruren = this.Duur > TimeSpan.FromHours(7);
}
return(bevatOveruren);
}
internal static Arrangement GetArrangement(ParameterizableConfigurationElement checkerConfiguration, Validator validator)
{
if (checkerConfiguration == null)
{
checkerConfiguration = new ParameterizableConfigurationElement();
}
IQueryable <Arrangement> arrangements = DataContext.Instance.ArrangementSet
.Where(c => c.Validator.ValidatorId == validator.ValidatorId &&
c.Parameters.Count == checkerConfiguration.Parameters.Count &&
c.Parameters.All(p => checkerConfiguration.Parameters.AllKeys.Contains(p.Name)));
Arrangement arrangement = null;
foreach (Arrangement dbArrangement in arrangements)
{
if (dbArrangement.Parameters.All(p => checkerConfiguration.Parameters[p.Name].Value == p.Value))
{
arrangement = dbArrangement;
break;
}
}
bool pendingChanges = false;
if (arrangement == null)
{
arrangement = DataContext.Instance.ArrangementSet.Add(new Arrangement
{
Validator = validator,
Description = checkerConfiguration.Description
});
foreach (NameValueConfigurationElement parameter in checkerConfiguration.Parameters)
{
arrangement.Parameters.Add(new Parameter {
Name = parameter.Name, Value = parameter.Value
});
}
pendingChanges = true;
}
else if (arrangement.Description != checkerConfiguration.Description)
{
arrangement.Description = checkerConfiguration.Description;
pendingChanges = true;
}
if (pendingChanges)
{
DataContext.Instance.SaveChanges();
}
return(arrangement);
}
private static void UpdateTones(Arrangement arrangement)
{
// template may not reflect current XML state, update tone slots
if (arrangement.ArrangementType != ArrangementType.Vocal)
{
var xml = Song2014.LoadFromFile(arrangement.SongXml.File);
if (xml.ToneBase != null)
{
arrangement.ToneBase = xml.ToneBase;
}
// A (ID 0)
if (xml.ToneA != null)
{
if (xml.ToneA != xml.ToneBase)
{
// SNG convertor expects ToneA to be ID 0
throw new InvalidDataException(String.Format("Invalid tone definition detected in {0}, ToneA (ID 0) is expected to be same as ToneBase.", arrangement.SongXml.File));
}
arrangement.ToneA = xml.ToneA;
}
else
{
arrangement.ToneA = null;
}
// B (ID 1)
if (xml.ToneB != null)
{
arrangement.ToneB = xml.ToneB;
}
else
{
arrangement.ToneB = null;
}
// C (ID 2)
if (xml.ToneC != null)
{
arrangement.ToneC = xml.ToneC;
}
else
{
arrangement.ToneC = null;
}
// D (ID 3)
if (xml.ToneD != null)
{
arrangement.ToneD = xml.ToneD;
}
else
{
arrangement.ToneD = null;
}
}
}
public AttributesHeader2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
{
IsVocal = arrangement.ArrangementType == Sng.ArrangementType.Vocal;
SongContent = (IsVocal) ? null : Song2014.LoadFromFile(arrangement.SongXml.File);
var dlcName = info.Name.ToLower();
var albumUrn = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}", dlcName));
var jsonUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("{0}_{1}", dlcName, arrangementFileName));
//FILL ATTRIBUTES
this.AlbumArt = albumUrn;
ArrangementName = arrangement.Name.ToString();
DLC = true;
DLCKey = info.Name;
LeaderboardChallengeRating = 0;
ManifestUrn = jsonUrn;
MasterID_RDV = arrangement.MasterId;
PersistentID = arrangement.Id.ToString().Replace("-", "").ToUpper();
Shipping = true;
SKU = "RS2";
SongKey = info.Name;
if (!IsVocal)
{
AlbumName = AlbumNameSort = info.SongInfo.Album;
ArtistName = info.SongInfo.Artist;
CentOffset = arrangement.TuningPitch != 0 ? TuningFrequency.Frequency2Cents(arrangement.TuningPitch) : 0.0;
ArtistNameSort = info.SongInfo.ArtistSort;
CapoFret = (arrangement.Sng2014.Metadata.CapoFretId == 0xFF) ? CapoFret = 0 : Convert.ToDecimal(arrangement.Sng2014.Metadata.CapoFretId);
DNA_Chords = arrangement.Sng2014.DNACount[(int) DNAId.Chord];
DNA_Riffs = arrangement.Sng2014.DNACount[(int) DNAId.Riff];
DNA_Solo = arrangement.Sng2014.DNACount[(int) DNAId.Solo];
NotesEasy = arrangement.Sng2014.NoteCount[0];
NotesMedium = arrangement.Sng2014.NoteCount[1];
NotesHard = arrangement.Sng2014.NoteCount[2];
EasyMastery = NotesEasy / NotesHard;
MediumMastery = NotesMedium / NotesHard;
Representative = Convert.ToInt32(!arrangement.BonusArr);
RouteMask = (int)arrangement.RouteMask;
// TODO this is not quite it but much closer
SongDiffEasy = SongContent.SongLength / NotesEasy;
SongDiffMed = SongContent.SongLength / NotesMedium;
SongDiffHard = SongContent.SongLength / NotesHard;
SongDifficulty = SongDiffHard;
SongLength = (double?)Math.Round(SongContent.SongLength, 3, MidpointRounding.AwayFromZero);
SongName = info.SongInfo.SongDisplayName;
SongNameSort = info.SongInfo.SongDisplayNameSort;
SongYear = info.SongInfo.SongYear;
var tunDef = TuningDefinitionRepository.Instance().Select(arrangement.Tuning, platform.version);
Tuning = tunDef.Tuning;
}
}
public LegendTitle(LegendItemSource source, Arrangement hLayout, Arrangement vLayout)
{
LegendTitle legendTitle = this;
LegendItemSource[] legendItemSourceArray = new LegendItemSource[1];
int index = 0;
LegendItemSource legendItemSource = source;
legendItemSourceArray[index] = legendItemSource;
this.sources = legendItemSourceArray;
this.items = new BlockContainer(hLayout);
this.hLayout = hLayout;
this.vLayout = vLayout;
this.backgroundPaint = (Paint) null;
this.legendItemGraphicEdge = RectangleEdge.__\u003C\u003ELEFT;
this.legendItemGraphicAnchor = RectangleAnchor.__\u003C\u003ECENTER;
this.legendItemGraphicLocation = RectangleAnchor.__\u003C\u003ECENTER;
this.legendItemGraphicPadding = new RectangleInsets(2.0, 2.0, 2.0, 2.0);
this.itemFont = LegendTitle.__\u003C\u003EDEFAULT_ITEM_FONT;
this.itemPaint = LegendTitle.__\u003C\u003EDEFAULT_ITEM_PAINT;
this.itemLabelPadding = new RectangleInsets(2.0, 2.0, 2.0, 2.0);
}
public void TestArrangementAnalyzer()
{
// Randomly picked 2 shanten hand. 34467p 44446s 3447m
var pinzu = new[] // 001201100 (0,3,5)(1,2,4)(2,0,0)(2,1,2)(2,2,3)
{
new Arrangement(0, 3, 5),
new Arrangement(1, 2, 4), // 2 incomplete mentsu
new Arrangement(2, 0, 0),
new Arrangement(2, 1, 2),
new Arrangement(2, 2, 3)
};
var souzu = new[] // 000401000 (0,2,5)(1,1,3)(2,0,0)(2,1,2)
{
new Arrangement(0, 2, 5), // 1 incomplete and 1 complete mentsu
new Arrangement(1, 1, 3),
new Arrangement(2, 0, 0),
new Arrangement(2, 1, 2)
};
var manzu = new[] // 001200100 (0,3,4)(1,1,2)(1,2,3)(2,0,0)(2,1,1)(2,2,2)
{
new Arrangement(0, 3, 4),
new Arrangement(1, 1, 2),
new Arrangement(1, 2, 3),
new Arrangement(2, 0, 0), // 1 complete pair
new Arrangement(2, 1, 1),
new Arrangement(2, 2, 2)
};
var honor = new Arrangement(0, 0, 0).Yield();
var analyzer = new ArrangementAnalyzer();
analyzer.AddSetOfArrangements(pinzu);
analyzer.AddSetOfArrangements(souzu);
analyzer.AddSetOfArrangements(manzu);
analyzer.AddSetOfArrangements(honor);
var shanten = analyzer.CalculateShanten();
Assert.AreEqual(2, shanten);
}
private void AssociateTechniques(Arrangement x, Attributes att, string technique)
{
att.AssociatedTechniques.Add(String.Format("{0}{1}", x.ArrangementType == Sng.ArrangementType.Bass ? "Bass" : "", technique));
}
private static string CreateCompactArrangementString(Arrangement a)
{
return $"({a.JantouValue},{a.MentsuCount},{a.MentsuValue})";
}
//TODO: investigate on values 0.9 and lower, spotted in DLC
public void GenerateDynamicVisualDensity(IAttributes attribute, dynamic song, Arrangement arrangement, GameVersion version)
{
if (arrangement.ArrangementType == ArrangementType.Vocal)
{
if (version == GameVersion.RS2014)
attribute.DynamicVisualDensity = Enumerable.Repeat(2.0f, 20).ToList();
else
attribute.DynamicVisualDensity = new List<float> {
4.5f, 4.3000001907348633f, 4.0999999046325684f, 3.9000000953674316f, 3.7000000476837158f,
3.5f, 3.2999999523162842f, 3.0999999046325684f, 2.9000000953674316f, 2.7000000476837158f,
2.5f, 2.2999999523162842f, 2.0999999046325684f,
2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f
};
}
else
{
const float floorLimit = 5f;
attribute.DynamicVisualDensity = new List<float>(20);
float endSpeed = Math.Min(45f, Math.Max(floorLimit, arrangement.ScrollSpeed)) / 10f;
if (song.Levels.Length == 1)
{
attribute.DynamicVisualDensity = Enumerable.Repeat(endSpeed, 20).ToList();
}
else
{
double beginSpeed = 4.5d;
double maxLevel = Math.Min(song.Levels.Length, 20d) - 1;
double factor = maxLevel > 0 ? Math.Pow(endSpeed / beginSpeed, 1d / maxLevel) : 1d;
for (int i = 0; i < 20; i++)
{
if (i >= maxLevel)
{
attribute.DynamicVisualDensity.Add(endSpeed);
}
else
{
attribute.DynamicVisualDensity.Add((float)(beginSpeed * Math.Pow(factor, i)));
}
}
}
}
}
public AttributesHeader2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
{
if (arrangement.ArrangementType == ArrangementType.ShowLight)
return;
IsVocal = arrangement.ArrangementType == Sng.ArrangementType.Vocal;
SongContent = (IsVocal) ? null : Song2014.LoadFromFile(arrangement.SongXml.File);
var dlcName = info.Name.ToLower();
var albumUrn = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}", dlcName));
var jsonUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("{0}_{1}", dlcName, arrangementFileName));
//FILL ATTRIBUTES
this.AlbumArt = albumUrn;
JapaneseVocal |= arrangement.Name == Sng.ArrangementName.JVocals;
ArrangementName = IsVocal ? Sng.ArrangementName.Vocals.ToString() : arrangement.Name.ToString(); //HACK: weird vocals stuff
DLC = true;
DLCKey = info.Name;
LeaderboardChallengeRating = 0;
ManifestUrn = jsonUrn;
MasterID_RDV = arrangement.MasterId;
PersistentID = arrangement.Id.ToString().Replace("-", "").ToUpper();
Shipping = true;
SKU = "RS2";
SongKey = info.Name;
if (!IsVocal)
{
AlbumName = AlbumNameSort = info.SongInfo.Album;
ArtistName = info.SongInfo.Artist;
CentOffset = (!arrangement.TuningPitch.Equals(0)) ? TuningFrequency.Frequency2Cents(arrangement.TuningPitch) : 0.0;
ArtistNameSort = info.SongInfo.ArtistSort;
CapoFret = (arrangement.Sng2014.Metadata.CapoFretId == 0xFF) ? CapoFret = 0 : Convert.ToDecimal(arrangement.Sng2014.Metadata.CapoFretId);
DNA_Chords = arrangement.Sng2014.DNACount[(int)DNAId.Chord];
DNA_Riffs = arrangement.Sng2014.DNACount[(int)DNAId.Riff];
DNA_Solo = arrangement.Sng2014.DNACount[(int)DNAId.Solo];
NotesEasy = arrangement.Sng2014.NoteCount[0];
NotesMedium = arrangement.Sng2014.NoteCount[1];
NotesHard = arrangement.Sng2014.NoteCount[2];
EasyMastery = NotesEasy / NotesHard;
MediumMastery = NotesMedium / NotesHard;
Metronome = (int?)arrangement.Metronome;
Representative = Convert.ToInt32(!arrangement.BonusArr);
RouteMask = (int)arrangement.RouteMask;
// TODO use ManifestFunctions.GetSongDifficulty() method (fix generation alghorythm)
SongDiffEasy = SongContent.SongLength / NotesEasy;
SongDiffMed = SongContent.SongLength / NotesMedium;
SongDiffHard = SongContent.SongLength / NotesHard;
SongDifficulty = SongDiffHard;
SongLength = (double?)Math.Round(SongContent.SongLength, 3, MidpointRounding.AwayFromZero);
SongName = info.SongInfo.SongDisplayName;
SongNameSort = info.SongInfo.SongDisplayNameSort;
SongYear = info.SongInfo.SongYear;
//Detect tuning
var tuning = TuningDefinitionRepository.Instance().SelectAny(SongContent.Tuning, platform.version);
if (tuning == null)
{
tuning = new TuningDefinition();
tuning.Tuning = SongContent.Tuning;
tuning.Name = tuning.UIName = arrangement.Tuning;
if (String.IsNullOrEmpty(tuning.Name))
{
tuning.Name = tuning.UIName = tuning.NameFromStrings(arrangement.TuningStrings, arrangement.ArrangementType == ArrangementType.Bass);
}
tuning.Custom = true;
tuning.GameVersion = GameVersion.RS2014;
TuningDefinitionRepository.Instance().Add(tuning, true);
}
Tuning = tuning.Tuning;
}
}
public override Arrangement get_Arrangement(long IDNivel, IDbConnection conn) {
Arrangement result = new Arrangement();
result.tradicaoDocumental = new List<string>();
result.ordenacao = new List<string>();
try {
// Tradicao documental
string query = string.Format(@"
SELECT ttd.Designacao
FROM Nivel n
INNER JOIN FRDBase frd ON frd.IDNivel = n.ID AND frd.isDeleted = 0
INNER JOIN SFRDTradicaoDocumental td ON td.IDFRDBase = frd.ID AND td.isDeleted = 0
INNER JOIN TipoTradicaoDocumental ttd ON ttd.ID = td.IDTipoTradicaoDocumental AND ttd.isDeleted = 0
WHERE n.ID = {0} AND n.isDeleted = 0 ",
IDNivel);
SqlCommand command = new SqlCommand(query, (SqlConnection)conn);
SqlDataReader reader = command.ExecuteReader();
while (reader.Read()) {
if (!reader.IsDBNull(0))
result.tradicaoDocumental.Add(reader.GetString(0));
}
reader.Close();
// Ordenacao:
query = string.Format(@"
SELECT ord.Designacao
FROM Nivel n
INNER JOIN FRDBase frd ON frd.IDNivel = n.ID AND frd.isDeleted = 0
INNER JOIN SFRDOrdenacao o ON o.IDFRDBase = frd.ID AND o.isDeleted = 0
INNER JOIN TipoOrdenacao ord ON ord.ID = o.IDTipoOrdenacao AND ord.isDeleted = 0
WHERE n.ID = {0} AND n.isDeleted = 0 ", IDNivel);
command.CommandText = query;
reader = command.ExecuteReader();
while (reader.Read()) {
if (!reader.IsDBNull(0))
result.ordenacao.Add(reader.GetString(0));
}
reader.Close();
}
catch (Exception ex) { Trace.WriteLine(ex); throw; }
return result;
}
public void GenerateDynamicVisualDensity(IAttributes attribute, dynamic song, Arrangement arrangement)
{
if (arrangement.ArrangementType == ArrangementType.Vocal)
{
attribute.DynamicVisualDensity = new List<float>{
4.5f, 4.3000001907348633f, 4.0999999046325684f, 3.9000000953674316f, 3.7000000476837158f,
3.5f, 3.2999999523162842f, 3.0999999046325684f, 2.9000000953674316f, 2.7000000476837158f,
2.5f, 2.2999999523162842f, 2.0999999046325684f,
2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f};
}
else
{
attribute.DynamicVisualDensity = new List<float>(20);
float endSpeed = Math.Min(45f, Math.Max(10f, arrangement.ScrollSpeed)) / 10f;
if (song.Levels.Length == 1)
{
for (int i = 0; i < 20; i++)
{
attribute.DynamicVisualDensity.Add(endSpeed);
}
}
else
{
double beginSpeed = 4.5d;
double maxLevel = Math.Min(song.Levels.Length, 16d) - 1;
double factor = maxLevel == 0 ? 1d : Math.Pow(endSpeed / beginSpeed, 1d / maxLevel);
for (int i = 0; i < 20; i++)
{
if (i >= maxLevel)
{
attribute.DynamicVisualDensity.Add(endSpeed);
}
else
{
attribute.DynamicVisualDensity.Add((float)(beginSpeed * Math.Pow(factor, i)));
}
}
}
}
}
private static void ParseTuning(Arrangement dest, Attributes2014 attr)
{
bool isBass = false;
TuningDefinition tuning = null;
switch (dest.Name)
{
case ArrangementName.Bass:
tuning = TuningDefinitionRepository.Instance().SelectForBass(attr.Tuning, GameVersion.RS2014);
isBass = true;
break;
case ArrangementName.Vocals:
break;
default:
tuning = TuningDefinitionRepository.Instance().Select(attr.Tuning, GameVersion.RS2014);
break;
}
if (tuning == null)
{
tuning = new TuningDefinition();
tuning.UIName = tuning.Name = TuningDefinition.NameFromStrings(attr.Tuning, isBass);
tuning.Custom = true;
tuning.GameVersion = GameVersion.RS2014;
tuning.Tuning = attr.Tuning;
TuningDefinitionRepository.Instance().Add(tuning, true);
}
dest.Tuning = tuning.UIName;
dest.TuningStrings = tuning.Tuning;
if (attr.CentOffset != null)
dest.TuningPitch = attr.CentOffset.Cents2Frequency();
}
/// <summary>
/// Loads required DLC info from folder.
/// </summary>
/// <returns>The DLCPackageData info.</returns>
/// <param name="unpackedDir">Unpacked dir.</param>
/// <param name="targetPlatform">Target platform.</param>
/// <param name = "sourcePlatform"></param>
public static DLCPackageData LoadFromFolder(string unpackedDir, Platform targetPlatform, Platform sourcePlatform = null)
{
var data = new DLCPackageData();
data.GameVersion = GameVersion.RS2014;
data.SignatureType = PackageMagic.CON;
if (sourcePlatform == null)
sourcePlatform = unpackedDir.GetPlatform();
//Arrangements / Tones
data.Arrangements = new List<Arrangement>();
data.TonesRS2014 = new List<Tone2014>();
//Load files
var jsonFiles = Directory.EnumerateFiles(unpackedDir, "*.json", SearchOption.AllDirectories).ToArray();
foreach (var json in jsonFiles)
{
var attr = Manifest2014<Attributes2014>.LoadFromFile(json).Entries.ToArray()[0].Value.ToArray()[0].Value;
var xmlName = attr.SongXml.Split(':')[3];
var xmlFile = Directory.EnumerateFiles(unpackedDir, xmlName + ".xml", SearchOption.AllDirectories).FirstOrDefault();
if (attr.Phrases != null)
{
if (data.SongInfo == null)
{
// Fill Package Data
data.Name = attr.DLCKey;
data.Volume = (attr.SongVolume == 0 ? -12 : attr.SongVolume); //FIXME: too low song volume issue, revert to -6 to fix.
data.PreviewVolume = (attr.PreviewVolume ?? data.Volume);
// Fill SongInfo
data.SongInfo = new SongInfo
{
SongDisplayName = attr.SongName,
SongDisplayNameSort = attr.SongNameSort,
Album = attr.AlbumName,
SongYear = attr.SongYear ?? 0,
Artist = attr.ArtistName,
ArtistSort = attr.ArtistNameSort,
AverageTempo = (int) attr.SongAverageTempo
};
}
// Adding Tones
foreach (var jsonTone in attr.Tones)
{
if (jsonTone == null) continue;
var key = jsonTone.Key;
if (data.TonesRS2014.All(t => t.Key != key))
{
// fix tones names that do not have the correct alphacase for cross matching
if (attr.Tone_Base.ToLower() == jsonTone.Name.ToLower() && attr.Tone_Base != jsonTone.Name)
jsonTone.Name = attr.Tone_Base;
if (attr.Tone_A != null && attr.Tone_A.ToLower() == jsonTone.Name.ToLower() && attr.Tone_A != jsonTone.Name)
jsonTone.Name = attr.Tone_A;
if (attr.Tone_B != null && attr.Tone_B.ToLower() == jsonTone.Name.ToLower() && attr.Tone_B != jsonTone.Name)
jsonTone.Name = attr.Tone_B;
if (attr.Tone_C != null && attr.Tone_C.ToLower() == jsonTone.Name.ToLower() && attr.Tone_C != jsonTone.Name)
jsonTone.Name = attr.Tone_C;
if (attr.Tone_D != null && attr.Tone_D.ToLower() == jsonTone.Name.ToLower() && attr.Tone_D != jsonTone.Name)
jsonTone.Name = attr.Tone_D;
data.TonesRS2014.Add(jsonTone);
}
}
// Adding Arrangement
data.Arrangements.Add(new Arrangement(attr, xmlFile));
}
else if (xmlFile.ToLower().Contains("_vocals"))
{
var voc = new Arrangement
{
Name = attr.JapaneseVocal == true ? ArrangementName.JVocals : ArrangementName.Vocals,
ArrangementType = ArrangementType.Vocal,
ScrollSpeed = 20,
SongXml = new SongXML {File = xmlFile},
SongFile = new SongFile {File = ""},
CustomFont = attr.JapaneseVocal == true
};
// Get symbols stuff from _vocals.xml
var fontSng = Path.Combine(unpackedDir, xmlName + ".sng");
var vocSng = Sng2014FileWriter.ReadVocals(xmlFile);
if (vocSng.IsCustomFont())
{
voc.CustomFont = true;
voc.FontSng = fontSng;
vocSng.WriteChartData(fontSng, new Platform(GamePlatform.Pc, GameVersion.None));
}
voc.Sng2014 = Sng2014File.ConvertXML(xmlFile, ArrangementType.Vocal, voc.FontSng);
// Adding Arrangement
data.Arrangements.Add(voc);
}
}
//ShowLights XML
var xmlShowLights = Directory.EnumerateFiles(unpackedDir, "*_showlights.xml", SearchOption.AllDirectories).FirstOrDefault();
if (!String.IsNullOrEmpty(xmlShowLights))
{
var shl = new Arrangement
{
ArrangementType = ArrangementType.ShowLight,
Name = ArrangementName.ShowLights,
SongXml = new SongXML { File = xmlShowLights },
SongFile = new SongFile { File = "" }
};
// Adding ShowLights
data.Arrangements.Add(shl);
}
//Get DDS Files
var ddsFiles = Directory.EnumerateFiles(unpackedDir, "album_*.dds", SearchOption.AllDirectories).ToArray();
if (ddsFiles.Any())
{
var ddsFilesC = new List<DDSConvertedFile>();
foreach (var file in ddsFiles)
switch (Path.GetFileNameWithoutExtension(file).Split('_')[2])
{
case "256":
data.AlbumArtPath = file;
ddsFilesC.Add(new DDSConvertedFile() { sizeX = 256, sizeY = 256, sourceFile = file, destinationFile = file.CopyToTempFile(".dds") });
break;
case "128":
ddsFilesC.Add(new DDSConvertedFile() { sizeX = 128, sizeY = 128, sourceFile = file, destinationFile = file.CopyToTempFile(".dds") });
break;
case "64":
ddsFilesC.Add(new DDSConvertedFile() { sizeX = 64, sizeY = 64, sourceFile = file, destinationFile = file.CopyToTempFile(".dds") });
break;
} data.ArtFiles = ddsFilesC;
}
// Lyric Art
var lyricArt = Directory.EnumerateFiles(unpackedDir, "lyrics_*.dds", SearchOption.AllDirectories).ToArray();
if (lyricArt.Any())
data.LyricArtPath = lyricArt.FirstOrDefault();
//Get other files
//Audio files
var targetAudioFiles = new List<string>();
var sourceAudioFiles = Directory.EnumerateFiles(unpackedDir, "*.wem", SearchOption.AllDirectories).ToArray();
foreach (var file in sourceAudioFiles)
{
var newFile = Path.Combine(Path.GetDirectoryName(file), String.Format("{0}_fixed{1}", Path.GetFileNameWithoutExtension(file), Path.GetExtension(file)));
if (targetPlatform.IsConsole != (sourcePlatform = file.GetAudioPlatform()).IsConsole)
{
OggFile.ConvertAudioPlatform(file, newFile);
targetAudioFiles.Add(newFile);
}
else targetAudioFiles.Add(file);
}
if (!targetAudioFiles.Any())
throw new InvalidDataException("Audio files not found.");
string audioPath = null, audioPreviewPath = null;
var a = new FileInfo(targetAudioFiles[0]);
if (targetAudioFiles.Count == 2)
{
var b = new FileInfo(targetAudioFiles[1]);
if (a.Length > b.Length)
{
audioPath = a.FullName;
audioPreviewPath = b.FullName;
}
else
{
audioPath = b.FullName;
audioPreviewPath = a.FullName;
}
}
else
audioPath = a.FullName;
data.OggPath = audioPath;
//Make Audio preview with expected name when rebuild
if (!String.IsNullOrEmpty(audioPreviewPath))
{
var newPreviewFileName = Path.Combine(Path.GetDirectoryName(audioPath), String.Format("{0}_preview{1}", Path.GetFileNameWithoutExtension(audioPath), Path.GetExtension(audioPath)));
File.Move(audioPreviewPath, newPreviewFileName);
data.OggPreviewPath = newPreviewFileName;
}
//AppID
var appidFile = Directory.EnumerateFiles(unpackedDir, "*.appid", SearchOption.AllDirectories).FirstOrDefault();
if (appidFile != null)
data.AppId = File.ReadAllText(appidFile);
//Package version
var versionFile = Directory.EnumerateFiles(unpackedDir, "toolkit.version", SearchOption.AllDirectories).FirstOrDefault();
if (versionFile != null)
data.PackageVersion = GeneralExtensions.ReadPackageVersion(versionFile);
else data.PackageVersion = "1";
return data;
}
private void Analyze(Arrangement arrangement, int currentTileType, int currentProtoGroup)
{
if (currentTileType >= _tileTypeCount)
{
_arrangements.Add(arrangement);
return;
}
Analyze(arrangement, currentTileType + 1, 0);
// Inlined a bunch of things for about 25% performance gain.
var count = _protoGroups.Count;
for (var i = currentProtoGroup; i < count; ++i)
{
var protoGroup = _protoGroups[i];
var isJantou = i <= 1;
if (isJantou)
{
if (_jantouValue != 0 || !protoGroup.CanInsert(_concealed, _used, currentTileType))
{
continue;
}
protoGroup.Insert(_concealed, _used, currentTileType);
var oldJantouValue = _jantouValue;
_jantouValue = protoGroup.Value;
var added = arrangement.SetJantouValue(_jantouValue);
Analyze(added, currentTileType, i);
protoGroup.Remove(_concealed, _used, currentTileType);
_jantouValue = oldJantouValue;
}
else
{
if (_usedMelds == 4 || !protoGroup.CanInsert(_concealed, _used, currentTileType))
{
continue;
}
protoGroup.Insert(_concealed, _used, currentTileType);
_usedMelds += 1;
var added = arrangement.AddMentsu(protoGroup.Value);
Analyze(added, currentTileType, i);
protoGroup.Remove(_concealed, _used, currentTileType);
_usedMelds -= 1;
}
}
}
public static Arrangement Read(Attributes2014 attr, Platform platform, Guid id, string filename, Stream data = null)
{
Arrangement result = null;
using (var str = data ?? File.OpenRead(filename))
{
switch (Path.GetExtension(filename))
{
case ".xml":
Sng2014File xml = null;
if (((ArrangementName)attr.ArrangementType) == ArrangementName.Vocals)
xml = Sng2014FileWriter.ReadVocals(data);
else
xml = Sng2014File.ConvertXML(str);
result = new Arrangement(attr, xml, id);
break;
case ".sng":
result = new Arrangement(attr, Sng2014File.ReadSng(str, platform), id);
break;
default:
throw new Exception("Unknown file type: " + filename);
}
result._songFilename = filename;
}
return result;
}
private static void AssertIsWorse(ArrangementComparer comparer, Arrangement a, Arrangement b)
{
Assert.IsTrue(comparer.IsWorseThan(a, b), $"{a} should be worse than {b}");
Assert.IsFalse(comparer.IsWorseThan(b, a), $"{b} should not be worse than {a}");
}
public AttributesHeader2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
{
if (arrangement.ArrangementType == ArrangementType.ShowLight)
return;
IsVocal = arrangement.ArrangementType == ArrangementType.Vocal;
SongContent = (IsVocal) ? null : Song2014.LoadFromFile(arrangement.SongXml.File);
var dlcName = info.Name.ToLower();
var albumUrn = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}", dlcName));
var jsonUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("{0}_{1}", dlcName, arrangementFileName));
//FILL ATTRIBUTES
this.AlbumArt = albumUrn;
JapaneseVocal |= arrangement.Name == Sng.ArrangementName.JVocals;
ArrangementName = IsVocal ? Sng.ArrangementName.Vocals.ToString() : arrangement.Name.ToString(); //HACK: weird vocals stuff
DLC = true;
DLCKey = info.Name;
LeaderboardChallengeRating = 0;
ManifestUrn = jsonUrn;
MasterID_RDV = arrangement.MasterId;
PersistentID = arrangement.Id.ToString().Replace("-", "").ToUpper();
Shipping = true;
SKU = "RS2";
SongKey = info.Name; // proof same same
if (IsVocal) return;
// added better AlbumNameSort feature
AlbumName = info.SongInfo.Album;
AlbumNameSort = info.SongInfo.AlbumSort;
ArtistName = info.SongInfo.Artist;
CentOffset = (!arrangement.TuningPitch.Equals(0)) ? TuningFrequency.Frequency2Cents(arrangement.TuningPitch) : 0.0;
ArtistNameSort = info.SongInfo.ArtistSort;
if (arrangement.ArrangementType == ArrangementType.Bass)
{
SerializeBassInfo = true;
BassPick = (int) arrangement.PluckedType;
}
else
SerializeBassInfo = false;
CapoFret = (arrangement.Sng2014.Metadata.CapoFretId == 0xFF) ? CapoFret = 0 : Convert.ToDecimal(arrangement.Sng2014.Metadata.CapoFretId);
DNA_Chords = arrangement.Sng2014.DNACount[(int)DNAId.Chord];
DNA_Riffs = arrangement.Sng2014.DNACount[(int)DNAId.Riff];
DNA_Solo = arrangement.Sng2014.DNACount[(int)DNAId.Solo];
NotesEasy = arrangement.Sng2014.NoteCount[0];
NotesMedium = arrangement.Sng2014.NoteCount[1];
NotesHard = arrangement.Sng2014.NoteCount[2];
EasyMastery = NotesEasy / NotesHard;
MediumMastery = NotesMedium / NotesHard;
Metronome = (int?)arrangement.Metronome;
// TODO: check for bug here
// if there is an equivalent bonus arrangement then Representative is set to "1" otherwise "0"
Representative = Convert.ToInt32(!arrangement.BonusArr);
RouteMask = (int)arrangement.RouteMask;
// TODO: use ManifestFunctions.GetSongDifficulty() method (fix generation algorithm)
// TODO: round to 9 decimal places and improve calculation
// TODO: fix SongDiff calculations
SongDiffEasy = SongContent.SongLength / NotesEasy;
SongDiffMed = SongContent.SongLength / NotesMedium;
SongDiffHard = SongContent.SongLength / NotesHard;
SongDifficulty = SongDiffHard;
SongLength = Math.Round(SongContent.SongLength, 3, MidpointRounding.AwayFromZero);
SongName = info.SongInfo.SongDisplayName;
SongNameSort = info.SongInfo.SongDisplayNameSort;
SongYear = info.SongInfo.SongYear;
//Detect tuning
var tuning = TuningDefinitionRepository.Instance.Detect(SongContent.Tuning, platform.version, arrangement.ArrangementType == ArrangementType.Bass);
Tuning = tuning.Tuning; //can we just use SongContent.Tuning
}
private static IEnumerable<Arrangement> CreateAllArrangements(int totalTiles)
{
for (var jantouValue = 0; jantouValue <= 2; ++jantouValue)
{
for (var mentsuCount = 0; mentsuCount <= 4; ++mentsuCount)
{
for (var mentsuValue = mentsuCount; mentsuValue <= mentsuCount * 3; ++mentsuValue)
{
var arrangement = new Arrangement(jantouValue, mentsuCount, mentsuValue);
if (arrangement.TotalValue <= totalTiles)
{
yield return arrangement;
}
}
}
}
}
private static bool IsPerfect(Arrangement arrangement)
{
return arrangement.MentsuValue == arrangement.MentsuCount * 3 && arrangement.JantouValue != 1;
}
/// <summary>
/// Determines whether an arrangement is worse than another.
/// </summary>
public bool IsWorseThan(Arrangement lhs, Arrangement rhs)
{
Validate.NotNull(lhs, nameof(lhs));
Validate.NotNull(rhs, nameof(rhs));
if (lhs == rhs)
{
return false;
}
// Same mentsu but better pairs.
if (lhs.JantouValue < rhs.JantouValue && lhs.MentsuCount == rhs.MentsuCount && lhs.MentsuValue == rhs.MentsuValue)
{
return true;
}
// Same TotalValue and MentsuCount, but higher PairValue is worse.
if (lhs.JantouValue > rhs.JantouValue && lhs.MentsuCount == rhs.MentsuCount && lhs.TotalValue == rhs.TotalValue)
{
return true;
}
// Not enough tiles in other suits to reach the same value.
var tilesInOtherSuits = 14 - _tileCount;
if (lhs.TotalValue + tilesInOtherSuits < rhs.TotalValue)
{
return true;
}
// If there are no tiles in other suits and the total value is equal, take the higher mentsu value (arbitrary choice).
if (tilesInOtherSuits == 0 && lhs.TotalValue == rhs.TotalValue && lhs.MentsuValue < rhs.MentsuValue)
{
return true;
}
// If there is exactly one tile in other suits:
if (tilesInOtherSuits == 1)
{
if (lhs.TotalValue < rhs.TotalValue)
{
return true;
}
if (lhs.HasJantou && rhs.HasJantou && lhs.TotalValue == rhs.TotalValue && lhs.MentsuValue < rhs.MentsuValue)
{
return true;
}
}
// Not enough unused groups to reach the same value in other suits.
var maxWithUnusedGroups = (4 - lhs.MentsuCount) * 3 + (lhs.HasJantou ? 0 : 2);
if (lhs.TotalValue + maxWithUnusedGroups < rhs.TotalValue)
{
return true;
}
// Both with or without jantou.
if (lhs.JantouValue == rhs.JantouValue)
{
// Perfect with more mentsu is better than perfect with less mentsu.
if (lhs.MentsuCount < rhs.MentsuCount)
{
return IsPerfect(lhs) && IsPerfect(rhs);
}
// Lower value with same MentsuCount is worse.
if (lhs.MentsuCount == rhs.MentsuCount)
{
return lhs.MentsuValue < rhs.MentsuValue;
}
// Same value with more mentsu is worse.
if (lhs.MentsuCount > rhs.MentsuCount)
{
return lhs.TotalValue <= rhs.TotalValue;
}
}
return false;
}
private static void ParseTones(Arrangement dest, Attributes2014 attr)
{
dest.ScrollSpeed = Convert.ToInt32(attr.DynamicVisualDensity.Last() * 10);
dest.PluckedType = (PluckedType)attr.ArrangementProperties.BassPick;
dest.RouteMask = (RouteMask)attr.ArrangementProperties.RouteMask;
dest.BonusArr = attr.ArrangementProperties.BonusArr == 1;
dest.ToneBase = attr.Tone_Base;
dest.ToneMultiplayer = attr.Tone_Multiplayer;
dest.ToneA = attr.Tone_A;
dest.ToneB = attr.Tone_B;
dest.ToneC = attr.Tone_C;
dest.ToneD = attr.Tone_D;
dest.Tones = attr.Tones.ToList();
}
public static void GenerateSNG(Arrangement arrangement, Platform platform)
{
string sngFile = Path.ChangeExtension(arrangement.SongXml.File, ".sng");
switch (platform.version)
{
case GameVersion.RS2012:
SngFileWriter.Write(arrangement.SongXml.File, sngFile, arrangement.ArrangementType, platform);
break;
case GameVersion.RS2014:
using (FileStream fs = new FileStream(arrangement.SongFile.File, FileMode.Create))
arrangement.Sng2014.WriteSng(fs, platform);
break;
default:
throw new InvalidOperationException("Unexpected game version value");
}
arrangement.SongFile.File = Path.GetFullPath(sngFile);
TMPFILES_SNG.Add(sngFile);
}
public static void GenerateSNG(Arrangement arrangement, Platform platform)
{
string sngFile = Path.ChangeExtension(arrangement.SongXml.File, ".sng");
switch (platform.version)
{
case GameVersion.RS2012:
SngFileWriter.Write(arrangement.SongXml.File, sngFile, arrangement.ArrangementType, platform);
break;
case GameVersion.RS2014:
if (arrangement.Sng2014 == null) {
// Sng2014File can be reused when generating for multiple platforms
// cache results
arrangement.Sng2014 = Sng2014File.ConvertXML(arrangement.SongXml.File, arrangement.ArrangementType);
}
using (FileStream fs = new FileStream(sngFile, FileMode.Create))
arrangement.Sng2014.WriteSng(fs, platform);
break;
default:
throw new InvalidOperationException("Unexpected game version value");
}
if (arrangement.SongFile == null)
arrangement.SongFile = new SongFile { File = "" };
arrangement.SongFile.File = Path.GetFullPath(sngFile);
TMPFILES_SNG.Add(sngFile);
}
public Attributes2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
: base(arrangementFileName, arrangement, info, platform)
{
#region VARIABLES
var dlcName = info.Name.ToLower();
var xblockUrn = String.Format(URN_TEMPLATE_SHORT, TagValue.EmergentWorld.GetDescription(), dlcName);
var showlightUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.XML.GetDescription(), String.Format("{0}_showlights", dlcName));
var songXmlUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.XML.GetDescription(), String.Format(AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName));
var songSngUrn = String.Format(URN_TEMPLATE, TagValue.Application.GetDescription(), TagValue.MusicgameSong.GetDescription(), String.Format(AggregateGraph2014.NAME_ARRANGEMENT, dlcName, arrangementFileName));
var manifestFunctions = new ManifestFunctions(platform.version);
#endregion
#region FILL ATTRIBUTES
ArrangementSort = arrangement.ArrangementSort;
BlockAsset = xblockUrn;
manifestFunctions.GenerateDynamicVisualDensity(this, SongContent, arrangement);
FullName = String.Format(AggregateGraph2014.NAME_ARRANGEMENT, info.Name, arrangement.Name);
MasterID_PS3 = (IsVocal) ? -1 : arrangement.MasterId;
MasterID_Xbox360 = (IsVocal) ? -1 : arrangement.MasterId;
PreviewBankPath = String.Format("song_{0}_preview.bnk", info.Name.ToLower());
RelativeDifficulty = 0; //Always 0 in RS2014
ShowlightsXML = showlightUrn;
SongAsset = songSngUrn;
SongBank = String.Format("song_{0}.bnk", info.Name.ToLower());
SongEvent = String.Format("Play_{0}", info.Name);
SongXml = songXmlUrn;
SongVolume = info.Volume;
PreviewVolume = (info.PreviewVolume != null) ? info.PreviewVolume : SongVolume;
// Only for Vocal
if (IsVocal)
InputEvent = "Play_Tone_Standard_Mic";
// Only for instruments
if (!IsVocal)
{
ArrangementProperties = SongContent.ArrangementProperties;
ArrangementProperties.BassPick = (int)arrangement.PluckedType;
ArrangementProperties.PathLead = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Lead);
ArrangementProperties.PathRhythm = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Rhythm);
ArrangementProperties.PathBass = Convert.ToInt32(arrangement.RouteMask == DLCPackage.RouteMask.Bass);
ArrangementProperties.RouteMask = (int)arrangement.RouteMask;
// BONUS ARRANGEMENT
ArrangementProperties.BonusArr = Convert.ToInt32(arrangement.BonusArr);
if (arrangement.Name == Sng.ArrangementName.Combo)
{ //Exclusive condition
if (arrangement.RouteMask == DLCPackage.RouteMask.Lead)
ArrangementType = (int)Sng.ArrangementName.Lead;
else if (arrangement.RouteMask == DLCPackage.RouteMask.Rhythm)
ArrangementType = (int)Sng.ArrangementName.Rhythm;
else
ArrangementType = (int)arrangement.Name;
}
else
ArrangementType = (int)arrangement.Name;
//Chords -- //TODO: MISSING GENERATE
ChordTemplates = new List<ChordTemplate>();
manifestFunctions.GenerateChordTemplateData(this, SongContent);
LastConversionDateTime = SongContent.LastConversionDateTime;
MaxPhraseDifficulty = manifestFunctions.GetMaxDifficulty(SongContent);
TargetScore = 100000;
PhraseIterations = new List<PhraseIteration>();
manifestFunctions.GeneratePhraseIterationsData(this, SongContent, platform.version);
//Score_MaxNotes -- Generated on function above
//Score_PNV -- Generated on function above
Phrases = new List<Phrase>();
manifestFunctions.GeneratePhraseData(this, SongContent);
Sections = new List<Section>();
manifestFunctions.GenerateSectionData(this, SongContent);
SongAverageTempo = SongContent.AverageTempo;
SongOffset = arrangement.Sng2014.Metadata.StartTime * -1;
//SongPartition -- Generated in DLCPackageCreator after this constructor
//Techniques -- //TODO: MISSING GENERATE
//Fix for Dead tones
var it = info.TonesRS2014;
Tones = new List<Tone2014>();
Tone_A = GetToneName(arrangement.ToneA, it);
Tone_B = GetToneName(arrangement.ToneB, it);
Tone_Base = GetToneName(arrangement.ToneBase, it);
Tone_C = GetToneName(arrangement.ToneC, it);
Tone_D = GetToneName(arrangement.ToneD, it);
Tone_Multiplayer = GetToneName(arrangement.ToneMultiplayer, it);
}
#endregion
}
// Load RS1 CDLC into PackageCreator
public static DLCPackageData RS1LoadFromFolder(string unpackedDir, Platform targetPlatform, bool convert)
{
var data = new DLCPackageData();
data.Arrangements = new List<Arrangement>();
data.TonesRS2014 = new List<Tone2014>();
data.Tones = new List<Tone>();
data.GameVersion = (convert ? GameVersion.RS2014 : GameVersion.RS2012);
data.SignatureType = PackageMagic.CON;
// set default volumes
data.Volume = -6.5F; // default maybe too quite
data.PreviewVolume = data.Volume;
//Load song manifest
var songsManifestJson = Directory.GetFiles(unpackedDir, "songs.manifest.json", SearchOption.AllDirectories);
if (songsManifestJson.Length < 1)
throw new DataException("No songs.manifest.json file found.");
if (songsManifestJson.Length > 1)
throw new DataException("More than one songs.manifest.json file found.");
List<Attributes> attr = new List<Attributes>();
var songsManifest = Manifest.Manifest.LoadFromFile(songsManifestJson[0]).Entries.ToArray();
for (int smIndex = 0; smIndex < songsManifest.Count(); smIndex++)
{
var smData = songsManifest[smIndex].Value.ToArray()[0].Value;
attr.Add(smData);
}
if (attr.FirstOrDefault() == null)
throw new DataException("songs.manifest.json file did not parse correctly.");
// Fill SongInfo
data.SongInfo = new SongInfo();
data.SongInfo.SongDisplayName = attr.FirstOrDefault().SongName;
data.SongInfo.SongDisplayNameSort = attr.FirstOrDefault().SongNameSort;
data.SongInfo.Album = attr.FirstOrDefault().AlbumName;
data.SongInfo.SongYear = (attr.FirstOrDefault().SongYear == 0 ? 2012 : attr.FirstOrDefault().SongYear);
data.SongInfo.Artist = attr.FirstOrDefault().ArtistName;
data.SongInfo.ArtistSort = attr.FirstOrDefault().ArtistNameSort;
data.Name = attr.FirstOrDefault().SongKey;
//Load tone manifest, even poorly formed tone_bass.manifest.json
var toneManifestJson = Directory.GetFiles(unpackedDir, "*tone*.manifest.json", SearchOption.AllDirectories);
if (toneManifestJson.Length < 1)
throw new DataException("No tone.manifest.json file found.");
// toolkit produces multiple tone.manifest.json files when packing RS1 CDLC files
// rather than change toolkit behavior just merge manifest files for now
if (toneManifestJson.Length > 1)
{
var mergeSettings = new JsonMergeSettings { MergeArrayHandling = MergeArrayHandling.Union };
JObject toneObject1 = new JObject();
foreach (var tone in toneManifestJson)
{
JObject toneObject2 = JObject.Parse(File.ReadAllText(tone));
//(toneObject1.SelectToken("Entries") as JArray).Merge(toneObject2.SelectToken("Entries"));
toneObject1.Merge(toneObject2, mergeSettings);
}
toneManifestJson = new string[1];
toneManifestJson[0] = Path.Combine(unpackedDir, "merged.tone.manifest");
string json = JsonConvert.SerializeObject(toneObject1, Formatting.Indented);
File.WriteAllText(toneManifestJson[0], json);
}
List<Tone> tones = new List<Tone>();
Manifest.Tone.Manifest toneManifest = Manifest.Tone.Manifest.LoadFromFile(toneManifestJson[0]);
for (int tmIndex = 0; tmIndex < toneManifest.Entries.Count(); tmIndex++)
{
var tmData = toneManifest.Entries[tmIndex];
tones.Add(tmData);
}
data.Tones = tones;
// Load AggregateGraph.nt
var songDir = Path.Combine(unpackedDir, data.Name);
var aggFile = Directory.GetFiles(songDir, "*.nt", SearchOption.TopDirectoryOnly)[0];
List<AgGraphNt> aggGraphData = AggregateGraph.AggregateGraph.ReadFromFile(aggFile);
// Load Exports\Songs\*.xblock
var xblockDir = Path.Combine(unpackedDir, data.Name, "Exports\\Songs");
var xblockFile = Directory.GetFiles(xblockDir, "*.xblock", SearchOption.TopDirectoryOnly)[0];
// xblockFile = "D:\\Temp\\Mapping\\songs.xblock";
XblockX songsXblock = XblockX.LoadFromFile(xblockFile);
// create project map for cross referencing arrangements with tones
var projectMap = AggregateGraph.AggregateGraph.ProjectMap(aggGraphData, songsXblock, toneManifest);
// Load xml arrangements
var xmlFiles = Directory.GetFiles(unpackedDir, "*.xml", SearchOption.AllDirectories);
if (xmlFiles.Length <= 0)
throw new DataException("Can not find any XML arrangement files");
List<Tone2014> tones2014 = new List<Tone2014>();
foreach (var xmlFile in xmlFiles)
{
if (xmlFile.ToLower().Contains("metadata")) // skip DeadFox file
continue;
// some poorly formed RS1 CDLC use just "vocal"
if (xmlFile.ToLower().Contains("vocal"))
{
var voc = new Arrangement();
voc.Name = ArrangementName.Vocals;
voc.ArrangementType = ArrangementType.Vocal;
voc.ScrollSpeed = 20;
voc.SongXml = new SongXML { File = xmlFile };
voc.SongFile = new SongFile { File = "" };
voc.CustomFont = false;
// Add Vocal Arrangement
data.Arrangements.Add(voc);
}
else
{
Attributes2014 attr2014 = new Attributes2014();
Song rsSong = new Song();
Song2014 rsSong2014 = new Song2014();
// optimized tone matching effort using project mapping algo
var result = projectMap.First(m => Path.GetFileName(m.SongXmlPath).ToLower() == Path.GetFileName(xmlFile).ToLower());
if (result.Tones.Count != 1)
throw new DataException("Invalid RS1 CDLC Tones Data");
var arrangement = attr.First(s => s.SongXml.ToLower().Contains(result.LLID));
var tone = tones.First(t => t.Key == result.Tones[0]);
using (var obj1 = new Rs1Converter())
{
rsSong = obj1.XmlToSong(xmlFile);
data.SongInfo.AverageTempo = (int)obj1.AverageBPM(rsSong);
}
if (arrangement.Tuning == "E Standard")
rsSong.Tuning = new TuningStrings { String0 = 0, String1 = 0, String2 = 0, String3 = 0, String4 = 0, String5 = 0 };
else if (arrangement.Tuning == "DropD")
rsSong.Tuning = new TuningStrings { String0 = -2, String1 = 0, String2 = 0, String3 = 0, String4 = 0, String5 = 0 };
else if (arrangement.Tuning == "OpenG")
rsSong.Tuning = new TuningStrings { String0 = -2, String1 = -2, String2 = 0, String3 = 0, String4 = 0, String5 = -2 };
else if (arrangement.Tuning == "EFlat")
rsSong.Tuning = new TuningStrings { String0 = -1, String1 = -1, String2 = -1, String3 = -1, String4 = -1, String5 = -1 };
else // default to standard tuning
{
arrangement.Tuning = "E Standard";
rsSong.Tuning = new TuningStrings { String0 = 0, String1 = 0, String2 = 0, String3 = 0, String4 = 0, String5 = 0 };
}
// save/write the changes to xml file
using (var obj1 = new Rs1Converter())
obj1.SongToXml(rsSong, xmlFile, true);
if (convert)
using (var obj1 = new Rs1Converter())
tones2014.Add(obj1.ToneToTone2014(tone, rsSong));
var test = tones2014.ToArray();
// load attr2014 with RS1 mapped values for use by Arrangement()
attr2014.Tone_Base = tone.Name;
attr2014.ArrangementName = arrangement.ArrangementName;
attr2014.CentOffset = 0;
attr2014.DynamicVisualDensity = new List<float>() { 2 };
attr2014.SongPartition = arrangement.SongPartition;
attr2014.PersistentID = IdGenerator.Guid().ToString();
attr2014.MasterID_RDV = RandomGenerator.NextInt();
attr2014.ArrangementProperties = new SongArrangementProperties2014();
// processing order is important - CAREFUL
// RouteMask None = 0, Lead = 1, Rhythm = 2, Any = 3, Bass = 4
// XML file names are usually meaningless to arrangement determination
if (arrangement.ArrangementName.ToLower().Contains("lead") ||
rsSong.Arrangement.ToLower().Contains("lead"))
{
attr2014.ArrangementName = "Lead";
attr2014.ArrangementType = (int)ArrangementType.Guitar;
attr2014.ArrangementProperties.RouteMask = (int)RouteMask.Lead;
attr2014.ArrangementProperties.PathLead = 1;
attr2014.ArrangementProperties.PathRhythm = 0;
attr2014.ArrangementProperties.PathBass = 0;
}
else if (arrangement.ArrangementName.ToLower().Contains("rhythm") ||
rsSong.Arrangement.ToLower().Contains("rhythm"))
// || rsSong.Arrangement.ToLower().Contains("guitar"))
{
attr2014.ArrangementName = "Rhythm";
attr2014.ArrangementType = (int)ArrangementType.Guitar;
attr2014.ArrangementProperties.RouteMask = (int)RouteMask.Rhythm;
attr2014.ArrangementProperties.PathLead = 0;
attr2014.ArrangementProperties.PathRhythm = 1;
attr2014.ArrangementProperties.PathBass = 0;
}
else if (arrangement.ArrangementName.ToLower().Contains("combo") ||
rsSong.Arrangement.ToLower().Contains("combo"))
{
attr2014.ArrangementName = "Combo";
attr2014.ArrangementType = (int)ArrangementType.Guitar;
attr2014.ArrangementProperties.RouteMask = arrangement.EffectChainName.ToLower().Contains("lead") ? (int)RouteMask.Lead : (int)RouteMask.Rhythm;
attr2014.ArrangementProperties.PathLead = arrangement.EffectChainName.ToLower().Contains("lead") ? 1 : 0;
attr2014.ArrangementProperties.PathRhythm = arrangement.EffectChainName.ToLower().Contains("lead") ? 0 : 1;
attr2014.ArrangementProperties.PathBass = 0;
}
else if (arrangement.ArrangementName.ToLower().Contains("bass") ||
rsSong.Arrangement.ToLower().Contains("bass"))
{
attr2014.ArrangementName = "Bass";
attr2014.ArrangementType = (int)ArrangementType.Bass;
attr2014.ArrangementProperties.RouteMask = (int)RouteMask.Bass;
attr2014.ArrangementProperties.PathLead = 0;
attr2014.ArrangementProperties.PathRhythm = 0;
attr2014.ArrangementProperties.PathBass = 1;
}
else
{
// default to Lead arrangment
attr2014.ArrangementName = "Lead";
attr2014.ArrangementType = (int)ArrangementType.Guitar;
attr2014.ArrangementProperties.RouteMask = (int)RouteMask.Lead;
attr2014.ArrangementProperties.PathLead = 1;
attr2014.ArrangementProperties.PathRhythm = 0;
attr2014.ArrangementProperties.PathBass = 0;
Console.WriteLine("RS1->RS2 CDLC Conversion defaulted to 'Lead' arrangment");
}
if (convert) // RS1 -> RS2 magic
{
using (var obj1 = new Rs1Converter())
rsSong2014 = obj1.SongToSong2014(rsSong);
// update ArrangementProperties
rsSong2014.ArrangementProperties.RouteMask = attr2014.ArrangementProperties.RouteMask;
rsSong2014.ArrangementProperties.PathLead = attr2014.ArrangementProperties.PathLead;
rsSong2014.ArrangementProperties.PathRhythm = attr2014.ArrangementProperties.PathRhythm;
rsSong2014.ArrangementProperties.PathBass = attr2014.ArrangementProperties.PathBass;
rsSong2014.ArrangementProperties.StandardTuning = (arrangement.Tuning == "E Standard" ? 1 : 0);
// <note time="58.366" linkNext="0" accent="0" bend="0" fret="7" hammerOn="0" harmonic="0" hopo="0" ignore="0" leftHand="-1" mute="0" palmMute="0" pluck="-1" pullOff="0" slap="-1" slideTo="-1" string="3" sustain="0.108" tremolo="0" harmonicPinch="0" pickDirection="0" rightHand="-1" slideUnpitchTo="-1" tap="0" vibrato="0" />
if (rsSong2014.Levels.Any(sl => sl.Notes.Any(sln => sln.Bend != 0)))
rsSong2014.ArrangementProperties.Bends = 1;
if (rsSong2014.Levels.Any(sl => sl.Notes.Any(sln => sln.Hopo != 0)))
rsSong2014.ArrangementProperties.Hopo = 1;
if (rsSong2014.Levels.Any(sl => sl.Notes.Any(sln => sln.SlideTo != -1)))
rsSong2014.ArrangementProperties.Slides = 1;
if (rsSong2014.Levels.Any(sl => sl.Notes.Any(sln => sln.Sustain > 0)))
rsSong2014.ArrangementProperties.Sustain = 1;
// fixing times that are off
var lastEbeatsTime = rsSong2014.Ebeats[rsSong2014.Ebeats.Length - 1].Time;
var lastPhraseIterationsTime = rsSong2014.PhraseIterations[rsSong2014.PhraseIterations.Length - 1].Time;
// tested ... not source of in game hangs
// confirm last PhraseIterations time is less than last Ebeats time
if (lastPhraseIterationsTime > lastEbeatsTime)
{
rsSong2014.PhraseIterations[rsSong2014.PhraseIterations.Length - 1].Time = lastEbeatsTime;
rsSong2014.Sections[rsSong2014.Sections.Length - 1].StartTime = lastEbeatsTime;
}
// tested ... not source of in game hangs
// confirm SongLength at least equals last Ebeats time
if (rsSong2014.SongLength < lastEbeatsTime)
rsSong2014.SongLength = lastEbeatsTime;
using (var obj2 = new Rs2014Converter())
obj2.Song2014ToXml(rsSong2014, xmlFile, true);
}
// Adding Song Arrangement
try
{
data.Arrangements.Add(new Arrangement(attr2014, xmlFile));
}
catch (Exception ex)
{
// mainly for the benifit of convert2012 CLI users
Console.WriteLine(@"This CDLC could not be auto converted." + Environment.NewLine + "You can still try manually adding the arrangements and assests." + Environment.NewLine + ex.Message);
}
}
}
// get rid of duplicate tone names
tones2014 = tones2014.Where(p => p.Name != null)
.GroupBy(p => p.Name).Select(g => g.First()).ToList();
data.TonesRS2014 = tones2014;
//Get Album Artwork DDS Files
var artFiles = Directory.GetFiles(unpackedDir, "*.dds", SearchOption.AllDirectories);
if (artFiles.Length < 1)
throw new DataException("No Album Artwork file found.");
if (artFiles.Length > 1)
throw new DataException("More than one Album Artwork file found.");
var targetArtFiles = new List<DDSConvertedFile>();
data.AlbumArtPath = artFiles[0];
targetArtFiles.Add(new DDSConvertedFile() { sizeX = 256, sizeY = 256, sourceFile = artFiles[0], destinationFile = artFiles[0].CopyToTempFile(".dds") });
data.ArtFiles = targetArtFiles;
//Audio files
var targetAudioFiles = new List<string>();
var audioFiles = Directory.GetFiles(unpackedDir, "*.ogg", SearchOption.AllDirectories);
if (audioFiles.Length < 1)
throw new DataException("No Audio file found.");
if (audioFiles.Length > 2)
throw new DataException("Too many Audio files found.");
int i;
for (i = 0; i < audioFiles.Length; i++)
{
if (convert && audioFiles[i].Contains("_fixed.ogg")) // use it
break;
if (!convert && !audioFiles[i].Contains("_fixed.ogg"))
break;
}
var sourcePlatform = unpackedDir.GetPlatform();
if (targetPlatform.IsConsole != (sourcePlatform = audioFiles[i].GetAudioPlatform()).IsConsole)
{
var newFile = Path.Combine(Path.GetDirectoryName(audioFiles[i]), String.Format("{0}_cap.ogg", Path.GetFileNameWithoutExtension(audioFiles[i])));
OggFile.ConvertAudioPlatform(audioFiles[i], newFile);
audioFiles[i] = newFile;
}
targetAudioFiles.Add(audioFiles[i]);
if (!targetAudioFiles.Any())
throw new DataException("Audio file not found.");
FileInfo a = new FileInfo(audioFiles[i]);
data.OggPath = a.FullName;
//AppID
if (!convert)
{
var appidFile = Directory.GetFiles(unpackedDir, "*APP_ID*", SearchOption.AllDirectories);
if (appidFile.Length > 0)
data.AppId = File.ReadAllText(appidFile[0]);
}
else
data.AppId = "248750";
//Package version
var versionFile = Directory.GetFiles(unpackedDir, "toolkit.version", SearchOption.AllDirectories);
if (versionFile.Length > 0)
data.PackageVersion = GeneralExtensions.ReadPackageVersion(versionFile[0]);
else data.PackageVersion = "1";
if (convert)
data.Tones = null;
return data;
}
/// <summary>
/// Returns all possible arrangements for the given hand.
/// </summary>
public IEnumerable<Arrangement> Analyze()
{
var comparer = new ArrangementComparer(_concealed, _meldCount);
var arrangement = new Arrangement(0, _meldCount, _meldCount * 3);
_usedMelds = _meldCount;
_jantouValue = 0;
Analyze(arrangement, 0, 0);
var arrangements = _arrangements.Where(a => !_arrangements.Any(other => comparer.IsWorseThan(a, other))).OrderBy(a => a.Id);
var compacter = new ArrangementGroupCompacter();
return compacter.GetCompacted(arrangements);
}
