// data this model uses
//private ProtoCharacterData m_data;
//public ProtoCharacterData GetData() {
// return m_data;
//}
//////////////////////////////////////////
/// Awake()
//////////////////////////////////////////
void Awake()
{
// init data asap
if (Name == "Goblin")
{
ProtoCharacterData data = IDL_ProtoCharacters.GetCharacter(Name);
// set various things
SetProperty("HP", data.HP);
SetProperty("Abilities", data.Abilities);
SetProperty("Name", data.Name);
}
else
{
// load the player's data
PlayerData data = PlayerLoader.LoadPlayer();
SetProperty("HP", data.GetMaxHP());
SetProperty("Name", data.Name);
SetProperty("Abilities", data.GetAbilities());
}
SetProperty("Effects", new Dictionary <string, Effect>());
// listen for messages
ListenForMessages(true);
}
public void CorrectPlayerLoadingTest()
{
var res = PlayerLoader.LoadFromDLL(TestingDLLs + "ExistingPlayersDLL");
Assert.NotNull(res);
Assert.AreEqual(3, res.Length);
}
public void Spawn(double x, double y)//cria o Player na tela
{
box = new PlayableSolid(x, y, Matriz.scale, Matriz.scale * 2, Run);
_PlayerLoader = new PlayerLoader(box, Id);
_PlayerLoader.Load(parts, sides);
box.MyEnt = this;
}
public static int Main(string[] argv)
{
ConsoleMessages.SendGreetings();
if (argv.Length != 1)
{
return(ConsoleMessages.SendError(1, "unexcpected amount of arguments; please pass only one path"));
}
var players = PlayerLoader.LoadFromDLL(argv[0]);
if (players == null)
{
return(ConsoleMessages.SendError(-1, $"could not load .dll from the given path: {argv[0]}"));
}
StandartDealer dealer = new();
int initialStack = 40000;
int roundsPerGame = 40;
int gameCycles = 1000;
foreach (var player in players)
{
StatCollector.RunBlackjackGame(dealer, player, player.GetType().ToString(),
initialStack, roundsPerGame, gameCycles).PrintMainData(Console.OpenStandardOutput());
Console.WriteLine();
}
return(0);
}
private void Init(UITexture ui_tex, float fov, LOADER_TYPE loader_type = LOADER_TYPE.ITEM)
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
if (model == null)
{
uiTexture = ui_tex;
uiRenderTexture = UIRenderTexture.Get(ui_tex, fov, false, -1);
model = Utility.CreateGameObject("UIModel", uiRenderTexture.modelTransform, uiRenderTexture.renderLayer);
switch (loader_type)
{
case LOADER_TYPE.PLAYER:
playerLoader = model.get_gameObject().AddComponent <PlayerLoader>();
break;
case LOADER_TYPE.NPC:
npcLoader = model.get_gameObject().AddComponent <NPCLoader>();
break;
case LOADER_TYPE.ITEM:
itemLoader = model.get_gameObject().AddComponent <ItemLoader>();
break;
case LOADER_TYPE.ENEMY:
enemyLoader = model.get_gameObject().AddComponent <EnemyLoader>();
break;
}
modelLayer = uiRenderTexture.renderLayer;
}
}
public void TestModReinstantiation()
{
TestPlayer player = null;
TestMod gameMod = null;
TestMod playerMod1 = null;
TestMod playerMod2 = null;
AddStep("load player", () =>
{
Mods.Value = new[] { gameMod = new TestMod() };
stack.Push(loader = new PlayerLoader(() => player = new TestPlayer()));
});
AddUntilStep("wait for loader to become current", () => loader.IsCurrentScreen());
AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
AddStep("retrieve mods", () => playerMod1 = (TestMod)player.Mods.Value.Single());
AddAssert("game mods not applied", () => gameMod.Applied == false);
AddAssert("player mods applied", () => playerMod1.Applied);
AddStep("restart player", () =>
{
var lastPlayer = player;
player = null;
lastPlayer.Restart();
});
AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
AddStep("retrieve mods", () => playerMod2 = (TestMod)player.Mods.Value.Single());
AddAssert("game mods not applied", () => gameMod.Applied == false);
AddAssert("player has different mods", () => playerMod1 != playerMod2);
AddAssert("player mods applied", () => playerMod2.Applied);
}
private IEnumerator DoLoadHelm(EquipItemTable.EquipItemData data)
{
EquipModelTable.Data model_data = data.GetModelData(sexID);
LoadObject lo_head = loadingQueue.LoadAndInstantiate(RESOURCE_CATEGORY.PLAYER_HEAD, ResourceName.GetPlayerHead(data.GetModelID(sexID)));
LoadObject lo_face = null;
if (model_data.needFace)
{
lo_face = loadingQueue.LoadAndInstantiate(RESOURCE_CATEGORY.PLAYER_FACE, ResourceName.GetPlayerFace(faceModelID));
}
yield return((object)loadingQueue.Wait());
Transform head = lo_head.Realizes(_transform, _transform.get_gameObject().get_layer());
head.set_localPosition(Vector3.get_zero());
head.set_localRotation(Quaternion.get_identity());
PlayerLoader.SetEquipColor(head, NGUIMath.IntToColor(data.modelColor0));
nodeMain = head;
yield return((object)this.StartCoroutine(InitRoopEffect(loadingQueue, head, SHADER_TYPE.NORMAL)));
if (lo_face != null)
{
Transform face = lo_face.Realizes(head, _transform.get_gameObject().get_layer());
_SetMannequinMaterial(face);
}
displayInfo = MonoBehaviourSingleton <GlobalSettingsManager> .I.uiModelRendering.helmDisplayInfo;
OnLoadFinished();
}
public PlayerView()
{
this.Players = new ObservableCollection <PlayerViewModel>();
this.InitializeComponent();
this.DataContext = this;
this.Loaded += delegate
{
if (!this.registered)
{
for (DependencyObject obj = this; obj != null; obj = LogicalTreeHelper.GetParent(obj))
{
MainWindow window = obj as MainWindow;
if (window != null)
{
window.RegisterForSeasonChanges(
delegate(FanastySeason season)
{
var players = new PlayerLoader(season);
this.Dispatcher.BeginInvoke(
new Action <IEnumerable <PlayerViewModel> >(this.Refresh),
players.GetViewModels());
});
this.registered = true;
break;
}
}
}
};
}
private void PlayerController_PlayerLoading(object sender, PlayerLoader e)
{
e.Loader = e.Loader
.Include(p => p.Units).ThenInclude(u => u.Equips)
.Include(p => p.Teams)
.Include(p => p.Formations);
}
private void load(OsuGameBase game)
{
Beatmap.Value = new DummyWorkingBeatmap(game);
AddStep("load dummy beatmap", () => Add(loader = new PlayerLoader(() => new Player
{
AllowPause = false,
AllowLeadIn = false,
AllowResults = false,
})));
AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
AddUntilStep(() => !loader.IsCurrentScreen, "wait for no longer current");
AddStep("load slow dummy beatmap", () =>
{
SlowLoadPlayer slow = null;
Add(loader = new PlayerLoader(() => slow = new SlowLoadPlayer
{
AllowPause = false,
AllowLeadIn = false,
AllowResults = false,
}));
Scheduler.AddDelayed(() => slow.Ready = true, 5000);
});
AddUntilStep(() => !loader.IsCurrentScreen, "wait for no longer current");
}
public ModelLoaderBase LoadModel(GameObject go, bool need_shadow, bool enable_light_probe, Action <Animator> on_complete, bool useSpecialModel)
{
if (IsUsePlayerModel())
{
PlayerLoader loader = go.AddComponent <PlayerLoader>();
PlayerLoadInfo player_load_info = CreatePlayerLoadInfo();
loader.StartLoad(player_load_info, go.get_layer(), 99, false, false, need_shadow, enable_light_probe, false, false, FieldManager.IsValidInField(), true, (!enable_light_probe) ? SHADER_TYPE.UI : ShaderGlobal.GetCharacterShaderType(), delegate
{
if (on_complete != null)
{
on_complete(loader.animator);
}
}, true, -1);
return(loader);
}
NPCLoader loader2 = go.AddComponent <NPCLoader>();
HomeThemeTable.HomeThemeData homeThemeData = Singleton <HomeThemeTable> .I.GetHomeThemeData(TimeManager.GetNow());
int num = Singleton <HomeThemeTable> .I.GetNpcModelID(homeThemeData, id);
int num2 = (num <= 0) ? specialModelID : num;
int npc_model_id = (!useSpecialModel || num2 <= 0) ? npcModelID : num2;
loader2.Load(npc_model_id, go.get_layer(), need_shadow, enable_light_probe, (!enable_light_probe) ? SHADER_TYPE.UI : ShaderGlobal.GetCharacterShaderType(), delegate
{
if (on_complete != null)
{
on_complete(loader2.animator);
}
});
return(loader2);
}
public void NoPlayersLoadingTest()
{
var res = PlayerLoader.LoadFromDLL(TestingDLLs + "NoPlayersDLL");
Assert.NotNull(res);
Assert.AreEqual(0, res.Length);
}
private void load(OsuGameBase game)
{
Beatmap.Value = new DummyWorkingBeatmap(game);
AddStep("load dummy beatmap", () => stack.Push(loader = new PlayerLoader(() => new Player(false, false))));
AddUntilStep("wait for current", () => loader.IsCurrentScreen());
AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
AddUntilStep("wait for no longer current", () => !loader.IsCurrentScreen());
AddStep("exit loader", () => loader.Exit());
AddUntilStep("wait for no longer alive", () => !loader.IsAlive);
AddStep("load slow dummy beatmap", () =>
{
SlowLoadPlayer slow = null;
stack.Push(loader = new PlayerLoader(() => slow = new SlowLoadPlayer(false, false)));
Scheduler.AddDelayed(() => slow.Ready = true, 5000);
});
AddUntilStep("wait for no longer current", () => !loader.IsCurrentScreen());
}
private void PlayerController_PlayerLoading(object sender, PlayerLoader e)
{
e.Loader = e.Loader
.Include(x => x.FriendList)
.ThenInclude(fl => fl.Friends)
.Include(x => x.FriendList)
.ThenInclude(fl => fl.FriendApplications);
}
public void Run()
{
//Load Scene
//Put character in it
PlayerLoader.LoadMain(0, 0);
SceneManager.LoadScene(SceneName);
SceneManager.sceneLoaded += SceneLoaded;
}
private IEnumerator DoLoad(int npc_model_id, int layer, bool need_shadow, bool enable_light_probes, SHADER_TYPE shader_type, Action callback)
{
loadingQueue = new LoadingQueue(this);
string model_name = ResourceName.GetNPCModel(npc_model_id);
LoadObject lo_model = loadingQueue.LoadAndInstantiate(RESOURCE_CATEGORY.NPC_MODEL, model_name);
string anim_name = ResourceName.GetNPCAnim(npc_model_id);
LoadObject lo_anim = loadingQueue.Load(RESOURCE_CATEGORY.NPC_ANIM, anim_name, new string[1]
{
anim_name + "Ctrl"
}, false);
if (loadingQueue.IsLoading())
{
yield return((object)loadingQueue.Wait());
}
model = lo_model.Realizes(this.get_transform(), layer);
if (model != null)
{
head = Utility.Find(model, "Head");
facial = model.GetComponentInChildren <NPCFacial>();
if (facial != null)
{
facial.animNode = Utility.Find(model, "Face");
}
animator = model.GetComponentInChildren <Animator>();
if (lo_anim != null && animator != null)
{
animator.set_runtimeAnimatorController(lo_anim.loadedObjects[0].obj as RuntimeAnimatorController);
}
}
PlayerLoader.SetLightProbes(model, enable_light_probes);
renderers = model.GetComponentsInChildren <Renderer>();
int j = 0;
for (int i = renderers.Length; j < i; j++)
{
if (renderers[j] is SkinnedMeshRenderer)
{
(renderers[j] as SkinnedMeshRenderer).set_localBounds(BOUNDS);
}
}
switch (shader_type)
{
case SHADER_TYPE.LIGHTWEIGHT:
ShaderGlobal.ChangeWantLightweightShader(renderers);
break;
case SHADER_TYPE.UI:
ShaderGlobal.ChangeWantUIShader(renderers);
break;
}
if (need_shadow)
{
shadow = PlayerLoader.CreateShadow(this.get_transform(), true, -1, shader_type == SHADER_TYPE.LIGHTWEIGHT);
}
coroutine = null;
callback?.Invoke();
}
private IEnumerator DoLoadWeapon(EquipItemTable.EquipItemData data)
{
int modelID = data.GetModelID(sexID);
string name = ResourceName.GetPlayerWeapon(modelID);
byte highTex = 0;
if (MonoBehaviourSingleton <GlobalSettingsManager> .IsValid())
{
EquipModelHQTable hqTable = MonoBehaviourSingleton <GlobalSettingsManager> .I.equipModelHQTable;
highTex = hqTable.GetWeaponFlag(modelID);
}
LoadObject lo = loadingQueue.LoadAndInstantiate(RESOURCE_CATEGORY.PLAYER_WEAPON, name);
LoadObject lo_high_reso_tex = PlayerLoader.LoadHighResoTexs(loadingQueue, name, highTex);
yield return((object)loadingQueue.Wait());
Transform weapon = lo.Realizes(_transform, _transform.get_gameObject().get_layer());
weapon.set_localPosition(Vector3.get_zero());
weapon.set_localRotation(Quaternion.get_identity());
Renderer[] renderers = weapon.GetComponentsInChildren <Renderer>();
PlayerLoader.SetEquipColor3(renderers, NGUIMath.IntToColor(data.modelColor0), NGUIMath.IntToColor(data.modelColor1), NGUIMath.IntToColor(data.modelColor2));
Material materialR = null;
Material materialL = null;
int j = 0;
for (int i = renderers.Length; j < i; j++)
{
Renderer r = renderers[j];
if (r.get_name().EndsWith("_L"))
{
materialL = r.get_material();
nodeSub = r.get_transform();
}
else
{
materialR = r.get_material();
nodeMain = r.get_transform();
}
}
yield return((object)this.StartCoroutine(InitRoopEffect(loadingQueue, weapon, SHADER_TYPE.NORMAL)));
PlayerLoader.ApplyWeaponHighResoTexs(lo_high_reso_tex, highTex, materialR, materialL);
displayInfo = new GlobalSettingsManager.UIModelRenderingParam.DisplayInfo(MonoBehaviourSingleton <GlobalSettingsManager> .I.uiModelRendering.WeaponDisplayInfos[(int)data.type]);
if (data.id == 50020201 || data.id == 50020200)
{
displayInfo.mainPos = new Vector3(0f, 0f, -0.21f);
displayInfo.mainRot.x += 180f;
displayInfo.subRot.x += 180f;
}
if (data.id == 60020200 || data.id == 60020201 || data.id == 60020202)
{
displayInfo.mainPos = new Vector3(0f, 0f, 0f);
displayInfo.mainRot = new Vector3(-64.50903f, 93.68915f, -118.1268f);
}
OnLoadFinished();
}
private void InitializePlayer()
{
_player = PlayerLoader.GetPlayer() ?? _player;
_player.OnMoneyChanged += OnMoneyChanged;
_player.OnAchievementUnlocked += OnAchievementUnlocked;
OnMoneyChanged(this, EventArgs.Empty);
InitializeSkinToolStrip();
InitializeSkillsToolStrip();
StartNewGame();
}
protected override ModelLoaderBase LoadModel()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
lastTargetNPCID = -1;
sexType = MonoBehaviourSingleton <UserInfoManager> .I.userStatus.sex;
PlayerLoader playerLoader = this.get_gameObject().AddComponent <PlayerLoader>();
playerLoader.StartLoad(PlayerLoadInfo.FromUserStatus(false, true, -1), 8, 99, false, false, true, true, false, false, false, false, SHADER_TYPE.NORMAL, null, true, -1);
return(playerLoader);
}
// This does the saving a loading of player data - the current level.
public static void SavePlayer(PlayerLoader player)
{
BinaryFormatter formatter = new BinaryFormatter();
string path = Application.persistentDataPath + "/player.savefile"; //where the save file is
FileStream stream = new FileStream(path, FileMode.Create);
PlayerData saveData = new PlayerData(player);
// Insert data into the player.savefile
formatter.Serialize(stream, saveData);
stream.Close();
}
protected virtual void LoadModel()
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
SetRenderPlayerModel(transRoot, UI.TEX_MODEL, PlayerLoadInfo.FromCharaInfo(data, true, true, true, isVisualMode), PLAYER_ANIM_TYPE.GetStatus(data.sex), new Vector3(0f, -0.75f, 14f), new Vector3(0f, 180f, 0f), isVisualMode, delegate(PlayerLoader player_loader)
{
if (player_loader != null)
{
loader = player_loader;
}
});
}
private void DeleteModel()
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
DeleteRenderTexture((Enum)UI.TEX_ENEMY);
SetVisibleWidgetEffect(UI.TEX_ENEMY, null);
if (model != null)
{
Object.DestroyImmediate(model.get_gameObject());
model = null;
loader = null;
}
}
public void LoadPlayer(PlayerLoadInfo load_info)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
if (playerShadow == null)
{
playerShadow = PlayerLoader.CreateShadow(MonoBehaviourSingleton <StageManager> .I.stageObject, false, -1, false);
playerShadow.get_transform().set_position(parameter.playerPos + new Vector3(0f, 0.005f, 0f));
}
ShaderGlobal.lightProbe = false;
if (!(playerLoader != null) || !playerLoader.loadInfo.Equals(load_info))
{
if (renderTexture != null)
{
Object.DestroyImmediate(renderTexture);
}
renderTexture = UIRenderTexture.Get(uiTexture, -1f, true, -1);
renderTexture.Disable();
renderTexture.nearClipPlane = parameter.renderTextureNearClip;
int num = -1;
if (MonoBehaviourSingleton <OutGameSettingsManager> .IsValid())
{
num = ((!MonoBehaviourSingleton <OutGameSettingsManager> .I.statusScene.isChangeHairShader) ? (-1) : MonoBehaviourSingleton <UserInfoManager> .I.userStatus.hairColorId);
}
playerLoader = renderTexture.modelTransform.get_gameObject().AddComponent <PlayerLoader>();
PlayerLoader obj = playerLoader;
int use_hair_overlay = num;
obj.StartLoad(load_info, renderTexture.renderLayer, PLAYER_ANIM_TYPE.GetStatus(MonoBehaviourSingleton <UserInfoManager> .I.userStatus.sex), false, false, false, false, false, true, true, true, SHADER_TYPE.NORMAL, delegate
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
playerLoader.get_transform().set_position(parameter.playerPos);
playerLoader.get_transform().set_eulerAngles(new Vector3(0f, (viewMode != 0) ? parameter.avatarPlayerRot : parameter.playerRot, 0f));
if (MonoBehaviourSingleton <UserInfoManager> .IsValid())
{
UserStatus userStatus = MonoBehaviourSingleton <UserInfoManager> .I.userStatus;
float num2 = (userStatus.sex != 0) ? parameter.playerScaleFemale : parameter.playerScaleMale;
playerLoader.get_transform().set_localScale(playerLoader.get_transform().get_localScale().Mul(new Vector3(num2, num2, num2)));
}
renderTexture.Enable(0.25f);
}, true, use_hair_overlay);
}
}
private static PlayerLoader Load(HomePlayerCharacter chara, GameObject go, FriendCharaInfo chara_info, PlayerLoader.OnCompleteLoad callback)
{
PlayerLoader playerLoader = go.AddComponent <PlayerLoader>();
PlayerLoadInfo playerLoadInfo = new PlayerLoadInfo();
if (chara_info != null)
{
playerLoadInfo.Apply(chara_info, false, true, true, true);
chara.sexType = chara_info.sex;
}
else
{
int num = Random.Range(0, 2);
int face_type_id;
int hair_style_id;
if (num == 0)
{
int[] defaultHasManFaceIndexes = Singleton <AvatarTable> .I.defaultHasManFaceIndexes;
face_type_id = defaultHasManFaceIndexes[Random.Range(0, defaultHasManFaceIndexes.Length)];
int[] defaultHasManHeadIndexes = Singleton <AvatarTable> .I.defaultHasManHeadIndexes;
hair_style_id = defaultHasManHeadIndexes[Random.Range(0, defaultHasManHeadIndexes.Length)];
}
else
{
int[] defaultHasWomanFaceIndexes = Singleton <AvatarTable> .I.defaultHasWomanFaceIndexes;
face_type_id = defaultHasWomanFaceIndexes[Random.Range(0, defaultHasWomanFaceIndexes.Length)];
int[] defaultHasWomanHeadIndexes = Singleton <AvatarTable> .I.defaultHasWomanHeadIndexes;
hair_style_id = defaultHasWomanHeadIndexes[Random.Range(0, defaultHasWomanHeadIndexes.Length)];
}
int[] defaultHasSkinColorIndexes = Singleton <AvatarTable> .I.defaultHasSkinColorIndexes;
int skin_color_id = defaultHasSkinColorIndexes[Random.Range(0, defaultHasSkinColorIndexes.Length)];
int[] defaultHasHairColorIndexes = Singleton <AvatarTable> .I.defaultHasHairColorIndexes;
int hair_color_id = defaultHasHairColorIndexes[Random.Range(0, defaultHasHairColorIndexes.Length)];
playerLoadInfo.SetFace(num, face_type_id, skin_color_id);
playerLoadInfo.SetHair(num, hair_style_id, hair_color_id);
OutGameSettingsManager.HomeScene.RandomEquip randomEquip = MonoBehaviourSingleton <OutGameSettingsManager> .I.homeScene.randomEquip;
uint equip_body_item_id = (uint)Utility.Lot(randomEquip.bodys);
uint equip_head_item_id = (uint)Utility.Lot(randomEquip.helms);
uint equip_arm_item_id = (uint)Utility.Lot(randomEquip.arms);
uint equip_leg_item_id = (uint)Utility.Lot(randomEquip.legs);
playerLoadInfo.SetEquipBody(num, equip_body_item_id);
if (Random.Range(0, 4) != 0)
{
playerLoadInfo.SetEquipHead(num, equip_head_item_id);
}
playerLoadInfo.SetEquipArm(num, equip_arm_item_id);
playerLoadInfo.SetEquipLeg(num, equip_leg_item_id);
chara.sexType = num;
}
playerLoader.StartLoad(playerLoadInfo, 0, 99, false, false, true, true, false, false, true, true, SHADER_TYPE.NORMAL, callback, true, -1);
return(playerLoader);
}
public void LoadPlayersFrom_PlayerNotClass_SetsValidationError()
{
// arrange
var loader = new PlayerLoader();
// act
loader.LoadPlayersFrom(new List <Type> {
typeof(InterfacePlayer)
});
// assert
Assert.That(loader.ValidationErrors, Has.Exactly(1).EqualTo("BoardBots.Tests.InterfacePlayer is not a class"));
}
public void LoadPlayersFrom_NoParameterlessConstructor_SetsValidationError()
{
// arrange
var loader = new PlayerLoader();
// act
loader.LoadPlayersFrom(new List <Type> {
typeof(ComplexConstructorPlayer)
});
// assert
Assert.That(loader.ValidationErrors, Has.Exactly(1).EqualTo("BoardBots.Tests.ComplexConstructorPlayer does not have a parameterless constructor"));
}
public void LoadPlayersFrom_ConstructorThrowsException_SetsValidationError()
{
// arrange
var loader = new PlayerLoader();
// act
loader.LoadPlayersFrom(new List <Type> {
typeof(ExceptionalPlayer)
});
// assert
Assert.That(loader.ValidationErrors, Has.Exactly(1).EqualTo("BoardBots.Tests.ExceptionalPlayer threw an exception while loading: Can't load me, sucka!"));
}
public void LoadPlayersFrom_SingleTypeWithValidPlayer_ReturnsPlayer()
{
// arrange
// act
var players = new PlayerLoader().LoadPlayersFrom(new List <Type> {
typeof(Fakeplayer)
});
// assert
Assert.That(players.Count, Is.EqualTo(1));
Assert.That(players[0].GetType(), Is.EqualTo(typeof(Fakeplayer)));
}
// Start is called before the first frame update
void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
return;
}
_instance = this;
DontDestroyOnLoad(gameObject);
SceneManager.sceneLoaded += SceneManager_sceneLoaded;
}
private void init()
{
initialized=true;
playerLoader=GameObject.Find("GameController").GetComponent<PlayerLoader>();
level=playerLoader.getLevel();
experience=playerLoader.getExp();
maxExperience=playerLoader.getMaxExperience();
float scalar=experience/(float)maxExperience;
transform.localScale=new Vector3(normalScale.x*scalar, normalScale.y, normalScale.z);
levelNumber.text=""+level;
}
private PlayerLoader Load(LoungePlayer chara, GameObject go, CharaInfo chara_info, PlayerLoader.OnCompleteLoad callback)
{
PlayerLoader playerLoader = go.AddComponent <PlayerLoader>();
PlayerLoadInfo playerLoadInfo = new PlayerLoadInfo();
if (chara_info != null)
{
playerLoadInfo.Apply(chara_info, false, true, true, true);
chara.sexType = chara_info.sex;
}
playerLoader.StartLoad(playerLoadInfo, 8, 99, false, false, true, true, false, false, true, true, SHADER_TYPE.NORMAL, callback, true, -1);
return(playerLoader);
}
public void init()
{
loader=GameObject.Find("GameController").GetComponent<PlayerLoader>();
setButtonSprites();
}
