/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
Util.UI.Elements.Button.ButtonFont = ContentManager.Load <SpriteFont>("Arial");
Util.UI.Elements.TextView.TextViewFont = ContentManager.Load <SpriteFont>("ArialSmall");
PrimitiveDrawer = new Primitive(Graphics.GraphicsDevice, spriteBatch);
PrimitiveDrawer.Depth = 1.0f;
Hud = new Hud();
Camera.LoadContent();
Hud.LoadContent();
MovingEntityRenderer.LoadContent();
GameRenderer.LoadContent();
Player.Init();
Player.ConnectToWorld();
LivingEntityType.Create(new WorldPosition(WorldGrid.BlockSize.X * 3, WorldGrid.BlockSize.Y * 3, Interior.Outside), LivingEntityType.lookup[3]).ConnectToWorld();
AppDomain.CurrentDomain.ProcessExit += new EventHandler((object sender, EventArgs e) =>
{
SaveAndExit();
});
}
public override void Initialize()
{
GUIFont = Game.Content.Load <SpriteFont>("font");
camera = new Camera2D(Game.GraphicsDevice.Viewport);
camera.Stretch = new Vector2(
Game.GraphicsDevice.Viewport.Width / targetResolution.X,
Game.GraphicsDevice.Viewport.Height / targetResolution.Y
);
gameRenderer = new GameRenderer(Game, gameScene, camera);
animator = new Animator(Game, gameScene);
phys = new PhysicsBasicEngine(Game, gameScene);
gui = new GUILogic(Game, camera, _userInput);
debugRenderer = new DebugRenderer(Game, gameScene, camera);
debugRenderer.Visible = false;
Game.Components.Add(phys);
Game.Components.Add(animator);
Game.Components.Add(gameRenderer);
Game.Components.Add(gui);
Game.Components.Add(debugRenderer);
level.InitLevel(gameScene);
createGameGui();
UnitSpawner.Scene = gameScene;
CopyAI ai = new CopyAI(gameScene, level.player2Base);
base.Initialize();
}
public void OnPointerEnter(PointerEventData eventData)
{
// Depending on the action we may want to highlight the city or not
PlayerAction action = GameRenderer.GetAction();
if (action == PlayerAction.SettleNewCity) // Highlight only empty areas that are close to a city of ours
// FIXME
{
}
else if (action == PlayerAction.Denuclearize) // Highlight only if city not empty and readioactive and ours, or any empty radioactive spot
// FIXME
{
}
else if (action == PlayerAction.BuildCityImprovements) // Highlight only if the city is ours and the improvement (if selected) is not yet in the city. On click select the city for the improvement
{
if ((vals.status != CityStatus.Owned && vals.status != CityStatus.Radioactive) || vals.owner != GD.localPlayerIndex)
{
return;
}
areWeOver = true;
SetSprite();
}
else // Action not selected: highlight, on click base details. More info only if we have intelligence
{
areWeOver = true;
SetSprite();
}
}
public override void Render()
{
base.Render();
if (_started)
{
var diff = _end - _start;
var x = diff.X;
var y = diff.Y;
Color c = Color.FromArgb(150, 150, 150);
if (Math.Abs(x) + Math.Abs(y) < MINIMUM_LINE)
{
c = Color.Red;
}
switch (game.Canvas.ColorControls.Selected)
{
case LineType.Blue:
StandardLine sl = new StandardLine(_start, _end, _addflip);
sl.CalculateConstants();
GameRenderer.DrawTrackLine(sl, c, game.SettingRenderGravityWells, true, false, false);
break;
case LineType.Red:
RedLine rl = new RedLine(_start, _end, _addflip);
rl.Multiplier = game.Canvas.ColorControls.RedMultiplier;
rl.CalculateConstants();
GameRenderer.DrawTrackLine(rl, c, game.SettingRenderGravityWells, true, false, false);
break;
case LineType.Scenery:
GameRenderer.RenderRoundedLine(_start, _end, c, 1);
break;
}
}
}
void LoadContent()
{
_mapLoader.LoadMapContent(_controller.GameEngine.GameState);
_controller.GameEngine.gameTime = new TimeSpan();
_renderer = new GameRenderer(_graphicsDevice,
_controller.GameEngine.GameState, _content);
}
private IEnumerator PlayTurnRoutine()
{
//Play Turn Things
//TODO: PLAY!
//yield return new WaitForSeconds(4f);
System.Random rnd = new System.Random();
//random=rnd(0,2);
//if(random == 0)
// //ortadan tas al
//else if(random == 1)
// //Oyuncudan tas al
//
// stone
yield return(new WaitForSeconds(1f));
WhichStone = rnd.Next(0, stones.Count);
spToGive.DropStone(stones[WhichStone]);
//print("AI THROW");
///Rendering the stone which the ai has thrown
GameRenderer.RenderGhostStone(stones[WhichStone], this.transform, spToGive.transform, false, spToGive.isPickable);
//DİĞER PLAYER DAN AL
//ORTADAN ÇEK
//STONE DAN BİRİNİ SEÇ AT.
yield return(null);
}
public static void Main()
{
using (var introForm = new IntroForm())
{
introForm.ShowDialog();
Global.ServerName = introForm.ServerName;
Global.IsLocalServer = introForm.IsLocalServer;
if (introForm.ClearExistingChunks && Global.IsLocalServer)
{
Global.ClearExistingChunks = true;
}
}
using (GameRenderer gameRenderer = new GameRenderer())
{
//Utilities.SetWindowTitle(example);
IServer server;
if (Global.IsLocalServer)
{
server = new ServerLocal();
}
else
{
server = new ServerRemote();
}
Server.Run(server);
gameRenderer.Run(30.0);
}
}
static void Main(string[] args)
{
GameRenderer renderer = new GameRenderer();
GivenWordsModel givenWords = new GivenWordsModel();
PlayerModel player = new PlayerModel();
GameRules gameRules = new GameRules(player, givenWords);
ClockModel clock = new ClockModel();
renderer.RenderGameStart();
clock.StartClock();
while (!gameRules.GetGameStatus())
{
renderer.RenderClearConsole();
renderer.RenderCurrentWords(givenWords);
renderer.RenderPlayerInput(player);
ConsoleKeyInfo userKey = Console.ReadKey();
gameRules.CheckPlayerInput(userKey);
gameRules.CheckGameOver();
}
clock.StopClock();
StatisticsModel statistics = new StatisticsModel(givenWords, player, clock.GetTimeInMinutes());
renderer.RenderEndGame(statistics, clock.GetTimeInSeconds());
Console.ReadKey();
}
private void DrawLimitMarker(Graphics g, Panel panel, string text)
{
if (LimitMarkerWidth.Value != 0 && text != null && text != string.Empty)
{
g.DrawLine((GameRenderer.HasVariableLengthControlCodes(text) ? markerPenOrange : markerPenBlack), LimitMarkerWidth.Value, 0, LimitMarkerWidth.Value, panel.AutoScrollMinSize.Height);
}
}
public GameLoop(Game game,
IFullscreenService fullscreenService,
IMetricsService metricsHandler,
IUpdateService updateChecker)
{
MetricsHandler = metricsHandler;
UpdateChecker = updateChecker;
#if WINDOWS || MONOMAC
if (METRICS_ENABLED)
{
Global.metrics_allowed = true;
}
#endif
if (Config.UPDATE_CHECK_ENABLED)
{
Global.update_check_allowed = true;
}
//@Yeti: make this work without Global later?
GameSettings = new Settings();
Global.gameSettings = GameSettings;
Game = game;
Renderer = new GameRenderer(game, fullscreenService);
IOHandler = new GameIOHandler(this, Renderer);
#if !MONOGAME
// Setup our OpenALSoundController to handle our SoundBuffer pools
OpenALInterface.create_sound_controller();
#endif
}
private void RedrawPreview(Graphics g, Panel panel, string text)
{
g.TranslateTransform(panel.AutoScrollPosition.X, panel.AutoScrollPosition.Y);
panel.AutoScrollMinSize = new Size((panel.ClientSize.Width - SystemInformation.VerticalScrollBarWidth), GameRenderer?.MeasureStringHeight(text) ?? panel.ClientSize.Height);
GameRenderer?.DrawString(g, text, OverridesEnabled);
DrawLimitMarker(g, panel, text);
}
private void PlaceLines(TrackWriter trk, bool preview)
{
if (controlPoints.Count > 1)
{
List <Vector2> curvePoints = GameRenderer.GenerateBezierCurve(controlPoints.ToArray(), Settings.Bezier.Resolution).ToList();
if (!preview)
{
game.Track.UndoManager.BeginAction();
}
for (int i = 1; i < curvePoints.Count; i++)
{
Vector2d _start = (Vector2d)curvePoints[i - 1];
Vector2d _end = (Vector2d)curvePoints[i];
if ((_end - _start).Length >= MINIMUM_LINE)
{
var added = CreateLine(trk, _start, _end, _addflip, Snapped, EnableSnap);
workingLines.Add(added);
}
}
game.Track.NotifyTrackChanged();
if (!preview)
{
game.Track.UndoManager.EndAction();
}
}
game.Invalidate();
}
public override void Render()
{
if (Active)
{
var color = Color.FromArgb(255, 0x00, 0x77, 0xcc);
if (_selectionbox != DoubleRect.Empty)
{
GameRenderer.RenderRoundedRectangle(_selectionbox, color, 2f / game.Track.Zoom);
RenderCorner(_selectionbox, true, true);
RenderCorner(_selectionbox, false, false);
RenderCorner(_selectionbox, true, false);
RenderCorner(_selectionbox, false, true);
if (_hoverscale)
{
RenderFilledCorner(_selectionbox, _nodetop, _nodeleft);
}
}
if (_drawbox != DoubleRect.Empty)
{
GameRenderer.RenderRoundedRectangle(_drawbox, color, 2f / game.Track.Zoom);
}
if (_hoverline != null)
{
GameRenderer.RenderRoundedLine(_hoverline.Position, _hoverline.Position2, Color.FromArgb(127, Constants.DefaultKnobColor), (_hoverline.Width * 2 * 0.8f));
GameRenderer.DrawKnob(_hoverline.Position, _snapknob1, false, _hoverline.Width, _snapknob1 && !_snapknob2 ? 1 : 0);
GameRenderer.DrawKnob(_hoverline.Position2, _snapknob2, false, _hoverline.Width, _snapknob2 && !_snapknob1 ? 1 : 0);
}
}
base.Render();
}
private void Control_Loaded(object sender, RoutedEventArgs e)
{
//FinalScoreViewModel dataCntx = (FinalScoreViewModel)Window.GetWindow(this).DataContext;
//Console.WriteLine(dataCntx.loadGame);
this.model = new GameModel(this.ActualWidth, this.ActualHeight);
this.logic = new GameLogic(this.model);
this.renderer = new GameRenderer(this.model);
Window win = Window.GetWindow(this);
if (win != null)
{
win.KeyDown += this.Win_KeyDown;
this.timer = new DispatcherTimer();
this.timer.Interval = TimeSpan.FromMilliseconds(50);
this.timer.Tick += this.Timer_Tick;
this.timer.Start();
this.bulletsTimer = new DispatcherTimer();
this.bulletsTimer.Interval = TimeSpan.FromMilliseconds(50);
this.bulletsTimer.Tick += this.Bullets_timer_Tick;
this.bulletsTimer.Start();
this.playerStaminaTimer = new DispatcherTimer();
this.playerStaminaTimer.Interval = TimeSpan.FromMilliseconds(500);
this.playerStaminaTimer.Tick += PlayerStaminaTimer_Tick;
this.playerStaminaTimer.Start();
}
this.InvalidateVisual();
}
public MainWindow()
{
Instance = this;
InitializeComponent();
world = World.Instance;
world.GameCompleted += World_GameCompleted;
var renderer = new GameRenderer(this.GameCanvas);
this.GameCanvas.Height = this.GameCanvas.Width = World.SIZE * GameRenderer.SPRITE_SIZE;
renderer.DrawWorld(world);
GameObject.World = world;
GameObject.Renderer = renderer;
this.DataContext = world;
world.PropertyChanged += World_PropertyChanged;
timer.Interval = TimeSpan.FromMilliseconds(100);
timer.Tick += world.GameLoop;
this.KeyDown += MainWindow_KeyDown;
//var agent = new Agent2D.Agent2D();
//for (int i = 0; i < 15; i++)
//{
// agent.Test();
// agent.Train();
//}
//agent.Test();
//Environment.Exit(0);
}
protected override void OnLoad(EventArgs e)
{
this.renderer = new GameRenderer();
this.game = new GameState();
InputManager.Initialize(this.Mouse);
}
public static void handleLogInit(RunningGameInfoMsg initMsg)
{
currentPlayers = initMsg.players;
localRenderer = null;
logQueue.Clear();
singleton.startInitQueue();
isSpectating = true;
}
public override void Render()
{
base.Render();
if (DrawingScenery && _mouseshadow != Vector2d.Zero && !game.Track.Playing)
{
GameRenderer.RenderRoundedLine(_mouseshadow, _mouseshadow, Color.FromArgb(100, 0x00, 0xCC, 0x00), 2f * game.Canvas.ColorControls.GreenMultiplier, false, false);
}
}
public static Piece getSubstitutivePiece(Chessboard board, Cell pos, Team squad)
{
Console.WriteLine("\nCon che pezzo vuoi sostituire il pedone?");
byte line = 4;
ConsoleColor col0, col1, col2, col3 = ConsoleColor.Black;
bool done = false;
Console.CursorTop = Console.CursorTop + 4;
while (!done)
{
Console.CursorTop = Console.CursorTop - 4;
col0 = ConsoleColor.Black;
col1 = ConsoleColor.Black;
col2 = ConsoleColor.Black;
col3 = ConsoleColor.Black;
switch (line % 4)
{
case 0: col0 = ConsoleColor.DarkRed; break;
case 1: col1 = ConsoleColor.DarkRed; break;
case 2: col2 = ConsoleColor.DarkRed; break;
case 3: col3 = ConsoleColor.DarkRed; break;
}
GameRenderer.Write("Regina\n", ConsoleColor.White, col0);
GameRenderer.Write("Torre\n", ConsoleColor.White, col1);
GameRenderer.Write("Cavallo\n", ConsoleColor.White, col2);
GameRenderer.Write("Alfiere\n", ConsoleColor.White, col3);
var key = Console.ReadKey(true).Key;
if (key == ConsoleKey.Enter)
{
break;
}
if (key == ConsoleKey.UpArrow)
{
line--;
}
else if (key == ConsoleKey.DownArrow)
{
line++;
}
}
System.Diagnostics.Debug.Print(">>>{0}", line % 4);
switch (line % 4)
{
case 0: return(new Queen(squad));
case 1: return(new Rook(squad));
case 2: return(new Knight(squad));
default: return(new Bishop(squad));
}
}
private void skControl1_PaintSurface(object sender, SkiaSharp.Views.Desktop.SKPaintSurfaceEventArgs e)
{
var canvas = e.Surface.Canvas;
GameRenderer gameRenderer = new GameRenderer(canvas, _scale, 80, GetHexagonHeight(80), new SKSize(skControl1.Width, skControl1.Height));
gameRenderer.ShowScoreboard = true;
gameRenderer.ShowRobotId = chkShowRobotId.Checked;
if (_timer.Enabled)
{
gameRenderer.Speed = timerSpeed;
}
else
{
gameRenderer.Speed = 0;
}
if (cboIndicator.SelectedItem == null || ((RobotIdSelection)cboIndicator.SelectedItem).IsNone)
{
gameRenderer.ShowDebugIndicators = false;
}
else if (((RobotIdSelection)cboIndicator.SelectedItem).IsAll)
{
gameRenderer.ShowDebugIndicators = true;
gameRenderer.ShowAllDebugIndicators = true;
}
else
{
gameRenderer.ShowDebugIndicators = true;
gameRenderer.ShowAllDebugIndicators = false;
gameRenderer.ShowDebugIndicatorRobotId = ((RobotIdSelection)cboIndicator.SelectedItem).Id;
}
if (_gameController != null)
{
if (_gameController.Round == 0)
{
gameRenderer.DrawStartScreen(_gameController.BlueTeamName, _gameController.RedTeamName);
}
else if (_gameController.IsFinished)
{
gameRenderer.DrawWinnerScreen(_gameController.WinnerTeam, _gameController.WinnerTeam == Team.Blue ? _gameController.BlueTeamName : _gameController.RedTeamName);
}
else
{
lock (_syncLockObj) {
gameRenderer.DrawGame(_gameController);
}
}
}
else
{
gameRenderer.DrawInfo();
}
}
private void OnDisable()
{
GameRenderer renderer = GameObject.FindObjectOfType <GameRenderer>();
if (renderer != null)
{
renderer.RemoveActivePanel(this);
}
}
public virtual void Draw(TimeSpan elapsed)
{
GameRenderer.Clear();
foreach (var component in DrawableComponents)
{
component.Draw(GameRenderer, elapsed);
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
this.InitializeComponent();
var renderer = new GameRenderer(this.GameCanvas);
var map = new Classic();
var engine = new Engine(map, renderer);
engine.InitGame();
engine.DrawGameObjects();
}
private void RenderCorner(DoubleRect box, bool top, bool left)
{
var corner = GetCorner(box, top, left);
var rect = new DoubleRect(
GameDrawingMatrix.ScreenCoordD(corner.Vector),
new Vector2d(corner.Width * game.Track.Zoom,
corner.Height * game.Track.Zoom));
GameRenderer.RenderRoundedRectangle(rect, Color.CornflowerBlue, 2, false);
}
public ColorWarsGame(ColorWarsSettings settings)
{
this.settings = settings;
this.playerList = new List <PlayerModel>();
this.playerControllersList = new List <PlayerController>();
this.gameBoard = new GameBoard(this.settings.StartingTerritorySize, this.settings.MapDimension);
this.gameRenderer = new GameRenderer(new GraphicsDeviceManager(this), this.settings);
this.gameActors = new ActorList();
this.scoreboard = new Scoreboard(this.playerList, this.gameBoard);
}
static void Main(string[] args)
{
Map map = new Map();
Bird bird = new Bird(5, 3);
GameRenderer gameRenderer = new GameRenderer(map, bird);
System.Timers.Timer timer = new System.Timers.Timer(200); // Timeris 200ms
GameRules gameRules = new GameRules(map, bird, timer);
GameTicker game = new GameTicker(gameRules, gameRenderer, timer);
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize( )
{
this.GraphicManager = new GraphicManager(this.Content);
this.AudioManager = new AudioManager(this.Content);
this.Renderer = new GameRenderer( );
this.GameProcessorManager = new GameProcessorManager( );
base.Initialize( );
}
private void LevelTimer_Tick(object sender, EventArgs e)
{
if (this.model.MyPlayer.Health == 0)
{
this.levelTimer.Stop();
foreach (var item in this.model.Projectiles)
{
item.Timer.Stop();
item.Timer = null;
}
this.shootOnce.Stop();
this.moveOnce.Stop();
this.updateTimer.Stop();
if (this.reloadTimer != null)
{
this.reloadTimer.Stop();
}
this.saveGameRepo.Insert(null);
GameOverWindow window = new GameOverWindow(this.loadigLogic, this.saveGameRepo);
window.Show();
Window win = Window.GetWindow(this);
win.Close();
}
if (this.model.LevelFinished)
{
this.levelTimer.Stop();
foreach (var item in this.model.Projectiles)
{
item.Timer.Stop();
item.Timer = null;
}
this.shootOnce.Stop();
this.moveOnce.Stop();
this.updateTimer.Stop();
if (this.reloadTimer != null)
{
this.reloadTimer.Stop();
}
this.gameLogic = null;
this.renderer = null;
this.loadigLogic.NextLevel();
this.gameLogic = new GameLogic(this.model);
this.renderer = new GameRenderer(this.model);
this.saveGameRepo.Insert(this.model as GameModel);
this.updateTimer.Start();
this.levelTimer.Start();
}
}
public MainWindow()
{
this.InitializeComponent();
var renderer = new GameRenderer(this.GameCanvas);
var map = new Classic();
var engine = new Engine(map, renderer);
engine.InitGame();
engine.DrawGameObjects();
///this.Dots();
}
private void DrawHover(GameLine line,
bool knob1, bool knob2, bool selected = false)
{
var start = line.Position;
var end = line.Position2;
var width = line.Width;
var elapsed = _hovertime.ElapsedMilliseconds;
int animtime = 250;
if (_hovertime.IsRunning)
{
if (elapsed > animtime * 2)
{
if (_hoverclick)
{
_hovertime.Stop();
}
else
{
_hovertime.Stop();
}
}
game.Track.Invalidate();
}
float hoverratio;
if (_hoverclick)
{
animtime = 75;
elapsed += 75 / 4;
hoverratio = Math.Min(animtime, elapsed) / (float)animtime;
}
else
{
hoverratio = Math.Min((Math.Min(animtime, elapsed) / (float)animtime), 0.5f);
}
var both = knob1 == knob2 == true;
var linealpha = both ? 64 : 48;
if (selected && both)
{
linealpha += 16;
}
GameRenderer.RenderRoundedLine(
start,
end,
Color.FromArgb(linealpha, Color.FromArgb(127, 127, 127)),
(width * 2));
bool canlifelock = CanLifelock && line.Type != LineType.Scenery;
GameRenderer.DrawKnob(start, knob1, canlifelock, width, hoverratio);
GameRenderer.DrawKnob(end, knob2, canlifelock, width, hoverratio);
}
//private readonly int queue_count = 7;
void Awake()
{
if (GRenderer == null) {
GRenderer = this;
DontDestroyOnLoad(GRenderer);
}
else if (GRenderer != this) {
Destroy (gameObject);
}
}
