void Awake()
{
if (instance == null)
instance = this;
else
Destroy(gameObject);
}
public void LoadGame()
{
m_cardManager = new CardManager(cardFile);
m_mobManager = new MobManager(mobFile);
m_characterManager = new CharacterManager(characterFile);
Application.LoadLevel("game");
}
// Use this for initialization
void Start()
{
_MainGameState = GameplayObject.GetComponent<MainGameState> ();
_CardManager = GameplayObject.GetComponent<CardManager> ();
_NameText = GetComponentInChildren<Text> ();
_CardsPanel = transform.FindChild ("Cards");
}
// Load all cards!
public void LoadCards(CardManager library)
{
foreach (CardBaseData cardData in _CardData) {
library.LoadCard(cardData);
}
// Fill in missing data with default cards.
for (int i = _CardData.Count; i < 64; ++i) {
CardBaseData nextData = GetDummyData(i);
library.LoadCard(nextData);
}
}
void Awake()
{
if(it == null)
{
it = this;
Init();
DontDestroyOnLoad(gameObject);
}
else if(it != this)
{
Destroy(gameObject);
}
}
// Setup initial relation value.
public void SetupInitialRelations(CardManager manager, IEnumerable<long> cards)
{
foreach (long cardType in cards) {
CardBaseData data = manager.GetCardBaseData(cardType);
if (data.Equals(CardBaseData.EmptyCard)) {
continue;
}
if (data.Relations != null) {
foreach (RelationBaseData relation in data.Relations) {
var otherCards = manager.FindCardsWithName(relation.OtherName);
foreach (CardBaseData otherCardData in otherCards) {
// Can be optimized (doesn't need to do fromCard lookup every time), but oh well.
ApplyRelationshipChange(data.CardType, otherCardData.CardType, relation.Relationship);
}
}
}
}
}
public void initiate(bool opponentcards) {
//checks if this cardmanager is a player's or an opponents
opponent = opponentcards;
if (this == Main.cardmanager) { oppmanager = Main.opponentcardmanager;
}else if (this == Main.opponentcardmanager) { oppmanager = Main.cardmanager; }
//creates a placeholder card to be cloned later to create cards
card = new Card (false);
card.core = GameObject.Find ("card");
card.core.renderer.enabled = false;
//gets the first slot that belongs to this cardmanager
string oppstring = "player";
if (opponent) { oppstring = "opp"; }
GameObject slot = GameObject.Find(oppstring + "slot1");
collisionslots.Add(slot); slots.Add(null);
//clone and create 5 slots based off a original slot
for (int n = 0; n < 3; ++n) {
GameObject newslot = (GameObject)Object.Instantiate(slot);
newslot.name = oppstring + "slot" + (n + 2);
newslot.transform.Translate(-150 * (n + 1), 0, 0);
collisionslots.Add(newslot); slots.Add(null);
}
//get the deck that belongs to this cardmanager
deck = GameObject.Find(oppstring + "deck");
//creates 30 cards and places them in the deck
for (int i = 0; i < 10; ++i) {
Card newcard = createcard ((int)Random.Range (0, Main.textures.carddetails.Count));
deckcards.Add (newcard);
newcard.originposition = deck.transform.position;
newcard.originposition.y += i * 1; newcard.originposition.z += Random.Range(-5, 5);
newcard.details.id = i;
}
//get the border card object
cardborder = GameObject.Find("bordercard");
cardborder.renderer.enabled = false;
}
public void ReceiveCards(CardManager.WeatherCard weatherCard, CardManager.EventCard eventCard, CardManager.ConsequenceCard consequenceOne, CardManager.ConsequenceCard consequenceTwo)
{
switch (weatherCard)
{
case CardManager.WeatherCard.Dag:
GameObject.Find("Darkness").GetComponent<Image>().color = new Color(0, 0, 0, .1f);
break;
case CardManager.WeatherCard.Nacht:
GameObject.Find("Darkness").GetComponent<Image>().color = new Color(0, 0, 0, .8f);
break;
case CardManager.WeatherCard.Mooi:
GameObject.Find("Darkness").GetComponent<Image>().color = new Color(0, 0, 0, 0);
break;
case CardManager.WeatherCard.Slecht:
GameObject.Find("Darkness").GetComponent<Image>().color = new Color(0, 0, 0, .4f);
break;
}
currentEvent += 1;
// Send Cards to Event or sumthin
GameObject.Find("EnemySpawner_" + currentEvent).GetComponent<EnemySpawner>().Initialize(eventCard, consequenceOne, consequenceTwo);
}
public void Start()
{
cm = GameObject.Find("GameManager").GetComponent <CardManager>();
FindObjectOfType <AudioManager>().Play("HocusPokus");
}
public bool CanRegister()
{
//Added by Ahmed Mohsen 25/10/2011- CR#xxxx(Limit Card registeration cards for user to be 5 cards for his online account)
if (this.NavigationState.Contact != null && this.NavigationState.Contact.Contact_ID > 0)
{
CardManager manager = new CardManager();
int cardCount = manager.GetCards(this.NavigationState.Contact.Contact_ID).Count;
if (cardCount >= int.Parse(System.Configuration.ConfigurationManager.AppSettings["MaxRegisteredCards"]))
{
return false;
}
}
return true;
//--------------------------------
}
void Start()
{
instance = this;
}
public override List <HexCell> GetCanUseCells(CardManager user)
{
return(base.GetCanUseCells(user));
}
void Start()
{
Instance = this;
}
// Use this for initialization
void Start()
{
_GameState = GamePlayObj.GetComponent<MainGameState> ();
_GameFlow = GetComponent<GameFlowControl> ();
_Canvas = transform.FindChild ("MenuCanvas");
_CardManager = GamePlayObj.GetComponent<CardManager> ();
_PlaceholderLibrary = gameObject.AddComponent<PlaceholderLibrary> ();
Transform debugView = _Canvas.FindChild ("DebugView");
Debug.Assert (debugView);
if (debugView) {
debugView.gameObject.SetActive(false);
}
}
public void Initialize(CardManager.EventCard MainEvent, CardManager.ConsequenceCard Concequence1, CardManager.ConsequenceCard Concequence2)
{
this.Concequence1 = Concequence1;
this.Concequence2 = Concequence2;
this.MainEvent = MainEvent;
if (MainEvent == CardManager.EventCard.RampSpoed || MainEvent == CardManager.EventCard.tRampSpoed || GameManager.Instance.CurrentEvent == 3)
{
isSpawining = true;
}
}
// Use this for initialization
void Start()
{
BoardMgr = GetComponent<BoardManager> ();
CardMgr = GetComponent<CardManager> ();
CameraMgr = GetComponent<CameraManager> ();
ComponentMgr = GetComponent<ComponentManager> ();
FileMgr = GetComponent<FileManager> ();
LanguageMgr = GetComponent<LanguageManager> ();
NetworkMgr = GetComponent<NetworkManager> ();
PlayerMgr = GetComponent<PlayerManager> ();
TechMgr = GetComponent<TechManager> ();
UnitMgr = GetComponent<UnitManager> ();
UIMgr = GetComponent<UIManager> ();
initializeOptions ();
}
public void SelectOrDeselectCard(CardManager card)
{
// If it's 0 then obivously we can select that card cause there's nothing in yet
if (selectedCards.Count == 0)
{
hasCardsSelected = true;
card.isSelected = true;
card.Clicked();
selectedCards.Add(card);
return;
}
// If it's already selected just remove it
if (card.isSelected)
{
selectedCards.Remove(card);
card.isSelected = false;
if (selectedCards.Count == 0)
{
hasCardsSelected = false;
card.Clicked();
}
if (isMultiple && selectedCards.Count == 1) // If it's currently a multiple and there's only one card then it's not a multiple anymroe
{
isMultiple = false;
card.Clicked();
}
if (isRun) // If it's a run and one card gets deselected, just deselect them all for simplicity.
{
for (int i = 0; i < selectedCards.Count; i++)
{
selectedCards[i].isSelected = false;
selectedCards[i].Clicked(); // Simulate click
}
selectedCards = new List <CardManager>();
isRun = false;
hasCardsSelected = false;
}
return;
}
// Check if they're the same symbol and if it's a run
if (!isMultiple)
{
if (card.associatedCard.cardSymbol == selectedCards[0].associatedCard.cardSymbol)
{
if (selectedCards[selectedCards.Count - 1].associatedCard.cardValue - card.associatedCard.cardValue == -1)
{
card.isSelected = true;
card.Clicked();
selectedCards.Add(card);
isRun = true;
return;
}
}
}
// Check if they're the same number
if (!isRun)
{
if (selectedCards[selectedCards.Count - 1].associatedCard.cardValue == card.associatedCard.cardValue)
{
card.isSelected = true;
card.Clicked();
selectedCards.Add(card);
isMultiple = true;
return;
}
}
}
/// <summary>
/// Ensure that card exists on BO, issued and not expired
/// </summary>
/// <param name="lMsg">the message of error if found</param>
/// <returns>if card is valid</returns>
public bool IsCardValid(out string lMsg)
{
bool lIsCardValid = true;
lMsg = "";
CardManager lCardManager = new CardManager();
string lCardNumber = _NavigationState.SB_Card.CardNumber;
BO_CardOverviewResponse lCardOverResponse = lCardManager.GetCardDetails(lCardNumber);
CardDetails lCardDetails = (lCardOverResponse != null) ? lCardOverResponse.CardOverview : null;
if (lCardDetails != null)
{
enumCardState lCardState = (enumCardState)Enum.Parse(typeof(enumCardState), lCardDetails.CardState);
//enumCardStatus lCardStatus = (enumCardStatus)Enum.Parse(typeof(enumCardStatus), lCardDetails.CardStatus);
PurseDetails lPurseDetails = lCardManager.GetCardPurseDetails(lCardNumber);
//check that the card state, status and purse if exists is valid
if (lCardState == enumCardState.Issued && lCardDetails.CardStatus == "8"
&& ((lPurseDetails != null && lPurseDetails.PurseStatus == "8") || lPurseDetails == null))
{
lIsCardValid = true;
}
else
{
lMsg = Resources.Resource_2_0.CardSelection_CardNotIssued;
lIsCardValid = false;
}
//check if the card is expired
if (lCardDetails.CardExpiryDate < DateTime.Now)
{
lMsg = Resources.Resource_2_0.CardSelection_CardExpired;
lIsCardValid = false;
}
}
else
{
lMsg = Resources.CardManagement.BONotConnected;
lIsCardValid = false;
}
if (lIsCardValid)
{
WriteLogEntry("IsCardValid", _NavigationState.SB_Card.CardNumber + ":Valid");
NavigationState.SB_Card.CardProfileCode = lCardDetails.CardProfile;
//Get the code value using the profile code
if (NavigationState.SB_Card.CardProfileCode != -1)
{
NavigationState.SB_Card.CardProfileValue = new CardManager().GetCardProfileByCodeValue(NavigationState.SB_Card.CardProfileCode.Value).Code_Description;
NavigationState.SB_Card.IsPersonalized = CardManager.IsPersonalizedCardProfile((int)NavigationState.SB_Card.CardProfileCode);
}
}
else
WriteLogEntry("IsCardValid", _NavigationState.SB_Card.CardNumber + ":" + lMsg);
return lIsCardValid;
}
private int getcardindex(int fromid, CardManager manager) {
for (int n = 0; n < manager.cards.Count; ++n) {
if (manager.cards[n].details.id == fromid) {
return n;
}
}
return -1;
}
/// <summary>
/// Load the BO profile code and value for the card to be topped-up besides loading the SB BO data object
/// </summary>
/// <returns></returns>
public bool LoadCardInfoIntoSession(BO_CardOverviewResponse pBO_Res)
{
try
{
WriteLogEntry("LoadCardInfoIntoSession", _NavigationState.SB_Card.CardNumber + ":Start");
CardManager lCardManager = new CardManager();
Card lcard = new Card();
lcard.CardNumber = NavigationState.SB_Card.CardNumber;
NavigationState.SB_Card.SB_BOdata = lCardManager.GetBackofficeDataForCard(lcard, pBO_Res);
if (NavigationState.SB_Card.SB_BOdata == null)
return false;
WriteLogEntry("LoadCardInfoIntoSession", _NavigationState.SB_Card.CardNumber + ":Completed");
return true;
}
catch (Exception ex)
{
if (!ExceptionHandler.IsUserFriendly(ex))
{
ExceptionHandler.handle(ex);
return false;
}
else
{ throw ex; }
}
}
// 카드 움직임
public static void move(CardManager main, Coordinate coord)
{
CardManager temp = CardsOnField[coord];
// 애니메이션
}
// 공격
public static void attack(CardManager main, CardManager target, int damage, int attackType)
{
target.damage(damage, attackType);
// 애니메이션
}
public Deck(CardManager cardManager)
{
m_cards = new List<CardInfo>();
m_discarded = new List<CardInfo>();
m_cardManager = cardManager;
}
/// <summary>
/// Ensure that card exists on BO, issued and not expired
/// </summary>
/// <param name="lMsg">the message of error if found</param>
/// <returns>if card is valid</returns>
public bool IsCardValid(out string lMsg)
{
bool lIsCardValid = true;
lMsg = "";
CardManager lCardManager = new CardManager();
string lCardNumber = _NavigationState.SB_Card.CardNumber;
BO_CardOverviewResponse lCardOverResponse = lCardManager.GetCardDetails(lCardNumber);
CardDetails lCardDetails = (lCardOverResponse != null) ? lCardOverResponse.CardOverview : null;
if (lCardDetails != null)
{
enumCardState lCardState = (enumCardState)Enum.Parse(typeof(enumCardState), lCardDetails.CardState);
//enumCardStatus lCardStatus = (enumCardStatus)Enum.Parse(typeof(enumCardStatus), lCardDetails.CardStatus);
PurseDetails lPurseDetails = lCardManager.GetCardPurseDetails(lCardNumber);
//check that the card state, status and purse if exists is valid
if (lCardState == enumCardState.Issued && lCardDetails.CardStatus == "8" &&
((lPurseDetails != null && lPurseDetails.PurseStatus == "8") || lPurseDetails == null))
{
lIsCardValid = true;
}
else
{
lMsg = Resources.Resource_2_0.CardSelection_CardNotIssued;
lIsCardValid = false;
}
//check if the card is expired
if (lCardDetails.CardExpiryDate < DateTime.Now)
{
lMsg = Resources.Resource_2_0.CardSelection_CardExpired;
lIsCardValid = false;
}
}
else
{
lMsg = Resources.CardManagement.BONotConnected;
lIsCardValid = false;
}
if (lIsCardValid)
{
WriteLogEntry("IsCardValid", _NavigationState.SB_Card.CardNumber + ":Valid");
NavigationState.SB_Card.CardProfileCode = lCardDetails.CardProfile;
//Get the code value using the profile code
if (NavigationState.SB_Card.CardProfileCode != -1)
{
NavigationState.SB_Card.CardProfileValue = new CardManager().GetCardProfileByCodeValue(NavigationState.SB_Card.CardProfileCode.Value).Code_Description;
NavigationState.SB_Card.IsPersonalized = CardManager.IsPersonalizedCardProfile((int)NavigationState.SB_Card.CardProfileCode);
}
}
else
{
WriteLogEntry("IsCardValid", _NavigationState.SB_Card.CardNumber + ":" + lMsg);
}
return(lIsCardValid);
}
void Start()
{
CardManager a = new CardManager(new Golem(), new Coordinate(1, 2));
a.damage(1, AttackTypes.Magical);
}
private void Awake()
{
cardManager = FindObjectOfType <CardManager>();
}
public bool IsCardProfileValidForRegistration(string pCardNumber)
{
try
{
CardManager lCardMgr = new CardManager();
int lProfileCode = lCardMgr.GetCardProfileCode(pCardNumber);
if (lProfileCode == SWC.SC_CardProfile.Tourist || lProfileCode == SWC.SC_CardProfile.Trainee)
{
return false;
}
}
catch (Exception ex)
{
if (!ExceptionHandler.IsUserFriendly(ex))
{
ex.Data.Add("PageName", "CardRegisteration");
ex.Data.Add("EventName", "IsCardProfileValidForRegistration");
ExceptionHandler.handle(ex);
}
else
{ throw ex; }
}
return true;
}
public LinkedCardServices(AccountServices accountServices)
{
cardManager = new CardManager();
this.accountServices = accountServices;
}
public override bool CanUseCard(CardManager user, HexCell cell)
{
return(base.CanUseCard(user, cell));
}
public void LoadLevel(string level)
{
ResetAllTheThings();
int loadedTiles = storyTrack.LoadStoryTrackJSON(level);
if(loadedTiles > 0) {
storyTrack.Display();
}
if(m_debug) {
m_debugCardManager = new CardManager("cards");
m_debugMobManager = new MobManager("mobs");
m_debugCharManager = new CharacterManager("characters");
}
CharacterInfo info = characterManager.GetCharacterByName("squire");
Person p = new Person(info);
characterManager.AddPersonToParty(p);
playerHand.cardManager = cardManager;
playerHand.level = this;
m_state = TurnState.draw;
}
public IHttpActionResult getUsernameByUserID([FromBody] int UID)
{
string username = CardManager.getUsernameByUserID(UID);
return(Ok(username));
}
void Start()
{
cardManager = CardManager.Instance;
}
public CardManagerTests()
{
cardManager = new CardManager(mockCardRepository.Object, mockCardTransactionRepository.Object, mockIAuthenticationManager.Object);
}
public GameObject GetPrefab()
{
return(CardManager.GetCardPrefab(((int)ID) - 1));
}
public void Start()
{
cm = GameObject.Find("GameManager").GetComponent <CardManager>();
}
public Deck(CardManager cardManager)
{
m_cards = new List <CardInfo>();
m_discarded = new List <CardInfo>();
m_cardManager = cardManager;
}
void Start()
{
getCards = GetComponent <CardManager>();
}
void Awake()
{
this.cardManger = this.GetComponent <CardManager>();
this.uiManager = this.GetComponent <UIManager>();
}
public async Task CardManager_Should_SendSecondRequestToCliet_IfTokenExpiredAndRetryOnUnauthorizedAsync()
{
// STC-26
var expiredJwtGenerator = new JwtGenerator(
AppSettings.AppId,
IntegrationHelper.ApiPrivateKey(),
AppSettings.ApiPublicKeyId,
TimeSpan.FromSeconds(1),
Substitute.For <VirgilAccessTokenSigner>());
var jwtGenerator = new JwtGenerator(
AppSettings.AppId,
IntegrationHelper.ApiPrivateKey(),
AppSettings.ApiPublicKeyId,
TimeSpan.FromMinutes(5),
new VirgilAccessTokenSigner()
);
var identity = faker.Random.AlphaNumeric(20);
var expiredToken = expiredJwtGenerator.GenerateToken(identity);
var accessTokenProvider = Substitute.For <IAccessTokenProvider>();
// suppose we have got expired token at the first attempt
// and we have got valid token at the second attempt
accessTokenProvider.GetTokenAsync(Arg.Any <TokenContext>()
).Returns(
args =>
((TokenContext)args[0]).ForceReload ?
jwtGenerator.GenerateToken(identity) :
expiredToken
);
var validator = new VirgilCardVerifier(new VirgilCardCrypto())
{
VerifySelfSignature = true, VerifyVirgilSignature = true
};
validator.ChangeServiceCreds(AppSettings.ServicePublicKeyDerBase64);
var manager = new CardManager(new CardManagerParams()
{
CardCrypto = new VirgilCardCrypto(),
AccessTokenProvider = accessTokenProvider,
ApiUrl = AppSettings.CardsServiceAddress,
RetryOnUnauthorized = true,
Verifier = validator
});
var keypair = new VirgilCrypto().GenerateKeys();
var card = await manager.PublishCardAsync(
new CardParams()
{
Identity = identity,
PublicKey = keypair.PublicKey,
PrivateKey = keypair.PrivateKey
});
Assert.NotNull(card);
var searchCard = await manager.SearchCardsAsync(identity);
Assert.AreEqual(searchCard.Count, 1);
var getCard = await manager.GetCardAsync(card.Id);
Assert.NotNull(getCard);
}
public AuthController(CardManager cardManager)
{
_cardManager = cardManager;
}
private WagoBK.Channels CreateChannelsFromFile(Stream InputFile)
{
//create Channel-Collection that will temporary hold imported data
WagoBK.Channels MyChannels = new Channels();
MyChannels.DIChannels.Clear();
MyChannels.DOChannels.Clear();
MyChannels.AIChannels.Clear();
MyChannels.AOChannels.Clear();
CardDefBase Card = null;
int CardChCounter = 0;
int CardSlot = 0;
MyChannels.ProjectCards.AddCard(CardSlot, new CardDef842(CardSlot)); //koppler not contained in file
CardSlot++;
System.IO.StreamReader TextReader = new System.IO.StreamReader(InputFile);
while (!TextReader.EndOfStream)
{
string Line = TextReader.ReadLine();
string[] sep = { ";" };
string[] ChannelDefString = Line.Split(sep, 4, StringSplitOptions.None);
string Name = ChannelDefString[3];
string BMK = ChannelDefString[0];
UInt16 CardCode = UInt16.Parse(ChannelDefString[2]);
char InOut = ChannelDefString[1].ToCharArray(0, 1)[0];
//check for doubled or invalid names??
string[] SpecialChars = { " ", ".", "!", "%", "&", "/", "\\", "(", ")", "{", "}", "*", "+", "-" };
foreach (string SpecialChar in SpecialChars)
{
if (Name.Contains(SpecialChar))
{
throw new Exception("invalid name " + Name);
}
}
if (Card == null ||
CardChCounter >= Card.GetChannelCount() ||
Card.GetType() != CardManager.CreateCardByCode(CardSlot, CardCode).GetType())
{
Card = CardManager.CreateCardByCode(CardSlot, CardCode);
CardChCounter = 0;
MyChannels.ProjectCards.AddCard(CardSlot++, Card);
}
;
switch (Card.GetChannelType())
{
case ChannelType.AI:
MyChannels.AIChannels.Add(Name, new AIChannelDef(Name, BMK, (CardDefAnalogIO)Card, CardChCounter));
break;
case ChannelType.AO:
MyChannels.AOChannels.Add(Name, new AOChannelDef(Name, BMK, (CardDefAnalogIO)Card, CardChCounter));
break;
case ChannelType.DI:
MyChannels.DIChannels.Add(Name, new DIChannelDef(Name, BMK, (CardDefDigitalIO)Card, CardChCounter));
break;
case ChannelType.DO:
MyChannels.DOChannels.Add(Name, new DOChannelDef(Name, BMK, (CardDefDigitalIO)Card, CardChCounter));
break;
}
CardChCounter++;
}
TextReader.Close();
return(MyChannels);
}
public void CardManager_Should_RaiseExceptionIfGetsInvalidCard()
{
// STC-13
var verifier = Substitute.For <ICardVerifier>();
verifier.VerifyCard(Arg.Any <Card>()).Returns(false);
var signCallBack = Substitute.For <Func <RawSignedModel, Task <RawSignedModel> > >();
signCallBack.Invoke(Arg.Any <RawSignedModel>()).Returns(args => (RawSignedModel)args[0]);
var jwtGenerator = new JwtGenerator(
faker.AppId(),
IntegrationHelper.ApiPrivateKey(),
AppSettings.ApiPublicKeyId,
TimeSpan.FromMinutes(10),
new VirgilAccessTokenSigner()
);
var accessTokenProvider = Substitute.For <IAccessTokenProvider>();
var identity = faker.Random.AlphaNumeric(20);
var token = jwtGenerator.GenerateToken(identity);
accessTokenProvider.GetTokenAsync(Arg.Any <TokenContext>()).Returns(
token
);
var model = faker.PredefinedRawSignedModel(null, true, true, true);
var client = Substitute.For <ICardClient>();
Func <Task <Tuple <RawSignedModel, bool> > > getStub = async() =>
{
return(new Tuple <RawSignedModel, bool>(model, false));
};
Func <Task <RawSignedModel> > publishStub = async() =>
{
return(model);
};
Func <Task <IEnumerable <RawSignedModel> > > searchStub = async() =>
{
return(new List <RawSignedModel>()
{
model
});
};
client.GetCardAsync(Arg.Any <string>(), Arg.Any <string>()).Returns(getStub.Invoke());
client.PublishCardAsync(Arg.Any <RawSignedModel>(), Arg.Any <string>()).Returns(publishStub.Invoke());
client.SearchCardsAsync(Arg.Any <string>(), Arg.Any <string>()).Returns(searchStub.Invoke());
var cardId = faker.CardId();
var searchCardIdentity = faker.Random.AlphaNumeric(20);
var manager = new CardManager(new CardManagerParams()
{
CardCrypto = new VirgilCardCrypto(),
AccessTokenProvider = accessTokenProvider,
SignCallBack = signCallBack,
Verifier = verifier,
ApiUrl = AppSettings.CardsServiceAddress
}
)
{
Client = client
};
Assert.Throws <CardVerificationException>(() => manager.ImportCardFromJson(model.ExportAsJson()));
Assert.Throws <CardVerificationException>(() => manager.ImportCardFromString(model.ExportAsString()));
Assert.ThrowsAsync <CardVerificationException>(async() => await manager.GetCardAsync(cardId));
Assert.ThrowsAsync <CardVerificationException>(async() => await manager.PublishCardAsync(model));
Assert.ThrowsAsync <CardVerificationException>(async() => await manager.SearchCardsAsync(searchCardIdentity));
Assert.Throws <CardVerificationException>(() => manager.ImportCard(model));
}
public Sprite GetSprite()
{
return(CardManager.GetCardSprite(((int)ID) - 1));
}
public void CardManager_Should_RaiseExceptionIfGetsCardWithDifferentId()
{
// STC-34
var verifier = Substitute.For <ICardVerifier>();
verifier.VerifyCard(Arg.Any <Card>()).Returns(true);
var crypto = new VirgilCrypto();
var keyPair = faker.PredefinedKeyPair();
var rawCardContent = new RawCardContent()
{
CreatedAt = DateTime.UtcNow,
Identity = "test",
PublicKey = crypto.ExportPublicKey(keyPair.PublicKey),
Version = "5.0"
};
var model = new RawSignedModel()
{
ContentSnapshot = SnapshotUtils.TakeSnapshot(rawCardContent)
};
var signer = new ModelSigner(new VirgilCardCrypto());
signer.SelfSign(
model, keyPair.PrivateKey, new Dictionary <string, string>()
{
{ "info", "some_additional_info" }
}
);
var signCallBack = Substitute.For <Func <RawSignedModel, Task <RawSignedModel> > >();
signCallBack.Invoke(Arg.Any <RawSignedModel>()).Returns(args => (RawSignedModel)args[0]);
var jwtGenerator = new JwtGenerator(
AppSettings.AppId,
IntegrationHelper.ApiPrivateKey(),
AppSettings.ApiPublicKeyId,
TimeSpan.FromMinutes(10),
new VirgilAccessTokenSigner()
);
var accessTokenProvider = Substitute.For <IAccessTokenProvider>();
var identity = faker.Random.AlphaNumeric(20);
var token = jwtGenerator.GenerateToken(identity);
accessTokenProvider.GetTokenAsync(Arg.Any <TokenContext>()).Returns(
token
);
var cardId = faker.CardId();
var client = Substitute.For <ICardClient>();
Func <Task <Tuple <RawSignedModel, bool> > > stub = async() =>
{
return(new Tuple <RawSignedModel, bool>(model, false));
};
client.GetCardAsync(Arg.Any <string>(), Arg.Any <string>()).Returns(stub.Invoke());
var manager = new CardManager(new CardManagerParams()
{
CardCrypto = new VirgilCardCrypto(),
AccessTokenProvider = accessTokenProvider,
SignCallBack = signCallBack,
Verifier = verifier,
ApiUrl = AppSettings.CardsServiceAddress
}
)
{
Client = client
};
Assert.ThrowsAsync <CardVerificationException>(async() => await manager.GetCardAsync(cardId));
}
//---------------------------------------------------------------------------------------------
public override void BoatOnClick(StateManager stateManager, CardManager cardManager, Boat boat)
{
if (stateManager.CurrentPlayerId != boat.Owner.PlayerId)
{
return;
}
// Initialize movement queue
boat.pendingMovements = new Queue <Movement>();
// Move out of the tile
boat.Move
(
new Movement
(
boat.GetPositionForCurrentTile() + Vector3.up * Definitions.SMOOTH_HEIGHT
)
);
boat.LeaveTile();
// Move
int tilesToMove = stateManager.LastRollResult;
for (int i = 0; i < tilesToMove; i++)
{
boat.currentTile = boat.currentTile.nextTile;
if (boat.currentTile.isCorner)
{
// Move to corner
boat.Move
(
new Movement
(
boat.GetPositionForCurrentTile() + Vector3.up * Definitions.SMOOTH_HEIGHT,
Quaternion.Euler(boat.gameObject.transform.eulerAngles.x, boat.gameObject.transform.eulerAngles.y + 90, boat.gameObject.transform.eulerAngles.z)
)
);
}
if (boat.currentTile.isInitialTile)
{
stateManager.CurrentPlayer().Money += Definitions.CANTIDAD_A_RECIBIR_SALIDA;
stateManager.CurrentPlayer().CrossedInitialTile = true;
}
}
// Final destination
boat.ArriveAtTile();
boat.currentTile.UpdateBoatPositions(boat);
Vector3 finalPosition = boat.GetPositionForCurrentTile();
boat.Move
(
new Movement
(
finalPosition + Vector3.up * Definitions.SMOOTH_HEIGHT
)
);
// Move into the tile
boat.Move
(
new Movement(finalPosition)
);
boat.isAnimating = true;
WaitingForAnimation.PendingAnimations.Add(boat.gameObject);
stateManager.CurrentState = WaitingForAnimation.GetInstance();
// Get a card if we rolled 6
if (stateManager.LastRollResult == 6)
{
// Get a card
ICard drawnCard = cardManager.DrawCardFromDeck();
if (drawnCard is PassiveCard)
{
drawnCard.PlayCard(boat.Owner, boat.currentTile);
}
else
{
boat.Owner.AddCard(drawnCard);
}
stateManager.ShowCardReceived(drawnCard.CardName());
}
// Move furtives if we rolled 1
if (stateManager.LastRollResult == 1)
{
stateManager.Furtives.Move(boat.currentTile);
}
// Resolve resources in our destination
boat.CollectResources();
}
public MainActivity()
{
_cardManager = new CardManager(new CardRepository());
}
// Use this for initialization
void Start()
{
cm = GameObject.Find("GameManager").GetComponent <CardManager>();
//forgePanel = null;
}
private void Awake()
{
instance = this;
}
//---------------------------------------------------------------------------------------------
public override void InventoryCardClick(StateManager stateManager, CardManager cardManager, CardInventoryButton inventoryCard)
{
cardManager.cardPlayed = inventoryCard.RepresentedCard;
stateManager.PlayingCard();
}
public override IEnumerator OnCharacterAdded(CharacterState character, CardState fromCard, RelicManager relicManager, SaveManager saveManager, PlayerManager playerManager, RoomManager roomManager, CombatManager combatManager, CardManager cardManager)
{
if (character.GetTeamType() == Team.Type.Heroes)
{
character.AddDeathSignal(OnEnemyDeath);
}
yield break;
}
public CardController(CardManager cardManager)
{
_cardManager = cardManager;
}
public void RegistCardManager(CardManager cardManager)
{
CardManagers.Add(cardManager);
}
public override bool check(CardManager card)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Binds the summary dropdownlist.
/// </summary>
/// <remarks></remarks>
//private void BindSummaryDropdownlist()
//{
// try
// {
// DropdownHdrManager dhm = new DropdownHdrManager();
// List<DropDown_HdrDTO> list = dhm.SearchDllHeader("Account_Summary").ToList();
// if (list.Count > 0)
// {
// ddlAccountSummary.DataSource = dhm.SearchDllDetail(list[0].DropDown_Hdr_Id);
// ddlAccountSummary.DataTextField = "Description";
// ddlAccountSummary.DataValueField = "DropDown_Dtl_Id";
// ddlAccountSummary.DataBind();
// ddlAccountSummary.Items.Insert(0, new ListItem("--Select Summary--", "0"));
// }
// ddlAccountSummary.SelectedIndex = ddlAccountSummary.Items.IndexOf(ddlAccountSummary.Items.FindByText("Account Summary"));
// }
// catch (Exception ex)
// {
// string str = ex.Message;
// }
//}
/// <summary>
/// Binds the card number dropdownlist.
/// </summary>
/// <param name="accountNumber">The account number.</param>
/// <remarks></remarks>
public void BindCardNumberDropdownlist(string accountNumber)
{
try
{
ddlCardNumber.Items.Clear();
//List<CH_CardDTO> lstCardnumbers = new CardManager().GetCardList(accountNumber);
List <CH_CardDTO> lstCardnumbers = new CardManager().GetAllCardsForATMPinReg(new CH_CardDTO()
{
Cr_Account_Nbr = accountNumber
});
if (lstCardnumbers != null)
{
foreach (var item in lstCardnumbers)
{
if (item.BASIC_CARD_FLAG == "0")
{
item.MASK_CARD_NUMBER = "Primary " + item.MASK_CARD_NUMBER;
}
else
{
item.MASK_CARD_NUMBER = "Add-On " + item.MASK_CARD_NUMBER;
}
}
if (lstCardnumbers.Count > 1)
{
ddlCardNumber.DataSource = lstCardnumbers;
ddlCardNumber.DataTextField = "MASK_CARD_NUMBER";
ddlCardNumber.DataValueField = "CARD_NUMBER";
ddlCardNumber.DataBind();
drpCardlist.Attributes.CssStyle.Add("display", "block");
divCardNumber.Visible = false;
}
else
{
Cardnumber = lstCardnumbers[0].card_number;
string StartCardnumber = "";
string EndCardnumber = "";
if (Cardnumber != "")
{
StartCardnumber = Cardnumber.Substring(0, 4);
if (Cardnumber.Length == 16)
{
EndCardnumber = Cardnumber.Substring(13, 3);
}
}
lblCreditCardNumber.Text = StartCardnumber + "XXXXXXXXX" + EndCardnumber;
drpCardlist.Attributes.CssStyle.Add("display", "none");
divCardNumber.Visible = true;
}
}
//ddlCardNumber.Items.Insert(0, new ListItem(Constants.selectSummary, zero));
}
catch (Exception ex)
{
string str = ex.Message;
}
}
void Start () {
manager = FindObjectOfType<CardManager>();
}
public abstract bool check(CardManager card );
