// Use this for initialization
void Start()
{
DontDestroyOnLoad(this.gameObject);
playerSelection = GameObject.FindGameObjectWithTag("GameController").GetComponent <PlayerSelection>();
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
}
private async Task <bool> SelectCardsToDiscard(IGameState gameState, int numberOfCardsToDiscard)
{
var options = gameState.Hand.VisitorCards.Select(p => new Option <Card>(p, p.DisplayText));
var selectedCards =
(await PlayerSelection.SelectMany(options, numberOfCardsToDiscard)).OfType <Option <Card> >().ToList();
if (!selectedCards.Any())
{
return(false);
}
selectedCards.ForEach(p => p.WrappedObject.Discard());
return(true);
}
public void Right(PlayerSelection playerSelection)
{
if (!gameStateManager.ReachedFlag)
{
if (playerSelection == PlayerSelection.Player)
{
gameStateManager.Player.MoveRight();
}
if (playerSelection == PlayerSelection.Enemy && gameStateManager.Multiplayer && selectedEnemy != null && !selectedEnemy.IsDead)
{
selectedEnemy.GoRight();
}
}
}
protected override async Task <bool> OnApply(IGameState gameState)
{
var selectedAction =
await
PlayerSelection.Select("Select action", "Choose a summer action to execute",
Actions.OfType <ISummerAction>().OfType <PlayerAction>());
if (selectedAction == null)
{
return(false);
}
return(await selectedAction.OnExecute());
}
public void ShowPreview()
{
UIBG.SetActive(false);
Cam3D.SetActive(true);
PlayerPreview.Show(false);
PlayerSelection.Hide(false);
PreviewManager.instance._TeamData.PlayerList.Clear();
foreach (PlayerData PD in TeamManager.instance.MyList)
{
PreviewManager.instance._TeamData.PlayerList.Add(PD);
}
PreviewManager.instance.AssignPlayers();
}
public void UpdateSelectedPanel(PlayerSelection selection)
{
if (selection.HasWorldoObjectsSelected())
{
selectedPanelObject.SetActive(true);
selectedPanel.Setup(selection);
GameManager.instance.selectedPanelOpen = true;
}
else
{
selectedPanelObject.SetActive(false);
GameManager.instance.selectedPanelOpen = false;
}
}
protected override async Task <bool> ApplyOption1(IGameState gameState)
{
var selectedStructure =
await
PlayerSelection.Select("Select structure", "Choose a structure to build",
gameState.Structures.Where(p => !p.IsBought && (p.Cost == 2 || p.Cost == 3)));
if (selectedStructure == null)
{
return(false);
}
selectedStructure.IsBought = true;
return(true);
}
protected override async Task <bool> ApplyOption2(IGameState gameState)
{
var selectedWine =
await
PlayerSelection.Select("Select wine", "Choose 1 wine to discard",
gameState.Wines.Where(p => p.IsBought));
if (selectedWine == null)
{
return(false);
}
selectedWine.IsBought = false;
gameState.VictoryPoints += 2;
return(true);
}
// Start is called before the first frame update
void Start()
{
playerManager = FindObjectOfType <PlayerManager>();
playerSelections = new List <PlayerSelection>();
foreach (PlayerUI playerUI in playerInterfaces)
{
playerUI.preview.sprite = unknownCharacter;
playerUI.title.sprite = placeholder;
PlayerSelection playerSelection = new PlayerSelection();
playerSelection.characterIndex = -1;
playerSelection.isReady = false;
playerSelections.Add(playerSelection);
}
}
protected override async Task <bool> ApplyOption2(IGameState gameState)
{
var selectedGrape =
await
PlayerSelection.Select("Select grape", "Choose 1 grap to discard",
gameState.Grapes.Where(p => p.IsBought));
if (selectedGrape == null)
{
return(false);
}
selectedGrape.IsBought = false;
gameState.Money += 2;
gameState.VictoryPoints++;
return(true);
}
protected override async Task <bool> ApplyOption1(IGameState gameState)
{
var selectedGrape =
await
PlayerSelection.Select("Select grape", "Choose a grape to discard",
gameState.Grapes.Where(p => p.IsBought));
if (selectedGrape == null)
{
return(false);
}
selectedGrape.IsBought = false;
gameState.ResidualMoney++;
return(true);
}
public static void PlayerSelection_ShowOutline_Prefix_HighlightLoot(PlayerSelection __instance, EntityComponent entity, ref PlayerSelection.SelectionType type, Single intensity = 0f, Single outline = 0.002f)
{
const PlayerSelection.SelectionType GrayColor = unchecked ((PlayerSelection.SelectionType) 0xFF____80_80_80);
const PlayerSelection.SelectionType VioletColor = unchecked ((PlayerSelection.SelectionType) 0xFF__EA_04_FF);
if (type != PlayerSelection.SelectionType.Select)
{
return;
}
if (entity is CharacterComponent charComp)
{
if (!charComp.IsDead())
{
return;
}
const String key = "AtomRPG.NuclearEdition.ShowOutline_Prefix_HighlightLoot.OnDeadLoot";
if (!charComp.Character.HasKey(key))
{
charComp.Character.AddKey(key);
Boolean fromCannibal = Game.World.Player.CharacterComponent.Character.CharProto.Stats.HasPerk(CharacterStats.Perk.Cannibal);
charComp.OnDeadLoot(fromCannibal);
}
if (charComp.Character.GetItemsCost() == 0)
{
type = GrayColor;
}
}
else if (entity is ChestComponent chestComp)
{
Chest chest = chestComp.chest;
if (chest.lockLevel != 0)
{
type = VioletColor;
return;
}
if (chest.Inventory.Count == 0)
{
type = GrayColor;
}
}
}
// Update is called once per frame
void Update()
{
int position = PlayerSelection.GetMyPosition(player_number);
if (position == 1)
{
object_first.SetActive(true);
}
else
{
object_first.SetActive(false);
}
// Debug.Log(position);
text_player_position.text = (position).ToString() + "º";
}
public static Boolean Prefix(PlayerSelection __instance, PlayerSelection.SelectionType type, ref Color __result)
{
UInt32 colorBits = (UInt32)type;
if (colorBits < 0x01000000)
{
return(HarmonyPrefixResult.CallOriginal);
}
Single a = ((colorBits & 0xFF_00_00_00) >> 24) / 256.0f;
Single r = ((colorBits & 0x00_FF_00_00) >> 16) / 256.0f;
Single g = ((colorBits & 0x00_00_FF_00) >> 8) / 256.0f;
Single b = (colorBits & 0x00_00_00_FF) / 256.0f;
__result = new Color(r, g, b, a);
return(HarmonyPrefixResult.SkipOriginal);
}
// Update is called once per frame
public bool Check()
{
Transform[] players = playerHolder.GetComponentsInChildren <Transform>();
for (int i = 0; i < players.Length; i++)
{
PlayerSelection playerSelection = players[i].GetComponent <PlayerSelection>();
if (!playerSelection)
{
continue;
}
if (!playerSelection.hasSelected)
{
return(false);
}
}
return(true);
}
public static void Prefix(PlayerSelection __instance, EntityComponent entity, ref PlayerSelection.SelectionType type, Single intensity = 0f)
{
const PlayerSelection.SelectionType GrayColor = unchecked ((PlayerSelection.SelectionType) 0xFF____80_80_80);
const PlayerSelection.SelectionType VioletColor = unchecked ((PlayerSelection.SelectionType) 0xFF__EA_04_FF);
if (type != PlayerSelection.SelectionType.Select)
{
return;
}
if (Game.World.Player.CharacterComponent.Character.Hallucinating.Level != ConditionLevel.Normal)
{
return;
}
if (entity is CharacterComponent characterComponent)
{
if (CharacterComponentHelper.TryGetLootCost(characterComponent, out var cost) && cost == 0)
{
type = GrayColor;
}
}
else if (entity is ChestComponent chestComponent)
{
Chest chest = chestComponent.chest;
if (chest.lockLevel != 0)
{
type = VioletColor;
return;
}
if (chest.Inventory.Count == 0)
{
type = GrayColor;
}
}
else if (entity is DoorComponent doorComponent)
{
var door = doorComponent.door;
if (door.lockLevel != 0)
{
type = VioletColor;
return;
}
}
}
private async Task <bool> HarvestField()
{
var selectedField =
await
PlayerSelection.Select("Select field", "Choose a field to harvest",
GameState.Fields.Where(p => p.IsBought && p.Vines.Any() && !p.HasBeenUsed));
if (selectedField == null)
{
return(false);
}
selectedField.HasBeenUsed = true;
AddToCrushpad(selectedField.RedVines, GameState.RedGrapes);
AddToCrushpad(selectedField.WhiteVines, GameState.WhiteGrapes);
return(true);
}
protected override async Task <bool> OnApply(IGameState gameState)
{
var selectedAction =
await
PlayerSelection.Select("Select action", "Choose which action you want to plan for.",
AllActions.OfType <IWinterAction>().Cast <PlayerAction>());
if (selectedAction == null)
{
return(false);
}
var worker = gameState.GetFirstAvailableWorker();
worker.HasBeenUsed = true;
worker.PlannedAction = selectedAction;
return(true);
}
void Awake()
{
transform.parent = General.GetParent("Players");
gameController = GameObject.FindObjectOfType <GameController>();
spriteRenderer = transform.FindChild("Sprite").GetComponent <SpriteRenderer>();
selection = GetComponentInChildren <PlayerSelection>();
selection.SetActive(false);
thisRigidbody = GetComponent <Rigidbody2D>();
mass = thisRigidbody.mass;
playerIA = GetComponent <PlayerIA>();
SetAiming(false);
// In the start the player is not playable
// Wait for the start
SetNonPlayable();
}
public void Setup(PlayerSelection selection)
{
playerSelection = selection;
worldObjects = selection.GetSelectedObjects();
if (worldObjects.Length == 1)
{
SetupOneCharacter();
}
else if (worldObjects.Length <= 10)
{
SetupToTenCharacters();
}
else if (worldObjects.Length > 10)
{
SetupMorecharacters();
}
}
protected override async Task <bool> OnApply(IGameState gameState)
{
var building = await PlayerSelection.Select("Select structure", "Choose a structure you want to build",
gameState.Structures.Where(p => !p.IsBought && p.Cost - 2 <= gameState.Money));
if (building == null)
{
return(false);
}
building.IsBought = true;
gameState.Money -= building.Cost - 2;
if (building.Cost >= 5)
{
gameState.VictoryPoints++;
}
return(true);
}
protected override async Task <bool> OnApply(IGameState gameState)
{
var selectedWine =
await
PlayerSelection.Select("Select wine", "Choose 1 wine to discard",
gameState.Wines.Where(p => p.IsBought));
if (selectedWine == null)
{
return(false);
}
selectedWine.IsBought = false;
gameState.Money += 4;
if (gameState.Wines.All(p => p.IsBought && p.Value < selectedWine.Value))
{
gameState.VictoryPoints += 2;
}
return(true);
}
// Use this for initialization
void Awake()
{
M = GameObject.FindGameObjectWithTag("MenuManager").GetComponent <MenuManager>();
E = GameObject.FindGameObjectWithTag("EnemyAI").GetComponent <EnemyAI>();
P = GameObject.FindGameObjectWithTag("PlayerSelection").GetComponent <PlayerSelection>();
if (M.selectedTeam().Equals(Team.Merry))
{
P.currenteam = Team.Merry;
E.myTeam = Team.Spooky;
}
else
{
P.currenteam = Team.Spooky;
E.myTeam = Team.Merry;
}
E.algToUse = M.chosenEnemyAI();
}
protected override async Task <bool> OnApply(IGameState gameState)
{
var options = gameState.Hand.VisitorCards.Select(p => new Option <Card>(p, p.DisplayText));
var selectedCards =
(await PlayerSelection.SelectMany(options, 2)).OfType <Option <Card> >().ToList();
if (selectedCards.Count != 2)
{
return(false);
}
selectedCards.ForEach(p => p.WrappedObject.Discard());
gameState.VineDeck.DrawToHand();
gameState.OrderDeck.DrawToHand();
gameState.SummerVisitorDeck.DrawToHand();
gameState.WinterVisitorDeck.DrawToHand();
return(true);
}
public Player(float x, float y, float width, float height, PlayerSelection state = PlayerSelection.PLAYER_ONE) : base("img/objects/player-spritesheet.png", 4, 6, 24)
{
SetXY(x, y);
this.width = (int)width;
this.height = (int)height;
this.state = state;
playerState = PlayerState.IDLE;
jumpingPower = -25f;
lives = 1;
SetPlayerFrame();
hitbox = new Sprite("img/objects/colors.png");
hitbox.alpha = 0f;
hitbox.width = this.width / 2;
hitbox.SetOrigin(this.width / 2, 0);
hitbox.x = this.width / 2;
AddChild(hitbox);
}
protected override async Task <bool> OnApply(IGameState gameState)
{
var selections = (await PlayerSelection.SelectMany(Options, RequiredSelections)).ToList();
if (selections.Count != RequiredSelections)
{
return(false);
}
foreach (var selection in selections)
{
if (!await selection.Apply(gameState))
{
return(false);
}
}
return(true);
}
public List <PlayerSelection> SelectAll()
{
PlayerData playerData = DeSerialize();
List <PlayerSelection> players = new List <PlayerSelection>();
foreach (Player player in playerData.Players)
{
PlayerSelection selection = new PlayerSelection
{
Player = player,
Selected = false
};
players.Add(selection);
}
return(players);
}
void CharacterChange(Player player, InputDevice controller)
{
PlayerSelection selection = player.Selection;
if (!selection.Character)
{
return;
}
if (controller[_changeRight].WasPressed)
{
selection.Pallete--;
}
if (controller[_changeLeft].WasPressed)
{
selection.Pallete++;
}
if (controller[_cancel].WasPressed)
{
}
}
protected override async Task <bool> OnApply(IGameState gameState)
{
var options =
gameState.Decks.Select(p => p.TopCardOnDiscardPile)
.Where(p => p != null)
.Select(p => new Option <Card>(p, p.Name)).ToList();
var selectedCards =
(await PlayerSelection.SelectMany(options, 2)).OfType <Option <Card> >()
.Select(p => p.WrappedObject)
.ToList();
if (selectedCards.Count != 2)
{
return(false);
}
foreach (var selectedCard in selectedCards)
{
selectedCard.TakeToHand();
}
return(true);
}
protected override async Task <bool> ApplyOption2(IGameState gameState)
{
var selectedWine = await PlayerSelection.Select("Select wine", "Choose 1 wine to age", gameState.Wines);
if (selectedWine == null)
{
return(false);
}
var nextLevelWine =
gameState.Wines.FirstOrDefault(p => p.Value == selectedWine.Value + 1 && p.Type == selectedWine.Type);
if (nextLevelWine == null || nextLevelWine.IsBought)
{
return(false);
}
selectedWine.IsBought = false;
nextLevelWine.IsBought = true;
return(await FillOrder.OnExecute());
}
/// <summary>
/// This updates the menu item checkboxes to reflect what the user chose as well as prepares anything else necessary.
/// </summary>
/// <param name="playerSelection">The chosen media player.</param>
private void UpdatePlayer(PlayerSelection playerSelection)
{
switch (playerSelection)
{
case PlayerSelection.Spotify:
this.toolStripMenuItemSpotify.Checked = true;
this.toolStripMenuItemItunes.Checked = false;
this.toolStripMenuItemWinamp.Checked = false;
this.toolStripMenuItemFoobar2000.Checked = false;
this.UpdateTextAndEmptyFile(this.resourceManager.GetString("SwitchedToSpotify"));
this.itunes = null;
this.itunesSetup = false;
break;
case PlayerSelection.iTunes:
this.toolStripMenuItemSpotify.Checked = false;
this.toolStripMenuItemItunes.Checked = true;
this.toolStripMenuItemWinamp.Checked = false;
this.toolStripMenuItemFoobar2000.Checked = false;
this.UpdateTextAndEmptyFile(this.resourceManager.GetString("SwitchedToiTunes"));
if (this.itunes == null && !this.itunesSetup)
{
this.SetUpItunes();
}
break;
case PlayerSelection.Winamp:
this.toolStripMenuItemSpotify.Checked = false;
this.toolStripMenuItemItunes.Checked = false;
this.toolStripMenuItemWinamp.Checked = true;
this.toolStripMenuItemFoobar2000.Checked = false;
this.UpdateTextAndEmptyFile(this.resourceManager.GetString("SwitchedToWinamp"));
this.itunes = null;
this.itunesSetup = false;
break;
case PlayerSelection.foobar2000:
this.toolStripMenuItemSpotify.Checked = false;
this.toolStripMenuItemItunes.Checked = false;
this.toolStripMenuItemWinamp.Checked = false;
this.toolStripMenuItemFoobar2000.Checked = true;
this.UpdateTextAndEmptyFile(this.resourceManager.GetString("SwitchedTofoobar2000"));
this.itunes = null;
this.itunesSetup = false;
break;
default:
this.toolStripMenuItemSpotify.Checked = true;
this.toolStripMenuItemItunes.Checked = false;
this.toolStripMenuItemWinamp.Checked = false;
this.toolStripMenuItemFoobar2000.Checked = false;
this.UpdateTextAndEmptyFile(this.resourceManager.GetString("SwitchedToSpotify"));
this.itunes = null;
this.itunesSetup = false;
break;
}
}
void SwitchPlayer()
{
if (M_GameMain.INSTANCE.CurrentGameStatus == Const.GAME_STATUS.Playing)
{
if (Input.GetKeyDown(KeyCode.Q) ||
Input.GetButtonDown("TriggerL") ||
Input.GetButtonDown("TriggerR") ||
Input.GetMouseButtonDown(2))
{
if (CurrentPlayerSelection == PlayerSelection.Mark)
{
CurrentPlayerSelection = PlayerSelection.Mark2;
m_QueueMark = m_QueueBase + 1;
m_QueueMark2 = m_QueueBase;
}
else
{
CurrentPlayerSelection = PlayerSelection.Mark;
m_QueueMark = m_QueueBase;
m_QueueMark2 = m_QueueBase + 1;
}
}
}
}
/* *
* 初期化に関するメソッド
* */
//unityを起動するときに実行します
void Awake()
{
INSTANCE = this;
CurrentPlayerSelection = PlayerSelection.Mark;
}
/// <summary>
///
/// </summary>
/// <param name="game"></param>
/// <param name="position"></param>
/// <param name="playerselection">Which of the 3 gui elements for player selection this inistance represents</param>
public PlayerInControlBtn(Game game, Point position, PlayerSelection playerselection)
: base(game, position)
{
this.playerSelection = playerselection;
}
