public void Disconnect()
{
try
{
SAMLog.Debug($"AndroidBilling.Disconnect");
if (IsConnected)
{
_serviceConnection.Disconnect();
}
}
catch (Exception e)
{
SAMLog.Error("IAB::Disconnect", e);
}
}
public void Cancel()
{
if (_stopped)
{
return;
}
try
{
mmServerSocket.Close();
}
catch (Java.IO.IOException e)
{
SAMLog.Error("ABTA::Thread3_Cancel", e);
}
}
private bool ProcessForwardLaserCannons(ref int p, byte[] d, long bseq, float sendertime)
{
int count = d[p];
p++;
for (int i = 0; i < count; i++)
{
var id = NetworkDataTools.GetByte(d[p + 0]);
var ifrac = NetworkDataTools.GetHighBits(d[p + 1], 3);
var boost = NetworkDataTools.GetLowBits(d[p + 1], 5);
var rotA = NetworkDataTools.GetSingle(d[p + 2], d[p + 3], d[p + 4], d[p + 5]);
var rotT = NetworkDataTools.GetSingle(d[p + 6], d[p + 7], d[p + 8], d[p + 9]);
var hp = NetworkDataTools.GetByte(d[p + 10]) / 255f;
var ct = NetworkDataTools.GetByteFloorRange(d[p + 11], 0, Cannon.LASER_CHARGE_COOLDOWN_MAX);
var shield = NetworkDataTools.GetByteFloorRange(d[p + 12], 0, Cannon.MAX_SHIELD_TIME);
var frac = Screen.GetFractionByID(ifrac, out bool gfbiError);
if (gfbiError)
{
SAMLog.Error("SNS-COMMON::PFLC_GFBI", "GetFractionByID returned error: Unknown Fraction " + ifrac + "\nData:\n" + ByteUtils.CompressBytesForStorage(d));
return(false);
}
Cannon c;
if (Screen.CannonMap.TryGetValue(id, out c))
{
LaserCannon bc = c as LaserCannon;
if (bc != null && ShouldRecieveData(frac, bc))
{
if (ShouldRecieveRotationData(frac, bc))
{
bc.RemoteRotationUpdate(rotA, rotT, sendertime);
}
if (ShouldRecieveStateData(frac, bc))
{
bc.RemoteUpdate(frac, hp, boost, ct, shield, sendertime);
}
}
}
p += PLEN_LASERCANNON;
}
return(true);
}
private async Task CreateNewUserLevelInternal(HUDElement spinner)
{
try
{
var r = await MainGame.Inst.Backend.GetNewCustomLevelID(MainGame.Inst.Profile);
if (!r.Item1)
{
MonoSAMGame.CurrentInst.DispatchBeginInvoke(() =>
{
spinner.Remove();
HUD.AddModal(new HUDFadeOutInfoBox(5, 2, 0.3f)
{
L10NText = L10NImpl.STR_CPP_COMERR,
TextColor = FlatColors.Clouds,
Background = HUDBackgroundDefinition.CreateRounded(FlatColors.Alizarin, 16),
CloseOnClick = true,
}, true);
});
return;
}
MonoSAMGame.CurrentInst.DispatchBeginInvoke(() =>
{
spinner.Remove();
MainGame.Inst.SetLevelEditorScreen(new SCCMLevelData(r.Item2, MainGame.Inst.Profile.OnlineUserID));
});
}
catch (Exception e)
{
SAMLog.Error("SCCMLENUL::DL", e);
MonoSAMGame.CurrentInst.DispatchBeginInvoke(() =>
{
spinner.Remove();
HUD.AddModal(new HUDFadeOutInfoBox(5, 2, 0.3f)
{
L10NText = L10NImpl.STR_CPP_COMERR,
TextColor = FlatColors.Clouds,
Background = HUDBackgroundDefinition.CreateRounded(FlatColors.Alizarin, 16),
CloseOnClick = true,
}, true);
});
}
}
private bool ProcessForwardMiniguns(ref int p, byte[] d, long bseq, float sendertime)
{
int count = d[p];
p++;
for (int i = 0; i < count; i++)
{
var id = NetworkDataTools.GetByte(d[p + 0]);
var ifrac = NetworkDataTools.GetHighBits(d[p + 1], 3);
var boost = NetworkDataTools.GetLowBits(d[p + 1], 5);
var rotA = NetworkDataTools.ConvertToRadians(NetworkDataTools.GetByte(d[p + 2]), 8);
var rotT = NetworkDataTools.ConvertToRadians(NetworkDataTools.GetByte(d[p + 3]), 8);
var hp = NetworkDataTools.GetByte(d[p + 4]) / 255f;
var chrg = NetworkDataTools.GetByte(d[p + 5]) / 255f;
var shield = NetworkDataTools.GetByteFloorRange(d[p + 6], 0, Cannon.MAX_SHIELD_TIME);
var frac = Screen.GetFractionByID(ifrac, out bool gfbiError);
if (gfbiError)
{
SAMLog.Error("SNS-COMMON::PFMG_GFBI", "GetFractionByID returned error: Unknown Fraction " + ifrac + "\nData:\n" + ByteUtils.CompressBytesForStorage(d));
return(false);
}
Cannon c;
if (Screen.CannonMap.TryGetValue(id, out c))
{
MinigunCannon bc = c as MinigunCannon;
if (bc != null && ShouldRecieveData(frac, bc))
{
if (ShouldRecieveRotationData(frac, bc))
{
bc.RemoteRotationUpdate(rotA, rotT, sendertime);
}
if (ShouldRecieveStateData(frac, bc))
{
bc.RemoteUpdate(frac, hp, boost, chrg, shield, sendertime);
}
}
}
p += PLEN_MINIGUN;
}
return(true);
}
private bool SaveToDisk()
{
var sdata = SerializeToString();
try
{
FileHelper.Inst.WriteData(Filename, sdata);
}
catch (IOException e)
{
if (e.Message.Contains("Disk full"))
{
MainGame.Inst.DispatchBeginInvoke(() =>
{
MainGame.Inst.ShowToast("SCCMLD::OOM", L10N.T(L10NImpl.STR_ERR_OUTOFMEMORY), 32, FlatColors.Flamingo, FlatColors.Foreground, 3f);
});
return(false);
}
else
{
SAMLog.Error("SCCMLD::WRITE", e);
return(false);
}
}
#if DEBUG
SAMLog.Debug($"SCCM saved ({sdata.Length})");
try
{
var p = new SCCMLevelData();
p.DeserializeFromString(sdata);
var sdata2 = p.SerializeToString();
if (sdata2 != sdata)
{
SAMLog.Error("SCCMLD:Serialization_mismatch", "Serialization test mismatch", $"Data_1:\n{sdata}\n\n----------------\n\nData_2:\n{sdata2}");
}
}
catch (Exception e)
{
SAMLog.Error("SCCMLD:Serialization-Ex", "Serialization test mismatch", e.ToString());
}
#endif
return(true);
}
protected override void Initialize()
{
try
{
base.Initialize();
OnInitialize();
screens = new ScreenManager(this);
OnAfterInitialize();
}
catch (Exception e)
{
SAMLog.FatalError("Game::Initialize", e);
}
}
public ushort AssignBulletID(Bullet bullet)
{
lastBulletID = (ushort)((lastBulletID + 1) % MAX_BULLET_ID);
if (!IsNetwork)
{
return(lastBulletID);
}
for (ushort i = 0; i < MAX_BULLET_ID; i++)
{
var ti = (ushort)((lastBulletID + i) % MAX_BULLET_ID);
if (BulletMapping[ti].Bullet == null || (BulletMapping[ti].State != RemoteBullet.RemoteBulletState.Normal && BulletMapping[ti].RemainingPostDeathTransmitions <= 0))
{
BulletMapping[ti].Bullet = bullet;
BulletMapping[ti].State = RemoteBullet.RemoteBulletState.Normal;
BulletMapping[ti].RemainingPostDeathTransmitions = RemoteBullet.POST_DEATH_TRANSMITIONCOUNT;
lastBulletID = ti;
return(ti);
}
}
SAMLog.Info("GDGS::TMB1", "Too many bullets+artifacts, no free fully-dead BulletID");
for (ushort i = 0; i < MAX_BULLET_ID; i++)
{
var ti = (ushort)((lastBulletID + i) % MAX_BULLET_ID);
if (BulletMapping[ti].Bullet == null || BulletMapping[ti].State != RemoteBullet.RemoteBulletState.Normal)
{
BulletMapping[ti].Bullet = bullet;
BulletMapping[ti].State = RemoteBullet.RemoteBulletState.Normal;
BulletMapping[ti].RemainingPostDeathTransmitions = RemoteBullet.POST_DEATH_TRANSMITIONCOUNT;
lastBulletID = ti;
return(ti);
}
}
SAMLog.Error("GDGS::TMB2", "Too many bullets, no free BulletID");
BulletMapping[lastBulletID].Bullet = bullet;
BulletMapping[lastBulletID].State = RemoteBullet.RemoteBulletState.Normal;
BulletMapping[lastBulletID].RemainingPostDeathTransmitions = RemoteBullet.POST_DEATH_TRANSMITIONCOUNT;
return(lastBulletID);
}
public GDGameScreen_MPClient(MainGame game, GraphicsDeviceManager gdm, LevelBlueprint bp, GameSpeedModes speed, int music, GDMultiplayerClient server)
: base(game, gdm, bp, FractionDifficulty.DIFF_3, false, true, false)
{
musicIdx = music;
GameSpeedMode = speed;
_server = server;
CanPause = false;
_server.Screen = this;
if (server.SessionUserID == 1)
{
_localPlayerFraction = GetFractionByID(2);
}
else if (server.SessionUserID == 2)
{
_localPlayerFraction = GetFractionByID(3);
}
else if (server.SessionUserID == 3)
{
_localPlayerFraction = GetFractionByID(4);
}
else if (server.SessionUserID == 4)
{
_localPlayerFraction = GetFractionByID(5);
}
else if (server.SessionUserID == 5)
{
_localPlayerFraction = GetFractionByID(6);
}
else
{
SAMLog.Error("GDGSMPC", "Client with SSID: " + server.SessionUserID);
}
foreach (var c in GetEntities <Cannon>())
{
c.ForceUpdateController();
}
GameHUD = new GDMultiplayerGameHUD(this, server);
#if DEBUG
_server.AddDebugLine(this);
#endif
}
public PurchaseQueryResult IsPurchased(string id)
{
if (!IsConnected)
{
return(PurchaseQueryResult.NotConnected);
}
id = PREFIX + id;
lock (_purchases)
{
if (_purchases.TryGetValue(id.ToLower(), out var purchase))
{
switch (purchase.State)
{
case PurchaseState.Purchased:
case PurchaseState.FreeTrial:
case PurchaseState.Restored:
return(PurchaseQueryResult.Purchased);
case PurchaseState.Canceled:
return(PurchaseQueryResult.Cancelled);
case PurchaseState.Refunded:
return(PurchaseQueryResult.Refunded);
case PurchaseState.PaymentPending:
case PurchaseState.Purchasing:
case PurchaseState.Deferred:
return(PurchaseQueryResult.Pending);
case PurchaseState.Failed:
case PurchaseState.Unknown:
return(PurchaseQueryResult.Error);
default:
SAMLog.Error("IAB_IOS::IP_EnumSwitch", "purchase.State := " + purchase.State);
return(PurchaseQueryResult.Error);
}
}
else
{
return(PurchaseQueryResult.NotPurchased);
}
}
}
public void HandleActivityResult(int requestCode, Result resultCode, Intent data)
{
if (requestCode == REQUEST_ENABLE_BT)
{
if (resultCode == Result.Ok)
{
SAMLog.Debug("Bluetooth enabled");
State = BluetoothAdapterState.Active;
}
else
{
SAMLog.Warning("ABTA::BNE", "Bluetooth [[not]] enabled");
State = BluetoothAdapterState.NotEnabledByUser;
}
}
}
public PurchaseQueryResult IsPurchased(string id)
{
try
{
if (_isInitializing)
{
return(PurchaseQueryResult.CurrentlyInitializing);
}
if (!IsConnected || _purchases == null)
{
return(PurchaseQueryResult.NotConnected);
}
int result = -1;
foreach (var purch in _purchases.Where(p => p.ProductId == id).OrderBy(p => p.PurchaseTime))
{
result = purch.PurchaseState;
if (purch.PurchaseState == AndroidBillingHelper.STATE_PURCHASED)
{
return(PurchaseQueryResult.Purchased);
}
}
if (result == -1)
{
return(PurchaseQueryResult.NotPurchased);
}
if (result == AndroidBillingHelper.STATE_CANCELLED)
{
return(PurchaseQueryResult.Cancelled);
}
if (result == AndroidBillingHelper.STATE_REFUNDED)
{
return(PurchaseQueryResult.Refunded);
}
SAMLog.Error("IAB::IsPurchased-Inv", "result has invalid value: " + result);
return(PurchaseQueryResult.Error);
}
catch (Exception e)
{
SAMLog.Error("IAB::IsPurchased-Ex", e);
return(PurchaseQueryResult.Error);
}
}
public static string MakeTextSafeWithWarn(SpriteFont font, string s, char c)
{
char[] cc = new char[s.Length];
for (int i = 0; i < s.Length; i++)
{
if (!font.Characters.Contains(s[i]) && s[i] != 0x0A && s[i] != 0x0D)
{
SAMLog.Warning("FRH::MC", $"Cant render char with font: 0x{((int)s[i]):X2}");
cc[i] = c;
}
else
{
cc[i] = s[i];
}
}
return(new string(cc));
}
protected override void OnDraw(IBatchRenderer sbatch)
{
if (GDOwner.Selection == this)
{
if (ObstacleType == ObstacleStubType.MirrorBlock || ObstacleType == ObstacleStubType.GlassBlock)
{
var a = FRotatedRectangle.CreateByCenter(Position, Width, Height, Rotation).GetBoundingRectangle();
sbatch.DrawCentered(Textures.TexPixel, Position, a.Width + GDConstants.TILE_WIDTH, a.Height + GDConstants.TILE_WIDTH, Color.Black * 0.333f);
}
else
{
sbatch.DrawCentered(Textures.TexPixel, Position, Width + GDConstants.TILE_WIDTH, Height + GDConstants.TILE_WIDTH, Color.Black * 0.333f);
}
}
switch (ObstacleType)
{
case ObstacleStubType.BlackHole:
CommonObstacleRenderer.DrawBlackHole(sbatch, Position, Lifetime, Width, -Power);
break;
case ObstacleStubType.WhiteHole:
CommonObstacleRenderer.DrawBlackHole(sbatch, Position, Lifetime, Width, Power);
break;
case ObstacleStubType.GlassBlock:
CommonObstacleRenderer.DrawGlassBlock(sbatch, FRotatedRectangle.CreateByCenter(Position, Width, Height, Rotation));
break;
case ObstacleStubType.MirrorBlock:
CommonObstacleRenderer.DrawMirrorBlock(sbatch, FRotatedRectangle.CreateByCenter(Position, Width, Height, Rotation));
break;
case ObstacleStubType.MirrorCircle:
CommonObstacleRenderer.DrawMirrorCircle(sbatch, Position, Width);
break;
case ObstacleStubType.VoidVircle:
CommonObstacleRenderer.DrawVoidCircle_BG(sbatch, Position, Width);
break;
default:
SAMLog.Error("LEOS::EnumSwitch_CS_OD", "ObstacleType = " + ObstacleType);
break;
}
}
private async Task DoLoad(int page, int reqid, bool async)
{
_mode = PresenterMode.Loading;
var r = await _loadFunc(this, page, reqid);
void FinishAction()
{
if (IsCurrentRequest(reqid))
{
switch (r)
{
case LoadFuncResult.Success:
_mode = PresenterMode.Normal;
_currentPage = page;
break;
case LoadFuncResult.LastPage:
_mode = PresenterMode.FullyLoaded;
_currentPage = page;
break;
case LoadFuncResult.Error:
_mode = PresenterMode.Normal;
break;
default:
SAMLog.Error("SCCMLP::EnumSwitch_DoLoad", "r = " + r);
break;
}
this.IsVisible = true;
_scrollbar.IsVisible = true;
_waitingCog.IsVisible = false;
}
}
if (async)
{
MainGame.Inst.DispatchBeginInvoke(FinishAction);
}
else
{
FinishAction();
}
}
private void SpawnOrb(LevelNode me, int cycle)
{
if (!NextLinkedNodes.Any())
{
return;
}
if (!MainGame.Inst.Profile.EffectsEnabled)
{
return;
}
FractionDifficulty d = FractionDifficulty.NEUTRAL;
switch (cycle % 4)
{
case 0: d = FractionDifficulty.DIFF_0; break;
case 1: d = FractionDifficulty.DIFF_1; break;
case 2: d = FractionDifficulty.DIFF_2; break;
case 3: d = FractionDifficulty.DIFF_3; break;
default:
SAMLog.Error("LN::EnumSwitch_SO", "value: " + (cycle % 4));
break;
}
if (!LevelData.HasCompletedOrBetter(d))
{
d = FractionDifficulty.NEUTRAL;
}
foreach (var t in OutgoingPipes)
{
if (!((GameEntity)t.NodeSource).IsInViewport && !((GameEntity)t.NodeSink).IsInViewport)
{
return;
}
var orb = new ConnectionOrb(Owner, t, d);
Manager.AddEntity(orb);
}
}
public FRotatedRectangle GetArea()
{
switch (WallType)
{
case WallStubType.Void:
return(FRotatedRectangle.CreateByCenter(FPoint.MiddlePoint(Point1, Point2), (Point2 - Point1).Length(), VoidWallBlueprint.DEFAULT_WIDTH, (Point2 - Point1).ToAngle()));
case WallStubType.Glass:
return(FRotatedRectangle.CreateByCenter(FPoint.MiddlePoint(Point1, Point2), (Point2 - Point1).Length(), GlassBlockBlueprint.DEFAULT_WIDTH, (Point2 - Point1).ToAngle()));
case WallStubType.Mirror:
return(FRotatedRectangle.CreateByCenter(FPoint.MiddlePoint(Point1, Point2), (Point2 - Point1).Length(), MirrorBlockBlueprint.DEFAULT_WIDTH, (Point2 - Point1).ToAngle()));
default:
SAMLog.Error("LEWS::EnumSwitch_GA", "WallType = " + WallType);
return(default(FRotatedRectangle));
}
}
public void SetMode(LevelEditorMode m)
{
Mode = m;
switch (m)
{
case LevelEditorMode.Mouse: GDHUD.ModePanel.SetActiveButton(GDHUD.ModePanel.BtnMouse); break;
case LevelEditorMode.AddCannon: GDHUD.ModePanel.SetActiveButton(GDHUD.ModePanel.BtnCannon); break;
case LevelEditorMode.AddWall: GDHUD.ModePanel.SetActiveButton(GDHUD.ModePanel.BtnWall); break;
case LevelEditorMode.AddObstacle: GDHUD.ModePanel.SetActiveButton(GDHUD.ModePanel.BtnObstacle); break;
case LevelEditorMode.AddPortal: GDHUD.ModePanel.SetActiveButton(GDHUD.ModePanel.BtnPortal); break;
default: SAMLog.Error("LES::EnumSwitch_TICS", "Mode = " + m); break;
}
}
public void SaveProfile()
{
var sdata = Profile.SerializeToString();
try
{
FileHelper.Inst.WriteData(GDConstants.PROFILE_FILENAME, sdata);
}
catch (IOException e)
{
if (e.Message.Contains("Disk full"))
{
DispatchBeginInvoke(() =>
{
ShowToast("MG::OOM", L10N.T(L10NImpl.STR_ERR_OUTOFMEMORY), 32, FlatColors.Flamingo, FlatColors.Foreground, 3f);
});
}
else
{
SAMLog.Error("MG::WRITE", e);
}
}
#if DEBUG
SAMLog.Debug($"Profile saved ({sdata.Length})");
try
{
var p = new PlayerProfile();
p.NoAfterSerializeFixes = true;
p.DeserializeFromString(sdata);
var sdata2 = p.SerializeToString();
if (sdata2 != sdata)
{
SAMLog.Error("Serialization_mismatch", "Serialization test mismatch", $"Data_1:\n{sdata}\n\n----------------\n\nData_2:\n{sdata2}");
}
}
catch (Exception e)
{
SAMLog.Error("Serialization-Ex", "Serialization test mismatch", e.ToString());
}
#endif
}
public override void Update(SAMTime gameTime, InputState istate)
{
base.Update(gameTime, istate);
if (Mode == ServerMode.CreatingNewGame)
{
Screen = null;
}
if (Mode == ServerMode.BeforeNewGame)
{
Screen = null;
}
if (ConnType == MultiplayerConnectionType.P2P)
{
var btm = (BluetoothNetworkMedium)_medium;
if (btm.Events.Count > 0)
{
var evt = btm.Events.Dequeue();
var param = FontRenderHelper.MakeTextSafe(Textures.HUDFontRegular, evt.Param, '?');
switch (evt.Type)
{
case BluetoothMediumEvent.BTEvent.TryConnection:
MainGame.Inst.ShowToast(null, L10N.TF(L10NImpl.STR_MP_TOAST_CONN_TRY, param), 40, FlatColors.Silver, FlatColors.Foreground, 2f);
break;
case BluetoothMediumEvent.BTEvent.ConnectionFailed:
MainGame.Inst.ShowToast(null, L10N.TF(L10NImpl.STR_MP_TOAST_CONN_FAIL, param), 40, FlatColors.Orange, FlatColors.Foreground, 2f);
break;
case BluetoothMediumEvent.BTEvent.ConnectionSucceeded:
MainGame.Inst.ShowToast(null, L10N.TF(L10NImpl.STR_MP_TOAST_CONN_SUCC, param), 40, FlatColors.Emerald, FlatColors.Foreground, 2f);
break;
default:
SAMLog.Error("GDMPC::Update_Evt", "type = " + evt.Type);
break;
}
}
}
}
public bool HasCompletedExact(FractionDifficulty d)
{
switch (d)
{
case FractionDifficulty.DIFF_0: return(Diff0_HasCompleted);
case FractionDifficulty.DIFF_1: return(Diff1_HasCompleted);
case FractionDifficulty.DIFF_2: return(Diff2_HasCompleted);
case FractionDifficulty.DIFF_3: return(Diff3_HasCompleted);
case FractionDifficulty.NEUTRAL:
case FractionDifficulty.PLAYER:
default:
SAMLog.Error("CLD::HasCompletedExact", "Invalid value: " + d);
return(false);
}
}
public static string EnumToString(QueryUserLevelCategory c)
{
switch (c)
{
case QueryUserLevelCategory.AllLevelsOfUserid: return("@user");
case QueryUserLevelCategory.TopLevelsAllTime: return("@top");
case QueryUserLevelCategory.HotLevels: return("@hot");
case QueryUserLevelCategory.NewLevels: return("@new");
case QueryUserLevelCategory.Search: return("@search");
default:
SAMLog.Error("QULCH::EnumSwitch_ETS", "c = " + c);
return("?");
}
}
public IFShape GetArea()
{
switch (ObstacleType)
{
case ObstacleStubType.BlackHole:
case ObstacleStubType.WhiteHole:
case ObstacleStubType.MirrorCircle:
case ObstacleStubType.VoidVircle:
return(new FCircle(Position, Width / 2f));
case ObstacleStubType.GlassBlock:
case ObstacleStubType.MirrorBlock:
return(new FRotatedRectangle(Position, Width, Height, Rotation));
default:
SAMLog.Error("LEOS::EnumSwitch_GA", "ObstacleType = " + ObstacleType);
return(null);
}
}
protected override void OnClick(GameEntityMouseArea area, SAMTime gameTime, InputState istate)
{
var ownr = ((GDOverworldScreen)Owner);
if (ownr.IsTransitioning)
{
return;
}
if (MainGame.Inst.Profile.AccountType == AccountType.Local)
{
MainGame.Inst.ShowToast(null, L10N.T(L10NImpl.STR_MP_CONNECTING), 40, FlatColors.Emerald, FlatColors.Foreground, 2f);
MainGame.Inst.Backend.CreateUser(MainGame.Inst.Profile).RunAsync();
return;
}
//MainGame.Inst.GDBridge.IAB.SynchronizePurchases(GDConstants.IABList);
var ustate = UnlockManager.IsUnlocked(Levels.WORLD_ID_ONLINE, true);
switch (ustate)
{
case WorldUnlockState.OpenAndUnlocked:
Owner.HUD.AddModal(new SCCMMainPanel(), true, 0.5f, 1f);
break;
case WorldUnlockState.ReachableButMustBePreviewed:
case WorldUnlockState.UnreachableButCanBePreviewed:
Owner.HUD.AddModal(new SCCMPreviewPanel(), true, 0.5f, 1f);
break;
case WorldUnlockState.UnreachableAndFullyLocked:
Owner.HUD.ShowToast("ONSCCM::LOCKED(MULTI)", L10N.T(L10NImpl.STR_GLOB_WORLDLOCK), 40, FlatColors.Pomegranate, FlatColors.Foreground, 1.5f);
MainGame.Inst.GDSound.PlayEffectError();
AddOperation(new ShakeNodeOperation());
break;
default:
SAMLog.Error("ONSCCM::EnumSwitch_OC", "ustate: " + ustate);
throw new ArgumentOutOfRangeException();
}
}
public void Connect(BluetoothDevice device)
{
CancelAllThreads();
try
{
_connectThread = new BTConnectThread(device, this);
_connectThread.Start();
}
catch (Exception e)
{
SAMLog.Error("ABTA::CantCreateConnectThread", e);
State = BluetoothAdapterState.Error;
CancelAllThreads();
return;
}
State = BluetoothAdapterState.Connecting;
}
private async Task Resync(string[] productIDs)
{
if (LastConnectError != null)
{
SAMLog.Debug("TryConnect: [[LastConnectError]]: " + LastConnectError);
}
try
{
SAMLog.Debug("AppleIABVersionBilling.TryConnect");
var sucess = await _iab.ConnectAsync();
if (!sucess)
{
LastConnectError = null; IsConnected = false; return;
}
await QueryStatesAsync(productIDs);
LastConnectError = null;
IsConnected = true;
IsSynchronized = true;
return;
}
catch (InAppBillingPurchaseException e)
{
SAMLog.Info("IAB_IOS::TryConnect_Start_1", e.PurchaseError.ToString(), e.ToString());
LastConnectError = e.PurchaseError;
IsConnected = false;
return;
}
catch (Exception e)
{
SAMLog.Info("IAB_IOS::TryConnect_Start_2", e);
LastConnectError = null;
IsConnected = false;
return;
}
}
public void StartScan()
{
State = BluetoothAdapterState.Scanning;
SAMLog.Debug($"StartDiscovery (1)");
if (Adapter.IsDiscovering)
{
Adapter.CancelDiscovery();
}
bool s = Adapter.StartDiscovery();
SAMLog.Debug($"StartDiscovery (2 => {s})");
lock (_foundDevices)
{
_foundDevices.Clear();
}
}
private async Task StartDownloadLevel()
{
try
{
var binary = await MainGame.Inst.Backend.DownloadUserLevel(MainGame.Inst.Profile, _meta.OnlineID);
if (binary == null)
{
MonoSAMGame.CurrentInst.DispatchBeginInvoke(() =>
{
HUD.ShowToast("SCCMLPD::DF(MULTI)", L10N.T(L10NImpl.STR_SCCM_DOWNLOADFAILED), 40, FlatColors.Flamingo, FlatColors.Foreground, 3f);
MonoSAMGame.CurrentInst.DispatchBeginInvoke(OnDownloadFailed);
});
return;
}
using (var ms = new MemoryStream(binary))
{
using (var br = new BinaryReader(ms))
{
var bp = new LevelBlueprint();
bp.BinaryDeserialize(br);
_blueprint = bp;
MonoSAMGame.CurrentInst.DispatchBeginInvoke(OnDownloadSuccess);
}
}
}
catch (Exception e)
{
MonoSAMGame.CurrentInst.DispatchBeginInvoke(() =>
{
HUD.ShowToast("SCCMLPD::DF(MULTI)", L10N.T(L10NImpl.STR_SCCM_DOWNLOADFAILED), 40, FlatColors.Flamingo, FlatColors.Foreground, 3f);
});
MonoSAMGame.CurrentInst.DispatchBeginInvoke(OnDownloadFailed);
SAMLog.Error("SCCMLPD:DownloadException", e);
}
}
private void InitEntities(GraphBlueprint g)
{
foreach (var bpNode in g.LevelNodes)
{
LevelBlueprint f;
if (Levels.LEVELS.TryGetValue(bpNode.LevelID, out f))
{
var data = MainGame.Inst.Profile.GetLevelData(f.UniqueID);
var pos = new FPoint(bpNode.X, bpNode.Y);
var node = new LevelNode(screen, pos, f, data);
screen.Entities.AddEntity(node);
Nodes.Add(node);
}
else
{
SAMLog.Error("LevelGraph::IE", $"Cannot find id {bpNode.LevelID:B} for graph");
}
}
foreach (var bpNode in g.WarpNodes)
{
if (bpNode.TargetWorld == Levels.WORLD_ID_GAMEEND)
{
var node = new WarpGameEndNode(screen, bpNode);
screen.Entities.AddEntity(node);
Nodes.Add(node);
}
else
{
var node = new WarpNode(screen, bpNode);
screen.Entities.AddEntity(node);
Nodes.Add(node);
}
}
InitialNode = new RootNode(screen, g.RootNode);
screen.Entities.AddEntity(InitialNode);
Nodes.Add(InitialNode);
}
public void StartWaiting()
{
CancelAllThreads();
EnsureDiscoverable(120);
try
{
_acceptThread = new BTAcceptThread(this);
_acceptThread.Start();
}
catch (Exception e)
{
SAMLog.Error("ABTA::CantCreateAcceptThread", e);
State = BluetoothAdapterState.Error;
CancelAllThreads();
return;
}
State = BluetoothAdapterState.Listen;
}
