TouchyTickets/TouchyTickets/ParkMap.cs

284 lines
13 KiB
C#
Raw Permalink Normal View History

2020-05-31 21:16:50 +02:00
using System;
2020-05-31 17:24:10 +02:00
using System.Collections.Generic;
2020-05-31 21:16:50 +02:00
using System.Linq;
2020-06-01 14:45:20 +02:00
using System.Runtime.Serialization;
2020-05-31 17:24:10 +02:00
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
2020-05-31 21:16:50 +02:00
using Microsoft.Xna.Framework.Input.Touch;
2020-05-31 17:24:10 +02:00
using MLEM.Extensions;
using MLEM.Misc;
using MLEM.Startup;
using MLEM.Textures;
2020-06-01 17:39:57 +02:00
using TouchyTickets.Attractions;
2020-07-10 20:45:23 +02:00
using TouchyTickets.Upgrades;
2020-05-31 17:24:10 +02:00
2023-02-11 10:16:42 +01:00
namespace TouchyTickets;
2020-05-31 17:24:10 +02:00
2023-02-11 10:16:42 +01:00
[DataContract]
public class ParkMap {
2020-07-09 00:25:44 +02:00
2023-02-11 10:16:42 +01:00
private const int AdditionalRadius = 15;
private const int AutoBuyIntervalSecs = 30;
2020-05-31 17:24:10 +02:00
2023-02-11 10:16:42 +01:00
[DataMember]
public readonly int Width;
[DataMember]
public readonly int Height;
[DataMember]
private readonly List<(Point, Attraction)> attractions = new();
private readonly Dictionary<Point, int> treePositions = new();
private readonly Dictionary<Point, int> fencePositions = new();
private readonly Attraction[,] attractionGrid;
2020-06-01 01:21:54 +02:00
2023-02-11 10:16:42 +01:00
[DataMember]
public double TicketsPerSecond { get; private set; }
public Attraction PlacingAttraction;
public AttractionModifier PlacingModifier;
public Point PlacingPosition;
public Point? SelectedPosition;
private bool draggingAttraction;
private double autoBuyCounter;
2020-06-01 16:18:07 +02:00
2023-02-11 10:16:42 +01:00
public ParkMap(int width, int height) {
this.Width = width;
this.Height = height;
this.attractionGrid = new Attraction[width, height];
2020-06-01 16:18:07 +02:00
2023-02-11 10:16:42 +01:00
// set up trees
var random = new Random();
for (var x = -ParkMap.AdditionalRadius; x < this.Width + ParkMap.AdditionalRadius; x++) {
for (var y = -ParkMap.AdditionalRadius; y < this.Height + ParkMap.AdditionalRadius; y++) {
var pos = new Point(x, y);
if (this.IsInBounds(pos))
continue;
if (random.Next(15) != 0)
continue;
var type = random.Next(3);
this.treePositions[pos] = type;
2020-06-01 16:18:07 +02:00
}
2020-05-31 17:24:10 +02:00
}
2023-02-11 10:16:42 +01:00
// set up fences
this.fencePositions[new Point(-1, -1)] = 2;
this.fencePositions[new Point(this.Width, -1)] = 3;
this.fencePositions[new Point(-1, this.Height)] = 4;
this.fencePositions[new Point(this.Width, this.Height)] = 5;
for (var x = 0; x < this.Width; x++) {
this.fencePositions[new Point(x, -1)] = 0;
this.fencePositions[new Point(x, this.Height)] = 0;
}
for (var y = 0; y < this.Height; y++) {
this.fencePositions[new Point(-1, y)] = 1;
this.fencePositions[new Point(this.Width, y)] = 1;
}
}
2020-07-08 16:04:44 +02:00
2023-02-11 10:16:42 +01:00
public void Update(TimeSpan passed, bool wasAway) {
var toSimulate = wasAway ? new TimeSpan(passed.Ticks / 2) : passed;
2020-07-08 16:04:44 +02:00
2023-02-11 10:16:42 +01:00
// handle auto-buying
this.autoBuyCounter += toSimulate.TotalSeconds;
this.TryAutoBuy();
var autoBuysPerAttraction = ((float) this.autoBuyCounter / ParkMap.AutoBuyIntervalSecs / this.attractions.Count).Ceil();
2020-07-08 16:04:44 +02:00
2023-02-11 10:16:42 +01:00
// update tickets
this.TicketsPerSecond = 0;
foreach (var (pos, attraction) in this.attractions) {
var genPerSecond = attraction.Update(toSimulate, this, pos);
this.TicketsPerSecond += genPerSecond;
// if we were away, we have to catch up with auto-buys while also taking into account
// the amount of tickets that each ride generates. The easiest way we can do this is
// to progress, between updating each ride, by a percentage of the total update amount
if (wasAway) {
for (var i = autoBuysPerAttraction; i > 0; i--) {
if (!this.TryAutoBuy())
break;
2020-07-09 00:25:44 +02:00
}
2020-06-01 16:18:07 +02:00
}
2023-02-11 10:16:42 +01:00
}
2020-05-31 21:16:50 +02:00
2023-02-11 10:16:42 +01:00
// map movement
if (GameImpl.Instance.DrawMap && GameImpl.Instance.UiSystem.Controls.HandleTouch) {
var camera = GameImpl.Instance.Camera;
if (MlemGame.Input.GetGesture(GestureType.Pinch, out var pinch)) {
// pinch zoom
var center = (pinch.Position + pinch.Position2) / 2;
var newDist = Vector2.Distance(pinch.Position + pinch.Delta, pinch.Position2 + pinch.Delta2);
var oldDist = Vector2.Distance(pinch.Position, pinch.Position2);
var newScale = newDist / oldDist * camera.Scale;
camera.Zoom(newScale - camera.Scale, center);
} else if (MlemGame.Input.GetGesture(GestureType.FreeDrag, out var drag)) {
if (this.draggingAttraction) {
// move the current placing position
var nextPos = (camera.ToWorldPos(drag.Position + drag.Delta) / Assets.TileSize).ToPoint();
// drag the center of the attraction
nextPos -= new Point(this.PlacingAttraction.Type.Width / 2, this.PlacingAttraction.Type.Height / 2);
if (this.PlacingAttraction.Type.GetCoveredTiles().Select(p => nextPos + p).All(this.IsInBounds))
this.PlacingPosition = nextPos;
2020-06-05 20:49:42 +02:00
} else {
2023-02-11 10:16:42 +01:00
// move the camera
camera.Position -= drag.Delta / camera.ActualScale;
}
} else if (this.PlacingAttraction != null) {
foreach (var touch in MlemGame.Input.TouchState) {
if (touch.State != TouchLocationState.Pressed)
continue;
// when first pressing down, go into attraction drag mode if we're touching the place location
var offset = (camera.ToWorldPos(touch.Position) / Assets.TileSize).ToPoint();
this.draggingAttraction = this.PlacingAttraction.Type.GetCoveredTiles()
.Any(p => this.PlacingPosition + p == offset);
}
} else {
// we're not placing an attraction, so we're in remove and move mode
if (MlemGame.Input.GetGesture(GestureType.Tap, out var tap) && GameImpl.Instance.UiSystem.Controls.GetElementUnderPos(tap.Position) == null) {
var pos = (camera.ToWorldPos(tap.Position) / Assets.TileSize).ToPoint();
var attraction = this.GetAttractionAt(pos);
if (attraction != null && (this.PlacingModifier == null || this.PlacingModifier.IsAffected(attraction))) {
// actually select the top left for easy usage later
this.SelectedPosition = this.attractions.First(kv => kv.Item2 == attraction).Item1;
} else {
this.SelectedPosition = null;
2020-06-05 20:49:42 +02:00
}
2020-05-31 21:16:50 +02:00
}
}
2023-02-11 10:16:42 +01:00
camera.ConstrainWorldBounds(new Vector2(-ParkMap.AdditionalRadius) * Assets.TileSize, new Vector2(this.Width + ParkMap.AdditionalRadius, this.Height + ParkMap.AdditionalRadius) * Assets.TileSize);
2020-05-31 17:24:10 +02:00
}
2023-02-11 10:16:42 +01:00
}
2020-05-31 17:24:10 +02:00
2023-02-11 10:16:42 +01:00
public void Draw(GameTime time, SpriteBatch batch, Vector2 position, float scale, float alpha, bool showSurroundings, RectangleF visibleArea) {
var tileSize = Assets.TileSize * scale;
// draw ground
var additionalRadius = showSurroundings ? ParkMap.AdditionalRadius : 0;
var minX = Math.Max(-additionalRadius, visibleArea.Left / tileSize.X).Floor();
var minY = Math.Max(-additionalRadius, visibleArea.Top / tileSize.Y).Floor();
var maxX = Math.Min(this.Width + additionalRadius, visibleArea.Right / tileSize.X).Ceil();
var maxY = Math.Min(this.Height + additionalRadius, visibleArea.Bottom / tileSize.Y).Ceil();
for (var x = minX; x < maxX; x++) {
for (var y = minY; y < maxY; y++) {
var pos = new Vector2(x, y);
var drawPos = position + pos * tileSize;
batch.Draw(Assets.TilesTexture[0, 0], drawPos, Color.White * alpha, 0, Vector2.Zero, scale, SpriteEffects.None, 0);
2020-06-01 16:18:07 +02:00
2023-02-11 10:16:42 +01:00
if (this.fencePositions.TryGetValue(pos.ToPoint(), out var fenceType)) {
batch.Draw(Assets.TilesTexture[fenceType, 1], drawPos, Color.White * alpha, 0, Vector2.Zero, scale, SpriteEffects.None, 0);
} else if (this.treePositions.TryGetValue(pos.ToPoint(), out var treeType)) {
batch.Draw(Assets.TilesTexture[1 + treeType, 0], drawPos, Color.White * alpha, 0, Vector2.Zero, scale, SpriteEffects.None, 0);
2020-06-08 22:55:33 +02:00
}
2020-06-01 01:21:54 +02:00
}
2020-05-31 17:24:10 +02:00
}
2023-02-11 10:16:42 +01:00
// selected attraction
if (this.SelectedPosition != null) {
var selected = this.SelectedPosition.Value;
var attr = this.GetAttractionAt(selected);
foreach (var pos in attr.Type.GetCoveredTiles())
batch.Draw(batch.GetBlankTexture(), new RectangleF(position + (selected + pos).ToVector2() * tileSize, tileSize), Color.Black * 0.25F * alpha);
}
// draw attractions
foreach (var (pos, attraction) in this.attractions) {
if (this.PlacingModifier != null && this.PlacingModifier.IsAffected(attraction)) {
var color = GameImpl.Instance.Tickets >= attraction.GetModifierPrice(this.PlacingModifier) ? Color.Yellow : Color.Red;
foreach (var offset in attraction.Type.GetCoveredTiles())
batch.Draw(batch.GetBlankTexture(), new RectangleF(position + (pos + offset).ToVector2() * tileSize, tileSize), color * 0.25F * alpha);
2020-05-31 17:24:10 +02:00
}
2023-02-11 10:16:42 +01:00
attraction.Draw(batch, position + pos.ToVector2() * tileSize, alpha, scale);
2020-05-31 17:24:10 +02:00
}
2023-02-11 10:16:42 +01:00
// placing attraction
if (this.PlacingAttraction != null) {
var placingPos = position + this.PlacingPosition.ToVector2() * tileSize;
var color = this.CanPlace(this.PlacingPosition, this.PlacingAttraction) ? Color.Yellow : Color.Red;
foreach (var pos in this.PlacingAttraction.Type.GetCoveredTiles())
batch.Draw(batch.GetBlankTexture(), new RectangleF(placingPos + pos.ToVector2() * tileSize, tileSize), color * 0.25F * alpha);
this.PlacingAttraction.Draw(batch, placingPos, alpha * 0.5F, scale);
2020-06-01 14:45:20 +02:00
}
2023-02-11 10:16:42 +01:00
}
2020-06-01 14:45:20 +02:00
2023-02-11 10:16:42 +01:00
public bool CanPlace(Point position, Attraction attraction) {
foreach (var offset in attraction.Type.GetCoveredTiles()) {
if (!this.IsInBounds(position + offset))
return false;
if (this.GetAttractionAt(position + offset) != null)
return false;
2020-06-05 20:49:42 +02:00
}
2023-02-11 10:16:42 +01:00
return true;
}
2020-06-05 20:49:42 +02:00
2023-02-11 10:16:42 +01:00
public void Place(Point position, Attraction attraction) {
foreach (var (x, y) in attraction.Type.GetCoveredTiles())
this.attractionGrid[position.X + x, position.Y + y] = attraction;
this.attractions.Add((position, attraction));
}
2020-05-31 17:24:10 +02:00
2023-02-11 10:16:42 +01:00
public Attraction Remove(Point position) {
var attraction = this.GetAttractionAt(position);
if (attraction != null) {
foreach (var (x, y) in attraction.Type.GetCoveredTiles())
this.attractionGrid[position.X + x, position.Y + y] = null;
this.attractions.Remove((position, attraction));
2020-06-01 15:18:20 +02:00
}
2023-02-11 10:16:42 +01:00
return attraction;
}
2020-06-01 15:18:20 +02:00
2023-02-11 10:16:42 +01:00
public Attraction GetAttractionAt(Point position) {
return !this.IsInBounds(position) ? null : this.attractionGrid[position.X, position.Y];
}
2020-06-08 18:01:10 +02:00
2023-02-11 10:16:42 +01:00
public int GetAttractionAmount(AttractionType type) {
return this.attractions.Count(a => type == null || a.Item2.Type == type);
}
2020-06-17 01:48:35 +02:00
2023-02-11 10:16:42 +01:00
public int GetModifierAmount(AttractionModifier modifier) {
return this.attractions.Sum(a => a.Item2.GetModifierAmount(modifier));
}
2020-07-21 21:51:30 +02:00
2023-02-11 10:16:42 +01:00
public bool IsAnyAttractionAffected(AttractionModifier modifier) {
return this.attractions.Any(a => modifier.IsAffected(a.Item2));
}
2023-02-11 10:16:42 +01:00
public IEnumerable<(Point, Attraction)> GetAttractions() {
foreach (var attraction in this.attractions)
yield return attraction;
}
public bool IsInBounds(Point pos) {
return pos.X >= 0 && pos.Y >= 0 && pos.X < this.Width && pos.Y < this.Height;
}
public ParkMap Copy(int? newWidth = null, int? newHeight = null) {
var newMap = new ParkMap(newWidth ?? this.Width, newHeight ?? this.Height);
foreach (var (pos, attraction) in this.attractions) {
if (newMap.CanPlace(pos, attraction))
newMap.Place(pos, attraction);
2020-06-01 23:02:47 +02:00
}
2023-02-11 10:16:42 +01:00
newMap.TicketsPerSecond = this.TicketsPerSecond;
return newMap;
}
2020-06-01 23:02:47 +02:00
2023-02-11 10:16:42 +01:00
private bool TryAutoBuy() {
if (!Options.Instance.AutoBuyEnabled)
return false;
if (GameImpl.Instance.Tickets < Options.Instance.MinTicketsForAutoBuy)
return false;
if (this.autoBuyCounter < ParkMap.AutoBuyIntervalSecs)
return false;
this.autoBuyCounter -= ParkMap.AutoBuyIntervalSecs;
2020-07-08 16:04:44 +02:00
2023-02-11 10:16:42 +01:00
var success = false;
// auto-buy modifiers
if (Upgrade.AutoPlaceModifiers[0].IsActive()) {
// loop through all attractions, but look at attractions with fewer applied modifiers first
foreach (var attraction in this.attractions.Select(kv => kv.Item2).OrderBy(a => a.GetModifierAmount(null))) {
var match = AttractionModifier.Modifiers.Values.Where(m => m.IsAffected(attraction));
// if we don't have level 2, we only want to increase existing modifiers
if (!Upgrade.AutoPlaceModifiers[1].IsActive())
match = match.Where(m => attraction.GetModifierAmount(m) > 0);
// we want to apply the least applied modifier on this attraction
var modifier = match.OrderBy(m => attraction.GetModifierAmount(m)).FirstOrDefault();
if (modifier != null && modifier.Buy(attraction))
success = true;
2020-07-08 16:04:44 +02:00
}
}
2023-02-11 10:16:42 +01:00
return success;
2020-05-31 17:24:10 +02:00
}
2023-02-11 10:16:42 +01:00
2020-05-31 17:24:10 +02:00
}