public void OnEvent(CardEvent e)
{
if (e.ResolvePhase == CardResolvePhase.Resolved)
{
StartCoroutine(DelayPassDay());
}
}
/// <summary>
/// Queries the database for a specific StoryCard Event.
/// Returns a CardEvent object made from the values in the Database
/// </summary>
/// <param name="id">The ID identifier of the event.</param>
/// <returns></returns>
public CardEvent GetCardEventById(int id = 0)
{
MySqlCommand command = new MySqlCommand("SELECT * FROM Event WHERE idEvent = @idVal", conn);
command.Parameters.AddWithValue("idVal", id);
CardEvent cardEvent = null;
using (reader = command.ExecuteReader())
{
if (reader.HasRows)
{
// Create Choices
// create the new event.
cardEvent = new CardEvent((int)reader[0], (string)reader[1], (Choice)reader[2],
(Choice)reader[3],
(Choice)reader[4]);
}
else
{
throw new GameDatabaseException("Statement did not return any rowns.");
}
}
reader.Close();
return(cardEvent);
}
public void A_card_which_was_created_during_the_period()
{
// Given
card.Size = 5;
var cardEvent = new CardEvent
{
Type = "CardCreationEvent",
DateTime = LeanKitConversions.DateTimeToCardEventDateTime(currentDate.AddDays(-2))
};
history.Add(cardEvent);
ApiSetupGetCardHistory(card.Id);
// When
var target = new LeanKitCardViewHistory(mockApi.Object, boardId, card, 5, currentDate);
// Then
Assert.AreEqual(5, target.PointsPerDay.Count);
Assert.AreEqual(card.Size, target.PointsPerDay[0].Points, "Incorrect points for day 0");
Assert.AreEqual(card.Size, target.PointsPerDay[1].Points, "Incorrect points for day 1");
Assert.AreEqual(0, target.PointsPerDay[2].Points, "Incorrect points for day 2");
Assert.AreEqual(0, target.PointsPerDay[3].Points, "Incorrect points for day 3");
Assert.AreEqual(0, target.PointsPerDay[4].Points, "Incorrect points for day 4");
}
public void A_card_which_moves_lane()
{
// Given
var cardEvent = new CardEvent
{
Type = "CardMoveEvent",
DateTime = LeanKitConversions.DateTimeToCardEventDateTime(currentDate.AddDays(-2)),
FromLaneId = 5,
ToLaneId = card.LaneId
};
history.Add(cardEvent);
ApiSetupGetCardHistory(card.Id);
// When
target = new LeanKitCardViewHistory(mockApi.Object, boardId, card, 5, currentDate);
// Then
Assert.AreEqual(5, target.PointsPerDay.Count);
Assert.AreEqual(card.LaneId, target.PointsPerDay[0].LaneId, "Incorrect lane id for day 0");
Assert.AreEqual(card.LaneId, target.PointsPerDay[1].LaneId, "Incorrect lane id for day 1");
Assert.AreEqual(cardEvent.FromLaneId, target.PointsPerDay[2].LaneId, "Incorrect lane id for day 2");
Assert.AreEqual(cardEvent.FromLaneId, target.PointsPerDay[3].LaneId, "Incorrect lane id for day 3");
Assert.AreEqual(cardEvent.FromLaneId, target.PointsPerDay[4].LaneId, "Incorrect lane id for day 4");
}
public static QueryResultList <CardEvent> GetCardEvents(CardEventSearchCondition con)
{
System.Threading.Thread.Sleep(_Random.Next(1, 5) * 1000);
List <CardEvent> ret = new List <CardEvent>();
DateTime dt = DateTime.Now;
for (int i = 0; i < 10; i++)
{
var userid = _Random.Next(1, 300);
var doorID = _Random.Next(1, 10);
var door = _Doors.Single(it => it.ID == doorID.ToString());
var ce = new CardEvent()
{
ID = Guid.NewGuid().ToString(),
UserID = userid.ToString(),
UserName = $"用户{userid}",
Department = $"电力部门{Math.Floor((double)userid / 30)}",
DoorID = door.ID,
DoorName = door.Name,
EventTime = dt,
Permitted = true,
Photo = null,
};
ret.Add(ce);
}
return(new QueryResultList <CardEvent>(ResultCode.Successful, String.Empty, ret));
}
public void ShowChoiceButtonScreen(CardEvent cardEvent)
{
_choice1Button.GetComponentInChildren <Text>().text = cardEvent.ChoiceButton1Text;
_choice2Button.GetComponentInChildren <Text>().text = cardEvent.ChoiceButton2Text;
_choice3Button.GetComponentInChildren <Text>().text = cardEvent.ChoiceButton3Text;
Animator.SetTrigger("ShowChoiceButtonsScreen");
}
public async Task <IActionResult> EditEventAsync(CardEvent newEvent, string department)
{
if (ModelState.IsValid)
{
var uEvent = await dbContext.CardEvents.FirstOrDefaultAsync(c => c.Id.Equals(newEvent.Id));
Department depart = await dbContext.Departments.FirstOrDefaultAsync(d => d.Name.Equals(department));
uEvent.Desc = newEvent.Desc;
uEvent.Name = newEvent.Name;
uEvent.Department = depart;
dbContext.CardEvents.Update(uEvent);
await dbContext.SaveChangesAsync();
var url = RedirectToAction("Events");
url.RouteValues = new RouteValueDictionary();
var result = url.RouteValues.TryAdd("department", RouteData.Values["department"]);
if (!result)
{
ModelState.AddModelError("", "Ошибка переадресовки");
ViewBag.Department = RouteData.Values["department"];
return(View(newEvent));
}
return(url);
}
else
{
ModelState.AddModelError("", "Введены некорректные данные");
ViewBag.Department = RouteData.Values["department"];
}
return(View(newEvent));
}
public async Task <IActionResult> CreateEventAsync(CardEvent card, string department)
{
if (ModelState.IsValid)
{
User user = await dbContext.Users.FirstOrDefaultAsync(u => u.UserName.Equals(User.Identity.Name));
Department depart = await dbContext.Departments.FirstOrDefaultAsync(d => d.Name.Equals(department));
CardEvent newCard = new CardEvent()
{
Department = depart,
Date = DateTime.Now,
Desc = card.Desc,
IsAlertResult = false,
Name = card.Name,
User = user
};
await dbContext.CardEvents.AddAsync(newCard);
dbContext.SaveChanges();
return(RedirectToAction("Events"));
}
else
{
ModelState.AddModelError("", "Ошибка ввода данных");
}
return(View());
}
public void OnDrag(PointerEventData eventData)
{
if (IsConfirmed)
{
return;
}
var moveStep = Vector2.Dot(SlideDiret, eventData.position - _lastDragPos);
moveStep = Mathf.SmoothDamp(0, moveStep, ref _dragSpeed, Time.deltaTime, 100000);
transform.localPosition += moveStep * (Vector3)SlideDiret.normalized;
var otherStep = Vector2.Dot(OtherDiret, eventData.position - _lastDragPos);
transform.localPosition += otherStep * (Vector3)OtherDiret.normalized;
_lastDragPos = eventData.position;
var posDir = Vector2.Dot(transform.localPosition, SlideDiret);
var previewResult = DirToResult(posDir);
if (transform.localPosition.magnitude < ConfirmDist)
{
CardEvent.Send(CardResolvePhase.Preview, previewResult, null);
_previewResult = null;
}
else
{
CardEvent.Send(CardResolvePhase.Preview, previewResult, ConfigData);
_previewResult = previewResult;
}
}
public void Confirm(CardResult result)
{
if (IsConfirmed)
{
return;
}
var clip = result == CardResult.Yes ? YesClip : NoClip;
if (clip != null)
{
AudioSource.PlayClipAtPoint(clip, Vector3.zero);
}
CardEvent.Send(CardResolvePhase.Preview, result, null);
Debug.Log($"Confirmed {result} {ConfigData.Id} {ConfigData.Destext}");
IsConfirmed = true;
CardEvent.Send(CardResolvePhase.Resolving, result, ConfigData);
DOTween.Kill(transform);
var dir = ResultToDir(result);
var endPos = dir * ResolvedDist * SlideDiret;
var time = Vector2.Distance(transform.localPosition, endPos) / 500;
transform.DOLocalMove(endPos, time)
.OnComplete(() => { CardEvent.Send(CardResolvePhase.Resolved, result, ConfigData); })
.SetEase(Ease.OutQuad);
_cardGroup.DOFade(0, time)
.SetEase(Ease.OutQuad);
}
private void CardExpanded(CardEvent message)
{
// do animation
AnimateTitle(CardState.Expanded);
// turn on user interaction
MainCardView.IsUserInteractionEnabled = false;
}
private void CardExpand(CardEvent obj)
{
// turn off swipe interaction
MainCardView.IsUserInteractionEnabled = false;
// animate Title out
AnimateTitle(CardState.Expanded);
}
private void Awake()
{
CardSelectedEvent = new CardEvent();
if (DebugMode)
{
SetCard(new Card(CardSuit.Spade, 13));
}
}
/// <summary>
/// Queries the database for a specific StoryCard.
/// Returns a StoryCard made from the data in the Database.
/// </summary>
/// <param name="id">The ID unique identifier of the StoryCard.</param>
/// <returns></returns>
public StoryCard GetStoryCardById(int id)
{
MySqlCommand command = new MySqlCommand("SELECT * FROM StoryCard WHERE idCard = @idVal", conn);
command.Parameters.AddWithValue("idVal", id);
StoryCard retStoryCard = null;
// Create new SqlDataReader object and read data from the command.
using (reader = command.ExecuteReader())
{
reader.Read();
if (reader.HasRows)
{
int cardID = (int)reader[0];
string ssmlContent = (string)reader[1];
CardType cardType = (CardType)Enum.Parse(typeof(CardType), (string)reader[2]);
int nextCardId = (int)reader[3];
string cardConten = (string)reader[5];
int eventId;
CardEvent cardEvent = null;
try
{
eventId = (int)reader[4];
cardEvent = GetCardEventById(eventId);
}
catch (Exception ex)
{
if (ex is InvalidCastException || ex is GameDatabaseException)
{
eventId = 0;
cardEvent = null;
}
else
{
throw ex;
}
}
//Close the reader. We don't need it anymore. Allows for another operation to be run.
reader.Close();
// create the new StoryCard
retStoryCard = new StoryCard(cardID, ssmlContent, cardType, nextCardId, cardEvent);
}
else
{
reader.Close();
throw new GameDatabaseException("Statement did not return any rowns.");
}
if (retStoryCard == null)
{
Console.WriteLine("WARNING: Null Value for Return StoryCard. Searched by ID= " + id);
}
return(retStoryCard);
}
}
public static EventType CardEventType(this CardEvent card)
{
EventType ev;
if (!Enum.TryParse <EventType>(card.Type.Substring(0, card.Type.Length - 5), true, out ev))
{
ev = EventType.Unrecognized;
}
return(ev);
}
void SetupEvents()
{
onStartOfTurn = Debug1;
onDrawCard = Debug2;
onAddPip = Debug3;
onSpiritPlay = Debug4;
onSpiritFade = Debug5;
onAttack = Debug6;
onDealDamage = Debug7;
onEndOfTurn = Debug8;
}
public void AddListener(string name, Action action)
{
if (events.ContainsKey(name))
{
events[name].action += action;
}
else
{
events[name] = new CardEvent(action);
}
}
public void Awake()
{
cardObjects = new List <GameObject>();
ClickCardEvent = new CardEvent();
if (TestMode)
{
Deck testDeck = new Deck();
SetCards(testDeck.DrawHand(6));
SetSelectableCards(true);
}
}
public void OnEndDrag(PointerEventData eventData)
{
if (_previewResult != null)
{
Confirm(_previewResult.Value);
_previewResult = null;
return;
}
CardEvent.Send(CardResolvePhase.Preview, CardResult.Yes, null);
transform.DOLocalMove(Vector3.zero, BackTime)
.SetEase(Ease.OutSine);
}
public void ShowInRegionPersonDetail(CardEvent ce, bool isIn)
{
if (_CurDialog == null || !_CurDialog.IsShowing)
{
_CurDialog = CreateDialog();
}
_CurDialogCreateTime = DateTime.Now;
var txtName = _CurDialog.FindViewById <TextView>(Resource.Id.txtName);
txtName.Text = ce.UserName;
var txtCardID = _CurDialog.FindViewById <TextView>(Resource.Id.txtCardID);
txtCardID.Text = ce.CardID;
var txtDept = _CurDialog.FindViewById <TextView>(Resource.Id.txtDept);
txtDept.Text = ce.Department;
var txtDoor = _CurDialog.FindViewById <TextView>(Resource.Id.txtDoor);
txtDoor.Text = ce.DoorName;
var txtTime = _CurDialog.FindViewById <TextView>(Resource.Id.txtTime);
txtTime.Text = ce.EventTime.ToString("yyyy-MM-dd HH:mm:ss");
var picAlarm = _CurDialog.FindViewById <ImageView>(Resource.Id.picAlarm);
if (!isIn)
{
picAlarm.Visibility = Android.Views.ViewStates.Gone;
}
else
{
picAlarm.Visibility = Android.Views.ViewStates.Visible;
}
if (_DicPerson.ContainsKey(ce.UserID))
{
var person = _DicPerson[ce.UserID];
var txtPhone = _CurDialog.FindViewById <TextView>(Resource.Id.txtPhone);
txtPhone.Text = person.Phone;
var picPhoto = _CurDialog.FindViewById <ImageView>(Resource.Id.picPhoto);
picPhoto.SetImageBitmap(null);
if (person.Photo != null && person.Photo.Length > 0)
{
var bmp = BitmapFactory.DecodeByteArray(person.Photo, 0, person.Photo.Length);
picPhoto.SetImageBitmap(bmp);
}
}
if (isIn)
{
StartAudio();
}
}
public void Show(CardEvent ce, Action cb = null)
{
gameObject.SetActive(true);
fader.color = new Color(0, 0, 0, 0);
fader.DOFade(.95f, 1);
cg.DOFade(1, .5f);
transform.GetChild(0).localScale = new Vector3(.85f, .85f, .85f);
transform.GetChild(0).DOScale(1, .5f).SetEase(Ease.OutExpo);
callback = cb;
cardEvent = ce;
eventTitle.text = ce.eventName.ToLower();
eventFlavor.text = ce.eventFlavor;
allyToAdd = null;
enemyToAdd = null;
//pick 2 rebels/allies
var hlist = DataStore.deployedHeroes.GetHealthy();
//make sure there are valid heroes/allies to target
if (hlist != null && hlist.Count > 0)
{
int[] rnd = GlowEngine.GenerateRandomNumbers(hlist.Count());
rebel1 = hlist[rnd[0]];
if (hlist.Count > 1)
{
rebel2 = hlist[rnd[1]];
}
else
{
rebel2 = rebel1;
}
}
else
{
rebel1 = new CardDescriptor()
{
name = "None"
};
rebel2 = rebel1;
}
foreach (var s in ce.content)
{
ParseCard(s);
}
}
public static IEnumerator MoveAndScaleCardTo(GameObject obj, Vector3 targetPos, Vector3 targetScale, float k)
{
CardEvent cardEvent = obj.GetComponent <CardEvent>();
if (cardEvent)
{
cardEvent.animationLock = true;
}
Vector3 initPos = obj.transform.position;
Vector3 initScale = obj.transform.localScale;
float p = 0;
while (p < 1f - 5e-3)
{
if (cardEvent == null || cardEvent.isDragged)
{
break;
}
p += (1 - p) * k;
Vector3 curPos = targetPos * p + initPos * (1 - p);
obj.transform.position = curPos;
Vector3 curScale = targetScale * p + initScale * (1 - p);
obj.transform.localScale = curScale;
yield return(null);
}
if ((cardEvent == null) || !cardEvent.isDragged)
{
obj.transform.position = targetPos;
obj.transform.localScale = targetScale;
if (cardEvent)
{
cardEvent.animationLock = false;
}
}
Game.Ctx.AnimationOperator.onAnimationEnd.Invoke();
yield return(null);
}
private void AddCardToNewStack(TCard card)
{
var stack = new CardStack <TCard, TCardDefinition>(this);
cardStacks.Add(stack);
stack.AddCard(card);
CardEvent cardGameEvent = new CardEvent(CardEvent.CardEventType.CardAdded);
card.RaiseEvent(cardGameEvent);
if (cardGameEvent.IsCancelled)
{
RemoveChild(stack);
cardStacks.Remove(stack);
return;
}
OnCardAdded?.Invoke();
}
/// <summary>
/// Debounce card event state.
/// </summary>
/// <param name="readerName">Reader for which we're debouncing events</param>
/// <param name="eventToQuash">Which event we should quash</param>
/// <returns>True if event debounced; false otherwise</returns>
/// <remarks>
/// Card state can change for things like Locked and InUse flags
/// so we don't want to fire the insert event for those.
/// </remarks>
private bool DebounceState(string readerName, CardEvent eventToQuash)
{
// Debounce state. Card state can change for things like Locked and InUse flags
// so we don't want to fire the insert event for those.
if (this.debouncer.ContainsKey(readerName))
{
if (this.debouncer[readerName] == eventToQuash)
{
return(true);
}
this.debouncer[readerName] = eventToQuash;
}
else
{
this.debouncer.Add(readerName, eventToQuash);
}
return(false);
}
public void A_card_in_the_ToDo_lane_with_history_and_a_card_in_the_archive_with_no_history()
{
// Given
AddDefaultLanesToBoard();
ApiSetupGetBoard(mockBoard.Id);
var card = new CardView {
Id = 350, LaneId = mockDoingLane.Id ?? 0, Size = 5
};
var history = AddCardToLane(mockBoard.Id, mockDoingLane, card);
var cardEvent = new CardEvent
{
Type = "CardMoveEvent",
DateTime = LeanKitConversions.DateTimeToCardEventDateTime(DateTime.Now.AddDays(-1)),
FromLaneId = mockToDoLane.Id ?? 0,
ToLaneId = mockDoingLane.Id ?? 0
};
history.Add(cardEvent);
card = new CardView {
Id = 200, LaneId = mockDoingLane.Id ?? 0, Size = 10
};
AddCardToLane(mockBoard.Id, mockDoingLane, card);
// When
RunTest(boardId: mockBoard.Id, numberOfDaysHistory: 5);
// Then
ActualLane(mockBacklogLane).AssertLaneHistoryIs(AllAre(value: 0, numberOfElements: 5), "Backlog");
ActualLane(mockToDoLane).AssertLaneHistoryIs(new List <int> {
0, 5, 5, 5, 5
}, "To Do");
ActualLane(mockDoingLane).AssertLaneHistoryIs(new List <int> {
15, 10, 10, 10, 10
}, "Doing");
ActualLane(mockDoneLane).AssertLaneHistoryIs(AllAre(value: 0, numberOfElements: 5), "Done");
ActualLane(mockArchiveLane).AssertLaneHistoryIs(AllAre(value: 0, numberOfElements: 5), "Archive");
}
public void A_card_which_changes_size()
{
// Given
int oldSize = 2;
card.Size = 5;
var cardEvent = new CardEvent
{
Type = "CardFieldsChangedEvent",
DateTime = LeanKitConversions.DateTimeToCardEventDateTime(currentDate.AddDays(-3)),
Changes = new List <CardEvent.FieldChange>
{
new CardEvent.FieldChange {
FieldName = "Description", OldValue = "XYZ"
},
new CardEvent.FieldChange {
FieldName = "Size", OldValue = oldSize.ToString()
}
}
};
history.Add(cardEvent);
ApiSetupGetCardHistory(card.Id);
// When
var target = new LeanKitCardViewHistory(mockApi.Object, boardId, card, 5, currentDate);
// Then
Assert.AreEqual(5, target.PointsPerDay.Count);
Assert.AreEqual(card.Size, target.PointsPerDay[0].Points, "Incorrect points for day 0");
Assert.AreEqual(card.Size, target.PointsPerDay[1].Points, "Incorrect points for day 1");
Assert.AreEqual(card.Size, target.PointsPerDay[2].Points, "Incorrect points for day 2");
Assert.AreEqual(oldSize, target.PointsPerDay[3].Points, "Incorrect points for day 3");
Assert.AreEqual(oldSize, target.PointsPerDay[4].Points, "Incorrect points for day 4");
}
public static DateTime ConvertedDateTime(this CardEvent t)
{
return(StringDateTimeToDateTime(t.DateTime));
}
public void GetEvent()
{
CardEvent.GetEvent();
}
public void StartShop()
{
activeEvent = shopEvent;
CreateShopCards();
}
public void ShowChoiceTextScreen(CardEvent cardEvent)
{
_choiceText.text = cardEvent.ChoiceText;
_cardImage.sprite = Resources.Load <Sprite>("Cards/" + cardEvent.SpriteName);
Animator.SetTrigger("ShowChoiceTextScreen");
}
