private void onAfterFadeIn(object sender, AGSEventArgs args)
{
if (args.TimesInvoked == 1)
{
_game.State.RoomTransitions.Transition = AGSRoomTransitions.Dissolve();
}
}
private void onRepeatedlyExecute(object sender, AGSEventArgs args)
{
if (!IsCurrentlyDragged)
{
return;
}
if (!IsDragEnabled || !_input.LeftMouseButtonDown)
{
IsCurrentlyDragged = false;
return;
}
float mouseX = _input.MouseX;
float mouseY = _input.MouseY;
if (DragMinX != null && mouseX < DragMinX.Value)
{
return;
}
if (DragMaxX != null && mouseX > DragMaxX.Value)
{
return;
}
if (DragMinY != null && mouseY < DragMinY.Value)
{
return;
}
if (DragMaxY != null && mouseY > DragMaxY.Value)
{
return;
}
_transform.X = _dragObjectStartX + (mouseX - _dragMouseStartX);
_transform.Y = _dragObjectStartY + (mouseY - _dragMouseStartY);
}
private void onRepeatedlyExecute(object sender, AGSEventArgs args)
{
if (!_visible.Visible || !_enabled.Enabled || _collider.BoundingBox == null ||
(!_input.LeftMouseButtonDown && !_input.IsTouchDrag) || Graphics == null ||
Graphics.BoundingBox == null || !Graphics.CollidesWith(_input.MouseX, _input.MouseY) ||
HandleGraphics == null)
{
if (_isSliding)
{
_isSliding = false;
onValueChanged();
}
return;
}
_isSliding = true;
if (IsHorizontal)
{
setValue(getSliderValue(MathUtils.Clamp(_input.MouseX - _collider.BoundingBox.MinX, 0f, Graphics.Width)));
}
else
{
setValue(getSliderValue(MathUtils.Clamp(_input.MouseY - _collider.BoundingBox.MinY
, 0f, Graphics.Height)));
}
}
private async Task onBottleInteract(object sender, AGSEventArgs args)
{
_bottleEffectClip.Play();
await _bottle.ChangeRoomAsync(null);
_player.Inventory.Items.Add(InventoryItems.Bottle);
}
private void onBeforeFadeIn(object sender, AGSEventArgs args)
{
var room = Room;
if (room == null)
{
return;
}
var clip = room.MusicOnLoad;
if (clip == null)
{
return;
}
if (!_crossFading.FadeIn)
{
_music = clip.Play(shouldLoop: true);
return;
}
float endVolume = clip.Volume;
var music = clip.Play(0f, shouldLoop: true);
_music = music;
music.TweenVolume(endVolume, _crossFading.FadeInSeconds, _crossFading.EaseFadeIn);
}
private void onComponentsInitialized(object sender, AGSEventArgs args)
{
var skin = Skin;
if (skin == null)
{
return;
}
skin.Apply(_entity);
}
private void onRepeatedlyExecute(object sender, AGSEventArgs args)
{
WalkLineInstruction currentLine = _currentWalkLine;
if (currentLine == null)
{
return;
}
if (currentLine.CancelToken.IsCancellationRequested || currentLine.NumSteps <= 1f)
{
_currentWalkLine = null; //Possible race condition here? If so, need to replace with concurrent queue
_lastFrame = null;
_compensateScrollX = _compensateScrollY = 0f;
currentLine.OnCompletion.TrySetResult(null);
return;
}
if (_cutscene.IsSkipping)
{
_obj.X = currentLine.Destination.X;
_obj.Y = currentLine.Destination.Y;
_currentWalkLine = null; //Possible race condition here? If so, need to replace with concurrent queue
_lastFrame = null;
_compensateScrollX = _compensateScrollY = 0f;
currentLine.OnCompletion.TrySetResult(null);
return;
}
PointF walkSpeed = adjustWalkSpeed(WalkStep);
float xStep = currentLine.XStep * walkSpeed.X;
float yStep = currentLine.YStep * walkSpeed.Y;
if (MovementLinkedToAnimation && _animation != null && _animation.Animation.Frames.Count > 1 &&
_animation.Animation.Sprite == _lastFrame)
{
//If the movement is linked to the animation and the animation speed is slower the the viewport movement, it can lead to flickering
//so we do a smooth movement for this scenario.
_obj.X += compensateForViewScrollIfNeeded(_obj.Room.Viewport.X, xStep, ref _compensateScrollX, ref _lastViewportX);
_obj.Y += compensateForViewScrollIfNeeded(_obj.Room.Viewport.Y, yStep, ref _compensateScrollY, ref _lastViewportY);
return;
}
if (_animation != null)
{
_lastFrame = _animation.Animation.Sprite;
}
_lastViewportX = _obj.Room.Viewport.X;
currentLine.NumSteps -= Math.Abs(currentLine.IsBaseStepX ? xStep : yStep);
if (currentLine.NumSteps >= 0f)
{
_obj.X += (xStep - _compensateScrollX);
_obj.Y += (yStep - _compensateScrollY);
}
_compensateScrollX = _compensateScrollY = 0f;
}
public AGSHasImage()
{
OnImageChanged = new AGSEvent <AGSEventArgs>();
OnAnchorChanged = new AGSEvent <AGSEventArgs>();
OnTintChanged = new AGSEvent <AGSEventArgs>();
_imageArgs = new AGSEventArgs();
_anchorArgs = new AGSEventArgs();
_tintArgs = new AGSEventArgs();
Anchor = new PointF(0.5f, 0f);
Tint = Colors.White;
}
private void onRepeatedlyExecute(object sender, AGSEventArgs args)
{
if (Inventory == null)
{
return;
}
if (!isRefreshNeeded())
{
return;
}
_refreshNeeded = false;
foreach (var obj in _inventoryItems)
{
obj.Visible = false;
_tree.TreeNode.AddChild(obj);
}
List <IObject> items = new List <IObject> (Inventory.Items.Count);
foreach (var item in Inventory.Items)
{
items.Add(item.Graphics);
}
_inventoryItems = items;
int topItem = TopItem;
int count = Math.Min(topItem + RowCount * ItemsPerRow, items.Count);
float stepX = ItemSize.Width;
float stepY = ItemSize.Height;
float x = stepX / 2f;
float y = _scale.Height - stepY / 2;
for (int item = topItem; item < count; item++)
{
IObject obj = items[item];
obj.X = x;
obj.Y = y;
_tree.TreeNode.AddChild(obj);
if (!_state.UI.Contains(obj))
{
_state.UI.Add(obj);
}
obj.Visible = true;
x += stepX;
if (x >= _scale.Width)
{
x = stepX / 2f;
y -= stepY;
}
}
}
private void onParentChanged(object sender, AGSEventArgs args)
{
if (_parent != null)
{
_parent.OnMatrixChanged.Unsubscribe(onSomethingChanged);
}
_parent = _tree.TreeNode.Parent;
if (_parent != null)
{
_parent.OnMatrixChanged.Subscribe(onSomethingChanged);
}
onSomethingChanged(sender, args);
}
public AGSGame(IGameState state, IGameEvents gameEvents, IMessagePump messagePump,
IGraphicsBackend graphics, IGLUtils glUtils)
{
_messagePump = messagePump;
_messagePump.SetSyncContext();
State = state;
Events = gameEvents;
_relativeSpeed = state.Speed;
_renderEventArgs = new AGSEventArgs();
_graphics = graphics;
_glUtils = glUtils;
GLUtils = _glUtils;
}
private void onSavedGameLoad(object sender, AGSEventArgs args)
{
_state.Rooms.OnListChanged.Unsubscribe(onRoomsChange);
foreach (var fader in _map.Values)
{
fader.Dispose();
}
foreach (var room in _state.Rooms)
{
_map.TryAdd(room.ID, new RoomCrossFader(this, room));
}
_state = _game.State;
_state.Rooms.OnListChanged.Subscribe(onRoomsChange);
}
private void onRepeatedlyExecute(object sender, AGSEventArgs args)
{
if (_game.State.Paused)
{
return;
}
var obj = Translate;
var hasRoom = HasRoom;
foreach (var sound in _playingSounds)
{
if (sound.Value.Sound.HasCompleted)
{
EmittedSound value;
_playingSounds.TryRemove(sound.Key, out value);
continue;
}
if (obj == null)
{
continue;
}
if (AutoPan)
{
float pan = MathUtils.Lerp(0f, -1f, _game.Settings.VirtualResolution.Width, 1f, obj.Location.X);
sound.Value.Sound.Panning = pan;
}
if (AutoAdjustVolume)
{
if (hasRoom == null)
{
continue;
}
var room = _game.State.Room;
if (room != hasRoom.Room)
{
return;
}
foreach (var area in room.GetMatchingAreas(obj.Location.XY, EntityID))
{
var scalingArea = area.GetComponent <IScalingArea>();
if (scalingArea == null || !scalingArea.ScaleVolume)
{
continue;
}
float scale = scalingArea.GetScaling(obj.Y);
sound.Value.Sound.Volume = AudioClip.Volume * scale;
}
}
}
}
private async Task onRepeatedlyExecute(object sender, AGSEventArgs args)
{
var target = TargetBeingFollowed;
var currentWalk = _currentWalk;
var followSettings = _followSettings;
if (target == null || followSettings == null)
{
if (currentWalk != null)
{
_walk.StopWalking();
}
return;
}
if (target == _lastTarget)
{
if (currentWalk != null && !currentWalk.IsCompleted)
{
return;
}
}
_lastTarget = target;
if (_counter > 0)
{
if (_hasRoom.Room != target.Room && _newRoomX == null)
{
_newRoomX = target.X;
_newRoomY = target.Y;
}
_counter--;
return;
}
_counter = MathUtils.Random().Next(_followSettings.MinWaitBetweenWalks, _followSettings.MaxWaitBetweenWalks);
if (_hasRoom.Room != target.Room)
{
if (_followSettings.FollowBetweenRooms)
{
await _hasRoom.ChangeRoomAsync(target.Room, _newRoomX, _newRoomY);
_walk.PlaceOnWalkableArea();
_newRoomX = null;
_newRoomY = null;
}
return;
}
setNextWalk(target, followSettings);
}
private void onBeforeFadeOut(object sender, AGSEventArgs args)
{
var music = _music;
if (music == null || music.HasCompleted)
{
return;
}
if (!_crossFading.FadeOut)
{
music.Stop();
return;
}
music.TweenVolume(0f, _crossFading.FadeOutSeconds, _crossFading.EaseFadeOut).Task.ContinueWith(_ =>
{
music.Stop();
});
}
private void onBeforeRender(object sender, AGSEventArgs args)
{
if (_room.Room != null && _room.Room != _game.State.Room)
{
return;
}
if (_withCaret.TreeNode.Parent == null)
{
_withCaret.TreeNode.SetParent(_tree.TreeNode);
}
bool isVisible = IsFocused;
if (isVisible)
{
_caretFlashCounter--;
if (_caretFlashCounter < 0)
{
isVisible = false;
if (_caretFlashCounter < -CaretFlashDelay)
{
_caretFlashCounter = (int)CaretFlashDelay;
}
}
}
_withCaret.Visible = isVisible;
_withCaret.Text = _textComponent.Text;
_withCaret.TextConfig = _textComponent.TextConfig;
var renderer = _withCaret.CustomRenderer as ILabelRenderer;
if (renderer != null)
{
renderer.CaretPosition = CaretPosition;
renderer.BaseSize = _textComponent.LabelRenderSize;
renderer.RenderCaret = true;
}
_textComponent.TextVisible = !isVisible;
renderer = _imageComponent.CustomRenderer as ILabelRenderer;
if (renderer != null)
{
renderer.CaretPosition = CaretPosition;
}
}
private void onBeforeRender(object sender, AGSEventArgs args)
{
var shader = _shakeShader;
if (shader != null)
{
shader = shader.Compile();
}
if (shader == null || shader != getActiveShader())
{
_shakeShader = null;
AGSGame.Game.Events.OnBeforeRender.Unsubscribe(onBeforeRender);
return;
}
shader.Bind();
shader.SetVariable("time", (float)args.TimesInvoked);
var currentStrength = _strength + MathUtils.Random().Next(1000) / 1000000f; //Adding a little jerkiness
shader.SetVariable("strength", currentStrength);
_strength = _strength * _decay;
}
private void onRepeatedlyExecute(object sender, AGSEventArgs args)
{
if (_player == null)
{
return;
}
if (_lastInventoryItem == _player.Inventory.ActiveItem)
{
return;
}
_lastInventoryItem = _player.Inventory.ActiveItem;
if (_lastInventoryItem != null)
{
_inventoryItemIcon.Image = _lastInventoryItem.CursorGraphics.Image;
_inventoryItemIcon.Animation.Sprite.Anchor = new AGS.API.PointF(0.5f, 0.5f);
_inventoryItemIcon.ScaleTo(15f, 15f);
}
_inventoryItemIcon.Visible = (_lastInventoryItem != null);
}
private void onRepeatedlyExecute(object sender, AGSEventArgs e)
{
var state = _game.State;
IObject hotspot = state.Room.GetObjectAt(_game.Input.MouseX, _game.Input.MouseY);
if (hotspot == null)
{
turnOffObjectSpecificCursor();
return;
}
IHasCursorComponent specialCursor = hotspot.GetComponent <IHasCursorComponent>();
if (specialCursor == null)
{
turnOffObjectSpecificCursor();
return;
}
if (_game.Input.Cursor != specialCursor.SpecialCursor)
{
_lastCursor = _game.Input.Cursor;
_game.Input.Cursor = specialCursor.SpecialCursor;
}
_showingObjectSpecificCursor = true;
}
private async Task lookOnWindow(object sender, AGSEventArgs args)
{
_room.Viewport.Camera.Enabled = false;
float scaleX = _room.Viewport.ScaleX;
float scaleY = _room.Viewport.ScaleY;
float angle = _room.Viewport.Angle;
float x = _room.Viewport.X;
float y = _room.Viewport.Y;
Tween zoomX = _room.Viewport.TweenScaleX(4f, 2f);
Tween zoomY = _room.Viewport.TweenScaleY(4f, 2f);
Task rotate = _room.Viewport.TweenAngle(0.1f, 1f, Ease.QuadOut).Task.
ContinueWith(t => _room.Viewport.TweenAngle(angle, 1f, Ease.QuadIn).Task);
Tween translateX = _room.Viewport.TweenX(240f, 2f);
Tween translateY = _room.Viewport.TweenY(100f, 2f);
await Task.WhenAll(zoomX.Task, zoomY.Task, rotate, translateX.Task, translateY.Task);
await Task.Delay(100);
await _player.SayAsync("Hmmm, nobody seems to be home...");
await Task.Delay(100);
zoomX = _room.Viewport.TweenScaleX(scaleX, 2f);
zoomY = _room.Viewport.TweenScaleY(scaleY, 2f);
rotate = _room.Viewport.TweenAngle(0.1f, 1f, Ease.QuadIn).Task.
ContinueWith(t => _room.Viewport.TweenAngle(angle, 1f, Ease.QuadOut).Task);
translateX = _room.Viewport.TweenX(x, 2f);
translateY = _room.Viewport.TweenY(y, 2f);
await Task.WhenAll(zoomX.Task, zoomY.Task, rotate, translateX.Task, translateY.Task);
_room.Viewport.Camera.Enabled = true;
}
private bool canCompleteRoomTransition(AGSEventArgs args)
{
return(_roomTransitions.State == RoomTransitionState.NotInTransition);
}
private bool canContinueRoomTransition(AGSEventArgs args)
{
return(_roomTransitions.State == RoomTransitionState.PreparingTransition ||
_roomTransitions.State == RoomTransitionState.NotInTransition);
}
private void onRepeatedlyExecute(object sender, AGSEventArgs args)
{
visit();
}
private void onBeforeFadeIn(object sender, AGSEventArgs args)
{
_player.PlaceOnWalkableArea();
}
private void onSoftKeyboardHidden(object sender, AGSEventArgs args)
{
_keyboardState.OnSoftKeyboardHidden.Unsubscribe(onSoftKeyboardHidden);
IsFocused = false;
}
private async Task onLeftEdgeCrossed(object sender, AGSEventArgs args)
{
await _player.ChangeRoomAsync(Rooms.DarsStreet.Result, 490);
}
private async Task onRightEdgeCrossed(object sender, AGSEventArgs args)
{
await _player.ChangeRoomAsync(Rooms.EmptyStreet.Result, 30);
}
public void Start(IGameSettings settings)
{
GameLoop = _resolver.Container.Resolve <IGameLoop>(new TypedParameter(typeof(AGS.API.Size), settings.VirtualResolution));
TypedParameter settingsParameter = new TypedParameter(typeof(IGameSettings), settings);
try { GameWindow = Resolver.Container.Resolve <IGameWindow>(settingsParameter); }
catch (Exception ese)
{
Debug.WriteLine(ese.ToString());
throw;
}
//using (GameWindow)
{
try
{
TypedParameter gameWindowParameter = new TypedParameter(typeof(IGameWindow), GameWindow);
GameWindow.Load += (sender, e) =>
{
Settings = Resolver.Container.Resolve <IRuntimeSettings>(settingsParameter, gameWindowParameter);
_graphics.ClearColor(0f, 0f, 0f, 1f);
_graphics.Init();
_glUtils.GenBuffers();
Factory = Resolver.Container.Resolve <IGameFactory>();
TypedParameter sizeParameter = new TypedParameter(typeof(AGS.API.Size), Settings.VirtualResolution);
Input = _resolver.Container.Resolve <IInput>(gameWindowParameter, sizeParameter);
TypedParameter inputParamater = new TypedParameter(typeof(IInput), Input);
TypedParameter gameParameter = new TypedParameter(typeof(IGame), this);
_renderLoop = _resolver.Container.Resolve <IRendererLoop>(inputParamater, gameParameter);
updateResolver();
AudioSettings = _resolver.Container.Resolve <IAudioSettings>();
SaveLoad = _resolver.Container.Resolve <ISaveLoad>();
_glUtils.AdjustResolution(settings.VirtualResolution.Width, settings.VirtualResolution.Height);
Events.OnLoad.Invoke(sender, new AGSEventArgs());
};
GameWindow.Resize += async(sender, e) =>
{
await Task.Delay(10); //todo: For some reason on the Mac, the GL Viewport assignment is overridden without this delay (so aspect ratio is not preserved), a bug in OpenTK?
resize();
Events.OnScreenResize.Invoke(sender, new AGSEventArgs());
};
GameWindow.UpdateFrame += async(sender, e) =>
{
try
{
_messagePump.PumpMessages();
if (State.Paused)
{
return;
}
adjustSpeed();
await GameLoop.UpdateAsync().ConfigureAwait(false);
AGSEventArgs args = new AGSEventArgs();
//Invoking repeatedly execute asynchronously, as if one subscriber is waiting on another subscriber the event will
//never get to it (for example: calling ChangeRoom from within RepeatedlyExecute calls StopWalking which
//waits for the walk to stop, only the walk also happens on RepeatedlyExecute and we'll hang.
//Since we're running asynchronously, the next UpdateFrame will call RepeatedlyExecute for the walk cycle to stop itself and we're good.
///The downside of this approach is that we need to look out for re-entrancy issues.
await Events.OnRepeatedlyExecute.InvokeAsync(sender, args);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
throw ex;
}
};
GameWindow.RenderFrame += (sender, e) =>
{
if (_renderLoop == null)
{
return;
}
try
{
// render graphics
_graphics.ClearScreen();
Events.OnBeforeRender.Invoke(sender, _renderEventArgs);
if (_renderLoop.Tick())
{
GameWindow.SwapBuffers();
}
if (Repeat.OnceOnly("SetFirstRestart"))
{
SaveLoad.SetRestartPoint();
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception when rendering:");
Debug.WriteLine(ex.ToString());
throw;
}
};
// Run the game at 60 updates per second
GameWindow.Run(UPDATE_RATE);
} catch (Exception exx)
{
Debug.WriteLine(exx.ToString());
throw;
}
}
}
private static void firstSetupVignette(object sender, AGSEventArgs args)
{
setVignetteResolution();
AGSGame.Game.Events.OnBeforeRender.Unsubscribe(firstSetupVignette);
AGSGame.Game.Events.OnScreenResize.Subscribe(onVignetteShaderResize);
}
private static void onVignetteShaderResize(object sender, AGSEventArgs args)
{
setVignetteResolution();
}
