public override AbilityTickable AbilityLogic(Vector2 target)
{
MovementTick movementTick = new GameObject().AddComponent <MovementTick>();
if (AttackOnArrival)
{
movementTick.Init(Owner, target, MovementSpeed, AttackRange, AttackDamage);
}
else
{
movementTick.Init(Owner, target, MovementSpeed);
}
return(movementTick);
}
protected override IEnumerator execute()
{
MatchEffectConfig deathPrefab = MatchEffects.GetConfig(this.effectPrefabName);
float deathDelay = AttackDelays.GetDelay(AttackDelays.DelayType.UnitDeath);
yield return(new WaitForSeconds(deathDelay));
MatchEffectsArea death = new GameObject(Constants.SE()).AddComponent <DeathEffectArea>();
death.Init(deathPrefab, this.card);
death.Play(null);
while (!death.get_Completed())
{
yield return(null);
}
if (this.postDeathCommand != null)
{
while (this.postDeathCommand.MoveNext())
{
yield return(this.postDeathCommand.Current);
}
}
Finder.FindOrThrow <CommandExecutor>().Execute(new DestroyEffectOnComplete(death));
yield break;
}
// Update is called once per frame
void Update()
{
currentTreeTime -= Time.deltaTime;
//GridManager.Singleton.TypeToDiffuse[typeof(Height)].FullDiffuse();
if (currentTreeTime <= 0)
{
currentTreeTime += TreeTime;
GridManager.Singleton.TypeToDiffuse[typeof(Tree)].FullDiffuse();
//mapGen.setTiles(GridManager.Singleton.TypeToDiffuse[typeof(Tree)].Grid, new Color(0.8f, 0.2f, 0.1f), new Color(0, 0, 1));
}
currentZonamiTime -= Time.deltaTime;
if (currentZonamiTime < 0)
{
currentZonamiTime += ZonamiTime;
var zonami = new GameObject().AddComponent <Zonami>();
zonami.Init(Random.Range(0, GridManager.Singleton.Width), Random.Range(0, GridManager.Singleton.Height));
GridManager.Singleton.TypeToDiffuse[typeof(Height)].AddEffect(zonami);
}
mapGen.updateMap(false);
}
public override void Init(string word, double duration)
{
transform.localPosition = Vector3.zero;
var width = 600f;
for (int i = 0; i < size; i++)
{
var l = new GameObject().AddComponent <BasicLine>();
l.transform.SetParent(transform);
// l.gameObject.layer = 14;
l.delay = Random.Range(0f, 0.5f);
l.duration = (1f - l.delay) * Random.Range(1f, 0.7f);
var y = Random.Range(-400, -550);
var x = -width + (width * 2f / (size - 1) * i) + Mathf.PerlinNoise(y * 0.1f, i * 0.1f) * 400 - 200f;
var endy = Random.Range(400, 600f);
l.start = new Vector3(x, y, 0) + transform.position;
l.end = new Vector3(x, endy, 0) + transform.position;
l.curveIn = AnimationCurveAsset.SteepIn;
l.curveOut = AnimationCurveAsset.HorizontalLineOut;
// l.gameObject.layer = 15;
lines.Add(l);
l.Init();
l.SetLineWidth(Random.Range(2, 10));
}
}
/// <summary>
/// Spawns the user interface screen.
/// </summary>
/// <returns>The user interface screen.</returns>
/// <param name="name">Name.</param>
/// <param name="doAddToStack">If set to <c>true</c> do add to stack.</param>
public GameObject SpawnUIScreen(string name, bool doAddToStack = true)
{
if (name == "GamePlay" || name == "GamePlay_help" || name == "GamePlay_hex")
{
if (WindowStack.Count > 0)
{
Destroy(WindowStack.Pop());
}
}
GameObject thisScreen = (GameObject)Instantiate(Resources.Load("UIScreens/" + name.ToString()));
thisScreen.name = name;
thisScreen.transform.SetParent(UICanvas.transform);
thisScreen.transform.localPosition = Vector3.zero;
thisScreen.transform.localScale = Vector3.one;
thisScreen.GetComponent <RectTransform> ().sizeDelta = Vector3.zero;
thisScreen.Init();
thisScreen.OnWindowLoad();
thisScreen.SetActive(true);
if (doAddToStack)
{
WindowStack.Push(thisScreen);
}
return(thisScreen);
}
/// <summary>
///
/// </summary>
/// <param name="fullUrl"></param>
/// <param name="toPath"></param>
/// <param name="useCache">如果存在则不下载了！</param>
/// <param name="expireDays"></param>
/// <param name="timeout"></param>
public static CHttpDownloader Load(string fullUrl, string toPath, bool useCache = false, int expireDays = 1, int timeout = 5)
{
var downloader = new GameObject("HttpDownlaoder+"+fullUrl).AddComponent<CHttpDownloader>();
downloader.Init(fullUrl, toPath, useCache, expireDays, timeout);
return downloader;
}
void Awake()
{
// Create board and player input
var boardController = new GameObject("BoardController").AddComponent <BoardController>();//Instantiate(_boardController, Vector3.zero, Quaternion.identity);
boardController.Init(_settings);
var playerInput = new GameObject("PlayerInput").AddComponent <PlayerInput>();
playerInput.TilesSelected += boardController.CheckSelectedTiles;
// Score UI
ScoreUIModel model = new ScoreUIModel();
boardController.ScoreChanged += (int score) => {
model.Value += score;
// End score
if (model.Value >= _settings.endScore)
{
Destroy(playerInput);
Instantiate(_endUI);
}
};
var view = Instantiate <ScoreUI>(_scoreView);
_scoreUIController = new ScoreUIController(model, view);
}
public static void Create()
{
var appodeal = new GameObject("AppodealController").AddComponent <AppodealController>();
appodeal.Init();
DontDestroyOnLoad(appodeal.gameObject);
}
void HandleRaceGameRequested()
{
OfflineGameRaceModeModule raceModule = new GameObject("RaceModule", typeof(OfflineGameRaceModeModule)).GetComponent <OfflineGameRaceModeModule>();
DontDestroyOnLoad(raceModule.gameObject);
raceModule.Init();
}
public override void Init(string word, double duration)
{
transform.localPosition = Vector3.zero;
for (int i = 0; i < size; i++)
{
var l = new GameObject().AddComponent <BasicLine>();
l.transform.SetParent(transform);
// l.gameObject.layer = 14;
l.delay = Random.Range(0f, 0.3f);
l.duration = Random.Range(0.5f, 0.7f);
var y = Random.Range(400, -400);
var x = Random.Range(-1200f, -800f);
var endx = Random.Range(600, 1200f);
l.start = new Vector3(x, y, 0) + transform.position;
l.end = new Vector3(endx, y, 0) + transform.position;
l.curveIn = AnimationCurveAsset.SteepIn;
l.curveOut = AnimationCurveAsset.HorizontalLineOut;
// l.gameObject.layer = 15;
lines.Add(l);
l.Init();
// l.gameObject.layer = 0;
}
}
public override AbilityTickable AbilityLogic(Vector2 target)
{
AOEObject ability = new GameObject().AddComponent <AOEObject>();
ability.Init(Owner, target, AOERadius, AOEDelay, AOEDamage, FXPrefab, FXScale);
return(ability);
}
public static AGHActor Create(Transform headNub)
{
var actor = new GameObject("Actor " + headNub.name).AddComponent <AGHActor>();
actor.Init(headNub);
return(actor);
}
public static void AddChunk(int x, int y)
{
Chunk chunk;
chunk = new GameObject("chunk").AddComponent <Chunk>();
chunk.Init(x, y);
}
private void Awake()
{
var mainController = new GameObject("MainController").AddComponent <MainController>();
mainController.Init();
Destroy(gameObject);
}
/// <summary>
/// Found yourself a brand spankin' new city! Make sure to give it some settings
/// so it knows how to build itself.
/// </summary>
/// <param name="position"></param>
/// <param name="settings"></param>
/// <param name="name"></param>
/// <returns></returns>
public static City CreateCity(Vector3 position, CitySettings settings, string name = "City")
{
City temp = new GameObject(name).AddComponent <City>();
temp.Init(position, settings);
return(temp);
}
public static DynamicPlotter GetDynamicPlotter(DynamicPlotData data)
{
var plotter = new GameObject().AddComponent <DynamicPlotter>();
var graph = new DynamicGraph();
data.Points.ForEach(point =>
graph.AddPlotPoint(new PlotPoint(point.XColumn, point.YColumn, point.ZColumn))
);
graph.AddTimePoints(data.TimeColumn);
plotter.Graph = graph;
plotter.PointHolder = GetPlotHolder();
plotter.PointPrefab = data.PointObject.transform;
plotter.Text = GetText3D();
plotter.PlotTitle = data.Title;
plotter.XAxisName = data.XName;
plotter.YAxisName = data.YName;
plotter.ZAxisName = data.ZName;
plotter.PlotScale = data.PlotScale;
plotter.Init();
return(plotter);
}
private void Start()
{
MainLoader <Sprite> .Instance.Load("Sprites/", "test_block");
MainLoader <Sprite> .Instance.Load("Sprites/", "test_portal");
MainLoader <Sprite> .Instance.Load("Sprites/", "test_player");
level = new Level();
level.Generate();
RoomObject roomObject;
foreach (Room r in level.roomsList)
{
roomObject = new GameObject("Room").AddComponent <RoomObject>();
roomObject.transform.SetParent(transform);
roomObject.Init(r);
_rooms.Add(roomObject);
}
foreach (PortalCouple pc in level.portalCouples)
{
_rooms.Find(r => r.Data.ID == pc.enRoomID).PlaceEntrancePortal(pc.ID);
_rooms.Find(r => r.Data.ID == pc.exRoomID).PlaceExitPortal(pc.ID);
}
SpawnPlayer();
PlayerCamera.Instance.Init(_player);
}
/// <summary>
/// Creates a straight line Road connected to two Intersections.
/// </summary>
/// <param name="head"></param>
/// <param name="tail"></param>
/// <param name="name"></param>
/// <returns></returns>
public static Road CreateRoad(Intersection head, Intersection tail, string name = "Road")
{
Road road = new GameObject(name).AddComponent <Road>();
road.Init(head, tail, head.city);
return(road);
}
public void SetBlocksValue(bool setNumber = true)
{
Block[] blocks = FindObjectsOfType <Block>();
int randomNum = 0;
foreach (Block block in blocks)
{
block.Init();
randomNum = UnityEngine.Random.Range(1, block.posX + block.posY + 2) * 2 + UnityEngine.Random.Range(1, 7);
if (levelLoader.GetCurrentSceneName() == Constants.SCENE_NAME.TUTORIAL)
{
randomNum = block.GetTutorialBlocksValue(block.posX, block.posY);
}
if (setNumber)
{
block.SetBlockValue(randomNum.ToString());
}
if (block.posX == 1 && block.posY == 1 && levelLoader.GetCurrentSceneName() == Constants.SCENE_NAME.LEVEL)
{
int randomNumInDices = diceController.GetDiceNumberRandomly();
block.SetBlockValue(randomNumInDices.ToString());
}
block.UpdateBlocksUI();
}
}
public override void OnUse(AbilityHitDetector AHD = null)
{
MeleeAbilityHitDetector MAHD = new GameObject().AddComponent <MeleeAbilityHitDetector>();
MAHD.Init(this, "Enemy", UsedBy.AimDirection);
base.OnUse(MAHD);
}
public static Cam2 InitCamera(string name, bool loadConfig = true, bool reload = false)
{
if (cams.TryGetValue(name, out var cam))
{
if (reload)
{
cam.settings.Reload();
return(cam);
}
throw new Exception("Already exists??");
}
cam = new GameObject($"Cam2_{name}").AddComponent <Cam2>();
try {
cam.Init(name, customScreen.AddNewView(), loadConfig);
} catch {
GameObject.DestroyImmediate(cam);
throw;
}
cams[name] = cam;
//Newly added cameras should always be the last child and thus on top
//ApplyCameraValues(viewLayer: true);
return(cam);
}
public void CardViewObjectMovedToDeckObject()
{
var system = new PlayerDeckRenderingSystem(_contexts);
var player = new GameObject().AddComponent <Player>();
player.PlayerId = 1;
var container = _contexts.game.CreateEntity();
container.AddPlayer(player);
var deck = new GameObject().AddComponent <CardContainer>();
deck.Init();
container.AddPlayerDeck(deck);
var card = _contexts.card.CreateEntity();
card.AddOwner(container);
card.AddDeckCard(DeckCard.Move);
card.AddView(new GameObject());
system.Execute();
Assert.AreEqual(container.playerDeck.PlayerDeckObject.ObjectContainer, card.view.GameObject.transform.parent.gameObject);
}
public ParticleEmitter CreateEmitter(Vector3 position, float angle, Transform parent, GameObject particleSystem)
{
if (particleSystem == null)
{
return(null);
}
ParticleEmitter particle = new GameObject("Emitter").AddComponent <ParticleEmitter>();
particle.transform.position = position;
particle.transform.localEulerAngles = new Vector3(0, 0, angle);
if (parent != null)
{
particle.transform.parent = parent;
}
else
{
particlesObject = GetParticlesObject();
particle.transform.parent = particlesObject;
}
particle.Init(particleSystem);
return(particle);
}
public IEnumerator theme_asset_is_null()
{
SceneManager.LoadScene(0);
MapGenerator generator = GameObject.Find("MapGenerator").GetComponent <MapGenerator>();
generator.Generate();
GridAssetSpawner spawner = generator.gameObject.GetComponent <GridAssetSpawner>();
GridAssets assets = new GameObject().AddComponent <GridAssets>();
GameObject assetPrefab = new GameObject();
GridAssetTheme[] themes = new GridAssetTheme[3];
for (int i = 0; i < themes.Length; ++i)
{
themes[i] = ScriptableObject.CreateInstance <GridAssetTheme>();
themes[i].SelectedTheme = GridAssetTheme.Theme.Forest;
}
themes[0].Sprites = new Sprite[9];
for (int i = 0; i < themes[0].Sprites.Length; ++i)
{
themes[0].Sprites[i] = Sprite.Create(new Texture2D(10, 10), new Rect(), Vector2.down);
}
assetPrefab.AddComponent <Tile>();
assets.Init(assetPrefab, themes);
spawner.Init(assets);
yield return(new WaitForEndOfFrame());
Assert.Throws <System.Exception>(() => generator.Generate(), $"The {generator.MapTheme.ToString()} (attached to: {spawner.name}) is null!");
}
public override void Create(Vector2 tileMercPos, JSONObject geo, Transform parent = null)
{
parent = parent ?? transform;
var buildingCorners = new List <Vector3>();
//foreach (var bb in geo["geometry"]["coordinates"].list)
//{
var bb = geo["geometry"]["coordinates"].list[0]; //this is wrong but cant fix it now
for (int i = 0; i < bb.list.Count - 1; i++)
{
var c = bb.list[i];
var dotMerc = GM.LatLonToMeters(c[1].f, c[0].f);
var localMercPos = new Vector2(dotMerc.x - tileMercPos.x, dotMerc.y - tileMercPos.y);
buildingCorners.Add(localMercPos.ToVector3xz());
}
//prevents duplicates coming from different tiles
//it sucks yea but works for now, cant use propery/id in json for some reason
var uniqPos = new Vector3(bb.list[0][1].f, 0, bb.list[0][0].f);
if (_buildingDictionary.ContainsKey(uniqPos))
{
return;
}
try
{
var buildingCenter = buildingCorners.Aggregate((acc, cur) => acc + cur) / buildingCorners.Count;
if (!_buildingDictionary.ContainsKey(buildingCenter))
{
for (int i = 0; i < buildingCorners.Count; i++)
{
//using corner position relative to building center
buildingCorners[i] = buildingCorners[i] - buildingCenter;
}
var building = new GameObject().AddComponent <Building>();
var kind = "";
if (geo["properties"].HasField("landuse_kind"))
{
kind = geo["properties"]["landuse_kind"].str;
}
if (geo["properties"].HasField("name"))
{
building.Name = geo["properties"]["name"].str;
}
building.Init(buildingCorners, kind, _settings);
building.name = "building";
building.transform.SetParent(parent, false);
building.transform.localPosition = buildingCenter;
_buildingDictionary.Add(uniqPos, building);
}
}
catch (Exception ex)
{
Debug.Log(ex);
}
//}
}
void onEntityCreated(IContext context, IEntity entity)
{
var entityBehaviour = new GameObject().AddComponent <EntityBehaviour>();
entityBehaviour.Init(context, entity);
entityBehaviour.transform.SetParent(_gameObject.transform, false);
}
void onEntityCreated(Pool pool, Entity entity)
{
var entityBehaviour = new GameObject().AddComponent <EntityBehaviour>();
entityBehaviour.Init(pool, entity);
entityBehaviour.transform.SetParent(_entitiesContainer, false);
}
void CreateTracks()
{
Tracks = new Track[_Track.Length];
float totalWheelbaseLenght = 0;
for (int x = 0; x < _Wheelbase.Length; x++)
{
totalWheelbaseLenght += Wheelbase(x);
}
float firstTrackPosition = totalWheelbaseLenght / 2;
for (int i = 0; i < _Track.Length; i++)
{
float trackPosition = firstTrackPosition;
for (int x = 0; x < i; x++)
{
trackPosition -= Wheelbase(x);
}
Track t = new GameObject("Track" + i).AddComponent <Track>();
t.transform.parent = transform;
t.transform.localPosition = new Vector3(trackPosition, 0, 0);
t.transform.localRotation = Quaternion.identity;
t.Width = Track(i);
t.Chasis = this;
t.Init();
Tracks[i] = t;
}
}
public void grid_generation_events_firing()
{
#region Arrange
GridAssetTheme[] themes = new GridAssetTheme[1];
themes[0] = ScriptableObject.CreateInstance <GridAssetTheme>();
themes[0].SelectedTheme = 0;
themes[0].TileDecorations = new TileDecoration[1];
themes[0].TileDecorations[0] = ScriptableObject.CreateInstance <TileDecoration>();
themes[0].Sprites = new Sprite[9];
for (int i = 0; i < themes[0].Sprites.Length; ++i)
{
themes[0].Sprites[i] = Sprite.Create(new Texture2D(10, 10), new Rect(), new Vector2(0, 0));
}
GridAssets assets = new GameObject().AddComponent <GridAssets>();
GameObject assetPrefab = new GameObject();
assetPrefab.AddComponent <SpriteRenderer>();
assetPrefab.AddComponent <Tile>();
assetPrefab.GetComponent <Tile>().TilePositionOnGrid = 0;
assets.Init(assetPrefab, themes);
GridAssetSpawner spawner = new GameObject().AddComponent <GridAssetSpawner>();
spawner.Init(assets);
GridContainer container = new GameObject().AddComponent <GridContainer>();
MapGenerator generator = new GameObject().AddComponent <MapGenerator>();
generator.Init(spawner, container, 0);
bool gridGenerating = false;
bool gridGenerated = false;
generator.OnMapGenerating += () => { gridGenerating = true; };
generator.OnMapGenerated += () => { gridGenerated = true; };
#endregion
Assert.DoesNotThrow(() => generator.Generate());
Assert.True(gridGenerating);
Assert.True(gridGenerated);
Assert.NotNull(generator.Grid);
}
//TODO combine/put all this data in separate data structure
public void AppRun(AssetDataAbstractBuilder parInitialAssetBuilder,
IAssetDatabaseUpdateStrategy parInitialAssetDatabaseUpdateStrategy,
SoundManagerColleague parViewSoundManagerColleague, ViewProviderColleague parViewSideViewProviderColleague)
{
if (CurrentAppState.CurrentBaseAppState != EBaseAppStates.Created)
{
throw new Exception("Already launched application model cannot be launched again!");
}
CurrentAppState = new AppState()
{
CurrentBaseAppState = EBaseAppStates.Running
};
//initialize resources manager
AppResourceManager = new ResourceManager(AppInfoConsts.ResourcesAssetsDirpath, parInitialAssetBuilder,
parInitialAssetDatabaseUpdateStrategy);
// AppResourceManager.LoadAssetPack("packTest");
// AppResourceManager.LoadAssetPack("gfx_smd");
// Console.WriteLine($"{AppResourceManager.GetAssetData<AssetDataText>("packTest", "/data.txt").TextData[0]}");
//initialize sound manager
ActualSoundManager = new AppSoundManager(AppResourceManager, this);
ActualSoundManager.AppSoundManagerMediator.ViewSoundManagerColleague = parViewSoundManagerColleague;
parViewSoundManagerColleague.Mediator = ActualSoundManager.AppSoundManagerMediator;
ActualSoundManager.UpdateLibrary();
AppViewProviderMediator.ViewProviderViewSide = parViewSideViewProviderColleague;
InitializeHumanPlayers();
/*
* var testObj = AppGamePool.GetObject<GameObject>(typeof(GameObject));
* testObj.Init(this);
* Console.WriteLine($"{testObj.LinkedAppModel}");
* testObj.DisableAndSendToPool();
* Console.WriteLine($"{testObj.LinkedAppModel}");
* Console.WriteLine($"{testObj.Test}");
*/
GameObject launchingObject = AppGamePool.GetObject <GameObject>(typeof(GameObject));
launchingObject.Init(this);
launchingObject.AddComponent <AppStartComponent>(AppGamePool
.GetObject <AppStartComponent>(typeof(AppStartComponent)).Init(launchingObject));
//var testComp = AppGamePool.GetObject<TestInputExitComponent>(typeof(TestInputExitComponent));
//testComp.Init(testObj);
//RegisterFixedUpdatableObject(new InputTestUpdatableObject(this));
//new InputTestUpdatableObject(this);
//TODO: Application startup logic
//TODO: Settings loading
//TODO: App state machine definitions
//TODO: Multithreading for physics
}
private void CreatePool(PoolConfig config)
{
Pool pool = new GameObject($"Pool ({ config.prefab.name })").AddComponent <Pool>();
pool.Init(config);
_pools.Add(config.prefab, pool);
}
public void AddFloor()
{
var tower = GetTower();
var floorGO = new GameObject("Floor", typeof (Floor)).GetComponent<Floor>();
floorGO.Init(FloorType.PointerPerTile);
Assert.AreEqual(1, tower.Floors.Count());
}
public void CheckCanBuildIfCanBuild()
{
var builder = new FloorDescBuilder(FloorType.First);
builder.MaxAmount = 1;
Assert.AreEqual(1, builder.MaxAmount);
var tower = GetTower();
Assert.IsTrue(builder.CanCreateInTower(tower));
var floor = new GameObject("Floor", typeof (Floor)).GetComponent<Floor>();
floor.Init(FloorType.First);
Assert.IsFalse(builder.CanCreateInTower(tower));
builder.MaxAmount = 2;
Assert.IsTrue(builder.CanCreateInTower(tower));
}
public void CreateBoardUI () {
board = new char[8,8];
// Create new holder objects for easy organisation/deletion of board UI elements
string holderName = "UI Holder";
if (transform.FindChild (holderName)) {
GameObject holderOld = transform.FindChild(holderName).gameObject;
DestroyImmediate(holderOld);
}
Transform uiHolder = new GameObject (holderName).transform;
boardVisibilityController = uiHolder.gameObject;
uiHolder.parent = transform;
Transform boardHolder = new GameObject ("Board Holder").transform;
boardHolder.parent = uiHolder;
Transform pieceHolder = new GameObject ("Piece Holder").transform;
pieceVisibilityController = pieceHolder.gameObject;
pieceHolder.parent = uiHolder;
// Generate board and piece squares
squares = new Renderer[8,8];
pieceSquares = new SpriteRenderer[8,8];
for (int i = 0; i < 8; i ++) {
for (int j = 0; j < 8; j ++) {
int x = GetIndex(j);
int y = GetIndex(i);
bool isLightSquare = SquareIsWhite(x,y);
Vector2 position = new Vector2(-4.5f + x+1, -4.5f + y+1);
string algebraicCoordinate = Definitions.fileNames[j].ToString() + Definitions.rankNames[i].ToString();
// squares
Transform newSquare = Instantiate((isLightSquare)?lightSquare:darkSquare, position, Quaternion.identity) as Transform;
newSquare.parent = boardHolder;
newSquare.name = algebraicCoordinate;
squares[x,y] = newSquare.GetComponent<Renderer>();
// pieces
PieceUI pieceUI = new GameObject(algebraicCoordinate).AddComponent<PieceUI>();
pieceUI.Init(algebraicCoordinate, position);
SpriteRenderer sprite = pieceUI.gameObject.AddComponent<SpriteRenderer>();
sprite.transform.position = position;
sprite.transform.parent = pieceHolder;
pieceSquares[x,y] = sprite;
}
}
// Create frame
Transform newFrame = Instantiate(frame, Vector3.forward * 0.1f, Quaternion.identity) as Transform;
newFrame.localScale = Vector3.one * (8 + frameSize);
newFrame.parent = uiHolder;
newFrame.GetComponent<Renderer> ().sharedMaterial.color = themes[themeIndex].frameColour;
PaintBoard (themes[themeIndex].lightColour, themes[themeIndex].darkColour);
InitializeSpriteDictionary ();
}
void ReloadScene(Device device)
{
bool gameRunning = false;
if (_map != null)
{
gameRunning = true;
_map.Dispose();
}
string[] mapContent = File.ReadAllLines(_mapFile);
_mapModifyDate = File.GetLastWriteTime(_mapFile);
_map = Add(new GameObject());
var y = mapContent.Length;
for (var l = 0; l < mapContent.Length; l++)
{
var line = mapContent[l];
for (int x = 0; x < line.Length; x++)
{
var c = line[x];
string blockTexture = null;
switch (c)
{
case 'm':
case 'M':
if (_player == null || _oldStartPos != new Vector3(x, y, 0))
{
if (_player == null)
{
_player = (Mario)Add(new Mario(device));
var deathController = _player.SearchComponent<MainPlayerDeath>();
GameObject dummyCameraTarget = null;
deathController.OnDeathStarted += delegate
{
dummyCameraTarget = Add(new GameObject());
dummyCameraTarget.Translate(_player.GlobalTransform.TranslationVector);
_camera.SearchComponent<LookAtObject>().Target = dummyCameraTarget;
};
deathController.OnDeathFinalized += delegate
{
if (dummyCameraTarget != null)
{
dummyCameraTarget.Dispose();
dummyCameraTarget = null;
}
_camera.SearchComponent<LookAtObject>().Target = _player;
deathController.Reset();
ReloadScene(device);
_player.Enabled = true;
_player.Transform = Matrix.Translation(_oldStartPos.X, _oldStartPos.Y + 0.5f, 0);
_player.SearchComponent<RigidBody>().Momentum = Vector3.Zero;
_player.SearchComponent<Blink>().IsActive = true;
_camera.Transform = _player.Transform * Matrix.Translation(0, 0, -15);
};
}
_player.Transform = Matrix.Translation(x, y + 0.5f, 0);
_oldStartPos = new Vector3(x, y, 0);
}
_player.IsSmall = c == 'm';
break;
case 'G':
_map.Add(new Goomba(device)).Translate(x, y, 0);
break;
case '?':
_map.Add(new ItemBlock(device)).Translate(x, y, 0);
break;
case 'B':
_map.Add(new BrickBlock(device)).Translate(x, y, 0);
break;
case 'P':
{
if (l > 0 && mapContent[l - 1].Length > x && mapContent[l - 1][x] == c)
break;
var height = 1;
while (l + height < mapContent.Length && mapContent[l + height][x] == c)
height++;
_map.Add(new Pipe(device, height)).Translate(x, y - (float)(height - 1) / 2, 0);
break;
}
case '|':
{
if (l > 0 && mapContent[l - 1].Length > x && mapContent[l - 1][x] == c)
break;
var height = 1;
while (l + height < mapContent.Length && mapContent[l + height][x] == c)
height++;
_map.Add(new Poll(device, height)).Translate(x, y - (float)(height - 1) / 2, 0);
break;
}
case 'D':
{
int width = 1;
while (x + 1 < line.Length && line[x + 1] == 'D')
{
width++;
x++;
}
_map.Add(new Trigger(o => o.Object.SendMessage("OnDeath", true),
width, 1, 2,
new Vector3(x - (float)(width - 1) / 2, y, 0)));
break;
}
case '^':
{
int width = 1;
while (x + 1 < line.Length && line[x + 1] == '^' && width < 3)
{
width++;
x++;
}
var size = width == 1 ? 2 : 4;
var sprite = _map.Add(new Objects.Sprite(device, "grass_" + width, size));
sprite.Transform = Matrix.Translation(x - 0.5f, y + size / 2 - 0.5f, -0.75f);
break;
}
case 'H':
case 'h':
{
var size = c == 'H' ? 8 : 4;
var sprite = _map.Add(new Objects.Sprite(device, "hill_" + size, size));
sprite.Transform = Matrix.Translation(x, y + size / 2 - 0.5f, 1);
break;
}
case '#':
{
var size = 8;
var sprite = _map.Add(new Objects.Sprite(device, "castle", size));
sprite.Transform = Matrix.Translation(x, y + size / 2 - 0.5f, 1);
break;
}
case 'C':
{
int width = 1;
while (x + 1 < line.Length && line[x + 1] == 'C' && width < 3)
{
width++;
x++;
}
var cloud = _map.Add(new Cloud(device, width));
cloud.Transform = Matrix.Scaling(2) * Matrix.Translation(x - (float)(width - 0.5f), y, 5f);
break;
}
case 'W':
{
int width = 1;
while (x + 1 < line.Length && line[x + 1] == 'W')
{
width++;
x++;
}
var water = _map.Add(new Water(device, 10 * width, 20));
water.Transform *= Matrix.Scaling(0.1f)
* Matrix.Translation(x - (float)(width - 1) / 2, y, 0);
break;
}
case 'S': blockTexture = "solid"; break;
case 'F': blockTexture = "floor"; break;
}
if (blockTexture != null)
{
int width = 1;
while (x + 1 < line.Length && line[x + 1] == c)
{
width++;
x++;
}
var obj = _map.Add(new Block(device, width, 1, 2, blockTexture));
obj.Translate(x - (float)(width - 1) / 2, y, 0);
}
}
y--;
}
if (gameRunning)
_map.Init();
}
public void AddObjectToLane(string name, int laneId, int _x, EnemySettings settings )
{
// print("new : " + name);
Enemy enemy = null;
switch (name)
{
case "CoinParticles":
enemy = Data.Instance.enemiesManager.GetEnemy("CoinParticles");
enemy.GetComponent<CoinsParticles>().particles.Emit(settings.qty);
enemy.GetComponent<CoinsParticles>().InitParticles();
break;
case "Skate":
enemy = Data.Instance.enemiesManager.GetEnemy("Skate");
break;
case "ObstacleGeneric":
enemy = Data.Instance.enemiesManager.GetEnemy("ObstacleGeneric");
break;
case "Victim":
enemy = Data.Instance.enemiesManager.GetEnemy("Victim");
break;
case "RatiJump":
enemy = Data.Instance.enemiesManager.GetEnemy("RatiJump");
break;
case "RatiEscudo":
enemy = Data.Instance.enemiesManager.GetEnemy("RatiEscudo");
break;
case "PowerUp":
if(Game.Instance.gameManager.characterManager.character.powerupManager.type == PowerupManager.types.NONE)
enemy = Data.Instance.enemiesManager.GetEnemy("PowerUp");
break;
case "Coin":
enemy = Data.Instance.enemiesManager.GetEnemy("Coins");
break;
case "ExplosionRatis":
enemy = Data.Instance.enemiesManager.GetEnemy("ExplosionRatis");
break;
case "Resorte":
enemy = Data.Instance.enemiesManager.GetEnemy("Resorte");
break;
case "PowerDown":
// if (Game.Instance.gameManager.characterManager.character.powerupManager.type == PowerupManager.types.NONE)
enemy = Data.Instance.enemiesManager.GetEnemy("PowerDown");
break;
}
if (enemy == null)
return;
GameObject go = enemy.gameObject;
sortInLayersByLane(go, laneId);
go.transform.SetParent(all[laneId].transform);
go.transform.localPosition = new Vector3(_x, 0, 0);
enemy.Init(settings, laneId);
}
