/// <summary>
/// 驗證發送加入好友請求資格
/// </summary>
/// <param name="initiatorData">initiatorData</param>
/// <param name="receiverData">receiverData</param>
/// <returns>bool</returns>
private bool VerifyFriendRequestQualification(InteractiveData initiatorData, InteractiveData receiverData)
{
if (initiatorData.BlacklistIDs.Contains(receiverData.MemberID))
{
this.logger.LogError($"Verify Friend Request Qualification Error For Initiator BlacklistIDs >>> InitiatorID:{initiatorData.MemberID} ReceiverID:{receiverData.MemberID}");
return(false);
}
if (initiatorData.FriendListIDs.Contains(receiverData.MemberID))
{
this.logger.LogError($"Verify Friend Request Qualification Error For Initiator FriendListIDs >>> InitiatorID:{initiatorData.MemberID} ReceiverID:{receiverData.MemberID}");
return(false);
}
if (initiatorData.RequestListIDs.Contains(receiverData.MemberID))
{
this.logger.LogError($"Verify Friend Request Qualification Error For Initiator RequestListIDs >>> InitiatorID:{initiatorData.MemberID} ReceiverID:{receiverData.MemberID}");
return(false);
}
if (receiverData.BlacklistIDs.Contains(initiatorData.MemberID))
{
this.logger.LogError($"Verify Friend Request Qualification Error For Receiver BlacklistIDs >>> InitiatorID:{initiatorData.MemberID} ReceiverID:{receiverData.MemberID}");
return(false);
}
if (receiverData.FriendListIDs.Contains(initiatorData.MemberID))
{
this.logger.LogError($"Verify Friend Request Qualification Error For Receiver FriendListIDs >>> InitiatorID:{initiatorData.MemberID} ReceiverID:{receiverData.MemberID}");
return(false);
}
return(true);
}
/// <summary>
/// 建立互動資料
/// </summary>
/// <param name="interactiveDto">interactiveDto</param>
/// <returns>InteractiveData</returns>
private InteractiveData CreateInteractiveData(InteractiveDto interactiveDto, int status)
{
InteractiveData interactiveData = this.mapper.Map <InteractiveData>(interactiveDto);
interactiveData.Status = status;
return(interactiveData);
}
private IEnumerable <IPoolable> InstansiateArrow(float deltaY, InteractiveData interactiveData)
{
var arrow = Instantiate(arrowPrefab);
arrow.transform.localScale *= 0.7f;
arrow.name = "Arrow";
var arrowComponent = arrow.GetComponent <Arrow>();
arrowComponent.SetData(interactiveData);
arrowComponent.IsRotating = true;
var arrowRigitBody = arrow.GetComponent <Rigidbody2D>();
var poolable = new Poolable(arrow);
poolable.OnFloated.Subscribe
(
() =>
{
arrow.transform.position = transform.position;
arrow.transform.rotation = transform.rotation;
arrowRigitBody.velocity = Vector2.zero;
arrowRigitBody.gravityScale = 0;
arrowRigitBody.AddForce(accelerate.Change(y: deltaY));
}
);
yield return(poolable);
}
private IEnumerable <IPoolable> InstansiateGrenade(InteractiveData interactiveData)
{
var grenade = Instantiate(grenadePrefab, transform.position, transform.rotation);
grenade.name = "Grenade";
grenade.GetComponent <ISetData <InteractiveData> >().SetData(interactiveData);
var grenadeRigidbody = grenade.GetComponent <Rigidbody2D>();
var poolable = new Poolable(grenade);
poolable.OnFloated.Subscribe
(
() =>
{
grenade.transform.position = transform.position;
grenade.transform.rotation = transform.rotation;
grenadeRigidbody.velocity = Vector2.zero;
grenadeRigidbody.AddForce(accelerate);
}
);
yield return(poolable);
}
public static InteractiveData SetAccelerateMultiplyingTo(this InteractiveData interactiveData, out float accelerateMultiply, out float accelerateMultiplyingTime)
{
accelerateMultiply = interactiveData.AccelerateMultiply;
accelerateMultiplyingTime = interactiveData.AccelerateMultiplyingTime;
return(interactiveData);
}
/// <summary>
/// 更新互動資料
/// </summary>
/// <param name="interactiveData">interactiveData</param>
/// <returns>bool</returns>
public async Task <bool> UpdateInteractiveData(InteractiveData interactiveData)
{
try
{
FilterDefinition <InteractiveData> filter = Builders <InteractiveData> .Filter.Eq("_id", interactiveData.Id);
ReplaceOneResult result = await this.interactiveDatas.ReplaceOneAsync(filter, interactiveData);
if (!result.IsAcknowledged)
{
this.logger.LogError($"Update Interactive Data Fail For IsAcknowledged >>> Data:{JsonConvert.SerializeObject(interactiveData)}");
return(false);
}
if (result.ModifiedCount == 0)
{
this.logger.LogError($"Update Interactive Data Fail For ModifiedCount >>> Data:{JsonConvert.SerializeObject(interactiveData)}");
return(false);
}
return(true);
}
catch (Exception ex)
{
this.logger.LogError($"Update Interactive Data Error >>> Data:{JsonConvert.SerializeObject(interactiveData)}\n{ex}");
return(false);
}
}
private IEnumerable <IPoolable> InstantiateBullets(InteractiveData interactiveData)
{
for (int i = 0; i < bulletCount; i++)
{
var bullet = Instantiate(bulletPrefab);
bullet.name = "BlasterBullet";
var bulletRigidbody = bullet.GetComponent <Rigidbody2D>();
bullet.GetComponent <ISetData <InteractiveData> >().SetData(interactiveData);
var poolable = new Poolable(bullet);
poolable.OnFloated.Subscribe
(
() =>
{
bullet.transform.position = transform.position;
bullet.transform.rotation = transform.rotation;
bulletRigidbody.velocity = Vector2.zero;
bulletRigidbody.AddForce(new Vector2(accelerate, 0));
}
);
yield return(poolable);
}
}
public void SetData(InteractiveData interactiveData)
{
interactiveData.SetTo(damageEntity);
damagedTime = interactiveData.DamageTime;
damagingCount = interactiveData.DamageCount;
}
private IEnumerable <IPoolable> InstansiateRocket(InteractiveData interactiveData)
{
var rocket = Instantiate(rocketPrefab, transform.position, transform.rotation);
rocket.name = "Rocket";
rocket.GetComponent <ISetData <InteractiveData> >().SetData(interactiveData);
var rocketRigidbody = rocket.GetComponent <Rigidbody2D>();
var poolable = new Poolable(rocket);
poolable.OnFloated.Subscribe
(
() =>
{
shootingExplosion.Play();
rocket.transform.position = shootingExplosion.transform.position;
rocket.transform.rotation = transform.rotation;
rocketRigidbody.velocity = Vector2.zero;
rocketRigidbody.AddForce(accelerate);
}
);
yield return(poolable);
}
private IEnumerable <IPoolable> InstantiateBullet(InteractiveData interactiveData, UnityAction onInteractHandler)
{
var bullet = Instantiate(bulletPrefab);
bullet.name = "bullet";
bullet.GetComponent <ISetData <InteractiveData> >().SetData(interactiveData);
bullet.GetComponent <ISubscribedInteract>().OnInteracted.Subscribe(onInteractHandler);
var poolable = new Poolable(bullet);
poolable.OnFloated.Subscribe
(
() =>
{
spriteRenderer.sprite = withoutBullet;
bullet.transform.position = transform.position;
bullet.transform.rotation = transform.rotation;
var rigitbody = bullet.GetComponent <Rigidbody2D>();
rigitbody.velocity = Vector2.zero;
rigitbody.AddForce(accelerate);
StartCoroutine(CoroutineT.Single
(
() => spriteRenderer.sprite = withBullet, shootingReload / 2)
);
}
);
yield return(poolable);
}
private static void DoAddRelationship(Actor ao, string animName)
{
if (settings.LimitRelationshipPointGain)
{
var mBehavior = FieldRefAccess <Actor, BehaviorTree>(ao, "mBehavior");
var mITActions = mBehavior.FindTasks <ITDecorator>();
if (mITActions != null && mITActions.Count > 0)
{
for (int i = 0; i < mITActions.Count; i++)
{
Dbgl($"{animName} interact id: {mITActions[i].iid.Value}");
if (mITActions[i] != null && mITActions[i].iid.Value == InteractIds[animName])
{
FieldRef <ITDecorator, int> mCurTimesRef = FieldRefAccess <ITDecorator, int>("mCurTimes");
if (mCurTimesRef(mITActions[i]) < InteractiveData.GetTimes(mITActions[i].iid.Value))
{
mCurTimesRef(mITActions[i])++;
Module <FavorManager> .Self.GainFavorValue(ao.InstanceId,
InteractiveData.GetFavorValue(InteractIds[animName]), true, true);
}
return;
}
}
}
}
Module <FavorManager> .Self.GainFavorValue(ao.InstanceId, InteractiveData.GetFavorValue(InteractIds[animName]), true, true);
}
/// <summary>
/// 取得會員互動狀態
/// </summary>
/// <param name="interactiveCommand">interactiveCommand</param>
/// <returns>Tuple(int, string)</returns>
public async Task <Tuple <int, string> > GetMemberInteractiveStatus(InteractiveCommandDto interactiveCommand)
{
try
{
bool verifyInteractiveCommandResult = this.VerifyInteractiveCommand(interactiveCommand, true, true);
if (!verifyInteractiveCommandResult)
{
this.logger.LogError($"Get Member Interactive Status Fail For Verify InteractiveCommand >>> InitiatorID:{interactiveCommand.InitiatorID} ReceiverID:{interactiveCommand.ReceiverID}");
return(Tuple.Create((int)InteractiveStatusType.None, "取得會員互動狀態失敗."));
}
InteractiveData receiverInteractiveData = await this.GetInteractiveData(interactiveCommand.ReceiverID, false);
if (receiverInteractiveData != null)
{
if (receiverInteractiveData.BlacklistIDs.Contains(interactiveCommand.InitiatorID))
{
return(Tuple.Create((int)InteractiveStatusType.None, "對方已設該會員為黑名單."));
}
if (receiverInteractiveData.FriendListIDs.Contains(interactiveCommand.InitiatorID))
{
return(Tuple.Create((int)InteractiveStatusType.Friend, string.Empty));
}
if (receiverInteractiveData.RequestListIDs.Contains(interactiveCommand.InitiatorID))
{
return(Tuple.Create((int)InteractiveStatusType.Request, string.Empty));
}
}
InteractiveData initiatorInteractiveData = await this.GetInteractiveData(interactiveCommand.InitiatorID, true);
if (initiatorInteractiveData != null)
{
if (initiatorInteractiveData.BlacklistIDs.Contains(interactiveCommand.ReceiverID))
{
return(Tuple.Create((int)InteractiveStatusType.Black, string.Empty));
}
if (initiatorInteractiveData.FriendListIDs.Contains(interactiveCommand.ReceiverID))
{
return(Tuple.Create((int)InteractiveStatusType.Friend, string.Empty));
}
if (initiatorInteractiveData.RequestListIDs.Contains(interactiveCommand.ReceiverID))
{
return(Tuple.Create((int)InteractiveStatusType.RequestHandler, string.Empty));
}
}
return(Tuple.Create((int)InteractiveStatusType.None, string.Empty));
}
catch (Exception ex)
{
this.logger.LogError($"Get Member Interactive Status Error >>> InitiatorID:{interactiveCommand.InitiatorID} ReceiverID:{interactiveCommand.ReceiverID}\n{ex}");
return(Tuple.Create((int)InteractiveStatusType.None, "取得會員互動狀態發生錯誤."));
}
}
/// <summary>
/// 加入黑名單
/// </summary>
/// <param name="interactiveCommand">interactiveCommand</param>
/// <returns>string</returns>
public async Task <string> AddBlacklist(InteractiveCommandDto interactiveCommand)
{
try
{
bool verifyInteractiveCommandResult = this.VerifyInteractiveCommand(interactiveCommand, true, true);
if (!verifyInteractiveCommandResult)
{
this.logger.LogError($"Add Blacklist Fail For Verify InteractiveCommand >>> InitiatorID:{interactiveCommand.InitiatorID} ReceiverID:{interactiveCommand.ReceiverID}");
return("加入黑名單失敗.");
}
//// 處理發起者互動資料
InteractiveData initiatorInteractiveData = await this.GetInteractiveData(interactiveCommand.InitiatorID, true);
if (initiatorInteractiveData == null)
{
this.logger.LogError($"Add Blacklist Fail For Get Interactive Data >>> InitiatorID:{interactiveCommand.InitiatorID}");
return("加入黑名單失敗.");
}
bool updateInitiatorBlacklistResult = this.UpdateListHandler(initiatorInteractiveData.BlacklistIDs, interactiveCommand.ReceiverID, true);
bool updateInitiatorFriendListResult = this.UpdateListHandler(initiatorInteractiveData.FriendListIDs, interactiveCommand.ReceiverID, false);
bool updateInitiatorRequestListResult = this.UpdateListHandler(initiatorInteractiveData.RequestListIDs, interactiveCommand.ReceiverID, false);
if (updateInitiatorBlacklistResult || updateInitiatorFriendListResult || updateInitiatorRequestListResult)
{
bool initiatorUpdateResult = await this.interactiveRepository.UpdateInteractiveData(initiatorInteractiveData);
if (!initiatorUpdateResult)
{
return("黑名單更新失敗.");
}
}
//// 處理接收者互動資料
InteractiveData receiverInteractiveData = await this.GetInteractiveData(interactiveCommand.ReceiverID, false);
if (receiverInteractiveData != null)
{
bool updateReceiverFriendListResult = this.UpdateListHandler(receiverInteractiveData.FriendListIDs, interactiveCommand.InitiatorID, false);
bool updateReceiverRequestListResult = this.UpdateListHandler(receiverInteractiveData.RequestListIDs, interactiveCommand.InitiatorID, false);
if (updateReceiverFriendListResult || updateReceiverRequestListResult)
{
bool receiverUpdateResult = await this.interactiveRepository.UpdateInteractiveData(receiverInteractiveData);
if (!receiverUpdateResult)
{
return("黑名單更新失敗.");
}
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Add Blacklist Error >>> InitiatorID:{interactiveCommand.InitiatorID} ReceiverID:{interactiveCommand.ReceiverID}\n{ex}");
return("加入黑名單發生錯誤.");
}
}
/// <summary>
/// 刪除好友
/// </summary>
/// <param name="interactiveCommand">interactiveCommand</param>
/// <returns>string</returns>
public async Task <string> DeleteFriend(InteractiveCommandDto interactiveCommand)
{
try
{
bool verifyInteractiveCommandResult = this.VerifyInteractiveCommand(interactiveCommand, true, true);
if (!verifyInteractiveCommandResult)
{
this.logger.LogError($"Delete Friend Fail For Verify InteractiveCommand >>> InitiatorID:{interactiveCommand.InitiatorID} ReceiverID:{interactiveCommand.ReceiverID}");
return("刪除好友失敗.");
}
InteractiveData initiatorInteractiveData = await this.GetInteractiveData(interactiveCommand.InitiatorID, false);
if (initiatorInteractiveData == null)
{
this.logger.LogError($"Delete Friend Fail For Get Initiator Interactive Data >>> InitiatorID:{interactiveCommand.InitiatorID}");
return("刪除好友失敗.");
}
InteractiveData receiverInteractiveData = await this.GetInteractiveData(interactiveCommand.ReceiverID, false);
if (receiverInteractiveData == null)
{
this.logger.LogError($"Delete Friend Fail For Get Receiver Interactive Data >>> ReceiverID:{interactiveCommand.ReceiverID}");
return("刪除好友失敗.");
}
//// 更新發起者互動資料
bool updateInitiatorFriendListResult = this.UpdateListHandler(initiatorInteractiveData.FriendListIDs, interactiveCommand.ReceiverID, false);
if (updateInitiatorFriendListResult)
{
bool initiatorUpdateResult = await this.interactiveRepository.UpdateFriendList(initiatorInteractiveData.MemberID, initiatorInteractiveData.FriendListIDs);
if (!initiatorUpdateResult)
{
return("好友名單更新失敗.");
}
}
//// 更新接收者互動資料
bool updateReceiverFriendListResult = this.UpdateListHandler(receiverInteractiveData.FriendListIDs, interactiveCommand.InitiatorID, false);
if (updateReceiverFriendListResult)
{
bool receiverUpdateResult = await this.interactiveRepository.UpdateFriendList(receiverInteractiveData.MemberID, receiverInteractiveData.FriendListIDs);
if (!receiverUpdateResult)
{
return("好友名單更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Delete Friend Error >>> InitiatorID:{interactiveCommand.InitiatorID} ReceiverID:{interactiveCommand.ReceiverID}\n{ex}");
return("刪除好友發生錯誤.");
}
}
public static InteractiveData SetDamageTo(this InteractiveData interactiveData, out float damage, out DamageType damageType, out float damageTime, out int damageCount)
{
damage = interactiveData.Damage;
damageType = interactiveData.DamageType;
damageTime = interactiveData.DamageTime;
damageCount = interactiveData.DamageCount;
return(interactiveData);
}
private void InstantiateArrows(InteractiveData interactiveData)
{
arrowPool = new Pool
(
InstansiateArrow(deltaY, interactiveData)
.With(InstansiateArrow(0, interactiveData))
.With(InstansiateArrow(-deltaY, interactiveData))
);
}
public void SetData(InteractiveData interactiveData)
{
interactiveData.SetTo(damageEntity);
damageEntity.ActionInCoroutineAttack =
x => x.AddColorBy(damageEntity.DamagedColor, interactiveData.DamageTime);
damageEntity.Collider = collider;
}
/// <summary>
/// 加入好友請求
/// </summary>
/// <param name="interactiveCommand">interactiveCommand</param>
/// <returns>string</returns>
public async Task <string> AddFriendRequest(InteractiveCommandDto interactiveCommand)
{
try
{
bool verifyInteractiveCommandResult = this.VerifyInteractiveCommand(interactiveCommand, true, true);
if (!verifyInteractiveCommandResult)
{
this.logger.LogError($"Add Friend Request Fail For Verify InteractiveCommand >>> InitiatorID:{interactiveCommand.InitiatorID} ReceiverID:{interactiveCommand.ReceiverID}");
return("加入好友請求失敗.");
}
//// 驗證發送加入好友請求資格
InteractiveData initiatorInteractiveData = await this.GetInteractiveData(interactiveCommand.InitiatorID, true);
if (initiatorInteractiveData == null)
{
this.logger.LogError($"Add Friend Request Fail For Get Initiator Interactive Data >>> InitiatorID:{interactiveCommand.InitiatorID}");
return("加入好友請求失敗.");
}
InteractiveData receiverInteractiveData = await this.GetInteractiveData(interactiveCommand.ReceiverID, true);
if (receiverInteractiveData == null)
{
this.logger.LogError($"Add Friend Request Fail For Get Receiver Interactive Data >>> ReceiverID:{interactiveCommand.ReceiverID}");
return("加入好友請求失敗.");
}
bool verifyFriendRequestQualificationResult = this.VerifyFriendRequestQualification(initiatorInteractiveData, receiverInteractiveData);
if (!verifyFriendRequestQualificationResult)
{
return("加入好友請求失敗.");
}
//// 更新接收者互動資料
bool updateReceiveRequestListResult = this.UpdateListHandler(receiverInteractiveData.RequestListIDs, interactiveCommand.InitiatorID, true);
if (updateReceiveRequestListResult)
{
bool receiverUpdateResult = await this.interactiveRepository.UpdateRequestList(receiverInteractiveData.MemberID, receiverInteractiveData.RequestListIDs);
if (!receiverUpdateResult)
{
return("加入好友請求名單更新失敗.");
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Add Friend Request Error >>> InitiatorID:{interactiveCommand.InitiatorID} ReceiverID:{interactiveCommand.ReceiverID}\n{ex}");
return("加入好友請求發生錯誤.");
}
}
public virtual void SetData(InteractiveData interactiveData)
{
reloadingTimeBetweenShoots = interactiveData.DamageTime;
interactiveData.SetTo(reloadingEntity);
hittingEffectsPool = new Pool <Vector2>
(
InstansiateHittingEffect()
.With(InstansiateHittingEffect())
);
bulletsPool = new Pool(InstansiateBullets(interactiveData));
}
public void SetData(InteractiveData interactiveData)
{
interactiveData.SetTo(damageEntity);
damageEntity.Collider = collider2D;
damageEntity.ActionInCoroutineAttack =
player =>
{
hittingEffect.transform.position = player.transform.position;
hittingEffect.Play();
player.AddColorBy(damageEntity.DamagedColor, damageEntity.ColoredTime);
};
}
/// <summary>
/// 建立互動資料
/// </summary>
/// <param name="interactiveData">interactiveData</param>
/// <returns>bool</returns>
public async Task <bool> CreateInteractiveData(InteractiveData interactiveData)
{
try
{
await this.interactiveDatas.InsertOneAsync(interactiveData);
return(true);
}
catch (Exception ex)
{
this.logger.LogError($"Create Interactive Data Error >>> Data:{JsonConvert.SerializeObject(interactiveData)}\n{ex}");
return(false);
}
}
private void WriteCode()
{
if (!scriptCode.text.EndsWith("\n") && scriptCode.text.Length > 1)
{
scriptCode.text += "\n";
}
scriptCode.text += OALScriptBuilder.GetInstance().AddCall(
interactiveData.fromClass, interactiveData.fromMethod,
OALProgram.Instance.RelationshipSpace.GetRelationshipByClasses(interactiveData.fromClass, interactiveData.toClass).RelationshipName, interactiveData.toClass,
interactiveData.toMethod
);
interactiveData = new InteractiveData();
}
/// <summary>
/// 加入好友
/// </summary>
/// <param name="interactiveDto">interactiveDto</param>
/// <returns>string</returns>
public async Task <string> JoinFriend(InteractiveDto interactiveDto)
{
try
{
if (string.IsNullOrEmpty(interactiveDto.MemberID))
{
return("會員編號無效.");
}
if (string.IsNullOrEmpty(interactiveDto.InteractiveID))
{
return("對方會員編號無效.");
}
InteractiveData interactiveData = await this.interactiveRepository.GetAppointInteractiveData(interactiveDto.MemberID, interactiveDto.InteractiveID);
if (interactiveData == null)
{
interactiveData = this.CreateInteractiveData(interactiveDto, (int)InteractiveType.Friend);
bool isSuccess = await this.interactiveRepository.CreateInteractiveData(interactiveData);
if (!isSuccess)
{
return("加入好友失敗.");
}
}
else
{
if (interactiveData.Status != (int)InteractiveType.Friend)
{
interactiveData.Status = (int)InteractiveType.Friend;
bool updateInteractiveDataResult = await this.interactiveRepository.UpdateInteractiveData(interactiveData);
if (!updateInteractiveDataResult)
{
return("加入好友失敗.");
}
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Join Friend Error >>> MemberID:{interactiveDto.MemberID} InteractiveID:{interactiveDto.InteractiveID}\n{ex}");
return("加入好友發生錯誤.");
}
}
public void StartAnimate()
{
InteractiveText.GetComponent <DotsAnimation>().currentText = "Select source class\n for call function\ndirectly in diagram\n.";
scriptCode.text = "";
OALScriptBuilder.GetInstance().Clear();
InteractiveData interactiveData = new InteractiveData();
isCreating = true;
introScreen.SetActive(false);
PanelInteractiveIntro.SetActive(true);
PanelMethod.SetActive(false);
PanelInteractive.SetActive(true);
PanelInteractiveCompleted.SetActive(false);
animationScreen.SetActive(true);
mainScreen.SetActive(false);
}
private InteractiveData AddInteractive(string filename, IdCode idCode, string name,
long openCost, int maxLevel, long increasingObjectCost, long increasingCost, long score, int tier)
{
var dynamicParatetrs = TryRead <DynamicParatetrs>(filename, @dynamic => new DynamicParatetrs(@dynamic));
var interactiveData = new InteractiveData
(
dynamicParatetrs, name, openCost, maxLevel,
increasingObjectCost, increasingCost,
score, tier
);
interactiveData.OnDataChanged.Subscribe(interactive => Write(filename, interactive.DynamicParatetrs));
interactives.Add(idCode, interactiveData);
return(interactiveData);
}
private IEnumerable <IPoolable> InstansiateBullets(InteractiveData interactiveData)
{
for (int i = 0; i < bulletCount; i++)
{
var bullet = Instantiate(bulletPrefab, transform.position, transform.rotation);
bullet.name = BulletName;
var bulleetLogic = bullet.GetComponent <Bullet>();
bulleetLogic.OnInteract.Subscribe(hittingEffectsPool.PoolObject);
bulleetLogic.SetData(interactiveData);
bulleetLogic.EffectShower = EffectShower;
var bulletRigidbody = bullet.GetComponent <Rigidbody2D>();
var poolable = new Poolable(bullet);
poolable.OnFloated.Subscribe
(
() =>
{
if (distanceToPlayer.magnitude < minShootingDistanse)
{
shootingExplosion.Play();
bullet.transform.position = shootingExplosion.transform.position;
bullet.transform.rotation = transform.rotation;
bulletRigidbody.velocity = Vector2.zero;
float angle = (PlayerTransform.position - transform.position).Atan2();
angle = Mathf.Deg2Rad * (angle * Mathf.Rad2Deg + RandomizeAngle);
bulletRigidbody.AddForce(accelerate * angle.ToVectorFromRad());
}
else
{
bullet.SetActive(false);
}
}
);
yield return(poolable);
}
}
/// <summary>
/// 移除好友
/// </summary>
/// <param name="interactiveDto">interactiveDto</param>
/// <returns>string</returns>
public async Task <string> RemoveFriend(InteractiveDto interactiveDto)
{
try
{
if (string.IsNullOrEmpty(interactiveDto.MemberID))
{
return("會員編號無效.");
}
if (string.IsNullOrEmpty(interactiveDto.InteractiveID))
{
return("對方會員編號無效.");
}
InteractiveData interactiveData = await this.interactiveRepository.GetAppointInteractiveData(interactiveDto.MemberID, interactiveDto.InteractiveID);
if (interactiveData == null)
{
//// 不做處理，認定已移除好友
this.logger.LogWarning($"No Interactive Data For Remove Friend >>> MemberID:{interactiveDto.MemberID} InteractiveID:{interactiveDto.InteractiveID}");
}
else
{
if (interactiveData.Status == (int)InteractiveType.Friend)
{
interactiveData.Status = (int)InteractiveType.None;
bool updateInteractiveDataResult = await this.interactiveRepository.UpdateInteractiveData(interactiveData);
if (!updateInteractiveDataResult)
{
return("移除好友失敗.");
}
}
}
return(string.Empty);
}
catch (Exception ex)
{
this.logger.LogError($"Remove Friend Error >>> MemberID:{interactiveDto.MemberID} InteractiveID:{interactiveDto.InteractiveID}\n{ex}");
return("移除好友發生錯誤.");
}
}
public void ResetInteractiveSelection()
{
if (interactiveData.fromClass != null)
{
Animation.Instance.HighlightClass(interactiveData.fromClass, false);
}
if (interactiveData.toClass != null)
{
Animation.Instance.HighlightClass(interactiveData.toClass, false);
}
if (interactiveData.fromMethod != null)
{
Animation.Instance.HighlightMethod(interactiveData.fromClass, interactiveData.fromMethod, false);
}
InteractiveText.GetComponent <DotsAnimation>().currentText = "Select source class\nfor call function\ndirectly in diagram\n.";
interactiveData = new InteractiveData();
UpdateInteractiveShow();
PanelInteractiveIntro.SetActive(true);
PanelMethod.SetActive(false);
}
/* Method to retrieve data from the .json file
*/
private void LoadGameData()
{
// Path.Combine combines strings into a file path
// Application.StreamingAssets points to Assets/StreamingAssets in the Editor, and the StreamingAssets folder in a build
string filePath = Path.Combine(Application.streamingAssetsPath, animalDataFileName);
if (File.Exists(filePath))
{
// Read the json from the file into a string
string dataAsJson = File.ReadAllText(filePath);
InteractiveData loadedData = JsonUtility.FromJson <InteractiveData>(dataAsJson);
// Retrieve the allAnimalData property of loadedData
allAnimalData = loadedData.allAnimalData;
}
else
{
Debug.LogError("Cannot load game data!");
}
}
public IEnumerable <IPoolable> InstansiateExposion(InteractiveData interactiveData)
{
var explosion = Instantiate(explosionPrefab, transform.position, transform.rotation);
explosion.name = "MineExplosion";
explosion.GetComponent <ISetData <InteractiveData> >().SetData(interactiveData);
var poolable = new Poolable(explosion);
poolable.OnFloated.Subscribe
(
() =>
{
explosion.transform.position = transform.position;
explosion.transform.rotation = transform.rotation;
}
);
yield return(poolable);
}
