private void CreateFollowedField()
{
var levelRecord = ScriptableUtils.GetCurrentLevelRecord();
_followedField = Object.Instantiate(levelRecord.Field);
_followedField.SetPlayer(_player);
}
private void SpawnSingle()
{
var type = SpawnUtils.GetRandomSpawnEnemyType();
var poolManager = CoreManager.Instance.GetData <PoolManager>();
var common = ScriptableUtils.GetCommonElements();
var view = (CollisionView)poolManager.GetItem <EnemyType>((int)type);
var command = CommandFactory.GetAiCommand(type);
var model = EnemyFactory.GetEnemyModel(type, command);
var controller = new EnemyController(model, view, _player.transform, view.GetComponent <Rigidbody>());
var position =
SpawnUtils.GetRandomSpawnPosition(_player.transform, common.SpawnInnerRange, common.SpawnOutRange);
view.transform.position = position;
controller.PlayerCollision -= OnPlayerCollision;
controller.PlayerCollision += OnPlayerCollision;
controller.Die -= OnEnemyDie;
controller.Die += OnEnemyDie;
_enemy.Add(controller);
_count++;
}
public void Move(Rigidbody rigidbody, Vector3 direction)
{
var level = ScriptableUtils.GetLevelRecord();
_rigidbody = rigidbody;
_startPoint = rigidbody.transform.position;
_startPosX = _startPoint.x;
_disposable = Observable.EveryFixedUpdate().Subscribe(_ =>
{
if (_rigidbody == null || Disabled || Kicked)
{
return;
}
_rigidbody.MovePosition(transform.position + transform.forward * (Time.deltaTime * level.PlayerSpeed));
});
_disposable = Observable.EveryUpdate().Subscribe(_ =>
{
if (_rigidbody == null)
{
return;
}
if (_rigidbody.velocity.x > 0)
{
_rigidbody.velocity = new Vector3(0, _rigidbody.velocity.y, _rigidbody.velocity.z);
_rigidbody.transform.position = new Vector3(_startPosX, _rigidbody.transform.position.y, _rigidbody.transform.position.z);
}
});
}
private void HpChange(int currentHp)
{
var playerRecord = ScriptableUtils.GetCurrentPlayerRecord();
var percent = (float)currentHp / playerRecord.Health;
_hpBar.fillAmount = percent;
}
private void InvokeMasterSpawn()
{
var records = ScriptableUtils.GetSpawnObjects();
var random = records.GetRandomElement();
var index = records.IndexOf(random);
Spawn.SafeInvoke(index);
}
public SpawnManager()
{
var record = ScriptableUtils.GetLevelRecord();
_spawnDistance = record.SpawnDistance;
_spawnRange = record.SpawnRange;
_items = new List <GameObject>();
}
public EnvironmentSpawnManager(PlayerView player)
{
_player = player;
_environment = new List <EnvironmentController>();
_poolManager = new PoolManager();
_max = ScriptableUtils.GetCurrentLevelRecord().EnvironmentMax;
_disposable = new CompositeDisposable();
}
public EnemySpawnManager(Transform playerTransform)
{
_disposable = new CompositeDisposable();
_player = playerTransform;
_enemy = new List <EnemyController>();
_poolManager = new PoolManager();
_max = ScriptableUtils.GetCurrentLevelRecord().EnemyMax;
}
private void SpawnBot()
{
var common = ScriptableUtils.GetCommonElements();
var point = _center.z - common.RestrictionH / 2f;
var element1 = Object.Instantiate(common.RestrictionObject);
element1.transform.localScale = new Vector3(common.RestrictionH, 10, 10);
element1.transform.position = new Vector3(_center.x, _center.y, point);
}
private void SpawnRight()
{
var common = ScriptableUtils.GetCommonElements();
var point = _center.x - common.RestrictionW / 2f;
var element1 = Object.Instantiate(common.RestrictionObject);
element1.transform.localScale = new Vector3(10, 10, common.RestrictionW);
element1.transform.position = new Vector3(point, _center.y, _center.z);
}
private void InitProjectile()
{
var poolManager = CoreManager.Instance.GetData <PoolManager>();
var weapons = ScriptableUtils.GetWeaponRecords();
foreach (var item in weapons)
{
poolManager.RegisterPool <WeaponType>((int)item.Type, item.ProjectilePrefab, item.FireRate);
}
}
private void InitEnvironment()
{
var level = ScriptableUtils.GetCurrentLevelRecord();
var poolManager = CoreManager.Instance.GetData <PoolManager>();
var environment = ScriptableUtils.GetEnvironmentRecords();
foreach (var item in environment)
{
poolManager.RegisterPool <EnvironmentType>((int)item.Type, item.Prefab, level.EnvironmentMax);
}
}
public FieldGenerator(Vector3 startPosition)
{
_currentPosition = startPosition;
_renderComponents = new List <RoadView>();
var level = ScriptableUtils.GetLevelRecord();
_prefabDefault = level.FieldPrefabDefault;
_prefabStart = level.FieldPrefabStart;
_prefabFinish = level.FieldPrefabFinish;
_finishDistance = level.FinishDistance;
}
private void UpdateStartButtonState()
{
if (!PhotonNetwork.IsMasterClient)
{
return;
}
var level = ScriptableUtils.GetLevelRecord();
var value = PhotonNetwork.CurrentRoom.PlayerCount >= level.MinPlayersToStart;
_startButton.gameObject.SetActive(value);
}
private void OnShot(WeaponType weapon, int current)
{
if (_currentType != weapon)
{
return;
}
var record = ScriptableUtils.GetWeaponRecord(weapon);
var bullets = record.FireRate - current;
EnableBullets(bullets);
}
public override void OnPlayerEnteredRoom(Player newPlayer)
{
UpdateConnectedLabel();
UpdateStartButtonState();
Debug.Log("Player enter " + PhotonNetwork.CurrentRoom.PlayerCount + " " + MaxPlayers);
var level = ScriptableUtils.GetLevelRecord();
if (PhotonNetwork.CurrentRoom.PlayerCount >= level.MinPlayersToStart)
{
Debug.Log("Start timer");
StartTimer();
}
}
public GameMediator(LevelModel container)
{
_inputController = new InputController(container.Input);
var playerRecord = ScriptableUtils.GetCurrentPlayerRecord();
var playerModel = new PlayerModel(playerRecord);
_playerController = new PlayerController(playerModel);
var player = _playerController.GetView();
_fieldManager = new FieldManager(player);
Subscribe();
}
public static IWeapon GetWeapon(WeaponType type)
{
var record = ScriptableUtils.GetWeaponRecord(type);
switch (type)
{
case WeaponType.Cannon:
return(new Cannon(type, record));
case WeaponType.MachineGun:
return(new MachineGun(type, record));
}
return(null);
}
public static AbstractEnvironmentModel GetEnvironmentModel(EnvironmentType type)
{
var record = ScriptableUtils.GetEnvironmentRecord(type);
switch (type)
{
case EnvironmentType.Box:
return(new BoxModel(type, record));
case EnvironmentType.Tree:
return(new TreeModel(type, record));
}
return(null);
}
public void StartSpawn()
{
var common = ScriptableUtils.GetCommonElements();
Observable.Timer(TimeSpan.FromSeconds(common.EnemySpawnTime))
.Repeat()
.Subscribe(_ =>
{
if (_count >= _max)
{
return;
}
SpawnSingle();
}).AddTo(_disposable);
}
public static AbstractEnemyModel GetEnemyModel(EnemyType type, IAiCommand command)
{
var record = ScriptableUtils.GetEnemyRecord(type);
switch (type)
{
case EnemyType.Skeleton:
return(new SmartZombieModel(type, command, record));
case EnemyType.Zombie:
return(new ZombieModel(type, command, record));
}
return(null);
}
private void InitPlayer()
{
var playerRecord = ScriptableUtils.GetCurrentPlayerRecord();
var commonRecord = ScriptableUtils.GetCommonElements();
_view = Object.Instantiate(playerRecord.PlayerPrefab);
_view.ModelUpdate(_model);
var rigidbody = _view.GetComponent <Rigidbody>();
InitMoveComponent(rigidbody);
_cameraFollower = Object.Instantiate(commonRecord.Camera);
_cameraFollower.Init(_view.transform);
EventHolder <GameEventType> .Dispatcher.Broadcast(GameEventType.WeaponSwap, _model.CurrentWeapon());
}
public static IAiCommand GetAiCommand(EnemyType type)
{
var record = ScriptableUtils.GetEnemyRecord(type);
var cType = record.Command;
switch (cType)
{
case CommandType.TargetFollow:
return(new TargetFollow());
case CommandType.BlindSearch:
return(new BlindSearch());
}
return(null);
}
void Awake()
{
PhotonNetwork.AutomaticallySyncScene = true;
InitManagers();
_connectButton.onClick.AddListener(Connect);
_startButton.onClick.AddListener(StartGame);
var level = ScriptableUtils.GetLevelRecord();
_lobbyTimer = new LobbyTimer(level.StartTimer);
_lobbyTimer.OnTimerEnd += StartGame;
_lobbyTimer.SingleTick += LobbyTimerUpdate;
PhotonNetwork.AddCallbackTarget(photonView);
}
public void StartWatch()
{
var level = ScriptableUtils.GetLevelRecord();
_cameraSmooth = level.CameraSmooth;
_disposable = Observable.EveryUpdate().Subscribe(x =>
{
if (_head == null)
{
return;
}
var t = _head.transform.position;
var pos = new Vector3(transform.position.x, transform.position.y, t.z);
var vector = !_first ? Vector3.Lerp(transform.position, pos, Time.deltaTime * _cameraSmooth) : pos;
transform.position = vector;
_first = true;
});
}
public void OnEvent(EventData photonEvent)
{
if (photonEvent.Code == EventName.StartRun)
{
var data = (object[])photonEvent.CustomData;
var playersList = PhotonNetwork.CurrentRoom.Players.Values.ToList();
var player = playersList.FirstOrDefault(x => x.ActorNumber == PhotonNetwork.LocalPlayer.ActorNumber);
Debug.Log(PhotonNetwork.LocalPlayer.ActorNumber);
var playerSlotIndex = playersList.IndexOf(player);
var receivedGridIndex = (int)data[PhotonNetwork.LocalPlayer.ActorNumber];
StartRun(receivedGridIndex);
}
if (photonEvent.Code == EventName.SpawnElement)
{
var records = ScriptableUtils.GetSpawnObjects();
var index = (int)photonEvent.CustomData;
var data = records[index];
if (data.Type == SpawnObjectType.Arch || data.Type == SpawnObjectType.Wall)
{
if (PhotonNetwork.IsMasterClient)
{
_spawnManager.SpawnObject(data);
}
}
else
{
_spawnManager.SpawnBonus(data, _playerController.Component);
}
}
if (photonEvent.Code == EventName.Finish)
{
Debug.Log("Finish ");
var playerId = (int)photonEvent.CustomData;
OnFinish(playerId);
}
}
public static void AddTypeAsChild()
{
ScriptableUtils.AddAsChild <AssetGameEventListenerVector2>("EventListener - ");
}
public static EnvironmentType GetRandomSpawnEnvironmentType()
{
var levelRecord = ScriptableUtils.GetCurrentLevelRecord();
return(levelRecord.Environment.GetRandomElement());
}
public static void AddTypeAsChild()
{
ScriptableUtils.AddAsChild <MatchAmountVar>("MatchCount - ");
}
bool ShowAvailableTypes(SerializedProperty childProperty, Type baseType, bool allowBaseType, string featureName, string title)
{
Type[] types;
string[] typesStrings;
int currentTypeIndex;
if (!AcceptedTypes.TryGetValue(baseType.Name, out types) ||
!AcceptedTypesStrings.TryGetValue(baseType.Name, out typesStrings))
{
if (allowBaseType)
{
types = Assembly
.GetAssembly(baseType)
.GetTypes()
.Where(t => !t.IsAbstract &&
baseType.IsAssignableFrom(t))
.ToArray();
}
else
{
types = Assembly
.GetAssembly(baseType)
.GetTypes()
.Where(t => !t.IsAbstract &&
baseType.IsAssignableFrom(t) &&
t != baseType)
.ToArray();
}
typesStrings = new string[types.Length + 1];
typesStrings[0] = "-";
for (var i = 1; i < typesStrings.Length; ++i)
{
typesStrings[i] = types[i - 1].Name.Replace(baseType.Name, "");
if (string.IsNullOrEmpty(typesStrings[i]))
{
typesStrings[i] = "(Simple)";
}
if (IsExternal)
{
typesStrings[i] = "[External] " + typesStrings[i];
}
}
if (!AcceptedTypes.ContainsKey(baseType.Name))
{
AcceptedTypes.Add(baseType.Name, types);
}
else
{
AcceptedTypes[baseType.Name] = types;
}
if (!AcceptedTypesStrings.ContainsKey(baseType.Name))
{
AcceptedTypesStrings.Add(baseType.Name, typesStrings);
}
else
{
AcceptedTypesStrings.Add(baseType.Name, typesStrings);
}
}
currentTypeIndex = childProperty.objectReferenceValue ? Array.IndexOf(types, childProperty.objectReferenceValue.GetType()) + 1 : 0;
int newTypeIndex = EditorGUILayout.Popup(currentTypeIndex, typesStrings, GUILayout.MinWidth(150));
if (newTypeIndex != currentTypeIndex)
{
if (newTypeIndex > 0) // set value
{
--newTypeIndex;
if (IsExternal)
{
childProperty.objectReferenceValue = null;
Debug.Log("Broke reference to external asset, now creating embeded asset instead.");
}
if (childProperty.objectReferenceValue == null)
{
Undo.RecordObject(childProperty.serializedObject.targetObject, "CREATE_ASSET");
var name = childProperty.serializedObject.targetObject.name.Substring(childProperty.serializedObject.targetObject.name.LastIndexOf(" - ") + 3);
var headingName = (!string.IsNullOrEmpty(featureName) ? featureName + " - " : "") + title + " - ";
childProperty.objectReferenceValue = ScriptableUtils.AddAsChild(types[newTypeIndex], headingName + name, childProperty.serializedObject.targetObject, false);
FoldedEntries.Add(childProperty.objectReferenceValue, true);
}
else
{
FoldedEntries.Remove(childProperty.objectReferenceValue);
/*
* var name = childProperty.objectReferenceValue.name;
* AssetDatabase.RemoveObjectFromAsset(childProperty.objectReferenceValue);
* childProperty.objectReferenceValue = ScriptableUtils.AddAsChild(types[newTypeIndex], name, this.serializedObject.targetObject, false);
*/
Undo.RecordObject(childProperty.serializedObject.targetObject, "MODIFY_ASSET");
var newInstance = ScriptableObject.CreateInstance(types[newTypeIndex]);
MonoScript monoScript = MonoScript.FromScriptableObject(newInstance);
SerializedObject so = new SerializedObject(childProperty.objectReferenceValue);
SerializedProperty scriptProperty = so.FindProperty("m_Script");
so.Update();
scriptProperty.objectReferenceValue = monoScript;
so.ApplyModifiedProperties();
FoldedEntries.Add(so.targetObject, true);
}
}
else // unset value
{
if (IsExternal)
{
childProperty.objectReferenceValue = null;
Debug.LogError("Deletion blocked for external assets to prevent user error with side effects. Delete directly or use the ScriptableTools windows if needed.");
}
else
{
FoldedEntries.Remove(childProperty.objectReferenceValue);
Undo.RecordObject(childProperty.serializedObject.targetObject, "DELETE_ASSET");
AssetDatabase.RemoveObjectFromAsset(childProperty.objectReferenceValue);
Undo.RecordObject(childProperty.objectReferenceValue, "DELETE_ASSET");
UnityEngine.Object.DestroyImmediate(childProperty.objectReferenceValue);
childProperty.objectReferenceValue = null;
Debug.LogError("DELETED ASSET SUCCESSFULLY");
}
}
return(true);
}
return(false);
}
