// Start is called before the first frame update
void Start()
{
ready = false;
scriptM = (MapSystem)map.GetComponent(typeof(MapSystem));
scriptP = (PickupSystem)pickupmap.GetComponent(typeof(PickupSystem));
}
// Start is called before the first frame update
void Start()
{
outlinable = GetComponent <Outlinable>();
playerRef = GameObject.Find("Player");
pickupSystem = playerRef.GetComponent <PickupSystem>();
lookAtSpot = GameObject.Find("LookAtSpot");
}
public LeagueCreationParameters ToDomain(FantasyCriticUser manager, IReadOnlyDictionary <string, MasterGameTag> tagDictionary)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
int freeDroppableGames = FreeDroppableGames;
if (UnlimitedFreeDroppableGames)
{
freeDroppableGames = -1;
}
int willNotReleaseDroppableGames = WillNotReleaseDroppableGames;
if (UnlimitedWillNotReleaseDroppableGames)
{
willNotReleaseDroppableGames = -1;
}
int willReleaseDroppableGames = WillReleaseDroppableGames;
if (UnlimitedWillReleaseDroppableGames)
{
willReleaseDroppableGames = -1;
}
var leagueTags = Tags.ToDomain(tagDictionary);
LeagueCreationParameters parameters = new LeagueCreationParameters(manager, LeagueName, StandardGames, GamesToDraft, CounterPicks,
freeDroppableGames, willNotReleaseDroppableGames, willReleaseDroppableGames, DropOnlyDraftGames, CounterPicksBlockDrops, MinimumBidAmount,
InitialYear, leagueTags, draftSystem, pickupSystem, scoringSystem, PublicLeague, TestLeague);
return(parameters);
}
public LeagueOptions(int standardGames, int gamesToDraft, int counterPicks, int counterPicksToDraft, int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames,
bool dropOnlyDraftGames, bool counterPicksBlockDrops, int minimumBidAmount, IEnumerable <LeagueTagStatus> leagueTags, IEnumerable <SpecialGameSlot> specialGameSlots,
DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, TradingSystem tradingSystem, TiebreakSystem tiebreakSystem, AnnualDate counterPickDeadline)
{
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
CounterPicksToDraft = counterPicksToDraft;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
CounterPicksBlockDrops = counterPicksBlockDrops;
MinimumBidAmount = minimumBidAmount;
LeagueTags = leagueTags.ToList();
SpecialGameSlots = specialGameSlots.OrderBy(x => x.SpecialSlotPosition).ToList();
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
TradingSystem = tradingSystem;
TiebreakSystem = tiebreakSystem;
CounterPickDeadline = counterPickDeadline;
_specialSlotDictionary = SpecialGameSlots.ToDictionary(specialGameSlot => StandardGames - SpecialGameSlots.Count + specialGameSlot.SpecialSlotPosition);
}
public LeagueCreationParameters ToDomain(FantasyCriticUser manager, EligibilityLevel maximumEligibilityLevel)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
int freeDroppableGames = FreeDroppableGames;
if (UnlimitedFreeDroppableGames)
{
freeDroppableGames = -1;
}
int willNotReleaseDroppableGames = WillNotReleaseDroppableGames;
if (UnlimitedWillNotReleaseDroppableGames)
{
willNotReleaseDroppableGames = -1;
}
int willReleaseDroppableGames = WillReleaseDroppableGames;
if (UnlimitedWillReleaseDroppableGames)
{
willReleaseDroppableGames = -1;
}
LeagueCreationParameters parameters = new LeagueCreationParameters(manager, LeagueName, StandardGames, GamesToDraft, CounterPicks,
freeDroppableGames, willNotReleaseDroppableGames, willReleaseDroppableGames, DropOnlyDraftGames, InitialYear, maximumEligibilityLevel, AllowYearlyInstallments, AllowEarlyAccess,
AllowFreeToPlay, AllowReleasedInternationally, AllowExpansions, AllowUnannouncedGames, draftSystem, pickupSystem, scoringSystem, PublicLeague, TestLeague);
return(parameters);
}
public LeagueYearParameters(Guid leagueID, int year, int standardGames, int gamesToDraft, int counterPicks, int counterPicksToDraft,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, bool counterPicksBlockDrops, int minimumBidAmount,
IEnumerable <LeagueTagStatus> leagueTags, IEnumerable <SpecialGameSlot> specialGameSlots,
DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, TradingSystem tradingSystem, TiebreakSystem tiebreakSystem, AnnualDate counterPickDeadline)
{
LeagueID = leagueID;
Year = year;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
CounterPicksToDraft = counterPicksToDraft;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
CounterPicksBlockDrops = counterPicksBlockDrops;
MinimumBidAmount = minimumBidAmount;
LeagueTags = leagueTags.ToList();
SpecialGameSlots = specialGameSlots.ToList();
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
TradingSystem = tradingSystem;
TiebreakSystem = tiebreakSystem;
CounterPickDeadline = counterPickDeadline;
}
void Start()
{
m_pickUpSystemLeft = LeftController.GetComponent <PickupSystem>();
m_pickUpSystemRight = RightController.GetComponent <PickupSystem>();
m_jetpackMovementLeft = LeftController.GetComponent <JetpackMovement>();
m_jetpackMovementRight = RightController.GetComponent <JetpackMovement>();
m_upwardMultiplier = m_jetpackMovementLeft.upwardMultiplier;
}
// Use this for initialization
void Start()
{
trackedObj = GetComponent <SteamVR_TrackedObject>();
m_device = SteamVR_Controller.Input((int)trackedObj.index);
m_pickupSystem = GetComponent <PickupSystem>();
m_triggerX = 0.0f;
pointerModel.SetActive(false);
m_pointerModelLocalScale = pointerModel.transform.localScale;
}
public void Initialize(PlayerModel player, GameConfig gameConfig)
{
inventoryView.Initialize(gameConfig.PlayerConfig.InventoryConfig);
inventoryView.Subscribe(player.Inventory);
inventoryView.Hide();
pickupNotification.Initialize(gameConfig.ControlsConfig);
_pickupSystem = new PickupSystem(player.Inventory, pickupNotification);
pickupNotification.Hide();
}
public EditLeagueYearParameters ToDomain(FantasyCriticUser manager, EligibilityLevel maximumEligibilityLevel)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
EditLeagueYearParameters parameters = new EditLeagueYearParameters(manager, LeagueID, Year, StandardGames, GamesToDraft, CounterPicks,
maximumEligibilityLevel, AllowYearlyInstallments, AllowEarlyAccess, draftSystem, pickupSystem, scoringSystem);
return(parameters);
}
public LeagueYear ToDomain(League league, EligibilityLevel maximumEligibilityLevel)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks,
maximumEligibilityLevel, AllowYearlyInstallments, AllowEarlyAccess, draftSystem, pickupSystem, scoringSystem);
return(new LeagueYear(league, Year, options, Lib.Enums.PlayStatus.FromValue(PlayStatus)));
}
public async Task <IActionResult> LeagueOptions()
{
var supportedYears = await _fantasyCriticService.GetSupportedYears();
var openYears = supportedYears.Where(x => x.OpenForCreation).Select(x => x.Year);
IReadOnlyList <EligibilityLevel> eligibilityLevels = await _fantasyCriticService.GetEligibilityLevels();
LeagueOptionsViewModel viewModel = new LeagueOptionsViewModel(openYears, DraftSystem.GetAllPossibleValues(),
PickupSystem.GetAllPossibleValues(), ScoringSystem.GetAllPossibleValues(), eligibilityLevels);
return(Ok(viewModel));
}
public LeagueYearAddParameters(League league, int draftGames, int pickupGames, int counterPicks, int year,
int eligibilityLevel, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem)
{
League = league;
DraftGames = draftGames;
PickupGames = pickupGames;
CounterPicks = counterPicks;
Year = year;
EligibilityLevel = eligibilityLevel;
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
}
public LeagueYear ToDomain(League league, EligibilityLevel maximumEligibilityLevel, IEnumerable <EligibilityOverride> eligibilityOverrides)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
var eligibilitySettings = new EligibilitySettings(maximumEligibilityLevel, AllowYearlyInstallments, AllowEarlyAccess,
AllowFreeToPlay, AllowReleasedInternationally, AllowExpansions);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks, FreeDroppableGames, WillNotReleaseDroppableGames, WillReleaseDroppableGames,
DropOnlyDraftGames, eligibilitySettings, draftSystem, pickupSystem, scoringSystem, league.PublicLeague);
return(new LeagueYear(league, Year, options, Lib.Enums.PlayStatus.FromValue(PlayStatus), eligibilityOverrides));
}
public LeagueOptions(int standardGames, int gamesToDraft, int counterPicks,
EligibilityLevel maximumEligibilityLevel, bool allowYearlyInstallments, bool allowEarlyAccess,
DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem)
{
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
MaximumEligibilityLevel = maximumEligibilityLevel;
AllowYearlyInstallments = allowYearlyInstallments;
AllowEarlyAccess = allowEarlyAccess;
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
}
//generates map using given generator
void GenerateMap(MapGenerator mapGenerator)
{
floorTileLayer = new GameObject[width, height];
wallTileLayer = new GameObject[width, height];
worldObjectLayer = new GameObject[width, height];
pickupSystem = new PickupSystem();
bulletSystem = new BulletSystem();
mapGenerator.Generate(this);
Player player = GameManager.instance.GetPlayer();
player.SetPosition(startX, startY);
}
public LeagueOptions(int standardGames, int gamesToDraft, int counterPicks, int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames,
bool dropOnlyDraftGames, EligibilitySettings eligibilitySettings, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague)
{
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
AllowedEligibilitySettings = eligibilitySettings;
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
}
public LeagueCreationParameters(FantasyCriticUser manager, string leagueName, int standardGames, int gamesToDraft, int counterPicks,
int initialYear, EligibilityLevel maximumEligibilityLevel, bool allowYearlyInstallments,
bool allowEarlyAccess, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem)
{
Manager = manager;
LeagueName = leagueName;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
InitialYear = initialYear;
AllowYearlyInstallments = allowYearlyInstallments;
AllowEarlyAccess = allowEarlyAccess;
MaximumEligibilityLevel = maximumEligibilityLevel;
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
}
public EditLeagueYearParameters(FantasyCriticUser manager, Guid leagueID, int year, int standardGames, int gamesToDraft, int counterPicks,
EligibilityLevel maximumEligibilityLevel, bool allowYearlyInstallments,
bool allowEarlyAccess, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem)
{
Manager = manager;
LeagueID = leagueID;
Year = year;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
AllowYearlyInstallments = allowYearlyInstallments;
AllowEarlyAccess = allowEarlyAccess;
MaximumEligibilityLevel = maximumEligibilityLevel;
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
}
public LeagueYear ToDomain(League league, SupportedYear year, IEnumerable <EligibilityOverride> eligibilityOverrides,
IEnumerable <TagOverride> tagOverrides, IEnumerable <LeagueTagStatus> leagueTags, IEnumerable <SpecialGameSlot> specialGameSlots,
FantasyCriticUser?winningUser, IEnumerable <Publisher> publishersInLeague)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
TradingSystem tradingSystem = Lib.Enums.TradingSystem.FromValue(TradingSystem);
TiebreakSystem tiebreakSystem = Lib.Enums.TiebreakSystem.FromValue(TiebreakSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
AnnualDate counterPickDeadline = new AnnualDate(CounterPickDeadlineMonth, CounterPickDeadlineDay);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks, CounterPicksToDraft, FreeDroppableGames, WillNotReleaseDroppableGames, WillReleaseDroppableGames,
DropOnlyDraftGames, CounterPicksBlockDrops, MinimumBidAmount, leagueTags, specialGameSlots, draftSystem, pickupSystem, scoringSystem, tradingSystem, tiebreakSystem, counterPickDeadline);
return(new LeagueYear(league, year, options, Lib.Enums.PlayStatus.FromValue(PlayStatus), eligibilityOverrides, tagOverrides, DraftStartedTimestamp, winningUser, publishersInLeague));
}
public LeagueOptions(int standardGames, int gamesToDraft, int counterPicks, int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames,
bool dropOnlyDraftGames, bool counterPicksBlockDrops, int minimumBidAmount, IEnumerable <LeagueTagStatus> leagueTags, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague)
{
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
CounterPicksBlockDrops = counterPicksBlockDrops;
MinimumBidAmount = minimumBidAmount;
LeagueTags = leagueTags.ToList();
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
}
void Start()
{
trackedObj = GetComponent <SteamVR_TrackedObject>();
m_device = SteamVR_Controller.Input((int)trackedObj.index);
if (startWithFullEnergy)
{
m_actualEnergy = maxEnergy;
}
if (shieldObject != null)
{
m_shieldCollider = shieldObject.GetComponent <Collider>();
m_shieldRenderer = shieldObject.GetComponent <MeshRenderer>();
}
m_pickupSystem = GetComponent <PickupSystem>();
}
public LeagueYear ToDomain(League league, IEnumerable <EligibilityOverride> eligibilityOverrides, IEnumerable <LeagueTagStatus> leagueTags)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
LeagueOptions options = new LeagueOptions(StandardGames, GamesToDraft, CounterPicks, FreeDroppableGames, WillNotReleaseDroppableGames, WillReleaseDroppableGames,
DropOnlyDraftGames, CounterPicksBlockDrops, MinimumBidAmount, leagueTags, draftSystem, pickupSystem, scoringSystem, league.PublicLeague);
Instant?draftStartedTimestamp = null;
if (DraftStartedTimestamp.HasValue)
{
draftStartedTimestamp = Instant.FromDateTimeUtc(DraftStartedTimestamp.Value);
}
return(new LeagueYear(league, Year, options, Lib.Enums.PlayStatus.FromValue(PlayStatus), eligibilityOverrides, draftStartedTimestamp));
}
void Start()
{
trackedObj = GetComponent <SteamVR_TrackedObject>();
m_otherDeviceGameObject = transform.parent.GetComponent <SteamVR_ControllerManager>().left;
if (m_otherDeviceGameObject == gameObject)
{
m_otherDeviceGameObject = transform.parent.GetComponent <SteamVR_ControllerManager>().right;
}
// Cache Variables
m_rigidBody = transform.parent.GetComponent <Rigidbody>();
m_pickupSystem = GetComponent <PickupSystem>();
m_device = SteamVR_Controller.Input((int)trackedObj.index);
m_otherDeviceJetpackMovement = m_otherDeviceGameObject.GetComponent <JetpackMovement>();
triggerX = 0.0f;
otherTriggerX = 0.0f;
m_downwardMultiplier = transform.parent.GetComponent <JetpackMovementDownwardMultiplier>().downwardMultiplier;
}
public EditLeagueYearParameters(FantasyCriticUser manager, Guid leagueID, int year, int standardGames, int gamesToDraft, int counterPicks,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, bool counterPicksBlockDrops, int minimumBidAmount,
IEnumerable <LeagueTagStatus> leagueTags, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague)
{
Manager = manager;
LeagueID = leagueID;
Year = year;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
CounterPicksBlockDrops = counterPicksBlockDrops;
MinimumBidAmount = minimumBidAmount;
LeagueTags = leagueTags.ToList();
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
}
public EditLeagueYearParameters(FantasyCriticUser manager, Guid leagueID, int year, int standardGames, int gamesToDraft, int counterPicks,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, EligibilityLevel maximumEligibilityLevel, bool allowYearlyInstallments,
bool allowEarlyAccess, bool allowFreeToPlay, bool allowReleasedInternationally, bool allowExpansions, DraftSystem draftSystem,
PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague)
{
Manager = manager;
LeagueID = leagueID;
Year = year;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
AllowedEligibilitySettings = new EligibilitySettings(maximumEligibilityLevel, allowYearlyInstallments, allowEarlyAccess, allowFreeToPlay,
allowReleasedInternationally, allowExpansions);
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
}
public LeagueYearParameters ToDomain(IReadOnlyDictionary <string, MasterGameTag> tagDictionary)
{
DraftSystem draftSystem = Lib.Enums.DraftSystem.FromValue(DraftSystem);
PickupSystem pickupSystem = Lib.Enums.PickupSystem.FromValue(PickupSystem);
TradingSystem tradingSystem = Lib.Enums.TradingSystem.FromValue(TradingSystem);
TiebreakSystem tiebreakSystem = Lib.Enums.TiebreakSystem.FromValue(TiebreakSystem);
ScoringSystem scoringSystem = Lib.Domain.ScoringSystems.ScoringSystem.GetScoringSystem(ScoringSystem);
int freeDroppableGames = FreeDroppableGames;
if (UnlimitedFreeDroppableGames)
{
freeDroppableGames = -1;
}
int willNotReleaseDroppableGames = WillNotReleaseDroppableGames;
if (UnlimitedWillNotReleaseDroppableGames)
{
willNotReleaseDroppableGames = -1;
}
int willReleaseDroppableGames = WillReleaseDroppableGames;
if (UnlimitedWillReleaseDroppableGames)
{
willReleaseDroppableGames = -1;
}
var counterPickDeadline = new AnnualDate(CounterPickDeadline.Month, CounterPickDeadline.Day);
var leagueTags = Tags.ToDomain(tagDictionary);
var specialGameSlots = SpecialGameSlots.Select(x => x.ToDomain(tagDictionary));
LeagueYearParameters parameters = new LeagueYearParameters(LeagueID, Year, StandardGames, GamesToDraft, CounterPicks, CounterPicksToDraft,
freeDroppableGames, willNotReleaseDroppableGames, willReleaseDroppableGames, DropOnlyDraftGames, CounterPicksBlockDrops, MinimumBidAmount,
leagueTags, specialGameSlots, draftSystem, pickupSystem, scoringSystem, tradingSystem, tiebreakSystem, counterPickDeadline);
return(parameters);
}
public LeagueCreationParameters(FantasyCriticUser manager, string leagueName, int standardGames, int gamesToDraft, int counterPicks,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, int initialYear, EligibilityLevel maximumEligibilityLevel,
bool allowYearlyInstallments, bool allowEarlyAccess, bool allowFreeToPlay, bool allowReleasedInternationally,
bool allowExpansions, bool allowUnannouncedGames, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague, bool testLeague)
{
Manager = manager;
LeagueName = leagueName;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
InitialYear = initialYear;
AllowedEligibilitySettings = new EligibilitySettings(maximumEligibilityLevel, allowYearlyInstallments, allowEarlyAccess,
allowFreeToPlay, allowReleasedInternationally, allowExpansions, allowUnannouncedGames);
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
TestLeague = testLeague;
}
public LeagueCreationParameters(FantasyCriticUser manager, string leagueName, int standardGames, int gamesToDraft, int counterPicks,
int freeDroppableGames, int willNotReleaseDroppableGames, int willReleaseDroppableGames, bool dropOnlyDraftGames, bool counterPicksBlockDrops, int minimumBidAmount,
int initialYear, IEnumerable <LeagueTagStatus> leagueTags, DraftSystem draftSystem, PickupSystem pickupSystem, ScoringSystem scoringSystem, bool publicLeague, bool testLeague)
{
Manager = manager;
LeagueName = leagueName;
StandardGames = standardGames;
GamesToDraft = gamesToDraft;
CounterPicks = counterPicks;
FreeDroppableGames = freeDroppableGames;
WillNotReleaseDroppableGames = willNotReleaseDroppableGames;
WillReleaseDroppableGames = willReleaseDroppableGames;
DropOnlyDraftGames = dropOnlyDraftGames;
CounterPicksBlockDrops = counterPicksBlockDrops;
MinimumBidAmount = minimumBidAmount;
InitialYear = initialYear;
LeagueTags = leagueTags.ToList();
DraftSystem = draftSystem;
PickupSystem = pickupSystem;
ScoringSystem = scoringSystem;
PublicLeague = publicLeague;
TestLeague = testLeague;
}
void Start()
{
trackedObj = GetComponent <SteamVR_TrackedObject>();
m_inventory = null;
handObject = null;
m_isHandBusy = false;
m_itemsInRange = new List <GameObject>();
m_inventoryOpen = false;
m_gadgetSelectorOpen = false;
GameObject otherDeviceGameObject = transform.parent.GetComponent <SteamVR_ControllerManager>().left;
if (otherDeviceGameObject == gameObject)
{
otherDeviceGameObject = transform.parent.GetComponent <SteamVR_ControllerManager>().right;
}
m_otherDevicePickupSystem = otherDeviceGameObject.GetComponent <PickupSystem>();
m_gadgetSelector = GetComponent <GadgetSelector>();
m_interactiveInRange = false;
}
