private void HandleKeyboardInput(PlayerTile actor)
{
if (actor.IsAlive)
{
HandlePlayerMovement(actor);
}
}
public static void Save(PlayerTile save)
{
if (!CheckIfGamesaveExists())
{
File.Create("save.rlgs").Close();
}
writer = new StreamWriter("save.rlgs");
string data = "";
data += save.MonstersKilled.ToString() + "|";
data += save.Lifes.ToString() + "|";
data += save.Score.ToString() + "|";
if (save.CurrentQuest != null)
{
data += (int)save.CurrentQuest.Type + "|";;
data += save.CurrentQuest.Progress + "|";;
data += save.CurrentQuest.Value + "|";;
data += save.CurrentQuest.Reward;
}
string encrypted = Encrypt(data);
writer.Write(encrypted);
writer.Close();
Console.WriteLine("Data succesfully saved");
}
// Update is called once per frame
public void OnGameOver(Team winningTeam) {
PlayEndGameAudio(winningTeam);
GetComponent<Image>().color = winningTeam == Team.Traitor ? gameSceneManager.traitorColor : gameSceneManager.loyalColor;
// continueButton.onClick.AddListener(gameSceneManager.GoToLobby);
int numberOfTraitors = 0;
foreach (PlayableCharacter player in FindObjectsOfType<PlayableCharacter>()) {
if (player.startingTeam == Team.Traitor) {
numberOfTraitors++;
}
if (player.startingTeam == winningTeam) {
PlayerTile tile = Instantiate(playerNamePrefab, winnersGrid).GetComponent<PlayerTile>();
// Ensure the tile has started before we call Init
tile.Start();
tile.Init(player);
}
}
// Set winning text
if (winningTeam == Team.Traitor) {
if (numberOfTraitors == 1) {
winningTeamText.text = "The traitor has won!";
} else {
winningTeamText.text = "The traitors have won!";
}
} else {
winningTeamText.text = "The loyals have won!";
}
gameObject.SetActive(true);
StartCoroutine("SwitchScenes");
}
public void AssignTile(PlayerTile playerTile)
{
if (Tiles.Count > FieldsCount)
{
throw new Exception("Ship tiles exceeded");
}
Tiles.Add(playerTile);
}
public void RaycastAll(PlayerTile playerTile, Vector3 offset, List <Vector3> initialPositions,
List <Vector3> endPositions,
ref List <Raycaster.HitResult> blockingObjectsResult,
ref List <Raycaster.FloorHitResult> floorResult)
{
playerTile.PlayerCastAll(ObjectManager, offset, initialPositions, endPositions, ref blockingObjectsResult,
ref floorResult);
}
void AddPlayerTile(PlayableCharacter player)
{
PlayerTile tile = Instantiate(playerTile, transform).GetComponent <PlayerTile>();
player.playerTile = tile;
player.playersUI = this;
tile.Init(player);
}
public void OnTileClick(PointerEventData data)
{
PlayerTile tile = data.pointerPress.GetComponent <PlayerTile>();
tile.selected = true;
turnPositionList.Add(new Vector2Int(tile.xPos, tile.yPos));
turnText.text = "Level: " + GameManager.instance.level + "\nTurn: " + (turnNumber - turnPositionList.Count);
TurnTiles(tile.xPos, tile.yPos);
}
public void Initialize(TileGrid _grid, PlayerTile _player)
{
grid = _grid;
player = _player;
player.transform.parent = this.transform;
for (int i = 0; i < grid.Tiles.Count; i++)
{
((Component)grid.Tiles[i]).transform.parent = this.transform;
}
}
public void SuscribeToTileTriggers(PlayerTile tile)
{
// Click event trigger
EventTrigger trigger = tile.GetComponent <EventTrigger>();
EventTrigger.Entry entry = new EventTrigger.Entry();
entry.eventID = EventTriggerType.PointerClick;
entry.callback.AddListener((data) => { OnTileClick((PointerEventData)data); });
trigger.triggers.Add(entry);
}
public static void CreateMyAsset()
{
PlayerTile asset = ScriptableObject.CreateInstance <PlayerTile>();
AssetDatabase.CreateAsset(asset, "Assets/PlayerTile.asset");
AssetDatabase.SaveAssets();
EditorUtility.FocusProjectWindow();
Selection.activeObject = asset;
}
public Coffee(string id, ActorType actorType, StatusType statusType, Transform3D transform,
OurEffectParameters effectParameters, Model model, List <CoffeeInfo> coffeeInfo, PlayerTile player) : base(
id, actorType,
statusType, transform, effectParameters, model, false, ETileType.None)
{
this.player = player;
CoffeeInfo = coffeeInfo;
InitializeCollision(-Vector3.Up * coffeeInfo[0].y);
InitializeTile();
IsMoving = false;
}
private void HandlePlayerMovement(PlayerTile playerTile)
{
if (keyboardManager.IsFirstKeyPress(Keys.Space) && !playerTile.IsAttached)
{
playerTile.Attach();
}
else if (!keyboardManager.IsKeyDown(Keys.Space) && keyboardManager.IsStateChanged() && playerTile.IsAttached
)
{
playerTile.Detach();
}
else if (keyboardManager.IsFirstKeyPress(Keys.R))
{
playerTile.SpawnAtNextCheckpoint();
}
if (!playerTile.IsMoving)
{
Vector3 moveDir = Vector3.Zero;
Vector3 look = cameraManager[cameraManager.ActiveCameraIndex].Transform3D.Look;
look = Math.Abs(look.X) > Math.Abs(look.Z)
? new Vector3(look.X < 0 ? -1 : 1, 0, 0)
: new Vector3(0, 0, look.Z < 0 ? -1 : 1);
Vector3 right = cameraManager[cameraManager.ActiveCameraIndex].Transform3D.Right;
right = Math.Abs(right.X) > Math.Abs(right.Z)
? new Vector3(right.X < 0 ? -1 : 1, 0, 0)
: new Vector3(0, 0, right.Z < 0 ? -1 : 1);
if (keyboardManager.IsKeyDown(Keys.Up) || keyboardManager.IsKeyDown(Keys.W))
{
moveDir = look;
}
else if (keyboardManager.IsKeyDown(Keys.Down) || keyboardManager.IsKeyDown(Keys.S))
{
moveDir = -look;
}
if (keyboardManager.IsKeyDown(Keys.Left) || keyboardManager.IsKeyDown(Keys.A))
{
moveDir = -right;
}
else if (keyboardManager.IsKeyDown(Keys.Right) || keyboardManager.IsKeyDown(Keys.D))
{
moveDir = right;
}
if (moveDir != Vector3.Zero)
{
EventManager.FireEvent(new MovementEvent {
type = MovementType.OnMove, direction = moveDir
});
}
}
}
private Tile CreatePlayer(Vector3 position)
{
PlayerTile playerTile = (PlayerTile)drawnActors["PlayerBlock"];
playerTile = playerTile.Clone() as PlayerTile;
playerTile?.InitializeCollision(position);
if (playerTile != null)
{
playerTile.ID += id++;
}
objectManager.Add(playerTile);
return(playerTile);
}
public void SetPlayerVote(Vote vote, PlayableCharacter player)
{
PlayerTile tile = player.playerTile;
if (vote == Vote.For)
{
tile.EnableVotingFor();
}
else if (vote == Vote.Against)
{
tile.EnableVotingAgainst();
}
}
public static PlayerTile Load()
{
if (!CheckIfGamesaveExists())
{
return(null);
}
try
{
reader = new StreamReader("save.rlgs");
}catch (Exception)
{
return(null);
}
string data = reader.ReadLine();
reader.Close();
string[] decrypted = new string[1];
try
{
decrypted = Decrypt(data).Split('|');
}
catch (ArgumentNullException e)
{
File.Delete("save.rlgs");
ErrorDisplayService.ShowError(e, "An error occured with loading your GameSave. It is probably corrupted.\nSorry, You have to start a new game :(", true);
return(null);
}
Quest currentQuest = null;
if (decrypted.Length >= 7)
{
currentQuest = new Quest(int.Parse(decrypted[3]), int.Parse(decrypted[4]),
int.Parse(decrypted[5]), int.Parse(decrypted[6]));
}
PlayerTile newPlayer = PlayerTile.LoadPlayer(
int.Parse(decrypted[2]),
int.Parse(decrypted[1]),
int.Parse(decrypted[0]),
currentQuest);
return(newPlayer);
}
public static bool ShowMenu()
{
if (SaveLoadService.CheckIfGamesaveExists())
{
player = SaveLoadService.Load();
}
bool atMenu = true;
Console.Clear();
while (atMenu)
{
Console.Clear();
bool continueCondition = player != null && player.IsAlive;
string continueOption = continueCondition ? "\n[2]Continue" : "";
Console.WriteLine("Welcome to Rougelike by DrMayx!\n\n" +
"Close game only from main menu.\n" +
"Game saves automatically on closing." +
$"\n\n[1]Start new Game{continueOption}\n[9]Exit");
switch (Console.ReadKey().Key)
{
case ConsoleKey.D1:
player = PlayerTile.CreateNewPlayer();
return(true);
case ConsoleKey.D2:
if (continueCondition)
{
return(true);
}
break;
case ConsoleKey.D9:
return(false);
case ConsoleKey.D0:
ShowDebugInfo();
break;
}
}
return(false);
}
//Do everything to destroy current game instance -> load another on restart.
private void DestroyGame()
{
if (game != null)
{
game?.RemoveCamera();
List <Actor3D> actor3Ds = ObjectManager.ActorList.FindAll(actor3D => actor3D != null);
foreach (Actor3D actor3D in actor3Ds)
{
actor3D.ControllerList.Dispose();
actor3D.EventHandlerList.Dispose();
}
ObjectManager.RemoveAll(actor3D => actor3D != null);
UiManager.Dispose();
InitUi();
physicsManager.Dispose();
SoundManager.Dispose();
player = null;
CameraManager.ActiveCameraIndex = 0;
}
}
public static void PlayerCastAll(this PlayerTile player, OurObjectManager objectManager, Vector3 offset,
List <Vector3> initialPositions, List <Vector3> endPositions,
ref List <HitResult> blockingObjectsResult, ref List <FloorHitResult> floorResult)
{
List <Actor3D> ignore = new List <Actor3D>();
ignore.AddRange(player.AttachedTiles);
ignore.Add(player);
offset = new Vector3(offset.X % 1f, offset.Y % 1f, offset.Z % 1f) * 0.9f;
for (int i = 0; i < initialPositions.Count; i++)
{
//Check if this block's trajectory is blocked by anything in its path
Vector3 maxDist = endPositions[i] - initialPositions[i];
Vector3 dir = Vector3.Normalize(maxDist);
blockingObjectsResult.AddRange(RaycastAll(objectManager, initialPositions[i] + offset, dir,
maxDist.Length() + 0.1f, ignore));
//If there's anything directly above this block and the block moves in Y, it's an illegal move
if (dir.Y > 0)
{
blockingObjectsResult.AddRange(RaycastAll(objectManager, initialPositions[i], Vector3.Up, 1f,
ignore));
}
//Check if this block will be on a floor tile after moving
HitResult hit = Raycast(objectManager, endPositions[i], Vector3.Down, 1f, ignore);
if (hit != null)
{
floorResult.Add(new FloorHitResult {
hitResult = hit, actor3D = ignore[i]
});
}
}
}
void Init()
{
targets = new List <TargetTile>();
gridTiles = new GameTile[Constants.GRID_SIZE][];
for (int i = 0; i < gridTiles.Length; i++)
{
gridTiles[i] = new GameTile[Constants.GRID_SIZE];
}
GameTile[] tiles = GetComponentsInChildren <GameTile>();
for (int i = 0; i < tiles.Length; i++)
{
int x = PositionToIndex(tiles[i].transform.localPosition.x);
int y = PositionToIndex(tiles[i].transform.localPosition.y);
if (x >= 0 && y >= 0 && x < Constants.GRID_SIZE && y < Constants.GRID_SIZE)
{
if (gridTiles[x][y] == null)
{
tiles[i].transform.localPosition = new Vector3(IndexToPosition(x), IndexToPosition(y), tiles[i].transform.localPosition.z);
gridTiles[x][y] = tiles[i];
}
else
{
Debug.LogError("Several tiles at the same spot.", tiles[i].gameObject);
tiles[i].gameObject.SetActive(false);
}
}
else
{
Debug.LogError("Tile out of bounds.", tiles[i].gameObject);
tiles[i].gameObject.SetActive(false);
}
if (tiles[i].gameObject.activeSelf)
{
if (tiles[i] is PlayerTile)
{
if (player == null)
{
player = tiles[i] as PlayerTile;
}
else
{
Debug.LogError("Two player tiles.", gameObject);
}
}
if (tiles[i] is TargetTile)
{
targets.Add(tiles[i] as TargetTile);
}
}
}
if (player == null)
{
Debug.LogError("Error: no player in level.", gameObject);
}
if (targets.Count == 0)
{
Debug.LogError("Error: no target in level.", gameObject);
}
//Debug.Log("Level intiated with " + targets.Count + " targets.");
}
protected override void Update(GameTime gameTime)
{
game?.Update();
//The game has its own "global timer" that runs out periodically and is defined in the GameConstants.
//Lots of temporal elements use this as a reference on how long a "turn" in the game is, its to give the player a sense of rhythm
if (currentMovementCoolDown <= 0)
{
currentMovementCoolDown = GameConstants.MovementCooldown;
EventManager.FireEvent(new MovingTilesEventInfo());
}
currentMovementCoolDown -= (float)gameTime.ElapsedGameTime.TotalSeconds;
//Fetch the Player and set the camera to target him is we don't have a reference to him.
if (player == null)
{
OurDrawnActor3D drawnActor3D =
ObjectManager.OpaqueList.Find(actor3D =>
actor3D is Tile tile && tile.ActorType == ActorType.Player);
if (CameraManager.ActiveCamera.ControllerList[0] is RotationAroundActor cam &&
drawnActor3D != null)
{
cam.Target = drawnActor3D;
player = drawnActor3D as PlayerTile;
drawnActor3D.StatusType = StatusType.Drawn | StatusType.Update;
}
}
//Don't update the Player if using wrong cam
if (player != null)
{
player.StatusType = CameraManager.ActiveCameraIndex switch
{
0 => StatusType.Drawn | StatusType.Update,
1 => StatusType.Drawn,
2 => StatusType.Drawn,
_ => player.StatusType
}
}
;
if (KeyboardManager.IsFirstKeyPress(Keys.Escape))
{
EventDispatcher.Publish(MenuManager.StatusType == StatusType.Off
? new EventData(EventCategoryType.Menu, EventActionType.OnPause, null)
: new EventData(EventCategoryType.Menu, EventActionType.OnPlay, null));
}
if (KeyboardManager.IsFirstKeyPress(Keys.C))
{
CameraManager.CycleActiveCamera();
}
//Cycle Through Audio
if (KeyboardManager.IsFirstKeyPress(Keys.N))
{
EventManager.FireEvent(new SoundEventInfo {
soundEventType = SoundEventType.PlayNextMusic
});
}
//Mute All Sounds
if (KeyboardManager.IsFirstKeyPress(Keys.M))
{
EventManager.FireEvent(new SoundEventInfo {
soundEventType = SoundEventType.ToggleMute
});
}
//Volume Changes
if (KeyboardManager.IsFirstKeyPress(Keys.L))
{
EventManager.FireEvent(new SoundEventInfo
{
soundEventType = SoundEventType.IncreaseVolume, soundVolumeType = SoundVolumeType.Master
});
}
else if (KeyboardManager.IsFirstKeyPress(Keys.K))
{
EventManager.FireEvent(new SoundEventInfo
{
soundEventType = SoundEventType.DecreaseVolume, soundVolumeType = SoundVolumeType.Master
});
}
//Pause/resume music
if (KeyboardManager.IsFirstKeyPress(Keys.P))
{
EventManager.FireEvent(new SoundEventInfo
{
soundEventType = SoundEventType.ToggleMusicPlayback, soundVolumeType = SoundVolumeType.Master
});
}
//if (KeyboardManager.IsFirstKeyPress(Keys.Escape))
// Exit();
base.Update(gameTime);
}
/// <summary>
/// Our Slave objects that we will later clone are all made here. Like "templates" of objects. (Like Prefabs in Unity)
/// </summary>
private void InitStaticModels()
{
/*
* Some initialization
*/
Color coffeeColor = new Color(111 / 255.0f, 78 / 255.0f, 55 / 255.0f, 0.95f);
CoffeeEffectParameters coffeeEffect = new CoffeeEffectParameters(main.Effects["Coffee"],
main.Textures["CoffeeUV"], main.Textures["CoffeeFlow"], coffeeColor);
Transform3D transform3D = new Transform3D(Vector3.Zero, -Vector3.Forward, Vector3.Up);
NormalEffectParameters normalEffectParameters = new NormalEffectParameters(main.Effects["Normal"],
main.Textures["Chocolate"], main.Textures["big-normalmap"],
main.Textures["big-displacement"], Color.White, 1, light);
/*
* Here we make the static Tiles.
*/
#region StaticTiles
//Create the Basic Tile
Tile chocolateTile = new Tile("ChocolateTile", ActorType.Primitive, StatusType.Drawn | StatusType.Update,
transform3D, normalEffectParameters, main.Models["Cube"],
true, ETileType.Static);
//Create the Plate Stacks
BasicEffectParameters effectParameters =
new BasicEffectParameters(main.ModelEffect, main.Textures["Ceramic"], Color.White, 1);
Tile plateStackTile = new Tile("plateStackTile", ActorType.Primitive, StatusType.Drawn | StatusType.Update,
transform3D, effectParameters, main.Models["PlateStack"],
true, ETileType.Static);
//Create the Fork Model
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["Finish"], Color.White, 1);
OurModelObject forkModelObject =
new OurModelObject("fork", ActorType.Decorator, StatusType.Drawn | StatusType.Update, transform3D,
effectParameters, main.Models["Fork"]);
//forkModelObject.ControllerList.Add(new RandomRotatorController("rotator", ControllerType.Curve));
//Create the Knife Model
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["Knife"], Color.White, 1);
OurModelObject knifeModelObject =
new OurModelObject("knife", ActorType.Decorator, StatusType.Drawn | StatusType.Update, transform3D,
effectParameters, main.Models["Knife"]);
//knifeModelObject.ControllerList.Add(new RandomRotatorController("rotator", ControllerType.Curve));
//Create the Single Plate Model
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["Finish"], Color.White, 1);
OurModelObject singlePlateModelObject = new OurModelObject("singlePlate", ActorType.Decorator,
StatusType.Drawn | StatusType.Update, transform3D, effectParameters,
main.Models["SinglePlate"]);
//singlePlateModelObject.ControllerList.Add(new RandomRotatorController("rotator", ControllerType.Curve));
#endregion StaticTiles
/*
* Here we create the Tiles that interact with you on collision.
*/
#region InteractableTiles
//Create Button Tile
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["Button"], Color.White, 1);
ActivatableTile activatable = new ActivatableTile("Button", ActorType.Primitive,
StatusType.Drawn | StatusType.Update, transform3D, effectParameters,
main.Models["Button"], false, ETileType.Button);
activatable.ControllerList.Add(new ColliderComponent("ButtonCC", ControllerType.Collider,
OnActivatableCollisionEnter));
//Create the Puddle (We call them spikes because they kill the player on collision)
coffeeEffect = (CoffeeEffectParameters)coffeeEffect.Clone();
coffeeEffect.UvTilesTexture = main.Textures["DropUV"];
coffeeEffect.CoffeeColor = new Color(new Color(239, 228, 176), 255);
Tile spike = new Tile("Spike", ActorType.Primitive, StatusType.Drawn | StatusType.Update, transform3D,
coffeeEffect, main.Models["Puddle"], false, ETileType.Spike);
spike.ControllerList.Add(new ColliderComponent("CC", ControllerType.Collider, OnHostileCollision));
//Create the Mug Pickups
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["Mug"], Color.White, 1);
Tile pickup = new Tile("Mug", ActorType.Primitive, StatusType.Drawn | StatusType.Update, transform3D,
effectParameters, main.Models["Mug"], false, ETileType.Star);
pickup.ControllerList.Add(new PlayerDeathComponent("PDC", ControllerType.Event));
pickup.ControllerList.Add(new ColliderComponent("CC", ControllerType.Collider, OnCollectibleCollision));
//Create the Goal Tile
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["sugarbox"], Color.White, 1);
Tile goal = new Tile("Goal", ActorType.Primitive, StatusType.Drawn | StatusType.Update, transform3D,
effectParameters, main.Models["SugarBox"], false, ETileType.Win);
goal.ControllerList.Add(new ColliderComponent("CCG", ControllerType.Collider, OnGoalCollided));
//Create the Checkpoint Tile
effectParameters =
new BasicEffectParameters(main.ModelEffect, main.Textures["WhiteSquare"], Color.White, 1);
Tile checkpoint = new Tile("Checkpoint", ActorType.Primitive, StatusType.Drawn | StatusType.Update,
transform3D, effectParameters, main.Models["Smarties"], false, ETileType.Checkpoint);
checkpoint.ControllerList.Add(new ColliderComponent("CC", ControllerType.Collider, OnCheckPointCollision));
#endregion
/*
* Here we create the Tiles that can Move
*/
#region MovableTiles
//Create the Attachable Tiles
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["SugarB"], Color.White, 1);
AttachableTile attachableTile = new AttachableTile("AttachableTile", ActorType.Primitive,
StatusType.Drawn | StatusType.Update, transform3D, effectParameters,
main.Models["Cube"], ETileType.Attachable);
attachableTile.ControllerList.Add(new TileMovementComponent("AttachableTileMC", ControllerType.Movement,
300));
attachableTile.ControllerList.Add(new PlayerDeathComponent("PDC", ControllerType.Event));
//Create the Player Tile
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["SugarW"], Color.White, 1);
PlayerTile playerTile = new PlayerTile("Player", ActorType.Player, StatusType.Drawn, transform3D,
effectParameters, main.Models["Cube"], ETileType.Player);
playerTile.ControllerList.Add(new PlayerController("PlayerPC", ControllerType.Player, main.KeyboardManager,
main.CameraManager));
TileMovementComponent tileMovementComponent = new TileMovementComponent("PTMC", ControllerType.Movement,
300);
playerTile.ControllerList.Add(tileMovementComponent);
playerTile.ControllerList.Add(new PlayerMovementComponent("PlayerMC", ControllerType.Movement));
playerTile.ControllerList.Add(new PlayerDeathComponent("PDC", ControllerType.Event));
//Create the Enemy Tiles
coffeeColor = new Color(coffeeColor, 255);
coffeeEffect = new CoffeeEffectParameters(main.Effects["Coffee"], main.Textures["DropUV"],
main.Textures["CoffeeFlow"], coffeeColor);
PathMoveTile enemy = new PathMoveTile("Enemy", ActorType.NonPlayer, StatusType.Drawn | StatusType.Update,
transform3D, coffeeEffect, main.Models["Drop"], false, ETileType.Enemy);
enemy.ControllerList.Add(new EnemyMovementComponent("emc", ControllerType.Movement, ActivationType.AlwaysOn,
0.5f, Smoother.SmoothingMethod.Smooth));
enemy.ControllerList.Add(new ColliderComponent("CC", ControllerType.Collider, OnHostileCollision));
//Create the Moving Platform Tiles
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["Biscuit"], Color.White, 1);
MovingPlatformTile movingPlatform = new MovingPlatformTile("MovingPlatform", ActorType.Platform,
StatusType.Drawn | StatusType.Update, transform3D, effectParameters,
main.Models["Biscuit"], true, ETileType.MovingPlatform);
movingPlatform.ControllerList.Add(new PathMovementComponent("platformpmc", ControllerType.Movement,
ActivationType.Activated, 0.5f, Smoother.SmoothingMethod.Decelerate));
//Create the Doors Tiles
effectParameters = new BasicEffectParameters(main.ModelEffect, main.Textures["Biscuit"], Color.White, 1);
PathMoveTile doorTile = new PathMoveTile("Door Tile", ActorType.Platform,
StatusType.Drawn | StatusType.Update, transform3D, effectParameters,
main.Models["Cube"], true, ETileType.Door);
doorTile.ControllerList.Add(new DoorMovementComponent("doorPMC", ControllerType.Movement,
ActivationType.Activated, 0.5f, Smoother.SmoothingMethod.Accelerate));
#endregion MovableTiles
//Now we add them all to our dictionary to later clone.
drawnActors = new Dictionary <string, OurDrawnActor3D>
{
{ "StaticTile", chocolateTile },
{ "PlateStackTile", plateStackTile },
{ "AttachableBlock", attachableTile },
{ "PlayerBlock", playerTile },
{ "GoalTile", goal },
{ "EnemyTile", enemy },
{ "ButtonTile", activatable },
{ "MovingPlatformTile", movingPlatform },
{ "DoorTile", doorTile },
{ "SpikeTile", spike },
{ "StarPickupTile", pickup },
{ "CheckpointTile", checkpoint },
{ "Knife", knifeModelObject },
{ "Fork", forkModelObject },
{ "SinglePlate", singlePlateModelObject },
{ "Coffee", coffee }
};
}
public override void Dispose()
{
objectManager = null;
playerTile = null;
pressSpace = null;
}
private void Start()
{
player = GetComponent <PlayerTile>();
}
public Game(PlayerTile player)
{
PlayerRef = player;
Instance = this;
}
