public async Task Get(int position)
{
if (lines == null)
{
string path = @"backers.csv";
StorageFolder folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
StorageFile file = await folder.GetFileAsync(path);
string csv = await FileIO.ReadTextAsync(file);
csv = csv.Remove(0, 12);
lines = csv.Split('\n');
}
for (int index = position; index < position + 250 && index < lines.Count(); index++)
{
var line = lines[index];
if (line == "")
{
continue;
}
string[] item = line.Split(';');
BackItem backers = new BackItem();
backers.Name = item[0];
backers.Country = item[1];
Locator.MainPageVM.Backers.Add(backers);
}
}
public void MoveBackgroundToTop(BackItem back)
{
back.rect.anchoredPosition = new Vector3(0, lastBack.rect.anchoredPosition.y + Const.BACK_HEIGHT - 10);
lastBack = back;
int lastIndex = colorIndex;
if (backCount == 0)
{
spawnLevel++;
if (IsClassicMode())
{
colorIndex = (colorIndex + 1) % 5;
SpawnNewObstacle(Random.Range(0, obstaclePrefabs.Count), back.rect.anchoredPosition / 100);
}
else
{
if (spawnLevel <= challengeController.listObstacles.Count)
{
colorIndex = (colorIndex + 1) % 5;
SpawnNewObstacle(challengeController.listObstacles[spawnLevel - 1] - 1, back.rect.anchoredPosition / 100);
}
}
}
backCount = (backCount + 1) % 2;
lastBack.SetUp(colorIndex, colorIndex != lastIndex ? lastIndex : colorIndex, colorIndex != lastIndex, false, spawnLevel);
}
public static void Back_item_infix_upgrade_modifiers_are_positive(BackItem backItem)
{
if (backItem.InfixUpgrade is InfixUpgrade)
{
Assert.All(backItem.InfixUpgrade.Attributes, actual => Assert.InRange(actual.Modifier, 1, int.MaxValue));
}
}
public void VipersBack_HasExpectedValues()
{
// Arrange
var attributes = new List <ItemStatAttribute>
{
new ItemStatAttribute("Power", .3m),
new ItemStatAttribute("ConditionDamage", .3m),
new ItemStatAttribute("Precision", .165m),
new ItemStatAttribute("Expertise", .165m)
};
// Act
var actual = new BackItem(attributes);
// Assert
const int expectedPower = 52;
const int expectedConditionDamage = 52;
const int expectedPrecision = 27;
const int expectedExpertise = 27;
Assert.AreEqual(expectedPower, actual.Power);
Assert.AreEqual(expectedConditionDamage, actual.ConditionDamage);
Assert.AreEqual(expectedPrecision, actual.Precision);
Assert.AreEqual(expectedExpertise, actual.Expertise);
}
public static void Back_item_suffix_item_id_is_null_or_positive(BackItem actual)
{
if (actual.SuffixItemId.HasValue)
{
Assert.InRange(actual.SuffixItemId.Value, 1, int.MaxValue);
}
}
public static void Back_item_infix_upgrade_id_is_positive(BackItem actual)
{
if (actual.InfixUpgrade is InfixUpgrade)
{
Assert.InRange(actual.InfixUpgrade.Id, 1, int.MaxValue);
}
}
public void SetPassDelta(float delta)
{
curLastBack = null;
passedDelta = delta;
float percent = Mathf.Clamp(passedDelta / (listObstacles.Count * Const.BACK_HEIGHT * 2), 0, 1);
progressMask.rectTransform.sizeDelta = new Vector2(percent * 400, 100);
}
private void LoadBack(Wz_Node backNode)
{
foreach (var node in backNode.Nodes)
{
var item = BackItem.LoadFromNode(node);
item.Name = $"back_{node.Text}";
item.Index = int.Parse(node.Text);
(item.IsFront ? this.Scene.Front : this.Scene.Back).Slots.Add(item);
}
}
private BackItem SpawnNewBackground(Vector3 localPos)
{
BackItem back = (BackItem)Instantiate(backPrefab, Vector3.zero, Quaternion.identity);
back.transform.SetParent(backRegion);
back.GetComponent <RectTransform>().anchoredPosition3D = localPos;
back.transform.localScale = Vector3.one;
back.onNewLevel += OnNewLevel;
back.onPassLevel += OnPassLevel;
return(back);
}
private void SetupBackground()
{
lastBack = SpawnNewBackground(Vector3.zero);
lastBack.SetUp(0, 5, true, true, 0);
backs.Add(lastBack);
colorIndex = Random.Range(1, 5);
float canvasHeight = backRegion.parent.GetComponent <RectTransform>().sizeDelta.y;
for (int i = 0; i < 2; i++)
{
Vector3 pos = new Vector3(0, lastBack.rect.anchoredPosition.y + (i == 0 ? canvasHeight : Const.BACK_HEIGHT));
lastBack = SpawnNewBackground(pos);
lastBack.SetUp(colorIndex, colorIndex, i == 0, false, 1);
backs.Add(lastBack);
}
}
private void ResetBackground(int startLevel)
{
float canvasHeight = backRegion.parent.GetComponent <RectTransform>().sizeDelta.y;
backs[0].rect.anchoredPosition3D = Vector3.zero;
backs[0].SetUp(0, 5, true, true, 0);
colorIndex = Random.Range(1, 5);
for (int i = 1; i < 3; i++)
{
Vector3 pos = new Vector3(0, backs[i - 1].rect.anchoredPosition.y + (i == 1 ? canvasHeight : Const.BACK_HEIGHT));
backs[i].rect.anchoredPosition3D = pos;
backs[i].SetUp(colorIndex, colorIndex, i == 1, false, startLevel);
backs[i].transform.SetAsLastSibling();
lastBack = backs[i];
}
backCount = 0;
}
private void PreloadResource(ResourceLoader resLoader, BackItem back)
{
string aniDir;
switch (back.Ani)
{
case 0: aniDir = "back"; break;
case 1: aniDir = "ani"; break;
case 2: aniDir = "spine"; break;
default: throw new Exception($"Unknown back ani value: {back.Ani}.");
}
string path = $@"Map\Back\{back.BS}.img\{aniDir}\{back.No}";
var aniItem = resLoader.LoadAnimationData(path);
back.View = new BackItem.ItemView()
{
Animator = CreateAnimator(aniItem, back.SpineAni)
};
}
public void BerserkersBack_HasExpectedValues()
{
// Arrange
var attributes = new List <ItemStatAttribute>
{
new ItemStatAttribute("Power", .35m),
new ItemStatAttribute("Precision", .25m),
new ItemStatAttribute("Ferocity", .25m)
};
// Act
var actual = new BackItem(attributes);
// Assert
const int expectedPower = 63;
const int expectedPrecision = 40;
const int expectedFerocity = 40;
Assert.AreEqual(expectedPower, actual.Power);
Assert.AreEqual(expectedPrecision, actual.Precision);
Assert.AreEqual(expectedFerocity, actual.Ferocity);
}
private MeshItem GetMeshBack(BackItem back)
{
//计算计算culling
if (back.ScreenMode != 0 && back.ScreenMode != renderEnv.Camera.DisplayMode + 1)
{
return(null);
}
//计算坐标
Point renderSize;
if (back.View.Animator is FrameAnimator)
{
var ani = (FrameAnimator)back.View.Animator;
renderSize = ani.CurrentFrame.Rectangle.Size;
}
else if (back.View.Animator is SpineAnimator)
{
var ani = (SpineAnimator)back.View.Animator;
var data = ani.Data.SkeletonData;
var rect = ani.Measure();
renderSize = rect.Size; // new Point((int)data.Width, (int)data.Height);
}
else
{
renderSize = Point.Zero;
}
int cx = (back.Cx == 0 ? renderSize.X : back.Cx);
int cy = (back.Cy == 0 ? renderSize.Y : back.Cy);
Vector2 tileOff = new Vector2(cx, cy);
Vector2 position = new Vector2(back.X, back.Y);
//计算水平卷动
if ((back.TileMode & TileMode.ScrollHorizontal) != 0)
{
position.X += ((float)back.Rx * 5 * back.View.Time / 1000) % cx;// +this.Camera.Center.X * (100 - Math.Abs(this.rx)) / 100;
}
else //镜头移动比率偏移
{
position.X += renderEnv.Camera.Center.X * (100 + back.Rx) / 100;
}
//计算垂直卷动
if ((back.TileMode & TileMode.ScrollVertical) != 0)
{
position.Y += ((float)back.Ry * 5 * back.View.Time / 1000) % cy;// +this.Camera.Center.Y * (100 - Math.Abs(this.ry)) / 100;
}
else //镜头移动比率偏移
{
position.Y += (renderEnv.Camera.Center.Y) * (100 + back.Ry) / 100;
}
//y轴镜头调整
//if (back.TileMode == TileMode.None && renderEnv.Camera.WorldRect.Height > 600)
// position.Y += (renderEnv.Camera.Height - 600) / 2;
//取整
position.X = (float)Math.Floor(position.X);
position.Y = (float)Math.Floor(position.Y);
//计算tile
Rectangle?tileRect = null;
if (back.TileMode != TileMode.None)
{
var cameraRect = renderEnv.Camera.ClipRect;
int l, t, r, b;
if ((back.TileMode & TileMode.Horizontal) != 0 && cx > 0)
{
l = (int)Math.Floor((cameraRect.Left - position.X) / cx) - 1;
r = (int)Math.Ceiling((cameraRect.Right - position.X) / cx) + 1;
}
else
{
l = 0;
r = 1;
}
if ((back.TileMode & TileMode.Vertical) != 0 && cy > 0)
{
t = (int)Math.Floor((cameraRect.Top - position.Y) / cy) - 1;
b = (int)Math.Ceiling((cameraRect.Bottom - position.Y) / cy) + 1;
}
else
{
t = 0;
b = 1;
}
tileRect = new Rectangle(l, t, r - l, b - t);
}
//生成mesh
var renderObj = GetRenderObject(back.View.Animator, back.Flip, back.Alpha);
if (renderObj == null)
{
return(null);
}
var mesh = batcher.MeshPop();
mesh.RenderObject = renderObj;
mesh.Position = position;
mesh.Z0 = 0;
mesh.Z1 = back.Index;
mesh.FlipX = back.Flip;
mesh.TileRegion = tileRect;
mesh.TileOffset = tileOff;
return(mesh);
}
public override void HandleMenuItem()
{
DoAction();
BackItem.OnItemWasChosen();
}
public void UpdateNewLevel(BackItem lastBack, float delta)
{
passedDelta = delta;
curLastBack = lastBack;
lastBackStartPosY = curLastBack.rect.anchoredPosition.y;
}
public static void Back_item_level_is_between_0_and_80(BackItem actual) => Assert.InRange(actual.Level, 0, 80);
public static async Task GetItems()
{
List <Item> allItems = new List <Item>();
List <int> allIds = apiOperations.GetAllIds(ITEMS_SUFFIX);
Console.WriteLine($"Got {allIds.Count} items Ids");
for (int i = 0; i < allIds.Count; i += 200)
{
IEnumerable <int> idsToDownload = allIds.Skip(i).Take(200);
StringBuilder endpoint = new StringBuilder(ITEMS_SUFFIX).Append("?ids=");
foreach (var id in idsToDownload)
{
endpoint.Append(id)
.Append(',');
}
endpoint.Length--;
List <APIResult <Item> > result = apiOperations.GetObjectsByIds <Item>(endpoint.ToString());
foreach (var apiItem in result)
{
Item itemToAdd = apiItem.ResultObject;
switch (itemToAdd.Type)
{
case "Armor":
Armor armor = JsonConvert.DeserializeObject <Armor>(apiItem.AdditionalDetails);
armor.Id = itemToAdd.Id;
itemToAdd.Armor = armor;
itemToAdd.ArmorId = armor.Id;
dbOperations.AddWithoutCommit <Armor>(armor);
break;
case "Weapon":
Weapon weapon = JsonConvert.DeserializeObject <Weapon>(apiItem.AdditionalDetails);
weapon.Id = itemToAdd.Id;
itemToAdd.Weapon = weapon;
itemToAdd.WeaponId = weapon.Id;
dbOperations.AddWithoutCommit <Weapon>(weapon);
break;
case "Back":
BackItem backItem = JsonConvert.DeserializeObject <BackItem>(apiItem.AdditionalDetails);
if (backItem == null)
{
backItem = new BackItem();
}
backItem.Id = itemToAdd.Id;
itemToAdd.BackItem = backItem;
itemToAdd.BackItemId = backItem.Id;
dbOperations.AddWithoutCommit <BackItem>(backItem);
break;
case "Consumable":
Consumable consumable = JsonConvert.DeserializeObject <Consumable>(apiItem.AdditionalDetails);
consumable.Id = itemToAdd.Id;
itemToAdd.Consumable = consumable;
itemToAdd.ConsumableId = consumable.Id;
dbOperations.AddWithoutCommit <Consumable>(consumable);
break;
case "Container":
Container container = JsonConvert.DeserializeObject <Container>(apiItem.AdditionalDetails);
container.Id = itemToAdd.Id;
itemToAdd.Container = container;
itemToAdd.ContainerId = container.Id;
dbOperations.AddWithoutCommit <Container>(container);
break;
case "Gathering":
GatheringTool gathering = JsonConvert.DeserializeObject <GatheringTool>(apiItem.AdditionalDetails);
gathering.Id = itemToAdd.Id;
itemToAdd.GatheringTool = gathering;
itemToAdd.GatheringToolId = gathering.Id;
dbOperations.AddWithoutCommit <GatheringTool>(gathering);
break;
case "Gizmo":
Gizmo gizmo = JsonConvert.DeserializeObject <Gizmo>(apiItem.AdditionalDetails);
gizmo.Id = itemToAdd.Id;
itemToAdd.Gizmo = gizmo;
itemToAdd.GizmoId = gizmo.Id;
dbOperations.AddWithoutCommit <Gizmo>(gizmo);
break;
case "MiniPet":
Miniature mini = JsonConvert.DeserializeObject <Miniature>(apiItem.AdditionalDetails);
mini.Id = itemToAdd.Id;
itemToAdd.Miniature = mini;
itemToAdd.MiniatureId = mini.Id;
dbOperations.AddWithoutCommit <Miniature>(mini);
break;
case "Tool":
SalvageKit salvage = JsonConvert.DeserializeObject <SalvageKit>(apiItem.AdditionalDetails);
salvage.Id = itemToAdd.Id;
itemToAdd.SalvageKit = salvage;
itemToAdd.SalvageKitId = salvage.Id;
dbOperations.AddWithoutCommit <SalvageKit>(salvage);
break;
case "Trinket":
Trinket trinket = JsonConvert.DeserializeObject <Trinket>(apiItem.AdditionalDetails);
trinket.Id = itemToAdd.Id;
itemToAdd.Trinket = trinket;
itemToAdd.TrinketId = trinket.Id;
dbOperations.AddWithoutCommit <Trinket>(trinket);
break;
case "UpgradeComponent":
UpgradeComponent upgrade = JsonConvert.DeserializeObject <UpgradeComponent>(apiItem.AdditionalDetails);
upgrade.Id = itemToAdd.Id;
itemToAdd.UpgradeComponent = upgrade;
itemToAdd.UpgradeComponentId = upgrade.Id;
dbOperations.AddWithoutCommit <UpgradeComponent>(upgrade);
break;
default:
break;
}
allItems.Add(apiItem.ResultObject);
}
Console.WriteLine($"Loaded {allItems.Count} out of {allIds.Count} items");
}
await dbOperations.AddToEntity <Item>(allItems);
Console.WriteLine("Getting items completed");
}
