public void TestFetch()
{
// Arrange
string description = "capture description";
this.requestMock.Expect(x => x.CreateRequest(this.baseUrl.ToString().TrimEnd('/') + this.orderUrl + this.path + "/1002")).Return(this.httpWebRequest);
string json = "{\r\n \"capture_id\": \"" + this.captureId + "\",\r\n \"description\": \"" + description + "\",\r\n }";
WebHeaderCollection headers = new WebHeaderCollection();
headers[HttpResponseHeader.ContentType] = "application/json";
HttpStatusCode status = HttpStatusCode.OK;
IResponse response = new Response(status, headers, json);
this.requestMock.Expect(x => x.Send(this.httpWebRequest, string.Empty)).Return(response);
// Act
CaptureData captureData = this.capture.Fetch();
// Assert
this.requestMock.VerifyAllExpectations();
Assert.AreEqual(this.captureId, captureData.CaptureId);
Assert.AreEqual(description, captureData.Description);
Assert.AreEqual(0, this.httpWebRequest.ContentLength);
TestsHelper.AssertRequest(this.merchantId, this.secret, this.httpWebRequest, HttpMethod.Get);
}
private PostProcessPaymentResult NewRegisterKlarnaOrder(PostProcessPaymentEvaluationContext context)
{
var retVal = new PostProcessPaymentResult();
var connector = ConnectorFactory.Create(
AppKey,
AppSecret,
Client.TestBaseUrl);
Client client = new Client(connector);
var order = client.NewOrder(context.OuterId);
OrderData orderData = order.Fetch();
if (orderData.Status != "CAPTURED")
{
var capture = client.NewCapture(order.Location);
CaptureData captureData = new CaptureData()
{
CapturedAmount = orderData.OrderAmount,
Description = "All order items is shipped",
OrderLines = orderData.OrderLines
};
capture.Create(captureData);
orderData = order.Fetch();
}
retVal.IsSuccess = orderData.Status == "CAPTURED";
retVal.NewPaymentStatus = retVal.IsSuccess ? PaymentStatus.Paid : PaymentStatus.Pending;
retVal.OrderId = context.Order.Id;
return(retVal);
}
public void TestCreate()
{
// Arrange
this.capture = new Klarna.Rest.OrderManagement.Capture(this.connector, this.orderUrl, string.Empty);
this.requestMock.Expect(x => x.CreateRequest(this.baseUrl.ToString().TrimEnd('/') + this.orderUrl + this.path)).Return(this.httpWebRequest);
CaptureData captureData = new CaptureData()
{
Description = "the desc...",
CapturedAmount = 111
};
WebHeaderCollection headers = new WebHeaderCollection();
headers["Location"] = this.location;
IResponse response = new Response(HttpStatusCode.Created, headers, string.Empty);
this.requestMock.Expect(x => x.Send(this.httpWebRequest, captureData.ConvertToJson())).Return(response);
// Act
this.capture.Create(captureData);
// Assert
this.requestMock.VerifyAllExpectations();
Assert.AreEqual(this.location, this.capture.Location.OriginalString);
Assert.AreEqual(captureData.ConvertToJson().Length, this.httpWebRequest.ContentLength);
TestsHelper.AssertRequest(this.merchantId, this.secret, this.httpWebRequest, HttpMethod.Post);
}
override public Capture UpdateCapture(InputState input, CaptureData data)
{
SnapDrawPrimitivesTool tool =
(context.ToolManager.ActiveRightTool as SnapDrawPrimitivesTool);
capture_data cap = data.custom_data as capture_data;
tool.UpdateDraw_Ray(input.vMouseWorldRay, cap.nStep);
if (input.bLeftMouseReleased)
{
if ((cap.nStep + 1) < tool.Steps)
{
cap.nStep++;
return(Capture.Continue);
}
else
{
tool.EndDraw();
return(Capture.End);
}
}
else
{
return(Capture.Continue);
}
}
public override Capture UpdateCapture(InputState input, CaptureData data)
{
if ((data.which == CaptureSide.Left && input.bLeftStickReleased) ||
(data.which == CaptureSide.Right && input.bRightStickReleased))
{
int nSide = (data.which == CaptureSide.Left) ? 0 : 1;
if (context.ToolManager.HasActiveTool(nSide))
{
context.ToolManager.DeactivateTool(nSide);
}
else if (
((data.which == CaptureSide.Left && input.RightCaptureActive == false) ||
(data.which == CaptureSide.Right && input.LeftCaptureActive == false)) &&
context.Scene.Selected.Count > 0)
{
context.Scene.ClearSelection();
}
return(Capture.End);
}
else
{
return(Capture.Continue);
}
}
public override Capture UpdateCapture(InputState input, CaptureData data)
{
if (input.bLeftShoulderReleased || input.bRightShoulderReleased)
{
cockpit.ActiveCamera.SetTargetVisible(false);
HandInfo hi = (HandInfo)data.custom_data;
if (hi.eMode == ActionMode.SetWorldScale)
{
hi.CompleteSetWorldScale(cockpit);
}
return(Capture.End);
}
else
{
HandInfo hi = (HandInfo)data.custom_data;
if (hi.eMode == ActionMode.SetWorldScale)
{
return(Update_SetWorldScale(input, data));
}
else
{
return(Update_TransformCamera(input, data));
}
}
}
override public Capture UpdateCapture(InputState input, CaptureData data)
{
// [RMS] this is a hack for trigger+shoulder grab gesture...really need some way to interrupt captures!!
if ((data.which == CaptureSide.Left && input.bLeftShoulderPressed) ||
(data.which == CaptureSide.Right && input.bRightShoulderPressed))
{
return(Capture.End);
}
//Ray3f sideRay = (data.which == CaptureSide.Left) ? input.vLeftSpatialWorldRay : input.vRightSpatialWorldRay;
Frame3f sideHandF = (data.which == CaptureSide.Left) ? input.LeftHandFrame : input.RightHandFrame;
sideHandF.Origin += SceneGraphConfig.VRHandTipOffset * sideHandF.Z;
bool bReleased = (data.which == CaptureSide.Left) ? input.bLeftTriggerReleased : input.bRightTriggerReleased;
if (bReleased)
{
tool.CutMesh();
return(Capture.End);
}
else
{
tool.UpdatePlane(sideHandF);
return(Capture.Continue);
}
}
/// <summary>
/// Invoked whenever a capture is attempted during the Strategy phase.
/// Creates the Capture data and switches to the Action portion of the game.
/// </summary>
/// <param name="move">The move that generated this capture attempt</param>
private void OnCaptureAttempted(Move move)
{
EPieceType light = EPieceType.None;
EPieceType dark = EPieceType.None;
// Determine pieces with heuristic where From is always the current team's moving piece
switch (StrategyGame.Instance.TurnState)
{
case ETeam.Light:
light = GameBoard.Instance[move.From];
dark = GameBoard.Instance[move.To];
break;
case ETeam.Dark:
dark = GameBoard.Instance[move.From];
light = GameBoard.Instance[move.To];
break;
}
// Create final capture data for action portion
Capture = new CaptureData(move, light, dark, (int)StrategyGame.Instance.TurnState);
// Begin switch to Action portion
SwitchToAction();
}
override public Capture ForceEndCapture(InputState input, CaptureData data)
{
DrawCurveTool tool = context.ToolManager.GetActiveTool((int)data.which) as DrawCurveTool;
tool.CancelDraw();
return(Capture.End);
}
public override Capture UpdateCapture(InputState input, CaptureData data)
{
GrabInfo gi = data.custom_data as GrabInfo;
bool bFinished = false;
if (data.which == CaptureSide.Left && (input.bLeftShoulderReleased || input.bLeftTriggerReleased))
{
bFinished = true;
}
else if (data.which == CaptureSide.Right && (input.bRightShoulderReleased || input.bRightTriggerReleased))
{
bFinished = true;
}
if (bFinished)
{
snaps_end_grab(gi.grabbedSO);
gi.complete();
Capture result = end_transform(data);
if (OnEndGrab != null)
{
OnEndGrab(this, gi.grabbedSO);
}
return(result);
}
Frame3f handF = (data.which == CaptureSide.Left) ? input.LeftHandFrame : input.RightHandFrame;
gi.stickDelta += (data.which == CaptureSide.Left) ? input.vLeftStickDelta2D : input.vRightStickDelta2D;
gi.update(handF, EnableSnapping ? Snaps : null);
// drop-a-copy on X/A button release
if ((data.which == CaptureSide.Left && input.bXButtonReleased) ||
(data.which == CaptureSide.Right && input.bAButtonReleased))
{
SceneObject copy = gi.grabbedSO.Duplicate();
// save an undo-point for the current xform, and start a new one. That way we can
// step between drop-a-copy stages
push_position_change(data);
gi.change = new TransformGizmoChange()
{
parentSO = new WeakReference(gi.grabbedSO),
parentBefore = gi.grabbedSO.GetLocalFrame(CoordSpace.SceneCoords),
parentScaleBefore = gi.grabbedSO.GetLocalScale()
};
// if we do this afterwards, and don't push an interaction state, then when
// we undo/redo we don't end up sitting on top of a duplicate.
cockpit.Scene.History.PushChange(
new AddSOChange()
{
scene = cockpit.Scene, so = copy, bKeepWorldPosition = false
});
}
return(Capture.Continue);
}
private byte[] GetImageBin(CaptureData captureData, byte[] binData)
{
if (binData == null)
{
return(null);
}
switch (captureData.compress)
{
#if UNITY_EDITOR
case TextureCompress.None:
return(ImageConversion.EncodeArrayToPNG(binData,
UnityEngine.Experimental.Rendering.GraphicsFormat.R8G8B8A8_SRGB,
(uint)captureData.width, (uint)captureData.height));
case TextureCompress.RGB_565:
return(ImageConversion.EncodeArrayToPNG(binData,
UnityEngine.Experimental.Rendering.GraphicsFormat.R5G6B5_UNormPack16,
(uint)captureData.width, (uint)captureData.height));
#endif
case TextureCompress.PNG:
case TextureCompress.JPG_BufferRGB565:
case TextureCompress.JPG_BufferRGBA:
return(binData);
}
return(null);
}
/// <summary>
/// Run the example code.
/// </summary>
public static void Main()
{
const string MerchantId = "0";
const string SharedSecret = "sharedSecret";
string orderId = "12345";
string captureId = "34567";
IConnector connector = ConnectorFactory.Create(MerchantId, SharedSecret, Client.EuTestBaseUrl);
Client client = new Client(connector);
IOrder order = client.NewOrder(orderId);
ICapture capture = client.NewCapture(order.Location, captureId);
try
{
CaptureData captureData = capture.Fetch();
}
catch (ApiException ex)
{
Console.WriteLine(ex.ErrorMessage.ErrorCode);
Console.WriteLine(ex.ErrorMessage.ErrorMessages);
Console.WriteLine(ex.ErrorMessage.CorrelationId);
}
catch (WebException ex)
{
Console.WriteLine(ex.Message);
}
}
override public Capture UpdateCapture(InputState input, CaptureData data)
{
capture_data d = data.custom_data as capture_data;
if (d.is_right)
{
if (input.bRightMouseReleased)
{
return(Capture.End);
}
}
else
{
if (input.bLeftMouseReleased)
{
return(Capture.End);
}
}
int point = (d.is_right || d.is_secondary_left) ? 1 : 0;
Ray3f ray = input.vMouseWorldRay;
AnyRayHit rayHit;
if (context.Scene.FindSceneRayIntersection(ray, out rayHit, false))
{
tool.UpdateMeasurePoint(rayHit.hitPos, CoordSpace.WorldCoords, point, true);
}
return(Capture.Continue);
}
override public Capture UpdateCapture(InputState input, CaptureData data)
{
if (input.nTouchCount == 0)
{
return(Capture.End);
}
Ray3f ray = input.vTouchWorldRay;
AnyRayHit rayHit;
if (context.Scene.FindSceneRayIntersection(ray, out rayHit, false))
{
tool.UpdateMeasurePoint(rayHit.hitPos, CoordSpace.WorldCoords, 0, true);
}
if (input.nTouchCount > 1)
{
ray = input.vSecondTouchWorldRay;
if (context.Scene.FindSceneRayIntersection(ray, out rayHit, false))
{
tool.UpdateMeasurePoint(rayHit.hitPos, CoordSpace.WorldCoords, 1, true);
}
}
return(Capture.Continue);
}
public override Capture UpdateCapture(InputState input, CaptureData data)
{
Vector2f vDelta = input.StickDelta2D((int)data.which);
internal_data d = data.custom_data as internal_data;
if (vDelta[0] < -0.75f)
{
if (d.last_sent_time == -1 || d.last_direction > 0 || FPlatform.RealTime() - d.last_sent_time > RepeatTime)
{
Cycle(-1);
d.last_sent_time = FPlatform.RealTime();
d.last_direction = -1;
}
}
else if (vDelta[0] > 0.75f)
{
if (d.last_sent_time == -1 || d.last_direction < 0 || FPlatform.RealTime() - d.last_sent_time > RepeatTime)
{
Cycle(1);
d.last_sent_time = FPlatform.RealTime();
d.last_direction = 1;
}
}
if (vDelta[StickAxis] == 0)
{
return(Capture.End);
}
return(Capture.Continue);
}
private void ExecuteFrameMetadata(int frameIdx, ProfilerSample sample)
{
var metadatas = sample.metaDatas.metadatas;
if (metadatas.Count < 2)
{
return;
}
var guidBin = metadatas[0].convertedObject as byte[];
var tagId = (int)metadatas[1].convertedObject;
var valueBin = metadatas[2].convertedObject as byte[];
if (guidBin == null || valueBin == null)
{
return;
}
System.Guid guid = new System.Guid(guidBin);
CaptureData captureData = null;
if (guid != MetadataGuid)
{
return;
}
if (tagId == InfoTag)
{
captureData = new CaptureData(frameIdx, valueBin);
this.captureFrameData.Add(captureData.idx, captureData);
return;
}
if (this.captureFrameData.TryGetValue(tagId, out captureData))
{
ExecuteBinData(captureData, valueBin);
}
}
// Start Transmission
public void TransmitDataToGroundStation()
{
dataAmount = CaptureData.GetIndex();
Debug.Log("Data amount: " + dataAmount);
timeBeforeNextTransmit = timePerData * dataAmount + timeBuffer;
StartCoroutine(DelayBeforeTransmit(timeBeforeNextTransmit));
}
override public Capture UpdateCapture(InputState input, CaptureData data)
{
RevolveTool tool =
(context.ToolManager.ActiveRightTool as RevolveTool);
SceneObject startHitSO = data.custom_data as SceneObject;
if (input.bLeftMouseReleased)
{
SORayHit soHit;
if (context.Scene.FindSORayIntersection(input.vMouseWorldRay, out soHit))
{
if (soHit.hitSO == startHitSO)
{
if (soHit.hitSO is PolyCurveSO)
{
tool.UpdateCurve(input.vMouseWorldRay, soHit);
}
else
{
tool.UpdateAxis(input.vMouseWorldRay, soHit);
}
}
}
return(Capture.End);
}
else
{
return(Capture.Continue);
}
}
/**********************************************************************************/
// функция проверки столкновения
// если цель здание - происходит захват
//
/**********************************************************************************/
override protected void CheckBulletBurn(Collision2D coll)
{
if (m_state == BULLET_STATE.FLY)
{
string otherObjTag = coll.gameObject.tag;
if (otherObjTag == "Player" || otherObjTag == "wall" || otherObjTag == "Building")
{
if (otherObjTag == "Player")
{
if (coll.gameObject.GetComponent <PlayerController>().playerId == (PLAYER)m_ownerID)
{
return;
}
}
m_state = BULLET_STATE.BURN;
// выключаем коллайдер для сработавшего сняаряда
speed = 0.0f;
m_rb2d.velocity = new Vector2(0, 0);
m_collider.enabled = false;
m_animator.SetBool("Burn", true);
PlayBurstSoundEffect();
if (otherObjTag == "Building")
{
CaptureData cdata = new CaptureData();
cdata.OwnweID = m_ownerID;
cdata.CapturePower = CapturePower;
coll.gameObject.SendMessage("Capture", cdata, SendMessageOptions.DontRequireReceiver);
}
}
}
}
/**********************************************************************************/
// функция захвата строения
// здесь определяется сменит ли здание владельца и устанавливается тип производимых юнитов
//
/**********************************************************************************/
public virtual void Capture(CaptureData cdata)
{
if (m_ownerId != cdata.OwnweID)
{
m_currentVirusStamina -= cdata.CapturePower;
if (m_currentVirusStamina <= 0)
{
m_ownerId = cdata.OwnweID;
Debug.Log("Building was captured by pl# " + m_ownerId.ToString());
m_animator.SetInteger("ownerID", m_ownerId);
m_animator.SetTrigger("isCuptured");
if (m_IIFlAnimator != null)
{
m_IIFlAnimator.SetInteger("ownerID", m_ownerId);
m_IIFlAnimator.SetTrigger("isCuptured");
}
// выбираем юнита для производства
if (m_ownerId == (int)PLAYER.PL1)
{
m_unitProdactionType = UnitToProduce_Pl1;
}
else if (m_ownerId == (int)PLAYER.PL2)
{
m_unitProdactionType = UnitToProduce_Pl2;
}
else
{
m_unitProdactionType = UnitToProduce_Neutral;
}
// при захвате обновляем счётчик производства, чтобы не воровать чужих юнитов
m_currentProductionTime = RateOfProduction;
// выставляем новую сопротивляемость
if (m_ownerId == (int)PLAYER.NEUTRAL)
{
m_currentVirusStamina = NeutralVirusStamina;
}
else
{
m_currentVirusStamina = MaxVirusStamina;
}
// увеличиваем счётчик очков за захват
GameManager.GetInstance().IncreasePlayerScopeBuildingCuptured((PLAYER)m_ownerId, CuptureScope);
m_virusMarker.SetOwner((PLAYER)m_ownerId);
m_createdUnitIDs.Clear();
// помечаем здание как разрушенное - больше оно не будет производить нейтральных юнитов
m_isDestroyed = true;
}
m_virusMarker.SetStamina(m_currentVirusStamina);
}
}
override public Capture UpdateCapture(InputState input, CaptureData data)
{
RevolveTool tool = context.ToolManager.GetActiveTool((int)data.which) as RevolveTool;
// [RMS] this is a hack for trigger+shoulder grab gesture...really need some way
// to interrupt captures!!
if ((data.which == CaptureSide.Left && input.bLeftShoulderPressed) ||
(data.which == CaptureSide.Right && input.bRightShoulderPressed))
{
tool.Cancel();
return(Capture.End);
}
if (data.custom_data == this)
{
// hack to detect button-press capture set
bool bReleased = (data.which == CaptureSide.Left) ? input.bXButtonReleased : input.bAButtonReleased;
if (bReleased)
{
tool.AddCurrent();
return(Capture.End);
}
}
else
{
Ray sideRay = (data.which == CaptureSide.Left) ? input.vLeftSpatialWorldRay : input.vRightSpatialWorldRay;
SceneObject startHitSO = data.custom_data as SceneObject;
bool bReleased = (data.which == CaptureSide.Left) ? input.bLeftTriggerReleased : input.bRightTriggerReleased;
if (bReleased)
{
SORayHit soHit;
if (context.Scene.FindSORayIntersection(sideRay, out soHit))
{
if (soHit.hitSO == startHitSO)
{
if (soHit.hitSO is PolyCurveSO)
{
if (tool.HasCurve)
{
tool.UpdateAxis(sideRay, soHit);
}
else
{
tool.UpdateCurve(sideRay, soHit);
}
}
else
{
tool.UpdateAxis(sideRay, soHit);
}
}
}
return(Capture.End);
}
}
return(Capture.Continue);
}
override public Capture ForceEndCapture(InputState input, CaptureData data)
{
DrawCurveTool tool =
(context.ToolManager.ActiveRightTool as DrawCurveTool);
tool.CancelDraw();
return(Capture.End);
}
Capture end_transform(CaptureData data)
{
push_position_change(data);
cockpit.Context.TransformManager.PopOverrideGizmoType();
in_grab = false;
grabbed_so = null;
return(Capture.End);
}
static void Main_Loaded(object sender, System.EventArgs e)
{
Localization.TryChangeFileName(Main.Values.LocalizationFileName);
MonsterData.TryChangeFileName(Main.Values.MonsterDataFileName);
CaptureData.TryChangeFileName(Main.Values.CaptureDataFileName);
PlayerData.TryChangeFileName(Main.Values.PlayerDataFileName);
Memory.TryChangeFileName(Main.Values.MemoryFileName);
}
public override Capture ForceEndCapture(InputState input, CaptureData data)
{
// do animated dismiss that will destroy menu on completion
HUDUtil.AnimatedDimiss_Scene(popup, cockpit.Scene, true, 0.2f);
// lose our reference
popup = null;
return(Capture.End);
}
private string GetFilePath(CaptureData captureData)
{
stringBuilder.Length = 0;
stringBuilder.Append(this.outputPath).Append("/ss-");
stringBuilder.Append(string.Format("{0:D5}", captureData.idx));
stringBuilder.Append(".png");
return(stringBuilder.ToString());
}
public CaptureData GetDetailPageInfo(string startTime)
{
try
{
webDriver.Navigate().Refresh();
CaptureData data = new CaptureData();
var element = webDriver.FindElement(By.Id("15-400-tab-1"));
base.ClickOnAndWaitForElementShow(element, ScoreTable);
base.WaitForPageReady();
base.WaitForAjax();
var table = webDriver.FindElement(By.Id("mbt-v2-game-boxscore-table"));
var visitnameEle = table.FindElements(By.XPath(".//thead/tr[1]/th"));
data.VisitTeamName = visitnameEle[0].Text;
var homenameEle = table.FindElements(By.XPath(".//tbody/tr[17]/td"));
data.HomeTeamName = homenameEle[0].Text;
var td1 = table.FindElement(By.XPath(".//tbody/tr[14]"));
var td2 = table.FindElement(By.XPath(".//tbody/tr[30]"));
var src1 = td1.FindElements(By.XPath("./td"));
var src2 = td2.FindElements(By.XPath("./td"));
data.VisitTwoP = src1[3].Text;
data.VisitThreeP = src1[5].Text;
data.VisitFG = src1[7].Text;
data.VisitFT = src1[9].Text;
data.VisitOffReb = src1[10].Text;
data.VisitDefReb = src1[11].Text;
data.VisitReb = src1[12].Text;
data.VisitASS = src1[13].Text;
data.VisitTO = src1[15].Text;
data.VisitScore = src1[22].Text;
data.HomeTwoP = src2[3].Text;
data.HomeThreeP = src2[5].Text;
data.HomeFG = src2[7].Text;
data.HomeFT = src2[9].Text;
data.HomeOffReb = src2[10].Text;
data.HomeDefReb = src2[11].Text;
data.HomeReb = src2[12].Text;
data.HomeASS = src2[13].Text;
data.HomeTO = src2[15].Text;
data.HomeScore = src2[22].Text;
return(data);
}
catch (Exception ex)
{
throw ex;
}
finally
{
webDriver.Close();
webDriver.Dispose();
}
}
override public Capture ForceEndCapture(InputState input, CaptureData data)
{
try {
tool.EndStroke();
} catch (Exception e) {
DebugUtil.Log("MeshEditorTool.ForceEndCapture: " + e.Message);
}
return(Capture.End);
}
public override Capture ForceEndCapture(InputState input, CaptureData data)
{
GrabInfo gi = data.custom_data as GrabInfo;
snaps_end_grab(gi.grabbedSO);
gi.complete();
return(end_transform(data));
}
public async Task <CaptureData> NavgateToNBADetailPageAsync(string id, string homeName, string visitName)
{
CaptureData data = new CaptureData();
string url = string.Format("http://china.nba.com/static/data/game/snapshot_{0}.json", id);
using (HttpClient client = new HttpClient())
{
var response = await client.GetAsync(url);
if (response.StatusCode == HttpStatusCode.OK)
{
try
{
var result = await response.Content.ReadAsStringAsync();
RootObject obj = JsonConvert.DeserializeObject <RootObject>(result);
data.HomeTeamName = obj.payload.homeTeam.profile.displayAbbr;
data.VisitTeamName = obj.payload.awayTeam.profile.displayAbbr;
data.HomeFT = obj.payload.homeTeam.score.ftpct.ToString();
data.VisitFT = obj.payload.awayTeam.score.ftpct.ToString();
data.HomeTO = obj.payload.homeTeam.score.turnovers.ToString();
data.VisitTO = obj.payload.awayTeam.score.turnovers.ToString();
data.HomeASS = obj.payload.homeTeam.score.assists.ToString();
data.HomeASS = obj.payload.awayTeam.score.assists.ToString();
data.HomeScore = obj.payload.homeTeam.score.score.ToString();
data.VisitScore = obj.payload.awayTeam.score.score.ToString();
data.HomeFG = obj.payload.homeTeam.score.fgpct.ToString();
data.VisitFG = obj.payload.awayTeam.score.fgpct.ToString();
data.HomeTwoP = string.Format("{0}%",
((float)(obj.payload.homeTeam.score.fgm - obj.payload.homeTeam.score.tpm)
/ (float)(obj.payload.homeTeam.score.fga - obj.payload.homeTeam.score.tpa) * 100).ToString("0.0"));
data.VisitTwoP = string.Format("{0}%",
((float)(obj.payload.awayTeam.score.fgm - obj.payload.awayTeam.score.tpm)
/ (float)(obj.payload.awayTeam.score.fga - obj.payload.awayTeam.score.tpa) * 100).ToString("0.0"));
data.HomeThreeP = obj.payload.homeTeam.score.tppct.ToString();
data.VisitThreeP = obj.payload.awayTeam.score.tppct.ToString();
data.HomeOffReb = obj.payload.homeTeam.score.offRebs.ToString();
data.VisitOffReb = obj.payload.awayTeam.score.offRebs.ToString();
data.HomeTO = obj.payload.homeTeam.score.turnovers.ToString();
data.VisitTO = obj.payload.awayTeam.score.turnovers.ToString();
data.GamesStartTime = obj.payload.boxscore.statusDesc;
data.GamesCurrentTime = obj.payload.boxscore.periodClock;
return(data);
}
catch
{
return(null);
}
}
return(null);
}
}
private CaptureData(string value, int index, int length, bool createCaptures)
{
Value = value;
Index = index;
Length = length;
// Prevent a StackOverflow recursion in the constructor
if (createCaptures)
{
Captures = new CaptureData[] { new CaptureData(value, index, length, false) };
}
}
private PostProcessPaymentResult NewRegisterKlarnaOrder(PostProcessPaymentEvaluationContext context)
{
var retVal = new PostProcessPaymentResult();
var connector = ConnectorFactory.Create(
AppKey,
AppSecret,
Client.TestBaseUrl);
Client client = new Client(connector);
var order = client.NewOrder(context.OuterId);
OrderData orderData = order.Fetch();
if (orderData.Status != "CAPTURED")
{
var capture = client.NewCapture(order.Location);
CaptureData captureData = new CaptureData()
{
CapturedAmount = orderData.OrderAmount,
Description = "All order items is shipped",
OrderLines = orderData.OrderLines
};
capture.Create(captureData);
orderData = order.Fetch();
}
retVal.IsSuccess = orderData.Status == "CAPTURED";
retVal.NewPaymentStatus = retVal.IsSuccess ? PaymentStatus.Paid : PaymentStatus.Pending;
retVal.OrderId = context.Order.Id;
return retVal;
}
/// <summary>
/// キャプチャループスレッド作成
/// </summary>
/// <param name="ms">キャプチャ間隔</param>
private void StartCaptureLoop(double ms = 50)
{
//Parallel.Invoke(() =>
m_Task = Task.Run(() =>
{
var capCnt = 0;
var sw = new Stopwatch();
var mat = new Mat(m_DstSize.Height, m_DstSize.Width, MatType.CV_8UC4, m_Bits);
var mat_xor = new Mat();
var mat_diff = new Mat();
var segRect = new Rectangle(0, 0, m_DstSize.Width / CaptureDivisionNum, m_DstSize.Height / CaptureDivisionNum);
var cData = new CaptureData()
{
captureData = m_Bits,
captureSize = m_DstSize,
isIntraFrame = true,
};
m_IntraFrameMat = new Mat(m_DstSize.Height, m_DstSize.Width, MatType.CV_8UC4);
sw.Start();
while (m_IsCapturing)
{
//Win32.BitBlt(hdc, 0, 0, dstSize.Height, dstSize.Width, m_ProcessDC, 0, 0, Win32.SRCCOPY);
Win32.StretchBlt(m_Hdc, 0, m_DstSize.Height, m_DstSize.Width, -m_DstSize.Height, m_ProcessDC,
m_SrcRect.X, m_SrcRect.Y, m_SrcRect.Width, m_SrcRect.Height, Win32.SRCCOPY);
Captured(this, cData);
try
{
Cv2.BitwiseXor(mat, m_IntraFrameMat, mat_xor);
Cv2.CvtColor(mat_xor, mat_diff, ColorConversionCodes.RGBA2GRAY);
}
catch
{
continue;
}
for (int y = 0; y < CaptureDivisionNum; y++)
{
for (int x = 0; x < CaptureDivisionNum; x++)
{
var segIdx = y * CaptureDivisionNum + x;
segRect.X = segRect.Width * x;
segRect.Y = segRect.Height * y;
var sRect = new Rect(segRect.X, segRect.Y, segRect.Width, segRect.Height);
var segDiff = mat_diff.SubMat(sRect);
var nonZero = segDiff.CountNonZero();
if (nonZero != 0)
{
var segCapture = mat.SubMat(sRect);
var img_buffer = segCapture.ImEncode(EncodeFormatExtension, m_EncodingParam);
var sData = new SegmentCaptureData()
{
segmentIdx = segIdx,
rect = segRect,
encodedFrameBuffer = img_buffer,
};
SegmentCaptured(this, sData);
var segIntra = m_IntraFrameMat.SubMat(sRect);
segCapture.CopyTo(segIntra);
}
}
}
var sleepMs = (ms * capCnt) - sw.Elapsed.TotalMilliseconds;
if (sleepMs > 0) Thread.Sleep((int)sleepMs);
capCnt++;
//Debug.Log(""+capCnt);
//GC.Collect();
//File.WriteAllBytes("dump/"+capCnt+".jpg", mat.ImEncode(EncodeFormatExtension, m_EncodingParam));
}
sw.Stop();
//Win32.SelectObject(hdc, hbmpPrev);
});
}
public CaptureData(string value, int index, int length, CaptureData[] captures)
: this(value, index, length, false)
{
Captures = captures;
}
