/* Functions */
/// <summary>
/// Returns a random object from the list.
/// </summary>
/// <returns> object </returns>
public Transform GetRandomObjectFromList()
{
if (mObjects.Count == 0)
{
return(null);
}
int randIndex = JCS_Random.Range(0, mObjects.Count);
Transform randObj = mObjects[randIndex];
return(randObj);
}
//========================================
// Unity's function
//------------------------------
protected override void Awake()
{
base.Awake();
// no effect happens
if (!RandomizeCashValueEffect ||
mRandomizeCashValue == 0)
{
return;
}
// randomize the cash value a bit.
mCashValue += JCS_Random.Range(-mRandomizeCashValue, mRandomizeCashValue + 1);
}
/// <summary>
/// Do the walk action depends on possibility.
/// </summary>
public void WalkByPossiblity()
{
float possibility = JCS_Random.Range(0, 100);
// possibility check
if (possibility > mPossibility)
{
return;
}
// start the algorithm to see if we
// find the direction to do,
// if not it will just go randomly.
WalkDirectionPossibility();
}
//========================================
// Self-Define
//------------------------------
//----------------------
// Public Functions
/// <summary>
/// Calculate possibility and drop the item.
/// </summary>
public void DropItems()
{
if (mMinNumItemDrop > mMaxNumItemDrop)
{
JCS_Debug.LogError(
"No item drop. min max.");
return;
}
// calculate and see if we do the drop action.
float doDrop = JCS_Random.Range(0, 100);
if (doDrop > mPossiblityDropAction)
{
return;
}
// start doing the drop action.
int itemDrop = JCS_Random.Range(mMinNumItemDrop, mMaxNumItemDrop + 1) * mDropRate;
bool isEven = ((itemDrop % 2) == 0) ? true : false;
int index = 0;
for (index = 0;
index < itemDrop;
++index)
{
JCS_Item item = ItemDropped();
if (item == null)
{
continue;
}
DropAnItem(item, index, isEven);
}
// make sure the object actually drop something.
if (index > 0)
{
// play drop sound.
PlayDropSound();
}
}
/// <summary>
/// Play a random animation in the animator.
/// </summary>
private void RandomPlayAnimationInAnimator()
{
int animLength = m2DAnimator.AnimationsLength;
if (animLength == 0)
{
return;
}
/*
* Just pick a random animation from the animator's animation array.
*/
int randIndex = JCS_Random.Range(0, animLength);
// play this animation
m2DAnimator.DoAnimation(randIndex);
}
/// <summary>
/// Once we do the drop item action,
/// re-calculate the next drop time.
/// so every time it drop is random.
/// </summary>
private void ResetTime()
{
if (!mDroped)
{
return;
}
// get the offset random time.
float randTime = JCS_Random.Range(-mRandomTimeRange, mRandomTimeRange);
// formula, on timing design here.
mDropRealTime = randTime + mTimePerDrop;
// reset timer
mDropTimer = 0;
mDroped = false;
}
//----------------------
// Protected Functions
//----------------------
// Private Functions
/// <summary>
/// Calculate the range and position relationship
/// in order to find the best destination in the
/// navigation map.
///
/// IMPORTANT(JenChieh): if the vector does not in the range,
/// enemy will stay at the place they are, which mean enemy
/// will do nothing...
/// </summary>
/// <returns> result destination </returns>
private Vector3 CalculateRange(Vector3 targetPos)
{
Vector3 newTargetPos = targetPos;
// set up the unknown angle
// 隨機"內角"
float angle = JCS_Random.Range(0, 360);
// define offset
float hypOffset = JCS_Random.Range(
-mAdjustRangeDistance,
mAdjustRangeDistance);
// add offset to current distance (hyp)
float hyp = mRangeDistance + hypOffset;
float opp = Mathf.Sin(angle) * hyp;
float adj = JCS_Mathf.PythagoreanTheorem(hyp, opp, JCS_Mathf.TriSides.adj);
bool flipX = JCS_Mathf.IsPossible(50);
bool flipZ = JCS_Mathf.IsPossible(50);
if (flipX)
{
newTargetPos.x -= adj;
}
else
{
newTargetPos.x += adj;
}
if (flipZ)
{
newTargetPos.z -= opp;
}
else
{
newTargetPos.z += opp;
}
return(newTargetPos);
}
//========================================
// Self-Define
//------------------------------
//----------------------
// Public Functions
/// <summary>
/// Spawn a random transform.
/// </summary>
public void SpawnATransform()
{
int spawnIndex = JCS_Random.Range(0, mSpawnList.Count);
// check null ref.
if (mSpawnList[spawnIndex] == null)
{
JCS_Debug.Log(
"Cannot spawn a null reference. Plz check the spawn list if there are transform attach or empty slot.");
return;
}
// spawn a object
Transform objSpawned = (Transform)JCS_Utility.SpawnGameObject(
mSpawnList[spawnIndex],
this.transform.position);
// randomize the position a bit.
Vector3 randPos = JCS_Utility.ApplyRandVector3(
// use the current spawner position.
objSpawned.transform.position,
new Vector3(mRandPosRangeX, mRandPosRangeY, mRandPosRangeZ),
new JCS_Bool3(mRandPosX, mRandPosY, mRandPosZ));
// randomize the rotation a bit.
Vector3 randRot = JCS_Utility.ApplyRandVector3(
// use the current spawner position.
objSpawned.transform.eulerAngles,
new Vector3(mRandRotRangeX, mRandRotRangeY, mRandRotRangeZ),
new JCS_Bool3(mRandRotationX, mRandRotationY, mRandRotationZ));
// randomize the rotation a bit.
Vector3 randScale = JCS_Utility.ApplyRandVector3(
// use the current spawner position.
objSpawned.transform.localScale,
new Vector3(mRandScaleRangeX, mRandScaleRangeY, mRandScaleRangeZ),
new JCS_Bool3(mRandScaleX, mRandScaleY, mRandScaleZ));
objSpawned.transform.position = randPos;
objSpawned.transform.eulerAngles = randRot;
objSpawned.transform.localScale = randScale;
}
//========================================
// Self-Define
//------------------------------
//----------------------
// Public Functions
/// <summary>
/// Randomly play one shot of sound
/// from the audio clip pool!
/// </summary>
public void PlayRandomSound()
{
if (mAudioClips.Length == 0)
{
return;
}
int randIndex = JCS_Random.Range(0, mAudioClips.Length);
if (mAudioClips[randIndex] == null)
{
JCS_Debug.LogError("JCS_SoundPoolAction", "You inlcude a null references in he audio pool...");
return;
}
float soundVolume = JCS_SoundSettings.instance.GetSoundBaseOnType(mSoundSettingType);
mSoundPlayer.PlayOneShot(mAudioClips[randIndex], soundVolume);
}
//----------------------
// Protected Functions
//----------------------
// Private Functions
/// <summary>
/// Do the actual shake job.
/// </summary>
private void DoEffect()
{
if (!mEffect)
{
return;
}
Vector3 pos = mShakeOrigin;
if (mJCS_2DCamera != null)
{
this.mShakeOrigin.x = mJCS_2DCamera.GetTargetTransform().position.x;
this.mShakeOrigin.y = mJCS_2DCamera.GetTargetTransform().position.y;
}
mShakeTimer += Time.deltaTime;
if (mShakeTimer < mShakeTime)
{
// shake randomly
// shakeTime / shakeTimer = shakeRate
pos.x += (JCS_Random.Range(-1, 1 + 1)) * mShakeMargin * (mShakeTime / mShakeTimer) / 5;
pos.y += (JCS_Random.Range(-1, 1 + 1)) * mShakeMargin * (mShakeTime / mShakeTimer) / 5;
// apply pos
this.transform.position = pos;
}
else
{
// back to original position
this.transform.position = mShakeOrigin;
mShakeTimer = 0;
mEffect = false;
// Enable the input
if (mStopInputWhileThisEffect)
{
JCS_GameManager.instance.GAME_PAUSE = false;
}
}
}
/// <summary>
/// Apply force in order to do hop effect.
/// </summary>
/// <param name="moveForce"> force to move in x axis </param>
/// <param name="jumpForce"> force to move in y axis </param>
/// /// <param name="depth"> include depth? </param>
public void DoForce(float moveForce, float jumpForce, bool depth = false)
{
mVelocity.y = jumpForce;
mVelocity.x = moveForce;
this.mMoveForce = moveForce;
this.mJumpForce = jumpForce;
mEffect = true;
// including depth!
if (depth)
{
float tempMoveForce = moveForce / 2.0f;
// override x
mVelocity.x = JCS_Random.Range(-tempMoveForce, tempMoveForce);
// apply depth
mVelocity.z = JCS_Random.Range(-tempMoveForce, tempMoveForce);
}
}
/// <summary>
/// Do the lightning effect once.
/// </summary>
private void DoEffect()
{
mLimitTimer += Time.deltaTime;
if (mLimitTime > mLimitTimer)
{
return;
}
mLimitTimer = 0;
int randNum = JCS_Random.Range(0, 100);
if (randNum <= mPossiblity)
{
DoLightning();
}
DoRandTime();
}
/* Functions */
protected override void Awake()
{
base.Awake();
mGoStraightAction = this.GetComponent <JCS_3DGoStraightAction>();
if (mRandomAbsorbTime != 0)
{
mTimeToAbsorb += JCS_Random.Range(-mRandomAbsorbTime, mRandomAbsorbTime);
}
if (mInitLookAction == null)
{
mInitLookAction = this.GetComponent <JCS_2DInitLookByTypeAction>();
}
if (mRandomTimeToLook != 0)
{
mTimeToLook += JCS_Random.Range(-mRandomTimeToLook, mRandomTimeToLook);
}
}
/// <summary>
/// Do the particle algorithm here.
/// </summary>
private void DoParticle()
{
if (mParticle == null)
{
return;
}
mSequenceTimer += Time.deltaTime;
// NOTE(jenchieh): magic number...
float time = JCS_Random.Range(0.5f, 1.0f);
if (time < mSequenceTimer)
{
// reset timer
mSequenceTimer = 0;
// do a sequence
DoSequenceParticle(mDensity);
}
}
/// <summary>
/// Do the fade algorithm.
/// </summary>
private void DoFade()
{
// if faded, redefine new time zone.
if (mFaded)
{
ResetTimeZone();
}
mTimeToChangeTimer += Time.deltaTime;
if (mTimeToChangeTimer < mRealTimeToChange)
{
return;
}
this.mAlphaObject.TargetAlpha = JCS_Random.Range(mMinFadeValue, mMaxFadeValue);
// set flag for time zone.
mFaded = true;
// reset timer.
mTimeToChangeTimer = 0;
}
/// <summary>
/// Do the randomize the transform position
/// offset algorithm.
/// </summary>
/// <param name="spawnPos"> position we want to apply. </param>
/// <returns> position after applied the random offset value. </returns>
public Vector3 RandTransform(Vector3 spawnPos)
{
Vector3 newPos = spawnPos;
if (mRandPosX)
{
float effectRange = JCS_Random.Range(-mRandPosRangeX, mRandPosRangeX);
newPos.x += effectRange;
}
if (mRandPosY)
{
float effectRange = JCS_Random.Range(-mRandPosRangeY, mRandPosRangeY);
newPos.y += effectRange;
}
if (mRandPosZ)
{
float effectRange = JCS_Random.Range(-mRandPosRangeZ, mRandPosRangeZ);
newPos.z += effectRange;
}
return(newPos);
}
/// <summary>
/// Return the randomize engular angles.
/// </summary>
/// <param name="angle"> engular angles we want to randomize. </param>
/// <returns> randomize angles. </returns>
public Vector3 RandDegree(Vector3 angle)
{
Vector3 newRotation = angle;
if (mRandDegreeX)
{
float randDegree = JCS_Random.Range(-mDegreeValueX, mDegreeValueX);
newRotation.x += randDegree;
}
if (mRandDegreeY)
{
float randDegree = JCS_Random.Range(-mDegreeValueY, mDegreeValueY);
newRotation.y += randDegree;
}
if (mRandDegreeZ)
{
float randDegree = JCS_Random.Range(-mDegreeValueZ, mDegreeValueZ);
newRotation.z += randDegree;
}
return(newRotation);
}
/// <summary>
/// Drop an item.
/// </summary>
/// <param name="item"> item u want to spawn </param>
/// <param name="index"> index to know the force this is pushing to. </param>
/// <param name="isEven"> is the index even number? </param>
/// <param name="isGravity"> do gravity effect. </param>
/// <param name="spreadEffect"> do spread effect. </param>
/// <param name="rotateDrop"> rotate while dropping. </param>
/// <param name="waveEffect"> do wave effect while on the ground. </param>
/// <param name="destroyFade"> while picking it up will fade and destroy. </param>
private void DropAnItem(
JCS_Item item,
int index,
bool isEven,
bool isGravity,
bool spreadEffect,
bool rotateDrop,
bool waveEffect,
bool destroyFade)
{
JCS_Item newItem = (JCS_Item)JCS_Utility.SpawnGameObject(
item,
this.transform.position,
this.transform.rotation);
bool isEvenIndex = ((index % 2) == 0) ? true : false;
if (isGravity)
{
JCS_OneJump oj = newItem.gameObject.AddComponent <JCS_OneJump>();
float gapDirection = mSpreadGap;
if (isEvenIndex)
{
gapDirection = -mSpreadGap;
}
oj.BounceBackfromWall = BounceBackfromWall;
float gapForce = 0;
if (spreadEffect)
{
if (isEven)
{
if (!isEvenIndex)
{
gapForce = (gapDirection * (index - 1)) + gapDirection;
}
else
{
gapForce = (gapDirection * (index)) + gapDirection;
}
}
// if total is odd
else
{
if (isEvenIndex)
{
gapForce = (gapDirection * (index));
}
else
{
gapForce = (gapDirection * (index)) + gapDirection;
}
}
}
float jumpForce = mJumpForce;
if (mRandomizeJumpForce)
{
jumpForce += JCS_Random.Range(-mRandomizeJumpForceForce, mRandomizeJumpForceForce);
}
oj.DoForce(gapForce, jumpForce, mIncludeDepth);
if (rotateDrop)
{
JCS_ItemRotation irx = newItem.gameObject.AddComponent <JCS_ItemRotation>();
irx.RotateSpeed = JCS_Random.Range(-mRotateSpeed, mRotateSpeed);
irx.Effect = true;
irx.RotateDirection = JCS_Vector3Direction.FORWARD;
// if z axis interact in game
if (mIncludeDepth)
{
// add rotation on y axis.
JCS_ItemRotation iry = newItem.gameObject.AddComponent <JCS_ItemRotation>();
iry.RotateSpeed = JCS_Random.Range(-mRotateSpeed, mRotateSpeed);
iry.Effect = true;
iry.RotateDirection = JCS_Vector3Direction.UP;
// add rotation on z axis.
JCS_ItemRotation irz = newItem.gameObject.AddComponent <JCS_ItemRotation>();
irz.RotateSpeed = JCS_Random.Range(-mRotateSpeed, mRotateSpeed);
irz.Effect = true;
irz.RotateDirection = JCS_Vector3Direction.RIGHT;
}
}
}
if (waveEffect)
{
JCS_3DConstWaveEffect cwe = newItem.gameObject.AddComponent <JCS_3DConstWaveEffect>();
cwe.SetObjectType(newItem.GetObjectType());
cwe.Effect = true;
}
if (destroyFade)
{
JCS_DestroyObjectWithTime dowt = newItem.gameObject.AddComponent <JCS_DestroyObjectWithTime>();
dowt.FadeTime = mFadeTime;
dowt.DestroyTime = mDestroyTime;
Renderer[] renderers = newItem.GetComponentsInChildren <Renderer>();
foreach (Renderer rdr in renderers)
{
JCS_FadeObject fo = rdr.gameObject.AddComponent <JCS_FadeObject>();
dowt.FadeObjects.Add(fo);
// set the object type the same.
fo.SetObjectType(item.GetObjectType());
fo.UpdateUnityData();
}
}
}
/// <summary>
/// Use to check if something possible by percentage.
/// 0 ~ 100.
/// </summary>
/// <returns></returns>
public static bool IsPossible(float val)
{
float possibility = JCS_Random.Range(0, 100);
return((val > possibility) ? true : false);
}
/// <summary>
/// Return the range distance.
/// </summary>
/// <returns> Value of the range distance. </returns>
private float GetRangeDistance()
{
float hypOffset = JCS_Random.Range(-mAdjustRangeDistance, mAdjustRangeDistance);
return(mRangeDistance + hypOffset);
}
/// <summary>
/// Do the fade algorithm.
/// </summary>
private void DoRange()
{
float newRange = JCS_Random.Range(mMinRangeValue, mMaxRangeValue);
this.mValueTweener.DoTween(newRange);
}
/// <summary>
/// Do the fade algorithm.
/// </summary>
private void DoFade()
{
this.mAlphaObject.TargetAlpha = JCS_Random.Range(mMinFadeValue, mMaxFadeValue);
}
/// <summary>
/// Decide what item to drop base on
/// the array list we have!
/// </summary>
/// <returns> item to drop. </returns>
private JCS_Item ItemDropped()
{
JCS_Item item = null;
float totalChance = 0;
// add all possiblity chance together.
for (int index = 0;
index < mItemSet.Length;
++index)
{
totalChance += mItemSet[index].dropRate;
}
float dropIndex = JCS_Random.Range(0, totalChance + 1);
float accumMaxDropRate = 0;
float accumMinDropRate = 0;
for (int index = 0;
index < mItemSet.Length;
++index)
{
accumMaxDropRate += mItemSet[index].dropRate;
if (index == 0)
{
if (JCS_Utility.WithInRange(
0,
mItemSet[0].dropRate,
dropIndex))
{
item = mItemSet[0].item;
break;
}
continue;
}
// 比如: 10, 20, 30, 40
// Loop 1: 0 ~ 10
// Loop 2: 20(30-10) ~ 30
// Loop 3: 30(60-30) ~ 60
// Loop 4: 40(100-60) ~ 100 每個都減掉上一個的Drop Rate!
if (JCS_Utility.WithInRange(
accumMinDropRate,
accumMaxDropRate,
dropIndex))
{
item = mItemSet[index].item;
break;
}
accumMinDropRate += mItemSet[index].dropRate;
}
// meaning the last one.
if (item == null &&
mItemSet.Length != 0 &&
mItemSet[mItemSet.Length - 1].dropRate != 0)
{
item = mItemSet[mItemSet.Length - 1].item;
}
return(item);
}
/// <summary>
/// Drop an item.
/// </summary>
/// <param name="item"> item u want to spawn </param>
/// <param name="index"> index to know the force this is pushing to. </param>
/// <param name="isEven"> is the index even number? </param>
/// <param name="isGravity"> do gravity effect. </param>
/// <param name="spreadEffect"> do spread effect. </param>
/// <param name="rotateDrop"> rotate while dropping. </param>
/// <param name="waveEffect"> do wave effect while on the ground. </param>
/// <param name="destroyFade"> while picking it up will fade and destroy. </param>
private void DropAnItem(
JCS_Item item,
int index,
bool isEven,
bool isGravity,
bool spreadEffect,
bool rotateDrop,
bool waveEffect,
bool destroyFade)
{
JCS_Item jcsi = (JCS_Item)JCS_Utility.SpawnGameObject(
item,
this.transform.position,
this.transform.rotation);
bool isEvenIndex = ((index % 2) == 0) ? true : false;
if (isGravity)
{
JCS_OneJump jcsoj = jcsi.gameObject.AddComponent <JCS_OneJump>();
float gapDirection = mSpreadGap;
if (isEvenIndex)
{
gapDirection = -mSpreadGap;
}
jcsoj.BounceBackfromWall = BounceBackfromWall;
float gapForce = 0;
if (spreadEffect)
{
if (isEven)
{
if (!isEvenIndex)
{
gapForce = (gapDirection * (index - 1)) + gapDirection;
}
else
{
gapForce = (gapDirection * (index)) + gapDirection;
}
}
// if total is odd
else
{
if (isEvenIndex)
{
gapForce = (gapDirection * (index));
}
else
{
gapForce = (gapDirection * (index)) + gapDirection;
}
}
}
float jumpForce = mJumpForce;
if (mRandomizeJumpForce)
{
jumpForce += JCS_Random.Range(-mRandomizeJumpForceForce, mRandomizeJumpForceForce);
}
jcsoj.DoForce(gapForce, jumpForce, mIncludeDepth);
if (rotateDrop)
{
JCS_ItemRotation jcsir = jcsi.gameObject.AddComponent <JCS_ItemRotation>();
jcsir.RotateSpeed = mRotateSpeed;
jcsir.Effect = true;
// if z axis interact in game
if (mIncludeDepth)
{
// add one more axis.
JCS_ItemRotation jcsir2 = jcsi.gameObject.AddComponent <JCS_ItemRotation>();
jcsir2.RotateSpeed = JCS_Random.Range(-mRotateSpeed, mRotateSpeed);
jcsir2.Effect = true;
jcsir2.RotateDirection = JCS_Vector3Direction.UP;
}
}
}
if (waveEffect)
{
JCS_3DConstWaveEffect jcscw = jcsi.gameObject.AddComponent <JCS_3DConstWaveEffect>();
jcscw.Effect = true;
}
if (destroyFade)
{
JCS_DestroyObjectWithTime jcsao = jcsi.gameObject.AddComponent <JCS_DestroyObjectWithTime>();
jcsao.GetFadeObject().FadeTime = mFadeTime;
jcsao.DestroyTime = mDestroyTime;
// set the object type the same.
jcsao.GetFadeObject().SetObjectType(item.GetObjectType());
jcsao.GetFadeObject().UpdateUnityData();
}
}
/// <summary>
/// Get the random position within the
/// certain range. (Circle)
/// </summary>
/// <param name="targetPos"> target position </param>
/// <param name="range"> radius of circle </param>
/// <param name="adjRange"> adjustable value? </param>
/// <returns></returns>
private Vector3 CalculateCirclePosition(Vector3 targetPos, float range, float adjRange = 0)
{
Vector3 newPos = mTargetTransform.position;
// set up the unknown angle
// ÀH¾÷"¤º¨¤"
float angle = JCS_Random.Range(0, 360);
// define offset
float hypOffset = JCS_Random.Range(
-adjRange,
adjRange);
// add offset to current distance (hyp)
float hyp = range + hypOffset;
float opp = Mathf.Sin(angle) * hyp;
float adj = JCS_Mathf.PythagoreanTheorem(hyp, opp, JCS_Mathf.TriSides.adj);
bool flipX = JCS_Mathf.IsPossible(50);
if (flipX)
{
newPos.x -= adj;
}
else
{
newPos.x += adj;
}
bool flipY = JCS_Mathf.IsPossible(50);
if (flipY)
{
newPos.y -= opp;
}
else
{
newPos.y += opp;
}
if (mIncludeDepth)
{
bool flipZ = JCS_Mathf.IsPossible(50);
if (flipZ)
{
newPos.z -= opp;
}
else
{
newPos.z += opp;
}
}
return(newPos);
}
/// <summary>
/// Sometimes if the algorithm cannot find which direction to go.
/// Just use the function instead of keep finding the direction.
///
/// For example, all three possiblity (Idle, Left, Right)
/// can be set to 100 percent. Than it will always have to
/// possiblity of direction to go, which mean the object could
/// not decide which direction to go.
/// </summary>
public void WalkRandomly()
{
int result = JCS_Random.Range(-1, 1 + 1);
WalkByStatus(result);
}
/// <summary>
/// Recusive function that will find the direction
/// and do the walk.
/// </summary>
public void WalkDirectionPossibility()
{
// direction we are going to use next.
Status direction = Status.IDLE;
// if is already get attack do the mad effect.
if (mMadEffect && mAttackRecorder != null)
{
Transform lastAttacker = mAttackRecorder.LastAttacker;
// if the last attacker does not exist,
// do nothing.
if (lastAttacker != null)
{
// if does exist, start following
// the attacker.
if (lastAttacker.position.x < this.transform.position.x)
{
direction = Status.LEFT;
}
else
{
direction = Status.RIGHT;
}
// do that direction and return.
WalkByStatus(direction);
return;
}
}
// record down how what does success to go with.
int resultCounter = 0;
float leftPossiblity = JCS_Random.Range(0, 100);
float idlePossiblity = JCS_Random.Range(0, 100);
float rightPossiblity = JCS_Random.Range(0, 100);
if (idlePossiblity < mToIdle)
{
// success to do idle
direction = Status.IDLE;
++resultCounter;
}
if (leftPossiblity < mToLeft)
{
// success to do left
direction = Status.LEFT;
++resultCounter;
}
if (rightPossiblity < mToRight)
{
// success to do right
direction = Status.RIGHT;
++resultCounter;
}
// if there are multiple result do randomly
if (resultCounter >= 2)
{
WalkRandomly();
}
// else if we successfully find the direction,
// use the direction algorithm found.
else
{
WalkByStatus(direction);
}
}
/// <summary>
/// Calculate possibility and drop the item.
/// </summary>
/// <param name="mustDropItem"> item must drop </param>
/// <param name="specIndex"> specific drop item index </param>
/// <param name="only"> only drop this item. </param>
/// <param name="count"> how many of this item u want to drop. </param>
public void DropItems(JCS_Item mustDropItem, int specIndex = -1, bool only = false, int count = 1)
{
if (mustDropItem == null)
{
JCS_Debug.LogError("Must drop item cannot be null references");
return;
}
if (count <= 0)
{
JCS_Debug.LogError("Cannot drop item with count less or equal to zero");
return;
}
int index = 0;
if (only)
{
// just
int itemDrop = count;
bool isEven = ((itemDrop % 2) == 0) ? true : false;
for (index = 0;
index < count;
++index)
{
// simple assign the item.
JCS_Item item = mustDropItem;
// do drop the item.
DropAnItem(item, index, isEven);
}
}
else
{
if (mMinNumItemDrop > mMaxNumItemDrop)
{
JCS_Debug.LogError("No item drop. min max.");
return;
}
// calculate and see if we do the drop action.
float doDrop = JCS_Random.Range(0, 100);
if (doDrop > mPossiblityDropAction)
{
return;
}
// start doing the drop action.
int itemDrop = JCS_Random.Range(mMinNumItemDrop, mMaxNumItemDrop + 1) * mDropRate + count;
bool isEven = ((itemDrop % 2) == 0) ? true : false;
int randDropIndex = specIndex;
// check index out of range.
if (specIndex < 0 || specIndex >= itemDrop)
{
randDropIndex = JCS_Random.Range(0, itemDrop);
}
for (index = 0; index < itemDrop; ++index)
{
JCS_Item item = null;
if (index == randDropIndex)
{
// assign must drop item.
item = mustDropItem;
}
else
{
item = ItemDropped();
}
if (item == null)
{
continue;
}
DropAnItem(item, index, isEven);
}
}
// make sure the object actually drop something.
if (index > 0)
{
// play drop sound.
PlayDropSound();
}
}
/// <summary>
/// Fly to a direction base on possibilities.
/// </summary>
public void FlyDirectionByPossiblity()
{
// direction we are going to use next.
StatusX directionX = StatusX.IDLE;
StatusY directionY = StatusY.IDLE;
// if is already get attack do the mad effect.
if (mMadEffect && mAttackRecorder != null)
{
Transform lastAttacker = mAttackRecorder.LastAttacker;
// if the last attacker does not exist,
// do nothing.
if (lastAttacker != null)
{
// NOTE(JenChieh): if does exist, start
// following the attacker.
// X-axis
if (lastAttacker.position.x < this.transform.position.x)
{
directionX = StatusX.LEFT;
}
else
{
directionX = StatusX.RIGHT;
}
// Y-axis
if (lastAttacker.position.y < this.transform.position.y)
{
directionY = StatusY.DOWN;
}
else
{
directionY = StatusY.UP;
}
// do that direction and return.
FlyByStatus(directionX, directionY);
return;
}
}
// record down how what does success to go with.
int resultCounterX = 0;
int resultCounterY = 0;
float idlePossiblityX = JCS_Random.Range(0, 100);
float leftPossiblity = JCS_Random.Range(0, 100);
float rightPossiblity = JCS_Random.Range(0, 100);
if (idlePossiblityX < mToIdleVetical)
{
// success to do idle in x axis
directionX = StatusX.IDLE;
++resultCounterX;
}
if (leftPossiblity < mToLeft)
{
// success to do left
directionX = StatusX.LEFT;
++resultCounterX;
}
if (rightPossiblity < mToRight)
{
// success to do right
directionX = StatusX.RIGHT;
++resultCounterX;
}
float idlePossiblityY = JCS_Random.Range(0, 100);
float upPossiblity = JCS_Random.Range(0, 100);
float downPossiblity = JCS_Random.Range(0, 100);
if (idlePossiblityY < mToIdleHorizontal)
{
// success to do idle in y axis
directionY = StatusY.IDLE;
++resultCounterY;
}
if (downPossiblity < mToDown)
{
// success to do left
directionY = StatusY.DOWN;
++resultCounterY;
}
if (upPossiblity < mToUp)
{
// success to do right
directionY = StatusY.UP;
++resultCounterY;
}
// if there are multiple result do randomly
if (resultCounterX >= 2 &&
resultCounterY >= 2)
{
FlyRandomly();
}
// else if we successfully find the direction,
// use the direction algorithm found.
else
{
FlyByStatus(directionX, directionY);
}
}
