public Character(CharacterPawn pawn, IInputSource inputSource, CharacterStatus status, CharacterStateController stateController, CharacterStateController weaponStateController, int teamId, CharacterInfo info)
{
Status = status;
Health = new FloatReactiveProperty(Status.MaxHealth.Value);
Pawn = pawn;
InputSource = inputSource;
StateController = stateController;
WeaponStateController = weaponStateController;
TeamId = teamId;
Info = info;
Inventory = new BasicInventory(this);
pawn.SetCharacter(this);
StateController.Initialize(this);
WeaponStateController.Initialize(this);
var inputSourceDisposable = inputSource as IDisposable;
if (inputSourceDisposable != null)
{
_compositeDisposable.Add(inputSourceDisposable);
}
Observable.EveryUpdate().Subscribe(OnUpdate).AddTo(_compositeDisposable);
status.MoveSpeed.Subscribe(UpdatePawnSpeed).AddTo(_compositeDisposable);
Health.Subscribe(OnHealthChange); //.AddTo( _compositeDisposable );
Instances.Add(this);
Status.ModifierCalculator.Changed += OnModifiersChange;
}
private void OnPawnEnter(CharacterPawn pawn)
{
if (PawnsInRoom == null)
{
PawnsInRoom = new HashSet <CharacterPawn>();
}
PawnsInRoom.Add(pawn);
if (!bExplored)
{
UIManager.Instance.QuestLog(string.Format("You found a new room at {0},{1},{2}", LogicPosition.x, LogicPosition.y, LogicPosition.z));
bExplored = true;
}
else
{
UIManager.Instance.QuestLog(string.Format("You entered a room which located at {0},{1},{2}", LogicPosition.x, LogicPosition.y, LogicPosition.z));
}
if (pawn.controller != null)
{
UIManager.Instance.SetRoomName(RoomProp.roomName);
}
Property.Room prop = RoomProp;
if (prop.EntryEvent != null)
{
prop.EntryEvent.CheckAndExecute(pawn, this);
}
//this.Show(true);
pawn.curRoom = this;
}
protected override void SetParam(CharacterPawn pawn, ActorInstance.ActorBase actor)
{
base.SetParam(pawn, actor);
#if UNITY_EDITOR
ParameterInfo[] param = method.GetParameters();
if (param.Length != 5)
{
Debug.LogErrorFormat("Function {0} param num NOT equal to 3!", Function);
}
else if (param[2].ParameterType != typeof(System.String))
{
Debug.LogErrorFormat("Function {0} param 2 is NOT string!", Function);
}
else if (param[3].ParameterType != typeof(System.String))
{
Debug.LogErrorFormat("Function {0} param 3 is NOT string!", Function);
}
else if (param[4].ParameterType != typeof(System.String))
{
Debug.LogErrorFormat("Function {0} param 4 is NOT string!", Function);
}
#endif
arrObj.Add(strParam0);
arrObj.Add(strParam1);
arrObj.Add(strParam2);
}
protected override void OnPickup(CharacterPawn picker)
{
if (picker != null)
{
picker.EquipWeapon(weapon);
}
}
public override bool CheckPlayer(CharacterPawn pawn, ActorInstance.ActorBase actor)
{
int value = 0;
switch (Attribute)
{
case CharacterAtrribute.STRENGTH:
value = pawn.CurStrength;
break;
case CharacterAtrribute.AGILITY:
value = pawn.CurAgility;
break;
case CharacterAtrribute.INTEL:
value = pawn.CurIntel;
break;
case CharacterAtrribute.SPIRIT:
value = pawn.CurSpirit;
break;
}
int num = Dice.RandomDice(value);
return(num >= MinValue && num <= MaxValue);
}
private void OnPawnExit(CharacterPawn pawn)
{
if (PawnsInRoom != null)
{
PawnsInRoom.Remove(pawn);
}
}
public static void InvokeEventSequence(CharacterPawn pawn, ActorBase actor, string sequenceName)
{
Property.EventSequence sequence = Resources.Load <Property.EventSequence>(string.Format("Events/EventSequence/{0}", sequenceName));
sequence.Init();
sequence.CheckAndExecute(pawn, actor);
}
public static void PlayEffect(CharacterPawn pawn, ActorBase actor, string name)
{
UIManager.Instance.QuestLog("Your touched a trigger.");
GameObject prefab = Resources.Load <GameObject>(name);
Object.Instantiate <GameObject>(prefab, actor.actorTrans);
}
public EventTimerInst(EventTimer timer, EventFunction eventFunc, CharacterPawn pawn, ActorInstance.ActorBase actor)
{
this.timer = timer;
this.funcToExecute = eventFunc;
this.pawn = pawn;
this.actor = actor;
timer.Init(this);
}
public void Dispose()
{
minimapImgBasement = null;
minimapImgGround = null;
minimapImgUpstairs = null;
mainCharImg = null;
mainPawn = null;
}
public bool TryExit(CharacterPawn pawn)
{
Property.Room prop = RoomProp;
if (prop.ExitEvent != null)
{
return(prop.ExitEvent.CheckAndExecute(pawn, this));
}
return(true);
}
private void OnTriggerExit(Collider collider)
{
CharacterPawn pawn = collider.GetComponent <CharacterPawn>();
if (pawn != null)
{
OnPawnExit(pawn);
}
}
public static void BonusAttribute(CharacterPawn pawn, ActorBase actor, Property.CharacterAtrribute attrib, int value)
{
int pre = 0;
switch (attrib)
{
case Property.CharacterAtrribute.STRENGTH:
pre = pawn.CurStrengthLev;
break;
case Property.CharacterAtrribute.AGILITY:
pre = pawn.CurAgilityLev;
break;
case Property.CharacterAtrribute.INTEL:
pre = pawn.CurIntellLev;
break;
case Property.CharacterAtrribute.SPIRIT:
pre = pawn.CurSpiritLev;
break;
}
int lev = Mathf.Clamp(pre + value, 0, 7);
//TODO: maybe this trigger make attribute level less than 0, which would kill player
switch (attrib)
{
case Property.CharacterAtrribute.STRENGTH:
pawn.CurStrengthLev = lev;
break;
case Property.CharacterAtrribute.AGILITY:
pawn.CurAgilityLev = lev;
break;
case Property.CharacterAtrribute.INTEL:
pawn.CurIntellLev = lev;
break;
case Property.CharacterAtrribute.SPIRIT:
pawn.CurSpiritLev = lev;
break;
}
if (pre > lev)
{
UIManager.Instance.QuestLog(string.Format("Your {0} has decreased {1} level", attrib, pre - lev));
}
else if (pre < lev)
{
UIManager.Instance.QuestLog(string.Format("Your {0} has increased {1} level", attrib, lev - pre));
}
else
{
UIManager.Instance.QuestLog(string.Format("Your {0} level stays the same.", attrib));
}
}
public override void OnExit(CharacterPawn pawn, TriggerMono mono)
{
BlockerMono blocker = mono as BlockerMono;
if (pawn != null && pawn.controller != null && pawn.PawnCollider != null && blocker != null && blocker.blockerCollider != null)
{
Physics.IgnoreCollision(pawn.PawnCollider, blocker.blockerCollider, false);
}
}
public void EnterScene(CharacterPawn pawn)
{
Connector connector = lobby.FindEntry(IntVector3.Invalid);
if (connector != null)
{
connector.TryGetThrough(pawn, IntVector3.Invalid);
}
}
protected virtual bool CheckAvailable(CharacterPawn pawn)
{
if (triggerProp.Checker != null)
{
return(triggerProp.Checker.CheckPlayer(pawn, this));
}
return(true);
}
private void OnTriggerEnter(Collider other)
{
CharacterPawn otherpawn = other.GetComponent <CharacterPawn>();
if (otherpawn != null)
{
OnPickup(otherpawn);
Destroy(gameObject);
}
}
public override bool Interupt(CharacterPawn pawn)
{
if (pawn == null || pawn.Velocity.sqrMagnitude > 0.001f)
{
Debug.LogWarning("Timer interrupt!");
return(true);
}
return(false);
}
public void SyncPawn(CharacterPawn pawn)
{
mainPawn = pawn;
if (mainPawn.curRoom != null)
{
IntVector3 logicPos = mainPawn.curRoom.LogicPosition;
LAYER layer = logicPos.y == -1 ? LAYER.BASEMENT : (logicPos.y == 0 ? LAYER.GROUND : LAYER.UPSTAIRS);
SetLayer(layer);
}
}
public static void PlayAnimation(CharacterPawn pawn, ActorBase actor, string anim)
{
if (anim.Equals("rushtowindow"))
{
UIManager.Instance.Message("rushtowindow");
}
else if (anim.Equals("rushtowindowStop"))
{
UIManager.Instance.Message("rushtowindowStop");
}
}
// Start is called before the first frame update
void Start()
{
player = GameObject.FindGameObjectWithTag("Player");
target = player.transform;
// get component
AITransform = GetComponent <Transform>();
AIpawn = GetComponent <CharacterPawn>();
// grab a random weapon then call the equip weapon
AIWeapon = defaultWeapons[Random.Range(0, defaultWeapons.Length)];
AIpawn.EquipWeapon(AIWeapon);
}
protected virtual void OnAnimationUpdate(CharacterPawn pawn)
{
if (pawn._animationController != null)
{
pawn._animationController.SetBool(info.animatorStateName, true);
}
if (pawn._weaponAnimationController != null)
{
pawn._weaponAnimationController.SetBool(info.weaponAnimatorStateName, true);
}
}
protected override bool CheckAvailable(CharacterPawn pawn)
{
if (!Available)
{
UIManager.Instance.Message("This door is broken");
return(false);
}
if (pawn.RemainMovePoint <= 0)
{
UIManager.Instance.Message("Not enough Move-Point!");
return(false);
}
return(true);
}
public static void TriggerRemoteTriggers(CharacterPawn pawn, ActorBase actor, string filterName)
{
Property.TriggerFilter filter = Resources.Load <Property.TriggerFilter>(string.Format("Trigger/TriggerFilter/{0}", filterName));
if (filter != null)
{
foreach (Trigger trig in GameLoader.Instance.RemoteTriggers)
{
if (filter.Check(trig))
{
trig.OnTriggerSuccess(pawn.controller);
}
}
}
}
public override bool CheckAndExecute(CharacterPawn pawn, ActorInstance.ActorBase actor)
{
if (pawn.RemainMovePoint <= 0)
{
UIManager.Instance.Message("Not enough Move-Point!");
return(false);
}
bool result = base.CheckAndExecute(pawn, actor);
UIManager.Instance.QuestLog("你触发了" + EventName);
UIManager.Instance.QuestLog(EventDesc);
return(result);
}
public override bool CheckAndExecute(CharacterPawn pawn, ActorInstance.ActorBase actor)
{
if (pawn.RemainMovePoint <= 0)
{
UIManager.Instance.Message("Not enough Move-Point!");
return(false);
}
bool result = base.CheckAndExecute(pawn, actor);
//consume all move-points
pawn.ConsumeMovePoint(pawn.RemainMovePoint);
return(result);
}
public override bool CheckPlayer(CharacterPawn pawn, ActorInstance.ActorBase actor)
{
ActorInstance.Connector door = actor as ActorInstance.Connector;
if (door != null && door.otherConnector != null)
{
string fromRoom = door.otherConnector.parentRoom.RoomProp.roomName;
foreach (string name in RoomFromList)
{
if (fromRoom.Equals(name))
{
return(true);
}
}
}
return(false);
}
public void Execute(CharacterPawn pawn, ActorInstance.ActorBase actor)
{
if (method == null)
{
Init();
}
if (method != null)
{
SetParam(pawn, actor);
method.Invoke(null, arrObj.ToArray());
}
else
{
Debug.LogErrorFormat("Function {0} doesn't exist!", Function);
}
}
public static void TriggerRemoteTriggers(CharacterPawn pawn, ActorBase actor, string filterName, string finderName, string sequenceName)
{
Property.TriggerFilter filter = Resources.Load <Property.TriggerFilter>(string.Format("Trigger/TriggerFilter/{0}", filterName));
Property.TargetFinder finder = Resources.Load <Property.TargetFinder>(string.Format("Trigger/TargetFinder/{0}", finderName));
Property.EventSequence sequence = Resources.Load <Property.EventSequence>(string.Format("Events/EventSequence/{0}", sequenceName));
if (filter != null && sequence != null)
{
foreach (Trigger trig in GameLoader.Instance.RemoteTriggers)
{
if (filter.Check(trig))
{
trig.CallEventSequence(pawn.controller, finder, sequence);
}
}
}
}
private void OnTriggerExit(Collider other)
{
CharacterPawn pawn = other.GetComponent <CharacterPawn>();
if (pawn != null && pawn.controller != null)
{
if (triggerProp.AutoTrigger)
{
TriggerExitAction(pawn.controller);
}
else
{
Debug.Log("RemoveTriggerAction");
pawn.controller.TriggerActions.Remove(TriggerAction);
}
}
}
public void SetTarget( CharacterPawn target )
{
this.target = target;
}
public override Vector3 GetDirectionTo( CharacterPawn otherPawn )
{
return planetTransform.GetDirectionTo( otherPawn.position );
}
public virtual Vector3 GetDirectionTo( CharacterPawn otherPawn )
{
return Vector3.forward;
}
private void OnSawEnemy( CharacterPawn characterPawn )
{
targetsSubject.SetValueAndForceNotify( characterPawn.character );
}
