public void ShareKnowledge(int PlayerID, PlayerCard Card)
{
RaiseEventOptions opt = new RaiseEventOptions {
Receivers = ReceiverGroup.All
};
///send playerid senderid card hashcode and a placeholder for request
///
byte[] content = { (byte)PlayerID, (byte)PhotonNetwork.player.ID, (byte)Card.GetHashCode(), (byte)1 };
for (int i = 0; i < 4; i++)
{
//shareKnowledgeRequestContent[i] = content[i];
}
Debug.Log(content.Length);
string debug = "";
for (int i = 0; i < 3; i++)
{
debug += content[i].ToString() + " ";
}
Debug.Log("in ShareKnoledge " + debug);
PhotonNetwork.RaiseEvent((byte)103, content, true, opt);
}
private void DisplayDeck( )
{
cardDragged = null;
cardDraggedFromCollection = null;
for (int i = 0; i < deck.Count; i++)
{
slots[i].Set(deck[i], i, CardDragedEvent, CardDroppedEvent, ClickedOnSlotEvent, false);
}
// We should be able to save the deck only if we have all the slots in it filled
int cardsInDeck = deck.Where(card => card != null).Count( );
if (cardsInDeck != PlayerCards.MaxCardsInDeck && (PlayerCards.MaxCardsInDeck - cardsInDeck) == 1)
{
onCanSaveDeck?.Invoke(false);
goButtonLabel.text = $"{PlayerCards.MaxCardsInDeck - cardsInDeck} More Card Is Needed!";
goButtonAnim.SetBool("Ready", false);
}
else if (cardsInDeck != PlayerCards.MaxCardsInDeck)
{
onCanSaveDeck?.Invoke(false);
goButtonLabel.text = $"{PlayerCards.MaxCardsInDeck - cardsInDeck} More Cards Are Needed!";
goButtonAnim.SetBool("Ready", false);
}
else
{
onCanSaveDeck?.Invoke(true);
goButtonLabel.text = "Save and Go to Battle";
goButtonAnim.SetBool("Ready", true);
}
}
private void PlayRowModifierCard(PlayerCard playerCard, Player sender, Player opponent, GwintSlot slot)
{
Card card = playerCard.Card;
switch (card.Effect)
{
case GwintEffect.Horn:
if (!ValidateRowModifierCard(card, slot))
{
throw new CommandException();
}
ClearSlotEffect(sender, slot, card.Effect);
var rowModifierSlot = new PlayerCardSlot
{
Card = card,
Slot = slot
};
sender.CardSlots.Add(rowModifierSlot);
break;
default:
throw new CommandException();
}
}
private void DebugCreatePlayer(string position, string team, int index, Vector2 startingPos, bool AI, string name)
{
PlayerCard initPCard = new PlayerCard(10, 20, 12, 112, 20, 4, name, GameManager.Instance.positions[position], 99);
PlayerInit i = new PlayerInit(initPCard, startingPos, GameManager.Instance.teams[team], null, AI);
testInitList[index] = i;
}
private void PlayCreatureCard(PlayerCard playerCard, Player sender, Player opponent, GwintSlot slot, long?targetCardId)
{
Card card = playerCard.Card;
SpawnCreature(playerCard, sender, opponent, slot);
switch (card.Effect)
{
case GwintEffect.MeleeScorch:
ScorchRowCards(opponent, GwintSlot.Melee, Constants.ScorchThresholdMelee);
break;
case GwintEffect.SiegScorch:
ScorchRowCards(opponent, GwintSlot.Siege, Constants.ScorchThresholdSiege);
break;
case GwintEffect.Nurse:
NurseCard(sender, opponent, targetCardId);
break;
case GwintEffect.Draw2:
DrawCards(sender, 2);
break;
case GwintEffect.SummonClones:
SummonCardClones(playerCard, sender, opponent);
break;
}
}
private void PlayCard(PlayerCard playerCard, Player sender, Player opponent, GwintSlot slot, long?targetCardId)
{
Card card = playerCard.Card;
if (card.Types.HasFlag(GwintType.Creature))
{
PlayCreatureCard(playerCard, sender, opponent, slot, targetCardId);
}
else if (card.Types.HasFlag(GwintType.Weather))
{
PlayWeatherCard(playerCard, sender, opponent, slot);
}
else if (card.Types.HasFlag(GwintType.Spell))
{
PlaySpellCard(playerCard, sender, opponent, slot, targetCardId);
}
else if (card.Types.HasFlag(GwintType.RowModifier))
{
PlayRowModifierCard(playerCard, sender, opponent, slot);
}
else if (card.Types.HasFlag(GwintType.GlobalEffect))
{
PlayGlobalEffectCard(playerCard, sender, opponent);
}
else
{
throw new CommandException();
}
sender.HandCards.Remove(playerCard);
}
private void stateChangeCallback(PlayerCard sender)
{
if (gameObject.activeInHierarchy)
{
startGameHint.SetActive(ReadyCheck());
}
}
// Update is called once per frame
public void DoUpdate()
{
if (Input.GetKeyUp(KeyCode.Space))
{
StartInitDeck();
}
if (bDeckSetupEnd)
{
UpdateCardPosition();
if (CheckFirstCardOutside())
{
RemoveCard(0, false);
}
if (CheckNeedGenerateNewCard())
{
float targetPositionX = 0; // 如果一张卡都没了 那么到第一张位置0
if (cardInRoll.Count > 0)
{
GameObject firstCard = cardInRoll[0].cardObject;
targetPositionX = firstCard.transform.localPosition.x + putInRollDuration * rollSpd + 100f * cardInRoll.Count; // 0.2秒后的位置
}
PlayerCard newCard = generateNewCard(false);
AddCard(newCard);
newCard.cardItem.DoMove(targetPositionX, putInRollDuration, () => {
newCard.cardItem.InitMoveEnd = true;
});
}
}
}
/// <summary>
/// Testing function used to generate card data for testing
/// </summary>
public void GenerateTestCards()
{
//generate 30 cards for the draw pile
for (int i = 0; i < 30; ++i)
{
Card newCard = new Card();
newCard.Title = "drawpile card " + i.ToString();
newCard.Description = "drawpile description " + i.ToString();
DrawPile.AddCard(newCard);
AllCards.AddCard(newCard);
}
//generate 10 cards for the discard pile
for (int i = 0; i < 10; ++i)
{
PlayerCard newCard = new PlayerCard();
newCard.Title = "discarded card " + i.ToString();
newCard.Description = "discarded description " + i.ToString();
newCard.FirstName = "FirstName" + i.ToString();
newCard.LastName = "LastName" + i.ToString();
newCard.Attributes = new PlayerAttributes(i, i);
DiscardPile.AddCard(newCard);
AllCards.AddCard(newCard);
}
//generate 5 cards for the exile pile
for (int i = 0; i < 5; ++i)
{
Card newCard = new Card();
newCard.Title = "exiled card " + i.ToString();
newCard.Description = "exiled description " + i.ToString();
ExilePile.AddCard(newCard);
AllCards.AddCard(newCard);
}
}
public virtual void trigger(ref PlayerCard card, GameObject card_gameObject)
{
if (shouldApplyInnerEffect())
{
((IEffectSelf)innerEffect).trigger(ref card, card_gameObject);
}
}
void OnClose()
{
string debug = "";
for (int i = 0; i < 4; i++)
{
debug += cont[i].ToString() + " ";
}
Debug.Log("in OnClose " + debug);
if (CityCard != PlayerCard.Empty)
{
gamemanager.SelectCardCallBack(CityCard);
CityCard = PlayerCard.Empty;
}
if (EventType == 1)//enent type 1 send request back
{
if (Request == -1)
{
Debug.LogError("should not be -1");
}
gamemanager.RequestCallback(Request == 1);
}
EventType = 0;
//if (cont[3] != -1)//change
//{
// gamemanager.RequestCallback(cont);
// cont = null;
// }
}
public void RemoveHandCard(PlayerCard card)
{
if (card != null)
{
if (m_lstAssetCards.Contains(card))
{
GameLogic.Get().m_mainGameUI.RemoveCardFromListView(GameLogic.Get().m_mainGameUI.m_assetListView, card);
m_lstAssetCards.Remove(card);
if (card.m_slot != AssetSlot.None)
{
m_lstAssetSlots[(int)card.m_slot] = null;
}
}
else
{
int index = m_lstPlayerCards.IndexOf(card);
if (index >= 0)
{
GameLogic.Get().m_mainGameUI.RemoveCardFromListView(GameLogic.Get().m_mainGameUI.m_handCardListView, card);
m_lstPlayerCards.Remove(card);
}
}
}
}
void OnEnable()
{
CityCard = PlayerCard.Empty;
//cont = null;
cont = new int[4];
cont[0] = -1;
}
private void BtnAdd_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (Collection.SelectedIndex() == -1)
{
return;
}
PlayerCard card = ((PlayerCard)Collection.SelectedItem());
if (!Collection.RemoveCard(card))
{
return;
}
PlayerCard offerCard = new PlayerCard();
offerCard.Id = card.Id;
offerCard.Name = card.Name;
offerCard.Quantity = 1;
if (!_cards.ContainsKey(offerCard.Id))
{
_cards.Add(offerCard.Id, offerCard);
}
else
{
_cards[offerCard.Id].Quantity++;
}
_ids.Add(offerCard.Id);
lb_choice.Items.Add(card.Name);
}
public void PlceCardOnField(PlayerCard card)
{
//depending on player type (position), parent it to the according Panel
Transform the_parent = null;
if (card.position == "A")
{
the_parent = my_A_panel.transform;
}
if (card.position == "M")
{
the_parent = my_M_panel.transform;
}
if (card.position == "F")
{
the_parent = my_F_panel.transform;
}
//creating the actual card template
GameObject this_card = Instantiate(card_prefab, the_parent);
//assigning the template its player information to display
this_card.GetComponent <CardDisplay>().AssignCard(card);
//eventually add this_card to a list of instantiated cards or something, to check them later
}
} //name used to refer to this effect in XML
public override void trigger()
{
//setup
int numToDraw = Mathf.FloorToInt(strength);
PlayerCard[] cards = new PlayerCard[numToDraw];
//fill the array with the Cards we want to draw
for (int i = 0; i < numToDraw; i++)
{
//attempt to draw from the deck
PlayerCard?drawn = DeckManagerScript.instance.DrawCardType(PlayerCardType.upgrade);
if (drawn != null)
{
//the draw succeeded, so we can use it directly
cards[i] = drawn.Value;
}
else
{
//the draw failed, so make a new card from thin air using the "Improvised Upgrade" token.
PlayerCard newCard = new PlayerCard();
newCard.data = CardTypeManagerScript.instance.getCardByName("Improvised Upgrade");
newCard.charges = newCard.data.cardMaxCharges;
cards[i] = newCard;
}
}
//tell the hand to draw these specific Cards.
PlayerHandScript.instance.StartCoroutine(PlayerHandScript.instance.drawCards(cards));
}
private void card_has_been_played(LOTRPlayer player)
{
player.play_card(card_played);
//game_event_handler.register_cards(new List<PlayerCard>() {card_played});
Debug.Log("CARD HAS BEEN PLAYED#(O$I()*%$U*(GJ$IOG");
if (cur_phase == GAMEPHASE.PLANNING)
{
game_event_handler.fire_game_event(GameEvent.CARD_PLAYED_KEY, new GameArgs(c: card_played, a: () =>
{
Debug.Log("OK WHY");
cur_state = GAMESTATE.PLAYING_CARDS;
card_played = null;
allow_actions_to_be_played();
}, p: get_cur_player(), game: this));
}
else //playing actions not in planning phase
{
Debug.Log(cur_state);
// cur_state = GAMESTATE.WAITING_FOR_PLAYER_TO_DECIDE_IF_HE_WANTS_TO_USE_ACTIONS;
game_event_handler.fire_game_event(GameEvent.CARD_PLAYED_KEY, new GameArgs(c: card_played, a: () =>
{
Debug.Log("Firing this game event CARD PLAYED CALLBACK");
card_played = null;
if (forced_response_after_action)
{
done_responding();
}
cur_state = state_before_actions;
//allow_actions_to_be_played();
}, p: get_cur_player(), game: this));
}
}
private void TranslateCard(PlayerCard card)
{
BCA_BoosterCard bca_bc = new BCA_BoosterCard(card, !_admin.Client.PlayerManager.Collections.ContainsKey(card.Id));
bca_bc.Margin = new Thickness(3);
_admin.Client.PlayerManager.AddCard(card.Id, card.Quantity);
bca_bc.SetImageSource(FormExecution.AssetsManager.GetImage("Sleeves", "203"));
wp_cards.Children.Add(bca_bc);
Storyboard storyboard = new Storyboard();
TranslateTransform translation = new TranslateTransform(0.0, 0.0);
bca_bc.RenderTransformOrigin = new Point(0.5, 0.5);
bca_bc.RenderTransform = translation;
DoubleAnimation translateXAnimation = new DoubleAnimation();
translateXAnimation.Duration = TimeSpan.FromMilliseconds(200);
translateXAnimation.From = -500;
translateXAnimation.To = 0;
storyboard.Children.Add(translateXAnimation);
Storyboard.SetTargetProperty(translateXAnimation, new PropertyPath("RenderTransform.X"));
Storyboard.SetTarget(translateXAnimation, bca_bc);
storyboard.Completed += (senderA, eA) => Storyboard_Completed(senderA, eA, bca_bc, card.Id);
storyboard.Begin();
}
public void played_action_from_hand(PlayerCard card, bool needs_response)
{
//game.wait_for_forced_response(after_responding_with_card: the_action);
Debug.Log("PLAUED " + card.get_name() + " FROM HAND");
forced_response_after_action = needs_response;
player_played_card(get_cur_player(), card);
}
// Update is called once per frame
void Update()
{
PlayerCard pCard = transform.root.FindChild("PlayerCard").GetComponent <PlayerCard>();
if (pCard.mCardList == null)
{
return;
}
if (name.Equals("BtnLeft"))
{
if (pCard.mListCnt <= 1)
{
transform.GetComponent <UIButton>().SetState(UIButtonColor.State.Disabled, true);
}
else
{
transform.GetComponent <UIButton>().SetState(UIButtonColor.State.Normal, true);
}
}
else
{
if (pCard.mListCnt >= pCard.mCardList.Count)
{
transform.GetComponent <UIButton>().SetState(UIButtonColor.State.Disabled, true);
}
else
{
transform.GetComponent <UIButton>().SetState(UIButtonColor.State.Normal, true);
}
}
}
public void discard_card_at_index(int index)
{
PlayerCard card_to_discard = cards_in_hand[index];
discard_pile.Add(card_to_discard);
cards_in_hand.RemoveAt(index);
}
public static PlayerCard FAKE_FARAMIR()
{
PlayerCard the_card = new PlayerCard("Faramir", LOTRGame.SPHERE_OF_INFLUENCE.LEADERSHIP,
new List <LOTRGame.TRAITS>()
{
LOTRGame.TRAITS.GONDOR, LOTRGame.TRAITS.NOBLE, LOTRGame.TRAITS.RANGER
},
cost: 4, willpower: 2, attack: 1, defense: 0, hp: 1,
ability:
"Action: Exhaust Faramir to choose a player. Each character controlled by that player gets +1 Willpower until the end of the phase.",
set: "??", type: "ALLY", unique: true);
the_card.set_action_card();
/*the_card.respond_to_event(GameEvent.ACTIVATED_ACTION,
* PlayerCardResponses.action_maker(CardEnablers.i_am_played, PlayerCardResponses.faramir,
* the_card));*/
List <Func <EventArgs, Card, bool> > all_action_criteria = new List <Func <EventArgs, Card, bool> >()
{
CardEnablers.i_am_played, CardEnablers.i_am_not_exhausted
};
the_card.set_action_criteria(all_action_criteria);
the_card.respond_to_event(GameEvent.ACTIVATED_ACTION,
PlayerCardResponses.action_maker(all_action_criteria, PlayerCardResponses.faramir,
the_card));
return(the_card);
}
public bool AreCardsOfTheSameType(PlayerCard cardToCheck, PlayerCard otherCard)
{
// Same level cards
if (otherCard.Card.Name == cardToCheck.Card.Name)
{
return(true);
}
// Level 2 or Level 3 card vs. lower level
if (otherCard.Card.LowerLevelVersion && otherCard.Card.LowerLevelVersion.Name == cardToCheck.Card.Name)
{
return(true);
}
// Level 3 card vs. Level 1
if (otherCard.Card.LowerLevelVersion && otherCard.Card.LowerLevelVersion.LowerLevelVersion && otherCard.Card.LowerLevelVersion.LowerLevelVersion.Name == cardToCheck.Card.Name)
{
return(true);
}
// Level 1 and Level 2 card vs. higher level
if (otherCard.Card.HigherLevelVersion && otherCard.Card.HigherLevelVersion.Name == cardToCheck.Card.Name)
{
return(true);
}
// Level 1 card vs. Level 3
if (otherCard.Card.HigherLevelVersion && otherCard.Card.HigherLevelVersion.HigherLevelVersion && otherCard.Card.HigherLevelVersion.HigherLevelVersion.Name == cardToCheck.Card.Name)
{
return(true);
}
return(false);
}
/// <summary>
/// Handle cards selection
/// </summary>
/// <param name="card"></param>
public void HandleCardSelected(PlayerCard card)
{
// 1st case: no cards clicked yet, set and reveal 1st card
if (firstCardOfPair == null)
{
firstCardOfPair = card;
firstCardOfPair.RevealCard();
}
// 2nd case: 1 card has been clicked, set and reveal 2nd card
else if (secondCardOfPair == null)
{
secondCardOfPair = card;
secondCardOfPair.RevealCard();
// Check if cards match
if (firstCardOfPair.Id != secondCardOfPair.Id)
{
// No match, flip cards back
StartCoroutine(WaitBeforeFlippingBack());
}
else
{
// Match found, clear selected cards
firstCardOfPair = null;
secondCardOfPair = null;
}
}
}
// 抽下一张牌
public PlayerCard DrawNextCard()
{
int baseId = UnityEngine.Random.Range(1, 6);
PlayerCard card = PlayerCardFactory.getInstance().CreatePlayerCard(baseId);
return(card);
}
public override PlayerCard[] CreateCardSet()
{
int[] cardIDs = new int[numberOfCards];
PlayerCard[] cardSet = new PlayerCard[numberOfCards];
// Filling array with card ID pairs (0,0,1,1,2,2,3,3,...)
for (int i = 0; i < numberOfCards; i++)
{
cardIDs[i] = i / 2;
}
// Shuffle cardID array
Shuffle(cardIDs);
// Creating cards
for (int i = 0; i < numberOfCards; i++)
{
// Instantiate the newCard at the origin with no rotation and add to cardSet
cardSet[i] = Instantiate(playerCardPrefab, new Vector3(0, 0, 0), Quaternion.identity);
// Set id to shuffled id
int newCardId = cardIDs[i];
// Assign new card in card set the shuffled id and corresponding image
cardSet[i].SetCardImageAndId(newCardId, sprites[newCardId]);
}
return(cardSet);
}
public void AcceptPlayersCardReturnsRankAndSuit(string playersCard, Rank expectedRank, Suit expectedSuit)
{
var card = new PlayerCard(playersCard);
Assert.Equal(expectedRank, card.Rank);
Assert.Equal(expectedSuit, card.Suit);
}
public PlayerCard DrawPlayerCard()
{
PlayerCard tmp = PlayerCardDeck[0];
PlayerCardDeck.Remove(tmp);
return(tmp);
}
public IEnumerator playerDraw(Player curPlayer, PlayerCard card1, PlayerCard card2)
{
playerCard1.SetActive(true);
playerCard2.SetActive(true);
yield return(StartCoroutine(moveAndFlipCard(playerCard1.transform, mapCentreLeft, playerCardFaces[(int)card1.getColour()], new Vector3(1.5f, 1.5f, 1.5f))));
playerCard1Title.text = card1.getName();
yield return(StartCoroutine(moveAndFlipCard(playerCard2.transform, mapCentreRight, playerCardFaces[(int)card2.getColour()], new Vector3(1.5f, 1.5f, 1.5f))));
playerCard2Title.text = card2.getName();
yield return(new WaitForSeconds(Vals.GENERIC_WAIT_TIME));
if (card1.getName().Equals("Epidemic"))
{
yield return(StartCoroutine(moveAndShrinkCard(playerCard1.transform, playerDiscardCentre)));
}
else
{
yield return(StartCoroutine(moveAndShrinkCard(playerCard1.transform, handCentres[curPlayer.getTurnOrderPos() - 1])));
}
if (card2.getName().Equals("Epidemic"))
{
yield return(StartCoroutine(moveAndShrinkCard(playerCard2.transform, playerDiscardCentre)));
}
else
{
yield return(StartCoroutine(moveAndShrinkCard(playerCard2.transform, handCentres[curPlayer.getTurnOrderPos() - 1])));
}
resetPosition(playerCard1, playerDeck.transform, playerCardBack, playerCard1Title);
resetPosition(playerCard2, playerDeck.transform, playerCardBack, playerCard2Title);
yield break;
}
public static PlayerCard GANDALF()
{
PlayerCard result = new PlayerCard("Gandalf", LOTRGame.SPHERE_OF_INFLUENCE.NEUTRAL,
new List <LOTRGame.TRAITS>()
{
LOTRGame.TRAITS.ISTARI
},
cost: 5, willpower: 4, attack: 4, defense: 4, hp: 4,
ability:
"At the end of the round, discard Gandalf from play. " +
"Response: After Gandalf enters play, (choose 1): draw 3 cards, deal 4 damage to 1 enemy in play, or reduce your threat by 5.",
set: "??", type: "ALLY", unique: false);
List <Func <EventArgs, Card, bool> > response_criteria = new List <Func <EventArgs, Card, bool> >()
{
CardEnablers.card_is_me
};
result.respond_to_event(GameEvent.CARD_PLAYED_KEY,
PlayerCardResponses.action_maker(response_criteria, PlayerCardResponses.gandalf_played, result));
result.respond_to_event(GameEvent.OPTION_1_PICKED,
PlayerCardResponses.action_maker(response_criteria, PlayerCardResponses.gandalf_draw_3, result));
result.respond_to_event(GameEvent.OPTION_2_PICKED,
PlayerCardResponses.action_maker(response_criteria, PlayerCardResponses.gandalf_deal_4_damage, result));
result.respond_to_event(GameEvent.OPTION_3_PICKED,
PlayerCardResponses.action_maker(response_criteria, PlayerCardResponses.gandalf_reduce_threat, result));
return(result);
}
public StartScreen(SpriteBatch spriteBatch, PlayerCard humanCard, PlayerCard alienCard, Player thisPlayer,
MapBuilder mapBuilder, Texture2D checkedTexture, Texture2D unCheckedTexture, SpriteFont font)
{
this.spriteBatch = spriteBatch;
this.humanCard = humanCard;
this.alienCard = alienCard;
this.thisPlayer = thisPlayer;
this.mapBuilder = mapBuilder;
this.checkedTexture = checkedTexture;
this.unCheckedTexture = unCheckedTexture;
//clientCheckBox = new CheckBox(unCheckedTexture, checkedTexture, "Client", new Rectangle(20, 300, 50, 50), spriteBatch, font);
//clientCheckBox.IsChecked = true;
serverCheckBox = new CheckBox(unCheckedTexture, checkedTexture, "Server", new Rectangle(20, 360, 50, 50), spriteBatch, font);
}
public void deal()
{
playerCard = new PlayerCard();
int ay = 0, ax = 0;
for (int i=0; i<14; i++) {
for(int id=0;id<4;id++){
Card.card cardVal = cardstack.draw();
playerCard.playerDealCard(id,i,cardVal);
if(id==0){
//Debug.Log(cardVal.number+" "+cardVal.color);
ax = i;
if(i>=12){
ay = 1;
ax = i-12;
}
string objname = "C"+ cardVal.number;
GameObject newCard = Instantiate (Resources.Load(objname),new Vector3(CardAxisX[ax],CardAxisY[ay],-0.19f),cardStatus.getRotate()) as GameObject;
newCard.transform.localScale = cardStatus.getScale();
newCard.AddComponent<Card>();
newCard.GetComponent<Card>().val = cardVal;
Renderer newCardRenderer = newCard.GetComponent<Renderer>();
newCardRenderer.materials[1].SetColor("_Color",cardVal.color);
CardExist[ax,ay] = true;
}
}
}
leadCard = cardstack.draw();
string leadobj = "C"+leadCard.number;
GameObject newLeadCard = Instantiate(Resources.Load(leadobj),new Vector3(1,1,-0.19f),cardStatus.getRotate()) as GameObject;
newLeadCard.transform.localScale = cardStatus.getScale();
newLeadCard.AddComponent<Card>();
Destroy(newLeadCard.GetComponent<BoxCollider>());
newLeadCard.GetComponent<Card>().val = leadCard;
Renderer newLeadCardRenderer = newLeadCard.GetComponent<Renderer>();
newLeadCardRenderer.materials[1].SetColor("_Color",leadCard.color);
}
/// <summary>
/// 当装备被装备时
/// </summary>
public virtual void OnEquiped(PlayerCard playerCard)
{
this.EquipedCard = playerCard;
//修改需要通告网络
}
//run this once to pass stats from title to game
public static void getPlayer1(PlayerCard importPlayer)
{
temp1 = importPlayer;
fromUpdate = false;
}
//takes information from card and gives it to player
void PassStats(Player playerIn, PlayerCard temp, out Profile playerOut)
{
playerIn.hpMax = temp.health;
playerIn.enduranceMax = temp.maxStamina;
playerIn.enduranceRegen = temp.stamRegen;
playerIn.AddAttackOption(temp.attack_1);
playerIn.AddAttackOption(temp.attack_2);
playerIn.AddAttackOption(temp.attack_3);
playerIn.AddAttackOption(temp.meditate_1);
playerIn.AddAttackOption(temp.meditate_2);
playerIn.AddAttackOption(temp.meditate_3);
playerIn.AddDefendOption(temp.defend_1);
playerIn.AddDefendOption(temp.defend_2);
playerIn.AddDefendOption(temp.defend_3);
playerIn.name = temp.name;
playerIn.chiPoints = temp.level;
playerOut = playerIn;
}
// Use this for initialization
void Start()
{
//Randomly decide which player goes first
if (Random.Range(1,3) == 2) playerTurn = PlayerIndex.One;
else playerTurn = PlayerIndex.Two;
player1 = new Player();
player2 = new Player();
if(!fromUpdate){
if (temp1 == null)
{
temp1 = GameObject.Find("default1").GetComponent<PlayerCard>();
}
PassStats((Player)player1, temp1, out player1);
if (temp2 == null)
{
temp2 = GameObject.Find("default2").GetComponent<PlayerCard>();
}
PassStats((Player)player2, temp2, out player2);
}
else{
passPlayer ((Player)playTemp1, out player1);
passPlayer ((Player)playTemp2, out player2);
}
player1.playerIndex = PlayerIndex.One;
player2.playerIndex = PlayerIndex.Two;
player1.RecoverHP(player1.hpMax);
player2.RecoverHP(player2.hpMax);
player1.UseEndurance(player1.enduranceMax);
player2.UseEndurance(player2.enduranceMax);
player1.profileObject = player1Object;
player2.profileObject = player2Object;
healthBar1Width = healthBar.width;
healthBar2Width = healthBar.width;
enduranceBar1Height = 0;
enduranceBar2Height = 0;
}
