public void StartWithAnimalSequence(AnimalBase animal, int actorPoseID, int animalPoseID)
{
if (Object.op_Equality((Object)animal, (Object)null))
{
return;
}
switch (this)
{
case AgentActor _:
case PlayerActor _:
this._withAnimalEnumerator = this.StartWithAnimalSequenceCoroutine(animal, actorPoseID, animalPoseID);
animal.SetImpossible(true, this);
animal.SetState(!(this is AgentActor) ? AnimalState.WithPlayer : AnimalState.WithAgent, (System.Action)null);
if (this._withAnimalDisposable != null)
{
this._withAnimalDisposable.Dispose();
}
this._withAnimalDisposable = (IDisposable)DisposableExtensions.AddTo <IDisposable>((M0)ObservableExtensions.Subscribe <Unit>((IObservable <M0>)Observable.FromCoroutine((Func <IEnumerator>)(() => this._withAnimalEnumerator), false), (System.Action <M0>)(_ => {}), (System.Action <Exception>)(ex =>
{
Debug.LogException(ex);
this._withAnimalEnumerator = (IEnumerator)null;
}), (System.Action)(() => this._withAnimalEnumerator = (IEnumerator)null)), (Component)this);
break;
}
}
private static T InitializeAnimal(AnimalTypeEnum type)
{
T animalObject = null;
switch (type)
{
case AnimalTypeEnum.Cow:
animalObject = AnimalBase.AnimalFactory(type) as T;
break;
case AnimalTypeEnum.Dog:
animalObject = AnimalBase.AnimalFactory(type) as T;
break;
case AnimalTypeEnum.Cat:
animalObject = AnimalBase.AnimalFactory(type) as T;
break;
case AnimalTypeEnum.Pig:
animalObject = AnimalBase.AnimalFactory(type) as T;
break;
case AnimalTypeEnum.Duck:
animalObject = AnimalBase.AnimalFactory(type) as T;
break;
}
return(animalObject);
}
public static string RusType(this AnimalBase animal)
{
var type = animal.Type();
switch (type)
{
case "Chicken":
return("Курица");
case "Cat":
return("Кошка");
case "Dog":
return("Собака");
case "Stork":
return("Аист");
case "Tiger":
return("Тигр");
case "Wolf":
return("Волк");
default:
return(type);
}
}
protected override void OnAwake(PlayerActor player)
{
player.SetActiveOnEquipedItem(false);
player.ChaControl.setAllLayerWeight(0.0f);
this.isEnd = false;
this.isWait = (Func <PlayerActor, bool>)null;
this.isNextEnabled = false;
if (this.disposable != null)
{
this.disposable.Clear();
}
this.disposable = new CompositeDisposable();
if (Object.op_Equality((Object)(this.hasAnimal = player.Animal), (Object)null))
{
this.isEnd = true;
this.ToErrorEnd(player);
}
else
{
this.animalName = this.hasAnimal.Name;
this.isCameraBlend = true;
this.getPercent = 30f;
if (this.hasAnimal is WildGround)
{
this.getPercent = (this.hasAnimal as WildGround).GetPercent;
}
this.getAnimalFlag = (double)Random.Range(0.0f, 100f) <= (double)this.getPercent;
if (this.getAnimalFlag && Singleton <Resources> .IsInstance() && Singleton <Manager.Map> .IsInstance())
{
List <StuffItem> itemList = Singleton <Manager.Map> .Instance.Player?.PlayerData?.ItemList;
if (itemList != null)
{
this.getIteminfo = this.hasAnimal.ItemInfo;
if (this.getIteminfo != null)
{
this.addItem = new StuffItem(this.getIteminfo.CategoryID, this.getIteminfo.ID, 1);
itemList.AddItem(this.addItem);
}
}
}
if (Singleton <Manager.Map> .IsInstance())
{
List <StuffItem> itemList = Singleton <Manager.Map> .Instance.Player?.PlayerData?.ItemList;
if (itemList != null && this.hasAnimal is WildGround)
{
ItemIDKeyPair getItemId = (this.hasAnimal as WildGround).GetItemID;
itemList.RemoveItem(new StuffItem(getItemId.categoryID, getItemId.itemID, 1));
}
}
MapUIContainer.SetCommandLabelAcception(CommandLabel.AcceptionState.None);
if (this.hasAnimal.AnimalType == AnimalTypes.Cat || this.hasAnimal.AnimalType == AnimalTypes.Chicken)
{
this.Initialize(player);
}
else
{
this.ToErrorEnd(player);
}
}
}
public Animal(AnimalBase pBase, int pLevel)
{
_base = pBase;
level = pLevel;
Init();
}
private void CheckAnimal()
{
List <AnimalBase> animalBaseList = ListPool <AnimalBase> .Get();
foreach (AnimalBase targetAnimal in this.Agent.TargetAnimals)
{
CollisionState collisionState;
if ((targetAnimal.AnimalType & this.targetAnimalType) != (AnimalTypes)0 && this.Agent.AnimalCollisionStateTable.TryGetValue(targetAnimal.InstanceID, out collisionState) && targetAnimal.IsWithAgentFree(this.Agent) && (collisionState == CollisionState.Enter || collisionState == CollisionState.Stay))
{
animalBaseList.Add(targetAnimal);
}
}
if (0 < animalBaseList.Count)
{
AnimalBase capturedInSight = this.GetCapturedInSight(this.Agent, animalBaseList);
if (Object.op_Equality((Object)capturedInSight, (Object)null))
{
ListPool <AnimalBase> .Release(animalBaseList);
return;
}
this.Agent.TargetInSightAnimal = capturedInSight;
}
ListPool <AnimalBase> .Release(animalBaseList);
}
public void DifferentAnimalsMakeDifferentNoises()
{
AnimalBase dog = AnimalFactory.GetAnimal(1);
AnimalBase cat = AnimalFactory.GetAnimal(2);
Assert.AreNotEqual(cat.SongOfItsPeople(), dog.SongOfItsPeople());
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="other"></param>
protected AnimalBase(AnimalBase other)
{
Id = other.Id;
Name = other.Name;
Age = other.Age;
Gender = other.Gender;
FoodSchedule = other.FoodSchedule;
}
private AnimalBase GetCapturedInSight(AgentActor _agent, List <AnimalBase> _animals)
{
AnimalBase element = _animals.GetElement <AnimalBase>(Random.Range(0, _animals.Count));
if (Object.op_Equality((Object)element, (Object)null))
{
return((AnimalBase)null);
}
return(this.IsCaptureInSight(_agent, element) ? element : (AnimalBase)null);
}
public void Initialize(AnimalBase _animal)
{
this.Clear();
this.Animal = _animal;
if (Object.op_Equality((Object)this.Animal, (Object)null))
{
return;
}
this.TableSetting();
}
public virtual TaskStatus OnUpdate()
{
this.CheckAnimal();
AnimalBase targetInSightAnimal = this.Agent.TargetInSightAnimal;
if (Object.op_Equality((Object)targetInSightAnimal, (Object)null))
{
return((TaskStatus)1);
}
return((targetInSightAnimal.AnimalType & this.targetAnimalType) == (AnimalTypes)0 ? (TaskStatus)1 : (TaskStatus)2);
}
private IEnumerator StartWithAnimalSequenceCoroutine(
AnimalBase animal,
int actorPoseID,
int animalPoseID)
{
// ISSUE: object of a compiler-generated type is created
return((IEnumerator) new Actor.\u003CStartWithAnimalSequenceCoroutine\u003Ec__Iterator1()
{
animal = animal,
animalPoseID = animalPoseID,
actorPoseID = actorPoseID,
\u0024this = this
});
}
private void ReleaseAnimal()
{
if (!Object.op_Inequality((Object)this.animal, (Object)null))
{
return;
}
this.animal.SetImpossible(false, (Actor)this.Agent);
if (Object.op_Equality((Object)this.Agent.TargetInSightAnimal, (Object)this.animal))
{
this.Agent.TargetInSightAnimal = (AnimalBase)null;
this.animal.SetSearchTargetEnabled(true, false);
}
this.animal = (AnimalBase)null;
}
private bool IsCaptureInSight(AgentActor _agent, AnimalBase _target)
{
if (Object.op_Equality((Object)_target, (Object)null))
{
return(false);
}
Vector3 position1 = _agent.FovTargetPointTable.get_Item(Actor.FovBodyPart.Head).get_position();
int layer = LayerMask.NameToLayer("Map");
Vector3 position2 = _target.Position;
Vector3 vector3 = Vector3.op_Subtraction(position1, position2);
Ray ray;
((Ray) ref ray).\u002Ector(position1, vector3);
return(!Physics.Raycast(ray, ((Vector3) ref vector3).get_magnitude(), 1 << layer));
}
private void Awake()
{
if (!Object.op_Implicit((Object)this._animal))
{
this._animal = (AnimalBase)((Component)this).GetComponent <AnimalBase>();
}
if (!Object.op_Implicit((Object)this._animal))
{
Object.Destroy((Object)this);
}
else
{
this.InstanceID = this._animal.InstanceID;
this.IsAnimalActive = true;
}
}
private ValueTuple <AIProject.SaveData.AnimalData, PetChicken> CreateChicken(
AIProject.SaveData.Environment.ChickenInfo info)
{
ValueTuple <AIProject.SaveData.AnimalData, PetChicken> valueTuple;
((ValueTuple <AIProject.SaveData.AnimalData, PetChicken>) ref valueTuple).\u002Ector((AIProject.SaveData.AnimalData)null, (PetChicken)null);
if (info == null || !Singleton <AnimalManager> .IsInstance() || Object.op_Equality((Object)this._currentFarmPoint, (Object)null))
{
return(valueTuple);
}
int _animalTypeID = 1;
AnimalBase animalBase = Singleton <AnimalManager> .Instance.CreateBase(_animalTypeID, 1);
IPetAnimal petAnimal = animalBase as IPetAnimal;
if (Object.op_Equality((Object)animalBase, (Object)null))
{
return(valueTuple);
}
((Component)animalBase).get_transform().SetParent(this._currentFarmPoint.AnimalRoot, true);
AIProject.SaveData.AnimalData animalData = new AIProject.SaveData.AnimalData();
animalData.AnimalID = animalBase.AnimalID;
animalData.RegisterID = this._currentFarmPoint.RegisterID;
animalData.AnimalType = AnimalTypes.Chicken;
animalData.AnimalTypeID = _animalTypeID;
animalData.InitAnimalTypeID = true;
animalData.BreedingType = BreedingTypes.Pet;
animalData.Nickname = info.name;
ItemIDKeyPair itemId = animalBase.ItemID;
animalData.ItemCategoryID = itemId.categoryID;
animalData.ItemID = itemId.itemID;
if (petAnimal != null)
{
petAnimal.AnimalData = animalData;
if (animalBase is PetChicken)
{
(animalBase as PetChicken).Initialize(this._currentFarmPoint);
}
}
valueTuple.Item1 = (__Null)animalData;
valueTuple.Item2 = (__Null)(animalBase as PetChicken);
return(valueTuple);
}
public virtual TaskStatus OnUpdate()
{
AnimalBase targetInSightAnimal = this.Agent.TargetInSightAnimal;
if (Object.op_Equality((Object)targetInSightAnimal, (Object)null))
{
return((TaskStatus)1);
}
if (!targetInSightAnimal.IsWithAgentFree(this.Agent))
{
return((TaskStatus)1);
}
AgentProfile.RangeParameter rangeSetting = Singleton <Resources> .Instance.AgentProfile.RangeSetting;
if (!this.Agent.NavMeshAgent.get_pathPending())
{
this.SetDestination(targetInSightAnimal.Position);
}
return(!this.HasArrived() ? (TaskStatus)3 : (TaskStatus)2);
}
public bool IsMatchAnimalWithActor(AnimalBase animal)
{
if (Object.op_Equality((Object)animal, (Object)null) || !animal.Active)
{
return(false);
}
switch (animal.CurrentState)
{
case AnimalState.WithPlayer:
return(this is PlayerActor);
case AnimalState.WithAgent:
return(this is AgentActor);
case AnimalState.WithMerchant:
return(this is MerchantActor);
default:
return(false);
}
}
public void Should_Support_Inheritance_Of_Complex_Objects_Inside_Array()
{
var entity = new MyEntity();
var animals = new AnimalBase[]
{
new Cat {
Friend = new Lion()
},
new Lion(),
new Tiger()
};
entity.SetData("MyAnimals", animals, true);
var animals2 = entity.GetData <AnimalBase[]>("MyAnimals", true);
animals2.Length.ShouldBe(3);
animals2[0].ShouldBeOfType <Cat>();
animals2[0].As <Cat>().Friend.ShouldBeOfType <Lion>();
animals2[1].ShouldBeOfType <Lion>();
animals2[2].ShouldBeOfType <Tiger>();
}
private void Start()
{
if (Object.op_Equality((Object)this._animal, (Object)null))
{
this._animal = (AnimalBase)((Component)this).GetComponent <AnimalBase>();
}
if (Object.op_Equality((Object)this._animal, (Object)null))
{
this._animal = (AnimalBase)((Component)this).GetComponentInChildren <AnimalBase>(true);
}
if (Object.op_Equality((Object)this._animal, (Object)null))
{
this._animal = (AnimalBase)((Component)this).GetComponentInParent <AnimalBase>();
}
if (Object.op_Equality((Object)this._animal, (Object)null))
{
Object.Destroy((Object)this);
}
else
{
this.StartLateUpdate();
}
}
public void CheckIfAllAnimalsAreDifferentFromEachOther(
[Values(AnimalTypeEnum.Cat, AnimalTypeEnum.Cow, AnimalTypeEnum.Dog, AnimalTypeEnum.Duck, AnimalTypeEnum.Pig)
] AnimalTypeEnum firstAnimalTypeEnumAnimal,
[Values(AnimalTypeEnum.Cat, AnimalTypeEnum.Cow, AnimalTypeEnum.Dog, AnimalTypeEnum.Duck, AnimalTypeEnum.Pig)
] AnimalTypeEnum secondAnimalTypeEnumAnimal)
{
if (firstAnimalTypeEnumAnimal == secondAnimalTypeEnumAnimal)
{
Assert.That(firstAnimalTypeEnumAnimal, Is.EqualTo(secondAnimalTypeEnumAnimal));
}
else
{
Assert.That(firstAnimalTypeEnumAnimal, Is.Not.EqualTo(secondAnimalTypeEnumAnimal));
Assert.That(
AnimalBase.AnimalFactory(firstAnimalTypeEnumAnimal).AnimalName,
Is.Not.EqualTo(AnimalBase.AnimalFactory(secondAnimalTypeEnumAnimal).AnimalName));
Assert.That(
AnimalBase.AnimalFactory(firstAnimalTypeEnumAnimal).AnimalSound,
Is.Not.EqualTo(AnimalBase.AnimalFactory(secondAnimalTypeEnumAnimal).AnimalSound));
Assert.That(
AnimalBase.AnimalFactory(firstAnimalTypeEnumAnimal).GetGetAnimalNameAndSound(),
Is.Not.EqualTo(AnimalBase.AnimalFactory(secondAnimalTypeEnumAnimal).GetGetAnimalNameAndSound()));
}
}
public virtual void OnStart()
{
((Task)this).OnStart();
this.Agent.RuntimeDesire = Desire.Type.Animal;
this.Agent.ChangeStaticNavMeshAgentAvoidance();
this.animal = this.Agent.TargetInSightAnimal;
if (Object.op_Equality((Object)this.animal, (Object)null))
{
return;
}
this.animal.SetSearchTargetEnabled(false, false);
this.Agent.StateType = AIProject.Definitions.State.Type.Immobility;
this.animal.BackupState = this.animal.CurrentState;
Dictionary <int, AnimalPlayState> source1;
if (!Singleton <Manager.Resources> .Instance.AnimalTable.WithAgentAnimeTable.TryGetValue(this.animal.AnimalTypeID, out source1) || source1.IsNullOrEmpty <int, AnimalPlayState>())
{
return;
}
List <int> source2 = ListPool <int> .Get();
source2.AddRange((IEnumerable <int>)source1.Keys);
this.Agent.StartWithAnimalSequence(this.animal, source2.GetElement <int>(Random.Range(0, source2.Count)));
}
void settingAnimal()
{
AnimalBase animal = new AnimalBase();
for (int i = 0; i < GameManager.getInstance.loadMapData.animalType.Count; i++)
{
string path = "";
switch (GameManager.getInstance.loadMapData.animalType[i])
{
case eAnimal.eDear:
path = "A_000";
break;
case eAnimal.eDear2:
path = "A_001";
break;
case eAnimal.eGiraffe:
path = "A_002";
break;
case eAnimal.eGiraffe2:
path = "A_003";
break;
case eAnimal.eRhinoceros:
path = "A_004";
break;
case eAnimal.eRhinoceros2:
path = "A_005";
break;
}
animalList.Add(TableLocator.animalDataTable.Find(path));
}
}
private void PostAct(AnimalBase anAnimal)
{
World.Instance.UpdateState();
}
public virtual TaskStatus OnUpdate()
{
AnimalBase targetInSightAnimal = this.Agent.TargetInSightAnimal;
return(Object.op_Inequality((Object)targetInSightAnimal, (Object)null) && (double)Vector3.Distance(this.Agent.Position, targetInSightAnimal.Position) <= (double)this.arrivedDistance ? (TaskStatus)2 : (TaskStatus)1);
}
public void StartWithAnimalSequence(AnimalBase animal, int poseID)
{
this.StartWithAnimalSequence(animal, poseID, poseID);
}
public void StartWithAnimalSequence(AnimalBase animal)
{
this.StartWithAnimalSequence(animal, 0, 0);
}
//Метод можно было лучше реализовать
public static string Type(this AnimalBase animal)
{
return(animal.GetType().Name);
}
public static string InitializeCustomAnimal(string animalName, string animalSound)
{
return(AnimalBase.GetInternalAnimalNameAndSound(animalName, animalSound));
}
public AnimalBehavior(AnimalBase animal, Action behavior, Func <bool> criterion, IAnimalBehavior next)
{
Behavior = behavior;
Criterion = criterion;
Next = next;
}
