public TriggerAnimationInteraction(SpawnCommand p_command, Int32 p_parentID, Int32 p_commandIndex) : base(p_command, p_parentID, p_commandIndex)
{
InteractiveObject interactiveObject = Grid.FindInteractiveObject(m_targetSpawnID);
m_container = (interactiveObject as PrefabContainer);
m_parent = Grid.FindInteractiveObject(m_parentID);
}
public void Reload(PrefabContainer container)
{
container.preview = AssetPreview.GetAssetPreview(container.prefab);
EditorUtility.SetDirty(dataBase);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public ResAssetManager(ResourceManager manager)
{
mResMgr = manager;
for (int i = 0; i < (int)AssetsType.Count; i++)
{
prefabPool[i] = new PrefabContainer();
}
}
public override void RemapEntityIds(IMyEntityIdRemapContext remapContext)
{
base.RemapEntityIds(remapContext);
PrefabContainer.RemapEntityIds(remapContext);
BuildingObject.RemapEntityIds(remapContext);
foreach (var obj in BuildingQueue)
{
obj.RemapEntityIds(remapContext);
}
}
public void DeletePrefab(PrefabContainer container)
{
dataBase.prefabList.Remove(container);
if (selectObject.realObject.GetInstanceID() == container.prefab.GetInstanceID())
{
selectObject.SetToNull();
}
EditorUtility.SetDirty(dataBase);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public void SelectPrefab(PrefabContainer container)
{
string sceneName = EditorSceneManager.GetActiveScene().name;
if (sceneName.Equals("Level Editor") || sceneName.Equals("Region Editor"))
{
if (selectObject == null)
{
selectObject = new SceneObjectContainer();
}
selectObject.SetObjectInfo(container);
usingWalls = false;
rotationSide = 0;
}
else
{
Debug.Log("You can only edit level in at the level editor scenes");
}
}
public void UpdateTile(int x, int y)
{
DestroyTile(x, y);
int tileIndex = level.data.GetFloor(x, y);
PrefabContainer tilePrefab = ResourceManager.GetFloorPrefab(tileIndex);
tilePrefab.gameObject.name = string.Format("Floor Tile [{0}, {1}]", x, y);
tilePrefab.gameObject.transform.SetParent(level.transform);
tilePrefab.spriteRenderer.sortingLayerName = "Floor";
tilePrefab.isometricTransform.Init(level, IsometricTransform.ElementType.Tile);
tilePrefab.isometricTransform.coords = new Vector3Int(x, y, 0);
tilePrefab.orientableSprite.Init(level);
floorPrefabs[x, y] = tilePrefab;
}
public void UpdateWall(int x, int y, int z)
{
DestroyWall(x, y, z);
int wallIndex = level.data.GetWall(x, y, z);
int rotatedZ = level.transformer.RotateWallInsideTile(new Vector3Int(x, y, z)).z;
PrefabContainer wallRes = ResourceManager.GetWallPrefab(wallIndex, z);
wallRes.gameObject.name = string.Format("Wall [{0}, {1} {2}]", x, y, z);
wallRes.gameObject.transform.SetParent(level.transform);
wallRes.spriteRenderer.sortingLayerName = "Wall";
wallRes.isometricTransform.Init(level, IsometricTransform.ElementType.Wall);
wallRes.isometricTransform.coords = new Vector3Int(x, y, z);
wallRes.orientableSprite.Init(level);
wallPrefabs[x, y, z] = wallRes;
}
// Write this object into message-out
internal override void Write(BinaryWriter binaryWriter)
{
base.Write(binaryWriter);
// Is building
MyMwcLog.IfNetVerbose_AddToLog("IsBuilding: " + IsBuilding);
MyMwcMessageOut.WriteBool(IsBuilding, binaryWriter);
// Building time from start
MyMwcLog.IfNetVerbose_AddToLog("BuildingTimeFromStart: " + BuildingTimeFromStart);
MyMwcMessageOut.WriteInt32(BuildingTimeFromStart, binaryWriter);
// Prefab container
bool isPrefabContainerObjectBuilder = PrefabContainer != null;
MyMwcMessageOut.WriteBool(isPrefabContainerObjectBuilder, binaryWriter);
if (isPrefabContainerObjectBuilder)
{
PrefabContainer.Write(binaryWriter);
}
// Building queue
int countBuildingQueueObjects = BuildingQueue == null ? 0 : BuildingQueue.Count;
MyMwcLog.IfNetVerbose_AddToLog("CountBuildingQueueObjects: " + countBuildingQueueObjects);
MyMwcMessageOut.WriteInt32(countBuildingQueueObjects, binaryWriter);
for (int i = 0; i < countBuildingQueueObjects; i++)
{
BuildingQueue[i].Write(binaryWriter);
}
// Building object
bool isBuildingObjectObjectBuilder = BuildingObject != null;
MyMwcMessageOut.WriteBool(isBuildingObjectObjectBuilder, binaryWriter);
if (isBuildingObjectObjectBuilder)
{
BuildingObject.Write(binaryWriter);
}
}
public void UpdateItem(int x, int y)
{
DestroyTile(x, y);
Vector2Int itemData = level.data.GetItem(x, y);
int itemIndex = itemData[0];
int itemOrientation = itemData[1];
PrefabContainer itemPrefab = ResourceManager.GetItemPrefab(itemIndex, itemOrientation);
itemPrefab.gameObject.name = string.Format("Item Tile [{0}, {1}]", x, y);
itemPrefab.gameObject.transform.SetParent(level.transform);
itemPrefab.spriteRenderer.sortingLayerName = "Items";
itemPrefab.isometricTransform.Init(level, IsometricTransform.ElementType.Item);
itemPrefab.isometricTransform.coords = new Vector3Int(x, y, 0);
itemPrefab.orientableSprite.Init(level);
itemPrefabs[x, y] = itemPrefab;
}
private void Start()
{
// Initialize static members
if (fallenWreckageContainer == null)
{
fallenWreckageContainer = GameObject.Find("FallenWreckageContainer").transform;
}
if (prefabContainer == null)
{
prefabContainer = PrefabContainer.Instance;
}
if (timeManager == null)
{
timeManager = FindObjectOfType <TimeManager>();
}
rigidBody = GetComponent <Rigidbody>();
meshFilter = GetComponent <MeshFilter>();
Energy = Random.Range(MinimumEnergy, MaximumEnergy);
meshFilter.sharedMesh = prefabContainer.GetWreckageMesh(Energy);
const float velocityMultiplier = 0.1f;
Velocity = new Vector3(
-2 + Random.Range(-0.1f, 0.1f),
-2 + Random.Range(-0.1f, 0.1f),
2 + Random.Range(-0.1f, 0.1f)
) / SizeFactor * velocityMultiplier;
AngularVelocity = new Vector3(
2 * Random.Range(0.1f, 2f) * 2 - 1 + Random.Range(-1f, 1f),
2 * Random.Range(0.1f, 2f) * 2 - 1 + Random.Range(-1f, 1f),
2 * Random.Range(0.1f, 2f) * 2 - 1 + Random.Range(-1f, 1f)
) / SizeFactor * velocityMultiplier;
SetSpeed();
}
void Start()
{
Board = new Board(coordinator);
prefabContainer = GameObject.Find("PrefabContainer").GetComponent <PrefabContainer>();
List <GameObject> tilePrefabsList = prefabContainer.GetWithPrefix("tile");
tilePrefabs = new Dictionary <TileTypes, GameObject>();
foreach (GameObject obj in tilePrefabsList)
{
tilePrefabs.Add(obj.GetComponent <Tile>().Type, obj);
}
tileObjs = new Dictionary <HexCoords, Tile>();
unitPrefabs = new Dictionary <UnitTypes, GameObject>();
foreach (var unit in prefabContainer.GetWithPrefix("unit"))
{
unitPrefabs.Add(unit.GetComponent <Unit>().Type, unit);
}
roadPrefab = prefabContainer.Get("road");
boardCollider = GetComponent <BoxCollider>();
Board.GenerateMap();
GenerateTileObjs();
GenerateCollider();
}
// Read this object from message-in
internal override bool Read(BinaryReader binaryReader, EndPoint senderEndPoint, int gameVersion)
{
if (base.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
// Is building
bool?isBuilding = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isBuilding == null)
{
return(NetworkError());
}
IsBuilding = isBuilding.Value;
MyMwcLog.IfNetVerbose_AddToLog("IsBuilding: " + IsBuilding);
// Building time from start
int?buildingTimeFromStart = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (buildingTimeFromStart == null)
{
return(NetworkError());
}
BuildingTimeFromStart = buildingTimeFromStart.Value;
MyMwcLog.IfNetVerbose_AddToLog("BuildingTimeFromStart: " + BuildingTimeFromStart);
// Prefab container
bool?isPrefabContainer = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isPrefabContainer == null)
{
return(NetworkError());
}
if (isPrefabContainer.Value)
{
PrefabContainer = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_PrefabContainer;
if (PrefabContainer == null)
{
return(NetworkError());
}
if (PrefabContainer.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
PrefabContainer = null;
}
// Building queue
int?countBuildingQueueObjects = MyMwcMessageIn.ReadInt32Ex(binaryReader, senderEndPoint);
if (countBuildingQueueObjects == null)
{
return(NetworkError());
}
MyMwcLog.IfNetVerbose_AddToLog("CountBuildingQueueObjects: " + countBuildingQueueObjects);
BuildingQueue = new List <MyMwcObjectBuilder_ObjectToBuild>(countBuildingQueueObjects.Value);
for (int i = 0; i < countBuildingQueueObjects; i++)
{
MyMwcObjectBuilder_ObjectToBuild objectToBuild = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_ObjectToBuild;
if (objectToBuild == null)
{
return(NetworkError());
}
if (objectToBuild.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
BuildingQueue.Add(objectToBuild);
}
// Building object
bool?isBuildingObject = MyMwcMessageIn.ReadBoolEx(binaryReader, senderEndPoint);
if (isBuildingObject == null)
{
return(NetworkError());
}
if (isBuildingObject.Value)
{
BuildingObject = MyMwcObjectBuilder_Base.ReadAndCreateNewObject(binaryReader, senderEndPoint) as MyMwcObjectBuilder_ObjectToBuild;
if (BuildingObject == null)
{
return(NetworkError());
}
if (BuildingObject.Read(binaryReader, senderEndPoint, gameVersion) == false)
{
return(NetworkError());
}
}
else
{
BuildingObject = null;
}
return(true);
}
// Calls to the edit window of the prefab Container.
public void Edit(PrefabContainer container)
{
dataBase.ShowEditWindow(this, container);
}
public void AddPrefabToDataBase(PrefabContainer container)
{
dataBase.AddPrefab(container);
}
private void Awake()
{
s_Instance = FindObjectOfType <PrefabContainer>();
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
float squareBounds = 128;
float2x2 bounds = new float2x2
{
c0 = new float2(-squareBounds, -squareBounds),
c1 = new float2(squareBounds, squareBounds)
};
dstManager.AddComponentData(entity, new PhysicsStep
{
Gravity = PhysicsStep.Default.Gravity,
SimulationType = SimulationType.UnityPhysics,
SolverIterationCount = PhysicsStep.Default.SolverIterationCount,
ThreadCountHint = PhysicsStep.Default.ThreadCountHint
});
//Entity eventSystem = dstManager.CreateEntity();
//DynamicBuffer<EventBuffer> eventBuffer = dstManager.AddBuffer<EventBuffer>(eventSystem);
blobAssetStore = new BlobAssetStore();
GameObjectConversionSettings settings = GameObjectConversionSettings.FromWorld(World.DefaultGameObjectInjectionWorld, blobAssetStore);
// Create a prefab entity //
Entity prefabEntitySqGy = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabThing, settings);
Entity prefabEntityTree = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabTree, settings);
Entity prefabEntityFruit = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabFruit, settings);
Entity prefabEntityBubble = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabBubble, settings);
Entity prefabEntityGround = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabGround, settings);
Entity prefabEntityBlink = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabBlink, settings);
Entity prefabEntityBullet = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabBullet, settings);
Entity prefabEntityAntiGrav = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabAntiGrav, settings);
Entity prefabEntityGnat = GameObjectConversionUtility.ConvertGameObjectHierarchy(
MonoPrefabGnat, settings);
// Get it's collider //
BlobAssetReference <Unity.Physics.Collider> prefabColliderSqGy =
dstManager.GetComponentData <PhysicsCollider>(prefabEntitySqGy).Value;
BlobAssetReference <Unity.Physics.Collider> prefabColliderTree =
dstManager.GetComponentData <PhysicsCollider>(prefabEntityTree).Value;
BlobAssetReference <Unity.Physics.Collider> prefabColliderFruit =
dstManager.GetComponentData <PhysicsCollider>(prefabEntityFruit).Value;
BlobAssetReference <Unity.Physics.Collider> prefabColliderGnat =
dstManager.GetComponentData <PhysicsCollider>(prefabEntityGnat).Value;
// Store these in a unique component for other systems to use later /
PrefabContainer container = new PrefabContainer
{
prefabEntityCreature = prefabEntitySqGy,
prefabEntityFruit = prefabEntityFruit,
prefabEntityTree = prefabEntityTree,
prefabEntityBubble = prefabEntityBubble,
prefabColliderCreature = prefabColliderSqGy,
prefabColliderFruit = prefabColliderFruit,
prefabColliderTree = prefabColliderTree,
prefabEntityGround = prefabEntityGround,
prefabEntityBlink = prefabEntityBlink,
prefabEntityBullet = prefabEntityBullet,
prefabEntityAntiGrav = prefabEntityAntiGrav,
prefabEntityGnat = prefabEntityGnat,
prefabColliderGnat = prefabColliderGnat,
};
World.DefaultGameObjectInjectionWorld.GetOrCreateSystem <AntiGravBubbleSystem>().Prefab = prefabEntityAntiGrav;
Entity containerEntity = dstManager.CreateEntity();
dstManager.AddComponentData(containerEntity, container);
World.DefaultGameObjectInjectionWorld.GetOrCreateSystem <ThingSpawnerSystem>().SetSingleton(container);
TerrainBounds terrainBounds = new TerrainBounds {
Bounds = bounds
};
Entity tbEnt = dstManager.CreateEntity();
dstManager.AddComponentData(tbEnt, terrainBounds);
World.DefaultGameObjectInjectionWorld.GetOrCreateSystem <TerrainSpawnerSystem>().SetSingleton(terrainBounds);
Entity civ = dstManager.CreateEntity();
Debug.Log("Civ created - " + civ);
dstManager.AddComponentData(civ, new Civilization
{
});
dstManager.AddComponentData(civ, new Building
{
Civ = civ,
Type = TaskTargetType.None
});
dstManager.AddBuffer <CivBuildings>(civ);
dstManager.AddBuffer <CivTaskList>(civ);
dstManager.AddBuffer <ResourcesNeeded>(civ);
// VARIABLES //
int numOfCreats = 1;
int numOfThings = 0;
int numOfTrees = 500;
int spawnPerFrame = 1;
if (numOfCreats >= 500 || numOfThings >= 500)
{
spawnPerFrame = 25;
}
else if (numOfCreats >= 100 || numOfThings >= 100)
{
spawnPerFrame = 20;
}
// VARIABLES //
Entity creatureSpawnerEntity = dstManager.CreateEntity();
ThingSpawner creatureSpawner = new ThingSpawner
{
PrefabEntity = prefabEntityGnat,
ToSpawn = numOfCreats,
PrefabCollider = prefabColliderGnat,
ThingToSpawn = ThingType.Creature,
SpawnPerCycle = spawnPerFrame,
SpawnForCiv = civ,
MinMaxSpawnPositions = new float3x2
{
c0 = new float3
{
x = -128,
y = 2,
z = -128
},
c1 = new float3
{
x = 128,
y = 5,
z = 128
}
}
};
dstManager.AddComponentData(creatureSpawnerEntity, creatureSpawner);
Entity thingSpawnerEntity = dstManager.CreateEntity();
ThingSpawner thingSpawner = new ThingSpawner
{
PrefabEntity = prefabEntitySqGy,
ToSpawn = numOfThings,
PrefabCollider = prefabColliderSqGy,
ThingToSpawn = ThingType.SquareGuy,
SpawnPerCycle = spawnPerFrame,
SpawnForCiv = civ,
MinMaxSpawnPositions = new float3x2
{
c0 = new float3
{
x = -128,
y = 2,
z = -128
},
c1 = new float3
{
x = 128,
y = 5,
z = 128
}
}
};
dstManager.AddComponentData(thingSpawnerEntity, thingSpawner);
Entity terrainSpawnerEntity = dstManager.CreateEntity();
dstManager.AddComponentData(terrainSpawnerEntity, new TerrainSpawner
{
NumOfBubbles = 0,
NumOfTrees = numOfTrees,
TerrainBuilt = 0
});
}
void Start()
{
prefabContainer = GameObject.Find("PrefabContainer").GetComponent <PrefabContainer>();
stateMachine = StateMachine <PlayerStates> .Initialize(this, PlayerStates.Idle);
}