public void AddMob(NonPlayer npc)
{
if (!mobs.Contains(npc))
{
mobs.Add(npc);
}
}
private void PerformLookAtNpc(Session session, Room room, NonPlayer npc)
{
session.WriteLine("You look at {0}.", npc.Name);
session.WriteLine("{0}", npc.Description);
if (npc.IsShopkeeper)
{
session.WriteLine("{0} is carrying: ", npc.Name);
if (npc.Inventory.Count > 0)
{
foreach (var item in npc.Inventory)
{
session.WriteLine("\t{0}", item.Value);
}
}
else
{
session.WriteLine("\tNothing");
}
}
room.SendPlayers(string.Format("{0} looks at {1}", session.Player.Forename, npc.Name), session.Player, null, session.Player);
session.WriteLine(string.Empty);
}
protected override IEnumerator Special()
{
NonPlayer casterActor
= Target.GetComponent <NonPlayer>();
casterActor.ThrowEvent(ConstValue.EventKey_SelectSkill,
eSkillTemplateType.TARGET_BLOCK);
IS_SKILL = true;
casterActor.RunSkill();
IS_SKILL_COOLDOWN = true;
Invoke("OffSkillCoolDown", 7f);
yield return(new WaitForEndOfFrame());
while (IS_SKILL)
{
if (OBJECT_STATE == eBaseObjectState.STATE_DIE)
{
break;
}
yield return(new WaitForEndOfFrame());
}
AddNextAI(eStateType.STATE_IDLE);
yield return(StartCoroutine(base.Special()));
}
public override string Execute(Player p, string[] input)
{
if (input.Length == 2)
{
if (input[1 - 1] == "murder" || input[1 - 1] == "execute")
{
NonPlayer target = p.Location.FindChar(input[2 - 1]);
if (target == null)
{
return($"I can't find this person you want to {input[1 - 1]}\r");
}
if (target.AreYou("target"))
{
target.AddIdentifier("dead");
p.Location.PresentChar.Remove(target);
return($"You have {input[1 - 1]}ed {input[2 - 1]}\r");
}
else
{
return($"You can't {input[1 - 1]} {input[2 - 1]}!\r" +
$"{input[2 - 1]} is not your target!\r");
}
}
return("What are you trying to do?\r");
}
return("This command only requires 2 words\r");
}
public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
TargetActor = animator.GetComponent <NonPlayer>();
TargetObject = (BaseObject)(TargetActor.GetData(ConstValue.ActorData_GetTarget));
if (TargetObject == null)
{
Debug.LogError("타겟널이야 홍은기 븅시나");
}
if (TargetActor.AI.CURRENT_AI_STATE == eStateType.STATE_SPECIAL)
{
TargetActor.AI.IS_SKILL = true;
bIsAttack = false;
CurTime = 0f;
}
//get_target을 보내 타겟 정보를 가져옴
//타겟(플레이어)의 위치를 구함
Vector3 targetPos = TargetObject.SelfTransform.position;
//보스의 위치를 구함
SelfPos = TargetActor.SelfTransform.position;
//FireBallCreate.transform.position = SelfPos;
//FireBallCreate.transform.localRotation = TargetActor.SelfTransform.rotation;
//보스와 타겟의 방향을 구함.
Vector3 norPos = (SelfPos - targetPos).normalized * 2f;
TargetPos = targetPos + norPos;
}
public void SendStagePlayerPop(Player player, int to_client_id = 0)
{
if (!(player == null))
{
if (player.IsCoopNone())
{
player.SetCoopMode(StageObject.COOP_MODE_TYPE.ORIGINAL, 0);
}
Coop_Model_StagePlayerPop coop_Model_StagePlayerPop = new Coop_Model_StagePlayerPop();
coop_Model_StagePlayerPop.id = 1002;
coop_Model_StagePlayerPop.sid = player.id;
coop_Model_StagePlayerPop.isSelf = (player is Self);
NonPlayer nonPlayer = player as NonPlayer;
if (player.createInfo != null)
{
if (nonPlayer == null)
{
coop_Model_StagePlayerPop.charaInfo = player.createInfo.charaInfo;
}
coop_Model_StagePlayerPop.extentionInfo = player.createInfo.extentionInfo;
}
coop_Model_StagePlayerPop.transferInfo = player.CreateTransferInfo();
Send(coop_Model_StagePlayerPop, true, to_client_id, null, null);
}
}
public static NonPlayer GetNearestAliveNpc(StageObject client)
{
NonPlayer result = null;
float num = 3.40282347E+38f;
int i = 0;
for (int count = MonoBehaviourSingleton <StageObjectManager> .I.playerList.Count; i < count; i++)
{
NonPlayer nonPlayer = MonoBehaviourSingleton <StageObjectManager> .I.playerList[i] as NonPlayer;
if (!object.ReferenceEquals(nonPlayer, null) && !(nonPlayer == client))
{
switch (nonPlayer.CanGoPray(client))
{
case NonPlayer.eNpcAllayState.SAME:
return(nonPlayer);
case NonPlayer.eNpcAllayState.CAN:
{
float lengthWithBetweenObject = GetLengthWithBetweenObject(client, nonPlayer);
if (lengthWithBetweenObject < num)
{
result = nonPlayer;
num = lengthWithBetweenObject;
}
break;
}
}
}
}
return(result);
}
public override void OnStateEnter(Animator animator, AnimatorStateInfo animatorStateInfo, int layerIndex)
{
TargetActor = animator.GetComponentInParent <NonPlayer>();
if (TargetActor.AI.CURRENT_AI_STATE == eStateType.STATE_SPECIAL)
{
TargetActor.AI.IS_SKILL = true;
}
}
public void InitializeNewGame()
{
string enemyName = "Rival Canidate";
m_NonPlayer = new NonPlayer(enemyName);
m_MainPlayer = new MainPlayer(GameMaster.Get().GetPlayerName());
m_Board = new Board();
m_ActivePlayer = new Player();
m_iTurnCount = 0;
}
private void CacheEntitySpawns()
{
foreach (var entity in WorldDatabase.GetEntities((ushort)Entry.Id))
{
// TODO: cache spawns by grid, only spawn when grid is loaded
// (int X, int Z) coord = GetGridCoord(vector);
var test = new NonPlayer(entity);
var vector = new Vector3(entity.X, entity.Y, entity.Z);
EnqueueAdd(test, vector);
}
}
private void updateButtons(VRAR_Tile tile)
{
//We can only attack neighbours
foreach (VRAR_Tile circleTile in GameStateManager.getInstance().getCurrentLevel().selectCircle(GamePlayManagerAR.instance.localPlayer.GetCurrentVec().x, GamePlayManagerAR.instance.localPlayer.GetCurrentVec().y, 1))
{
if (circleTile == currentTile)
{
//if there is an npc show attack button
NonPlayer npc = tile.getNPC();
if (npc != null)
{
attackButtonPrefab.SetActive(true);
}
//if there is another player also show attack button
if (client != null)
{
List <BasePlayer> players = client.getPlayerList();
foreach (BasePlayer player in players)
{
if (player.GetCurrentTile() == tile)
{
attackButtonPrefab.SetActive(true);
}
}
}
}
}
if (tile.GetWalkable())
{
walkButtonPrefab.SetActive(true);
//if an object is walkable that means there is no object there so we can ignore te rest in this function
return;
}
BaseTileObject baseTileObject = tile.getInteractableObject();
//show hand if interactable
if (baseTileObject.getInteractable() || tile.getInterior() != null)
{
handButtonPrefab.SetActive(true);
inspectButtonPrefab.SetActive(true);
currentTileText.text = baseTileObject.getName();
}
//if its not interactable we want to allow the player to inspec the object, but not if ther is object (id == 0)
else
{
inspectButtonPrefab.SetActive(true);
currentTileText.text = baseTileObject.getName();
}
}
public override void OnStateEnter(Animator animator, AnimatorStateInfo animatorStateInfo, int layerIndex)
{
//TargetPlayer = animator.GetComponentInParent<Player>();
//if (TargetPlayer.CURRENT_STATE == ePlayerStateType.STATE_ATTACK)
//{
// TargetPlayer.IS_ATTACK = true;
// bIsAttack = false;
//}
TargetActor = animator.GetComponentInParent <NonPlayer>();
if (TargetActor.AI.CURRENT_AI_STATE == eStateType.STATE_ATTACK)
{
TargetActor.AI.IS_ATTACK = true;
bIsAttack = false;
bFinalAttack = false;
}
switch (TargetActor.TEMPLATE_KEY)
{
case "ENEMY_1":
{
RunSkillTiming = 0.3f;
}
break;
case "ENEMY_2":
{
RunSkillTiming = 0.6f;
bLookAt = true;
}
break;
case "ENEMY_3":
{
RunSkillTiming = 0.234f;
bGiantEnemy = true;
}
break;
case "ENEMY_BOSS":
{
RunSkillTiming = 0.5f;
bBossEnemy = true;
}
break;
}
}
private void OnRaisePlayer(Player dead_player)
{
NonPlayer nearestAliveNpc = AIUtility.GetNearestAliveNpc(dead_player);
if (!(nearestAliveNpc == null) && !(nearestAliveNpc.controller == null))
{
Brain brain = nearestAliveNpc.controller.brain;
if (!(brain == null) && brain.think != null)
{
brain.targetCtrl.SetAllyTarget(dead_player);
if (brain.fsm != null)
{
brain.fsm.ChangeState(STATE_TYPE.RAISE_ALLY);
}
}
}
}
void GotAttack(NetworkMessage netMsg)
{
AttackMessage attackMessage = netMsg.ReadMessage <AttackMessage>();
VRAR_Tile tile = GameStateManager.getInstance().getCurrentLevel().getTileFromIndexPos(attackMessage.targetTileX, attackMessage.targetTileY);
NonPlayer npc = tile.getNPC();
if (npc != null)
{
//CHeck if we did the attack and show the hitsplat if true
if (IsMyId(attackMessage.id))
{
UIManager.Instance.SpawnHitSplat(tile.getNPC().GetObject().transform, attackMessage.result);
}
npc.DecreaseHealth(attackMessage.result);
players[attackMessage.id].DoAttackAnim();
}
else //if there is no npc check if there is a player
{
foreach (BasePlayer player in players.Values)
{
if (player.GetCurrentTile() == tile)
{
//CHeck if we did the attack and show the hitsplat if true
if (IsMyId(attackMessage.id))
{
UIManager.Instance.SpawnHitSplat(player.GetObject().transform, attackMessage.result);
}
//the player died ! move them to their spawn location
if (player.DecreaseHealth(attackMessage.result))
{
//After a player died we have to go through all the players again and make sure all their positios are ok
//first the local player and then the external players
TileRenderer.instance.teleportLocalPlayer(GamePlayManagerAR.instance.localPlayer.GetCurrentVec().x, GamePlayManagerAR.instance.localPlayer.GetCurrentVec().y);
foreach (BasePlayer moreplayers in players.Values)
{
if (moreplayers != GamePlayManagerAR.instance.localPlayer)
{
TileRenderer.instance.teleportExternalPlayer(moreplayers);
}
}
}
players[attackMessage.id].DoAttackAnim();
}
}
}
}
public override void Execute(Session session, CommandContext context)
{
// validate item arg
if (string.IsNullOrWhiteSpace(context.ArgumentString))
{
session.WriteLine("Sell what?");
return;
}
PlayerItem itemToSell = ItemHelper.FindInventoryItem(session.Player, context.ArgumentString, false, false);
if (itemToSell == null)
{
session.WriteLine("You don't have that to sell.");
return;
}
// get shopkeeper in room
var room = RoomHelper.GetPlayerRoom(session.Player.Location);
NonPlayer shopkeeper = null;
foreach (var npc in room.GetNpcs())
{
if (npc.IsShopkeeper)
{
shopkeeper = npc;
break;
}
}
if (shopkeeper == null)
{
session.WriteLine("You can't sell that here.");
return;
}
// destroy item, remove from inventory, give gold, save player
var sellPrice = itemToSell.Value / 2;
session.Player.Gold += sellPrice;
session.Player.Inventory.Remove(itemToSell.Key);
Server.Current.Database.Save(session.Player); // save so they can't try to sell again
session.WriteLine("You sold {0} for {1} gold.", itemToSell.Name, sellPrice);
Server.Current.Database.Delete <PlayerItem>(itemToSell.Key);
}
public void InspectButtonPressed()
{
//Clear buttons and hide tilehighlighter
//clearButtons();
//TileRenderer.instance.updateTileHighlighter(this.transform, false);
BaseTileObject baseTileObject = null;
List <BaseTileObject> objectList = currentTile.getDumbObjectsList();
if (objectList != null && objectList.Count > 0)
{
baseTileObject = currentTile.getDumbObjectsList()[0];
}
//show hand if interactable
if (baseTileObject != null)
{
currentTileText.text = baseTileObject.getInspect();
return;
}
NonPlayer npc = currentTile.getNPC();
if (npc != null)
{
currentTileText.text = npc.GetInspect();
return;
}
if (client != null)
{
List <BasePlayer> players = client.getPlayerList();
foreach (BasePlayer player in players)
{
if (player.GetCurrentTile() == currentTile)
{
currentTileText.text = "This is " + player.GetName();
return;
}
}
}
}
public override void OnStateEnter(Animator animator, AnimatorStateInfo animatorStateInfo, int layerIndex)
{
TargetActor = animator.GetComponentInParent<NonPlayer>();
if (TargetActor.AI.CURRENT_AI_STATE == eStateType.STATE_SPECIAL)
{
TargetActor.AI.IS_SKILL = true;
bIsAttack = false;
CurTime = 0f;
}
TargetObject = (BaseObject)(TargetActor.GetData(ConstValue.ActorData_GetTarget));
Vector3 targetPos = TargetObject.SelfTransform.position;
SelfPos = TargetActor.SelfTransform.position;
Vector3 norPos = (SelfPos - targetPos).normalized * 2f;
TargetPos = targetPos + norPos;
}
private void RenderMarker(RenderContext context, Point pos, NonPlayer npc)
{
var tileSize = TileSize;
Color markerColor;
var marker = NpcMarker(npc, out markerColor);
if (!string.IsNullOrEmpty(marker))
{
var screen = GameToScreen(new Vector2(pos.X, pos.Y - 0.5f));
var opacity = 1.0f;
var now = DateTime.Now;
if (_lastStamp == null || (now - _lastStamp.Value).TotalMilliseconds >= SignPeriodInMs * 2)
{
_lastStamp = now;
}
else
{
var passed = (now - _lastStamp.Value).TotalMilliseconds;
if (passed >= SignPeriodInMs * 2)
{
_lastStamp = now;
}
else if (passed >= SignPeriodInMs)
{
opacity = 0.5f + 0.5f * (float)(passed - SignPeriodInMs) / SignPeriodInMs;
}
else
{
opacity = 1.0f - 0.5f * (float)(passed) / SignPeriodInMs;
}
}
var font = Font;
var measureSize = font.MeasureString(marker);
var x = screen.X + (tileSize.X - measureSize.X) / 2;
var y = screen.Y + (tileSize.Y - measureSize.Y) / 2 - 8;
context.DrawString(font, marker, new Vector2(x, y), markerColor * opacity);
}
}
private int deltaHp(NonPlayer npc)
{
int hp;
if (npc.Constitution > 20)
{
hp = Convert.ToInt32(npc.MaxHitPoints * 0.08);
}
else if (npc.Constitution > 15)
{
hp = Convert.ToInt32(npc.MaxHitPoints * 0.05);
}
else
{
hp = Convert.ToInt32(npc.MaxHitPoints * 0.03);
}
return(hp);
}
private static string NpcMarker(NonPlayer npc, out Color color)
{
string result = null;
color = Color.White;
switch (npc.Info.CreatureType)
{
case CreatureType.Merchant:
result = "$";
color = Color.Gold;
break;
case CreatureType.Instructor:
result = "^";
break;
}
return(result);
}
public override string Execute(Player chr, string[] text)
{
if (text[1 - 1] == "talk")
{
if (text[2 - 1] != "to")
{
return("Who do you want to talk to?");
}
NonPlayer target = chr.Location.FindChar(text[3 - 1].ToLower());
if (target == null)
{
return("This person is not in this room.");
}
return(target.Talk(chr));
}
return("I don't understand this word");
}
public CombatRound Hit(NonPlayer mob)
{
var round = new CombatRound();
if (Server.Current.Random.Next(HitRoll) + 1 >= mob.Armor)
{
// hit
var damage = Server.Current.Random.Next(DamRoll) + 1;
mob.HitPoints -= damage;
// apply experience
ExperienceResolver.ApplyExperience(this, damage);
var damageAction = CombatHelper.GetDamageAction(mob, damage);
// player text
var playerText = string.Format("You {0} {1} for {2} damage!\n", damageAction.Singular, mob.Name, damage);
round.AddText(this, playerText, CombatTextType.Player);
// group text (excludes player)
var groupText = string.Format("{0} {1} {2}!\n", Forename, damageAction.Plural, mob.Name);
round.AddText(this, groupText, CombatTextType.Group);
}
else
{
var playerText = string.Format("You miss {0}!\n", mob.Name);
round.AddText(this, playerText, CombatTextType.Player);
var groupText = string.Format("{0} misses {1}!\n", Forename, mob.Name);
round.AddText(this, groupText, CombatTextType.Group);
}
// finally set some generic room text
round.AddText(null, string.Format("{0} is fighting {1}!\n", Forename, mob.Name), CombatTextType.Room);
return(round);
}
//handle the attack that is SendToAll on the server itself
void handleAttack(int id, int attackId, int targetTileX, int targetTileY, int result)
{
VRAR_Tile tile = GameStateManager.instance.getCurrentLevel().getTileFromIndexPos(targetTileX, targetTileY);
NonPlayer npc = tile.getNPC();
if (npc != null)
{
npc.DecreaseHealth(result);
}
else //if there is no npc check if there is a player
{
foreach (BasePlayer player in players.Values)
{
if (player.GetCurrentTile() == tile)
{
//the player died ! move them to their spawn location
player.DecreaseHealth(result);
print("hit player but no teleport stuff implemented on server");
/*if (player.DecreaseHealth(result))
* {
* //After a player died we have to go through all the players again and make sure all their positios are ok
* //first the local player and then the external players
* TileRenderer.instance.teleportLocalPlayer(GamePlayManagerAR.instance.localPlayer.GetCurrentVec().x, GamePlayManagerAR.instance.localPlayer.GetCurrentVec().y);
* foreach (BasePlayer moreplayers in players.Values)
* {
* if (moreplayers != GamePlayManagerAR.instance.localPlayer)
* {
* TileRenderer.instance.teleportExternalPlayer(moreplayers);
* }
* }
*
* }*/
}
}
}
}
public override Map LoadItem(Module module, string id, ObjectData data)
{
var dataObj = data.Data;
if (module.Dungeons.ContainsKey(id))
{
RaiseError("There's already MapTemplate with id '{0}'", id);
}
var map = new Map(dataObj.EnsurePoint("Size"))
{
Local = dataObj.EnsureBool("Local")
};
map.Name = dataObj.EnsureString("Name");
map.Explored = dataObj.OptionalBool("Explored", false);
map.Light = dataObj.OptionalBool("Light", false);
if (map.Explored)
{
foreach (var tile in map.GetAllCells())
{
tile.IsExplored = true;
}
}
var legend = new Dictionary <char, object>();
var legendObject = dataObj.EnsureJObject(LegendName);
foreach (var pair in legendObject)
{
if (string.IsNullOrEmpty(pair.Key))
{
RaiseError("Map legend item id could not be empty.");
}
if (pair.Key.Length != 1)
{
RaiseError("Map legend item id {0} could consist only from single symbol.'", pair.Key);
}
var symbol = pair.Key[0];
if (ForbiddenLegendItems.IndexOf(symbol) != -1)
{
RaiseError("Symbol '{0}' can't be used in legend.", symbol);
}
object item = null;
var asValue = pair.Value as JValue;
if (asValue != null)
{
// Spawn
item = new SpawnSpot();
}
else
{
var obj = (JObject)pair.Value;
do
{
var tileInfoId = obj.OptionalString(TileInfoIdName);
if (!string.IsNullOrEmpty(tileInfoId))
{
item = module.TileInfos.Ensure(tileInfoId);
break;
}
var tileObjectId = obj.OptionalString(TileObjectIdName);
if (!string.IsNullOrEmpty(tileObjectId))
{
item = module.TileObjects.Ensure(tileObjectId);
break;
}
var creatureInfoId = obj.OptionalString(CreatureInfoIdName);
if (!string.IsNullOrEmpty(creatureInfoId))
{
item = module.CreatureInfos.Ensure(creatureInfoId);
break;
}
}while (false);
}
legend[symbol] = item;
}
var dataObject = dataObj.EnsureJArray(DataName);
var pos = Point.Zero;
var entities = new List <Tuple <object, Point> >();
for (var i = 0; i < dataObject.Count; ++i)
{
var lineToken = dataObject[i];
var line = lineToken.ToString();
pos.X = 0;
for (var j = 0; j < line.Length; ++j)
{
Tile lastTile = null;
if (pos.X > 0)
{
lastTile = map[pos.X - 1, pos.Y];
}
var symbol = line[j];
object item;
if (symbol == '{')
{
// Exit
var sb = new StringBuilder();
++j;
var hasEnd = false;
for (; j < line.Length; ++j)
{
symbol = line[j];
if (symbol == '}')
{
hasEnd = true;
break;
}
sb.Append(symbol);
}
if (!hasEnd)
{
RaiseError("Exit sequence lacks closing curly bracket.");
}
if (lastTile == null)
{
RaiseError("Last tile is null.");
}
lastTile.Exit = Exit.FromString(sb.ToString());
continue;
}
if (symbol == '[')
{
// Exit
var sb = new StringBuilder();
++j;
var hasEnd = false;
for (; j < line.Length; ++j)
{
symbol = line[j];
if (symbol == ']')
{
hasEnd = true;
break;
}
sb.Append(symbol);
}
if (!hasEnd)
{
RaiseError("Sign sequence lacks closing square bracket.");
}
if (lastTile == null)
{
RaiseError("Last tile is null.");
}
lastTile.Sign = sb.ToString();
continue;
}
if (!legend.TryGetValue(symbol, out item))
{
RaiseError("Unknown symbol '{0}'.", symbol);
}
if (item is SpawnSpot)
{
map.SpawnSpot = lastTile.Position;
continue;
}
var asCreatureInfo = item as CreatureInfo;
if (asCreatureInfo != null)
{
var npc = new NonPlayer(asCreatureInfo);
entities.Add(new Tuple <object, Point>(npc, lastTile.Position));
continue;
}
var asObjectInfo = item as TileObject;
if (asObjectInfo != null)
{
entities.Add(new Tuple <object, Point>(asObjectInfo, lastTile.Position));
continue;
}
var asTileInfo = item as TileInfo;
if (asTileInfo != null)
{
map[pos].Info = asTileInfo;
}
++pos.X;
}
++pos.Y;
}
// Place entities
foreach (var entity in entities)
{
var asObjectInfo = entity.Item1 as TileObject;
if (asObjectInfo != null)
{
map[entity.Item2].Object = asObjectInfo;
continue;
}
var asCreature = entity.Item1 as Creature;
if (asCreature != null)
{
asCreature.Place(map, entity.Item2);
continue;
}
}
return(map);
}
public Player CreatePlayer(int id, CreatePlayerInfo create_info, bool self, Vector3 pos, float dir, PlayerTransferInfo transfer_info = null, PlayerLoader.OnCompleteLoad callback = null)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
if (create_info.charaInfo == null)
{
Log.Error("StageObjectManager.CreatePlayer() charaInfo is NULL");
return(null);
}
GameObject val = new GameObject();
val.set_name("Player:" + id);
val.get_transform().set_parent(base._transform);
int num = 0;
if (create_info.extentionInfo != null)
{
num = create_info.extentionInfo.npcDataID;
}
bool flag = num > 0;
Player player;
if (self)
{
player = val.AddComponent <Self>();
if (MonoBehaviourSingleton <InGameCameraManager> .IsValid())
{
MonoBehaviourSingleton <InGameCameraManager> .I.target = player._transform;
}
}
else if (flag)
{
player = val.AddComponent <NonPlayer>();
NonPlayer nonPlayer = player as NonPlayer;
nonPlayer.npcId = num;
if (Singleton <NPCTable> .IsValid())
{
nonPlayer.npcTableData = Singleton <NPCTable> .I.GetNPCData(num);
}
nonPlayer.lv = create_info.extentionInfo.npcLv;
nonPlayer.lv_index = create_info.extentionInfo.npcLvIndex;
}
else
{
player = val.AddComponent <Player>();
}
player.id = id;
player._transform.set_position(pos);
player._transform.set_eulerAngles(new Vector3(0f, dir, 0f));
player.SetState(create_info, transfer_info);
if (MonoBehaviourSingleton <InGameRecorder> .IsValid())
{
int userId = create_info.charaInfo.userId;
InGameRecorder.PlayerRecord playerRecord = player.record = MonoBehaviourSingleton <InGameRecorder> .I.GetPlayer(id, userId);
playerRecord.isSelf = self;
playerRecord.isNPC = flag;
playerRecord.charaInfo = create_info.charaInfo;
playerRecord.beforeLevel = create_info.charaInfo.level;
}
if (self)
{
player.AddController <SelfController>();
}
else if (flag)
{
player.AddController <NpcController>();
}
if (MonoBehaviourSingleton <InGameSettingsManager> .IsValid())
{
EffectPlayProcessor component = MonoBehaviourSingleton <InGameSettingsManager> .I.get_gameObject().GetComponent <EffectPlayProcessor>();
if (component != null && component.effectSettings != null)
{
player.effectPlayProcessor = val.AddComponent <EffectPlayProcessor>();
player.effectPlayProcessor.effectSettings = component.effectSettings;
}
}
PlayerLoadInfo playerLoadInfo = new PlayerLoadInfo();
if (player.weaponData != null)
{
playerLoadInfo.SetEquipWeapon(create_info.charaInfo.sex, (uint)player.weaponData.eId);
}
playerLoadInfo.Apply(create_info.charaInfo, false, true, true, true);
player.Load(playerLoadInfo, callback);
player.OnSetPlayerStatus(create_info.charaInfo.level, create_info.charaInfo.atk, create_info.charaInfo.def, create_info.charaInfo.hp, false, transfer_info);
player.StartFieldBuff(MonoBehaviourSingleton <FieldManager> .IsValid() ? MonoBehaviourSingleton <FieldManager> .I.currentFieldBuffId : 0);
return(player);
}
public Player CreateNonPlayer(int id, CreatePlayerInfo.ExtentionInfo extention_info, Vector3 pos, float dir, PlayerTransferInfo transfer_info = null, PlayerLoader.OnCompleteLoad callback = null)
{
//IL_0237: Unknown result type (might be due to invalid IL or missing references)
CreatePlayerInfo createPlayerInfo = new CreatePlayerInfo();
createPlayerInfo.charaInfo = new CharaInfo();
bool flag = QuestManager.IsValidInGame() && MonoBehaviourSingleton <QuestManager> .I.GetVorgonQuestType() != QuestManager.VorgonQuetType.NONE;
bool flag2 = false;
if (extention_info != null)
{
createPlayerInfo.extentionInfo = extention_info;
}
else
{
createPlayerInfo.extentionInfo = new CreatePlayerInfo.ExtentionInfo();
flag2 = true;
}
NPCTable.NPCData nPCData = null;
if (flag2)
{
List <int> list = new List <int>();
int i = 0;
for (int count = nonplayerList.Count; i < count; i++)
{
NonPlayer nonPlayer = nonplayerList[i] as NonPlayer;
if (nonPlayer != null)
{
list.Add(nonPlayer.npcId);
}
}
nPCData = Singleton <NPCTable> .I.GetNPCDataRandom(NPCTable.NPC_TYPE.FIGURE, list);
if (nPCData != null)
{
createPlayerInfo.extentionInfo.npcDataID = nPCData.id;
}
}
else
{
nPCData = Singleton <NPCTable> .I.GetNPCData(createPlayerInfo.extentionInfo.npcDataID);
}
if (flag)
{
int npc_id = VorgonPreEventController.NPC_ID_LIST[id % 3];
nPCData = Singleton <NPCTable> .I.GetNPCData(npc_id);
}
if (nPCData == null)
{
return(null);
}
nPCData.CopyCharaInfo(createPlayerInfo.charaInfo);
NpcLevelTable.NpcLevelData npcLevelData = null;
if (flag2)
{
int lv = 1;
if (QuestManager.IsValidInGame() && MonoBehaviourSingleton <QuestManager> .I.GetCurrentQuestEnemyID() > 0)
{
lv = MonoBehaviourSingleton <QuestManager> .I.GetCurrentQuestEnemyLv();
}
if (flag)
{
lv = 80;
}
npcLevelData = Singleton <NpcLevelTable> .I.GetNpcLevelRandom((uint)lv);
if (npcLevelData != null)
{
createPlayerInfo.extentionInfo.npcLv = (int)npcLevelData.lv;
createPlayerInfo.extentionInfo.npcLvIndex = npcLevelData.lvIndex;
}
}
else
{
npcLevelData = Singleton <NpcLevelTable> .I.GetNpcLevel((uint)createPlayerInfo.extentionInfo.npcLv, createPlayerInfo.extentionInfo.npcLvIndex);
}
if (npcLevelData == null)
{
return(null);
}
npcLevelData.CopyHomeCharaInfo(createPlayerInfo.charaInfo, (!flag2) ? null : createPlayerInfo.extentionInfo);
if (flag)
{
for (int j = 0; j < createPlayerInfo.charaInfo.equipSet.Count; j++)
{
createPlayerInfo.charaInfo.equipSet[j].eId = VorgonPreEventController.NPC_WEAPON_ID_LIST[id % 3];
}
}
return(CreatePlayer(id, createPlayerInfo, false, pos, dir, transfer_info, callback));
}
public Combat FindFight(NonPlayer npc)
{
return(Fights.FirstOrDefault(f => f.GetMobs().Contains(npc)));
}
public void RemoveFromCombat(NonPlayer npc)
{
mobs.Remove(npc);
}
public void setNPC(NonPlayer npc)
{
_npc = npc;
setDirty();
}
public void setNPC(NonPlayer npc)
{
_npc = npc;
}
