/// <summary>
/// ■brakePower:ブレーキの強さ
/// </summary>
public EngineSpeedCalc(VehicleSettings.EngineSettings engineSettings, VehicleSettings.PenaltySettings penaltySettings,
GearParam gearParam, IReadOnlyReactiveProperty <GearState> gear)
{
mEngineSettings = engineSettings;
mPenaltySettings = penaltySettings;
mCurrentGear = gear;
mLowestSpeed = gearParam.GetGearData(GearState.REVERSE).MaxSpeed;
mEngineRpmCalculator = new EngineRpmCalculator(gearParam, gear);
mCurrentGear
.Buffer(2, 1)
.Subscribe(x =>
{
//現在のギアデータ
GearData gearData = gearParam.GetGearData(x.Last());
//1つ前のギアデータ
GearData lateGearData = gearParam.GetGearData(x.First());
//現在のギアに必要な回転数を取得
mNeedSpeed = gearData.NeedSpeed;
//現在のギアの最大回転数を取得
mMaxSpeed = gearData.MaxSpeed;
//ギア変更前の最大回転数を取得
mPreMaxSpeed = lateGearData.MaxSpeed;
//エンジンブレーキの強さを取得
mEngineBrakePow = gearData.EngineBrake;
//1秒あたりのエンジン回転数を取得
mAccPow = gearData.EngineRot;
});
}
private static void LoadGearAsset(GearData gear)
{
if (allGear.ContainsKey(gear.gearID))
{
GearData conflict = allGear[gear.gearID];
string warning =
string.Format("{3}: Gear '{0}' has conflicting ID with '{1}' (id {2}), skipping...",
gear.gearName, conflict.gearName, gear.gearID, gear.name);
Debug.LogWarning(warning);
return;
}
allGear.Add(gear.gearID, gear);
gearByName.Add(gear.gearName, gear);
//see if the list for this catagory already exists
if (gearBySlotType.TryGetValue(gear.requiredSlot, out List <GearData> catagory))
{
catagory.Add(gear);
}
else
{
List <GearData> newcatagory = new List <GearData>();
newcatagory.Add(gear);
gearBySlotType.Add(gear.requiredSlot, newcatagory);
}
}
public LoadoutSlot(string name, GearSlotTypes slot, bool hidden)
{
this.name = name;
this.type = slot;
this.hidden = hidden;
this.contains = null;
}
public GearData Pop()
{
if (activePool == null)
{
MakeActive();
}
int budget = Random.Range(0, poolSum);
GearData selected = null;
int index = 0;
while (budget >= 0 && index < activePool.Count)
{
selected = activePool[index];
budget -= (int)selected.rarity;
index++;
}
if (index != 0)
{
index--;
}
activePool.RemoveAt(index--);
poolSum -= (int)selected.rarity;
return(selected);
}
public static LootPool GenerateMasterLootPool()
{
if (!loaded)
{
Debug.LogError("Made lootpool when lootpool wasn't loaded!");
}
LootPool master = new LootPool();
foreach (KeyValuePair <int, GearData> pair in allGear)
{
GearData gear = pair.Value;
if (gear.rarity != LootPool.LootRarity.DontSpawn)
{
//only one of each can be equipped at a time, so the lootpool only needs one copy
if (gear.requiredSlot == GearSlotTypes.Head ||
gear.requiredSlot == GearSlotTypes.Body ||
gear.requiredSlot == GearSlotTypes.Core)
{
master.AddGear(gear);
}
else
{
master.AddGear(gear, n: 2);
}
}
}
return(master);
}
void SetGearInfo(string json)
{
_gearResponseData = JsonConvert.DeserializeObject <GearResponseData>(json);
for (int i = 0; i < _gearResponseData.gears.Count; i++)
{
GearData data = _gearResponseData.gears[i];
}
}
public void EquipIntoSlot(GearData gear, LoadoutSlots slot)
{
if (!CanEquipIntoSlot(gear, slot))
{
throw new ArgumentException("Cannot equip " + gear + " into " + slot.ToString());
}
LoadoutSlot slotcontainer = slots[slot];
slotcontainer.contains = gear;
}
public void AddRewardOption(GearData newGear)
{
RewardScreenItem option = Instantiate(rewardScreenTemplate, rewardContainer);
option.SetGear(newGear);
option.gameObject.SetActive(true);
option.OnMouseEnter += () => { MouseOverOption(newGear); };
option.OnMouseExit += () => { MouseLeaveOption(); };
option.OnMouseClick += () => { MouseSelectOption(option); };
activeOptions.Add(option);
}
public void MouseOverOption(GearData gear)
{
if (activePreviews.Count != 0)
{
ClearPreviews();
}
foreach (CardBundle card in gear.Cards)
{
CreateCardPreview(card.card, card.amount);
}
}
public void ForceSetGear(GearData gear)
{
equippedGear = gear;
if (gear != null)
{
icon.enabled = true;
icon.sprite = gear.art;
}
else
{
icon.enabled = false;
}
}
public int GetCountOf(GearData gear)
{
int gearID = gear.gearID;
if (contents.TryGetValue(gearID, out int existingQuantity))
{
return(existingQuantity);
}
else
{
return(0);
}
}
public void AddItem(GearData gear, int n = 1)
{
int gearID = gear.gearID;
if (contents.TryGetValue(gearID, out int existingQuantity))
{
contents[gearID] = existingQuantity + n;
}
else
{
contents.Add(gearID, n);
}
}
public void BuildGearList()
{
_gearList = new List <StoreItem>();
//Debug.Log(OnlineManager.Instance.GearResponseData.gears.Count);
for (int i = 0; i < OnlineManager.Instance.GearResponseData.gears.Count; i++)
{
GearData gearData = OnlineManager.Instance.GearResponseData.gears[i];
StoreItem storeItem = new StoreItem();
storeItem.Name = gearData.name;
storeItem.Type = gearData.gear_type.ToUpper();
if (gearData.body_type != null)
{
storeItem.BodyType = gearData.body_type.ToUpper();
}
else
{
storeItem.BodyType = "";
}
storeItem.DisplayName = gearData.display_name;
storeItem.Description = gearData.description;
storeItem.AssetName = gearData.asset_name;
storeItem.IconName = gearData.icon_name;
storeItem.Coins = gearData.coins;
storeItem.Gems = gearData.gems;
storeItem.Level = gearData.level;
storeItem.HealthBonus = gearData.health_bonus;
storeItem.SpeedBonus = gearData.speed_bonus;
storeItem.RangeBonus = gearData.range_bonus;
storeItem.Hair = gearData.hair;
if (gearData.owned_by_default)
{
storeItem.OwnedByDefault = 1;
}
else
{
storeItem.OwnedByDefault = 0;
}
if (gearData.equipped_by_default)
{
storeItem.EquippedByDefault = 1;
}
else
{
storeItem.EquippedByDefault = 0;
}
storeItem.ColorDecal = gearData.color_decal;
_gearList.Add(storeItem);
}
BuildCurrentGearList();
}
/// <summary>
/// Get a list of each kind of unique gear piece in the inventory that fits in a given slot
/// </summary>
/// <param name="slotFilter">The requiredSlot to filter for</param>
/// <returns></returns>
public List <GearData> GetAllGearTypesOfSlot(GearSlotTypes slotFilter)
{
List <GearData> output = new List <GearData>();
foreach (KeyValuePair <int, int> pair in contents)
{
GearData gear = GearDatabase.GetGearDataByID(pair.Key);
if (gear.requiredSlot == slotFilter)
{
output.Add(gear);
}
}
return(output);
}
public bool CanEquipIntoSlot(GearData gear, LoadoutSlots slot)
{
if (!SlotIsFree(slot))
{
return(false);
}
LoadoutSlot slotcontainer = slots[slot];
if (slotcontainer.type != gear.requiredSlot)
{
return(false);
}
return(true);
}
public void AddGear(GearData gear, int n = 1)
{
if (quantities.TryGetValue(gear, out int current))
{
quantities[gear] = current + n;
}
else
{
pool.Add(gear);
quantities.Add(gear, n);
}
//if (gear.rarity != LootRarity.DontSpawn)
//{
// poolSum += (int)gear.rarity * n;
//}
}
public void RemoveItem(GearData gear)
{
int gearID = gear.gearID;
if (contents.TryGetValue(gearID, out int existingQuantity))
{
int newQuantity = existingQuantity - 1;
if (newQuantity > 0)
{
contents[gearID] = newQuantity;
}
else
{
contents.Remove(gearID);
}
}
}
public void CreateButton(string label, GearData gear, Sprite icon)
{
Button newButton = Instantiate(buttonTemplate, transform);
newButton.GetComponentInChildren <Text>().text = label;
if (icon != null)
{
Image img = newButton.transform.Find("GearIcon").GetComponent <Image>();
img.enabled = true;
img.sprite = icon;
}
newButton.onClick.AddListener(() => { manager.OnEquipmentSelectionMade(gear); });
newButton.gameObject.SetActive(true);
newButton.gameObject.name = label;
activeButtons.Add(newButton);
}
/// <summary>
///
/// </summary>
/// <param name="gear">the gear to equip</param>
/// <param name="inventory">the inventory to return unequipped items into</param>
public void SetEquippedGear(GearData gear, InventoryCollection inventory)
{
if (equippedGear != null && inventory != null)
{
inventory.AddItem(equippedGear);
}
equippedGear = gear;
if (gear != null)
{
icon.enabled = true;
icon.sprite = gear.art;
UpdateDependants(true, inventory);
}
else
{
icon.enabled = false;
UpdateDependants(false, inventory);
}
}
public void RemoveGear(GearData gear)
{
if (quantities.TryGetValue(gear, out int current))
{
int newcurrent = current - 1;
if (newcurrent > 0)
{
quantities[gear] = newcurrent;
}
else
{
quantities.Remove(gear);
pool.Remove(gear);
}
//if (gear.rarity != LootRarity.DontSpawn)
// {
// poolSum -= (int)gear.rarity;
// }
}
}
internal Boolean DefineNewPositions(double positionChange)
{
posResult = PositionAnalysisResults.Normal;
InitializeJointsAndLinks(positionChange);
if (posResult == PositionAnalysisResults.InvalidPosition)
{
return(false);
}
var numUnknownJoints = joints.Count(j => j.positionKnown != KnownState.Fully);
while (posResult != PositionAnalysisResults.NoSolvableDyadFound && numUnknownJoints > 0)
{
posResult = PositionAnalysisResults.NoSolvableDyadFound;
foreach (var j in joints)
{
if (j.positionKnown == KnownState.Fully || j.JustATracer)
{
continue;
}
Joint knownJoint1;
Joint knownJoint2;
GearData gData;
double angleChange;
switch (j.TypeOfJoint)
{
case JointType.R:
#region R-R-R
if (FindKnownSlopeOnLink(j, j.Link1, out knownJoint1) &&
FindKnownSlopeOnLink(j, j.Link1, out knownJoint2, knownJoint1))
{
var sJPoint = solveViaIntersectingLines(j, knownJoint1, knownJoint2);
assignJointPosition(j, sJPoint, j.Link1);
setLinkPositionFromRotate(j, j.Link1);
setLinkPositionFromRotate(j, j.Link2);
}
else if (FindKnownPositionOnLink(j, j.Link1, out knownJoint1) &&
FindKnownPositionOnLink(j, j.Link2, out knownJoint2))
{
var sJPoint = solveViaCircleIntersection(j, knownJoint1, knownJoint2);
assignJointPosition(j, sJPoint, j.Link1);
setLinkPositionFromRotate(j, j.Link1);
setLinkPositionFromRotate(j, j.Link2);
}
#endregion
#region R-R-P
else if (FindKnownPositionOnLink(j, j.Link1, out knownJoint1) &&
FindKnownSlopeOnLink(j, j.Link2, out knownJoint2))
{
var sJPoint = solveViaCircleAndLineIntersection(j, knownJoint1, knownJoint2,
out angleChange);
assignJointPosition(j, sJPoint, j.Link1);
setLinkPositionFromRotate(j, j.Link1, angleChange);
setLinkPositionFromRotate(j, j.Link2);
}
#endregion
#region P-R-R
else if (FindKnownSlopeOnLink(j, j.Link1, out knownJoint1) &&
FindKnownPositionOnLink(j, j.Link2, out knownJoint2))
{
var sJPoint = solveViaCircleAndLineIntersection(j, knownJoint2, knownJoint1,
out angleChange);
assignJointPosition(j, sJPoint, j.Link2);
setLinkPositionFromRotate(j, j.Link2, angleChange);
setLinkPositionFromRotate(j, j.Link1);
}
#endregion
#region P-R-P
else if (FindKnownSlopeOnLink(j, j.Link1, out knownJoint1) &&
FindKnownSlopeOnLink(j, j.Link2, out knownJoint2))
{
var sJPoint = solveViaIntersectingLines(j, knownJoint1, knownJoint2);
assignJointPosition(j, sJPoint, j.Link1);
setLinkPositionFromRotate(j, j.Link1);
setLinkPositionFromRotate(j, j.Link2);
}
#endregion
#region R-R-GG
else if (FindKnownPositionOnLink(j, j.Link1, out knownJoint1) &&
GearData.FindKnownGearAngleOnLink(j, j.Link1, j.Link2, joints, links, gearsData,
out gData))
{
gData.SolveGearCenterFromKnownGearAngle(j, knownJoint1, links, out angleChange);
setLinkPositionFromRotate(knownJoint1, j.Link1, angleChange);
}
#endregion
#region GG-R-R
else if (FindKnownPositionOnLink(j, j.Link2, out knownJoint1) &&
GearData.FindKnownGearAngleOnLink(j, j.Link2, j.Link1, joints, links, gearsData,
out gData))
{
gData.SolveGearCenterFromKnownGearAngle(j, knownJoint1, links, out angleChange);
setLinkPositionFromRotate(knownJoint1, j.Link2, angleChange);
}
#endregion
break;
case JointType.P:
#region R-P-R
if (FindKnownPositionOnLink(j, j.Link1, out knownJoint1) &&
FindKnownPositionOnLink(j, j.Link2, out knownJoint2))
{
var sJPoint = solveRPRIntersection(j, knownJoint1, knownJoint2, out angleChange);
assignJointPosition(j, sJPoint, j.Link2);
setLinkPositionFromRotate(knownJoint1, j.Link1, angleChange);
setLinkPositionFromRotate(j, j.Link2, angleChange);
}
#endregion
#region P-P-R
else if (FindKnownSlopeOnLink(j, j.Link1, out knownJoint1) &&
FindKnownPositionOnLink(j, j.Link2, out knownJoint2))
{
/* in this case, the block is on the rotating link and the slide is on the sliding link */
var sJPoint = solveViaSlopeToCircleIntersectionPPR(j, knownJoint1, knownJoint2);
assignJointPosition(j, sJPoint, j.Link2);
setLinkPositionFromRotate(j, j.Link1);
setLinkPositionFromRotate(j, j.Link2);
//setLinkPositionFromTranslation(knownJoint1, j.Link1, sJPoint.x - j.xLast, sJPoint.y - j.yLast,
// j.SlideAngle);
//setLinkPositionFromTranslation(j, j.Link2, sJPoint.x - j.xLast, sJPoint.y - j.yLast);
}
#endregion
#region R-P-P
else if (FindKnownPositionOnLink(j, j.Link1, out knownJoint1) &&
FindKnownSlopeOnLink(j, j.Link2, out knownJoint2))
{
/* in this case, the slide is on the rotating link and the block is on the sliding link */
Point sJPoint = solveViaSlopeToCircleIntersectionRPP(j, knownJoint1, knownJoint2);
assignJointPosition(j, sJPoint, j.Link2);
setLinkPositionFromRotate(j, j.Link1);
setLinkPositionFromRotate(j, j.Link2);
//setLinkPositionFromTranslation(j, j.Link2, sJPoint.x - j.xLast, sJPoint.y - j.yLast);
}
#endregion
#region P-P-P
else if (FindKnownSlopeOnLink(j, j.Link1, out knownJoint1) &&
FindKnownSlopeOnLink(j, j.Link2, out knownJoint2))
{
var sJPoint = solveViaIntersectingLines(j, knownJoint1, knownJoint2);
assignJointPosition(j, sJPoint, j.Link1);
setLinkPositionFromRotate(j, j.Link1);
setLinkPositionFromRotate(j, j.Link2);
}
#endregion
break;
case JointType.RP:
#region R-RP-R&P
//if (FindKnownPositionOnLink(j.Link1, out knownJoint1) &&
// FindKnownPositionAndSlopeOnLink(j.Link2, out knownJoint2))
//{
// throw new Exception("I didn't think it was possible to have an unknown joint for R-RP-R&P");
// /* why is it not possible?
// * because j.Link2 would be the fixed pivot within the joint and since it was known fully,
// * j would have j.knownState = KnownState.Fully and would not be cycled over. */
//}
#endregion
#region P-RP-R&P
//else if (FindKnownSlopeOnLink(j.Link1, out knownJoint1)
// &&
// FindKnownPositionAndSlopeOnLink(j.Link2,
// out knownJoint2))
//{
// throw new Exception("I didn't think it was possible to have an unknown joint for R-RP-R&P");
// /* same as above. */
//}
#endregion
#region R&P-RP-R
if (FindKnownPositionAndSlopeOnLink(j, j.Link1, out knownJoint1) &&
FindKnownPositionOnLink(j, j.Link2, out knownJoint2))
{
var sJPoint = solveRotatePinToSlot(j, knownJoint2, out angleChange);
assignJointPosition(j, sJPoint, j.Link2);
setLinkPositionFromRotate(j, j.Link2, angleChange);
}
#endregion
#region R&P-RP-P
else if (FindKnownPositionAndSlopeOnLink(j, j.Link1, out knownJoint1) &&
FindKnownSlopeOnLink(j, j.Link2, out knownJoint2))
{
/* not sure this is right, but j must be partially known so it has enough
* information to define the first line. */
var sJPoint = solveViaIntersectingLines(j, j, knownJoint2);
assignJointPosition(j, sJPoint, j.Link2);
setLinkPositionFromRotate(j, j.Link2);
//setLinkPositionFromTranslation(j, j.Link2, sJPoint.x - j.xLast, sJPoint.y - j.yLast);
}
#endregion
break;
case JointType.G:
gData = gearsData[joints.IndexOf(j)];
#region R-G-R
if (gData.IsGearSolvableRGR(joints, links))
{
gData.SolveGearPositionAndAnglesRGR(joints, links);
posResult = PositionAnalysisResults.Normal;
}
#endregion
#region P-G-R
else if (gData.IsGearSolvablePGR(joints, links))
{
gData.SolveGearPositionAndAnglesPGR(joints, links);
posResult = PositionAnalysisResults.Normal;
}
#endregion
#region R-G-P
else if (gData.IsGearSolvableRGP(joints, links))
{
gData.SolveGearPositionAndAnglesRGP(joints, links);
posResult = PositionAnalysisResults.Normal;
}
#endregion
break;
}
if (posResult == PositionAnalysisResults.InvalidPosition)
{
return(false);
}
}
numUnknownJoints = joints.Count(j => j.positionKnown != KnownState.Fully);
}
if (posResult == PositionAnalysisResults.NoSolvableDyadFound && numUnknownJoints > 0)
{
try
{
if (NDPS == null)
{
NDPS = new NonDyadicPositionSolver(this);
}
var NDPSError = 0.0;
NDPS.Run_PositionsAreClose(out NDPSError);
PositionError = Math.Sqrt(NDPSError);
}
catch (Exception e)
{
Debug.WriteLine("Error in setting up and running NonDyadicPositionSolver.");
}
}
if (posResult == PositionAnalysisResults.InvalidPosition)
{
return(false);
}
if (joints.Any(j => Math.Abs(j.x - j.xInitial) > maximumDeltaX || Math.Abs(j.y - j.yInitial) > maximumDeltaY))
{
return(false);
}
if (joints.All(j => Math.Abs(j.x - j.xLast) < minimumDeltaX && Math.Abs(j.y - j.yLast) < minimumDeltaY &&
links.All(c => Math.Abs(c.Angle - c.AngleLast) < Constants.AngleMinimumFactor)))
{
return(false);
}
UpdateSliderPosition();
return(true);
}
public void CreateButton(GearData gear)
{
CreateButton(gear.gearName, gear, gear.art);
}
public static bool RunGeneric(List <GearDataHistoryItem> _HistoryArray, GearData _Data, UploadID _Uploader)
{
return(RunGeneric_T(_HistoryArray, new GearDataHistoryItem(_Data, _Uploader), GearDataHistoryItem.IsSame, GearDataHistoryItem.Time1BiggerThan2, GearDataHistoryItem.CopyUploader2To1));
}
public void SetGear(GearData gear)
{
this.gear = gear;
gearTitle.text = gear.gearName;
gearSprite.sprite = gear.art;
}
public bool ContainsItem(GearData gear)
{
return(contents.ContainsKey(gear.gearID));
}
