public void RunCommands(List <VMArchitectureCommand> commands)
{
for (var i = 0; i < commands.Count; i++)
{
var com = commands[i];
switch (com.Type)
{
case VMArchitectureCommandType.WALL_LINE:
VMArchitectureTools.DrawWall(this, new Point(com.x, com.y), com.x2, com.y2, com.pattern, com.style, com.level, false);
break;
case VMArchitectureCommandType.WALL_DELETE:
VMArchitectureTools.EraseWall(this, new Point(com.x, com.y), com.x2, com.y2, com.pattern, com.style, com.level);
break;
case VMArchitectureCommandType.WALL_RECT:
VMArchitectureTools.DrawWallRect(this, new Rectangle(com.x, com.y, com.x2, com.y2), com.pattern, com.style, com.level);
break;
case VMArchitectureCommandType.PATTERN_FILL:
VMArchitectureTools.WallPatternFill(this, new Point(com.x, com.y), com.pattern, com.level);
break;
case VMArchitectureCommandType.PATTERN_DOT:
VMArchitectureTools.WallPatternDot(this, new Point(com.x, com.y), com.pattern, com.x2, com.y2, com.level);
break;
case VMArchitectureCommandType.FLOOR_FILL:
VMArchitectureTools.FloorPatternFill(this, new Point(com.x, com.y), com.pattern, com.level);
break;
case VMArchitectureCommandType.FLOOR_RECT:
VMArchitectureTools.FloorPatternRect(this, new Rectangle(com.x, com.y, com.x2, com.y2), com.style, com.pattern, com.level);
break;
}
}
}
public int RunCommands(List <VMArchitectureCommand> commands, bool transient)
{
int cost = 0; //negative for sellback;
int pdCount = 0;
ushort pdVal = 0;
VMAvatar lastAvatar = null;
for (var i = 0; i < commands.Count; i++)
{
var com = commands[i];
var avaEnt = Context.VM.Entities.FirstOrDefault(x => x.PersistID == com.CallerUID);
if ((avaEnt == null || avaEnt is VMGameObject) && !transient)
{
return(0); //we need an avatar to run a command from net
}
var avatar = (transient)? null : (VMAvatar)avaEnt;
lastAvatar = avatar;
var styleInd = -1;
var walls = Content.Content.Get().WorldWalls;
walls.WallStyleToIndex.TryGetValue(com.style, out styleInd);
//if patterns are invalid, don't do anything.
switch (com.Type)
{
case VMArchitectureCommandType.WALL_LINE:
if (styleInd == -1)
{
break; //MUST be purchasable style
}
var lstyle = walls.GetWallStyle(com.style);
var nwCount = VMArchitectureTools.DrawWall(this, new Point(com.x, com.y), com.x2, com.y2, com.pattern, com.style, com.level, false);
if (nwCount > 0)
{
cost += nwCount * lstyle.Price;
if (avatar != null)
{
Context.VM.SignalChatEvent(new VMChatEvent(avatar.PersistID, VMChatEventType.Arch,
avatar.Name,
Context.VM.GetUserIP(avatar.PersistID),
"placed " + nwCount + " walls."
));
}
}
break;
case VMArchitectureCommandType.WALL_DELETE:
var dwCount = VMArchitectureTools.EraseWall(this, new Point(com.x, com.y), com.x2, com.y2, com.pattern, com.style, com.level);
if (dwCount > 0)
{
cost -= 7 * dwCount;
if (avatar != null)
{
Context.VM.SignalChatEvent(new VMChatEvent(avatar.PersistID, VMChatEventType.Arch,
avatar.Name,
Context.VM.GetUserIP(avatar.PersistID),
"erased " + dwCount + " walls."
));
}
}
break;
case VMArchitectureCommandType.WALL_RECT:
if (styleInd == -1)
{
break; //MUST be purchasable style
}
var rstyle = walls.GetWallStyle(com.style);
var rwCount = VMArchitectureTools.DrawWallRect(this, new Rectangle(com.x, com.y, com.x2, com.y2), com.pattern, com.style, com.level);
if (rwCount > 0)
{
cost += rwCount * rstyle.Price;
if (avatar != null)
{
Context.VM.SignalChatEvent(new VMChatEvent(avatar.PersistID, VMChatEventType.Arch,
avatar.Name,
Context.VM.GetUserIP(avatar.PersistID),
"placed " + rwCount + " walls (rect)."
));
}
}
break;
case VMArchitectureCommandType.PATTERN_FILL:
var pattern = GetPatternRef(com.pattern);
if (pattern == null && com.pattern != 0)
{
break;
}
var pfCount = VMArchitectureTools.WallPatternFill(this, new Point(com.x, com.y), com.pattern, com.level);
if (pfCount.Total > 0)
{
cost -= pfCount.Cost - pfCount.Cost / 5;
cost += (pattern == null) ? 0 : pattern.Price * pfCount.Total;
if (avatar != null)
{
Context.VM.SignalChatEvent(new VMChatEvent(avatar.PersistID, VMChatEventType.Arch,
avatar.Name,
Context.VM.GetUserIP(avatar.PersistID),
"pattern filled " + pfCount + " walls with pattern #" + com.pattern
));
}
}
break;
case VMArchitectureCommandType.PATTERN_DOT:
var pdpattern = GetPatternRef(com.pattern);
if (pdpattern == null && com.pattern != 0)
{
break;
}
var dot = VMArchitectureTools.WallPatternDot(this, new Point(com.x, com.y), com.pattern, com.x2, com.y2, com.level);
pdVal = com.pattern;
if (dot.Total > -1)
{
cost -= dot.Cost - dot.Cost / 5;
cost += (pdpattern == null) ? 0 : pdpattern.Price;
pdCount++;
}
break;
case VMArchitectureCommandType.FLOOR_FILL:
var ffpattern = GetFloorRef(com.pattern);
if (ffpattern == null && com.pattern != 0)
{
break;
}
var ffCount = VMArchitectureTools.FloorPatternFill(this, new Point(com.x, com.y), com.pattern, com.level);
if (ffCount.Total > 0)
{
cost -= (ffCount.Cost - ffCount.Cost / 5) / 2;
cost += (ffpattern == null) ? 0 : ffpattern.Price * ffCount.Total / 2;
if (avatar != null)
{
Context.VM.SignalChatEvent(new VMChatEvent(avatar.PersistID, VMChatEventType.Arch,
avatar.Name,
Context.VM.GetUserIP(avatar.PersistID),
"floor filled " + ffCount.Total / 2f + " with pattern #" + com.pattern
));
}
}
break;
case VMArchitectureCommandType.FLOOR_RECT:
var frpattern = GetFloorRef(com.pattern);
if (frpattern == null && com.pattern != 0)
{
break;
}
var frCount = VMArchitectureTools.FloorPatternRect(this, new Rectangle(com.x, com.y, com.x2, com.y2), com.style, com.pattern, com.level);
if (frCount.Total > 0)
{
cost -= (frCount.Cost - frCount.Cost / 5) / 2;
cost += (frpattern == null) ? 0 : frpattern.Price * frCount.Total / 2;
if (avatar != null)
{
Context.VM.SignalChatEvent(new VMChatEvent(avatar.PersistID, VMChatEventType.Arch,
avatar.Name,
Context.VM.GetUserIP(avatar.PersistID),
"placed " + frCount.Total / 2f + " tiles with pattern #" + com.pattern
));
}
}
break;
}
}
if (lastAvatar != null && pdCount > 0)
{
Context.VM.SignalChatEvent(new VMChatEvent(lastAvatar.PersistID, VMChatEventType.Arch,
lastAvatar.Name,
Context.VM.GetUserIP(lastAvatar.PersistID),
"pattern dotted " + pdCount + " walls with pattern #" + pdVal
));
}
return(cost);
}
public override void Update(UpdateState state)
{
base.Update(state);
ModePositions[3].Y = 11;
ModeTargets[3].Y = 7.896059f;
if (Dead)
{
return;
}
if (vm == null)
{
InitializeLot();
}
vm.Update();
if (World != null && !Initialized)
{
var rcs = (World.State as WorldStateRC);
if (rcs != null)
{
Cam = (WorldCamera3D)rcs.Camera;
rcs.FixedCam = true;
rcs.CameraMode = true;
}
SetMode(UICASMode.FamilySelect);
SetFamilies();
Initialized = true;
//FamilySimInterp = FamilySimInterp;
}
if (World.State.PreciseZoom != 1)
{
World.State.PreciseZoom = World.State.PreciseZoom;
}
switch (Mode)
{
case UICASMode.FamilySelect:
if (World.State.Level != 2)
{
World.State.Level = 2;
World.State.DrawRoofs = true;
vm.Context.Blueprint.Cutaway = new bool[vm.Context.Blueprint.Cutaway.Length];
vm.Context.Blueprint.Damage.Add(new FSO.LotView.Model.BlueprintDamage(FSO.LotView.Model.BlueprintDamageType.WALL_CUT_CHANGED));
}
break;
default:
if (World.State.Level != 1 && Cam == null)
{
World.State.Level = 1;
World.State.DrawRoofs = false;
vm.Context.Blueprint.Cutaway = VMArchitectureTools.GenerateRoomCut(vm.Context.Architecture, World.State.Level, World.State.CutRotation,
new HashSet <uint>(vm.Context.RoomInfo.Where(x => x.Room.IsOutside == false).Select(x => (uint)x.Room.RoomID)));
vm.Context.Blueprint.Damage.Add(new FSO.LotView.Model.BlueprintDamage(FSO.LotView.Model.BlueprintDamageType.WALL_CUT_CHANGED));
}
break;
}
vm.Context.Clock.Minutes = 0;
vm.Context.Clock.Hours = 12;
var disableAccept = false;
switch (Mode)
{
case UICASMode.SimEdit:
if (CASPanel.FirstNameTextBox.CurrentText.Length == 0)
{
disableAccept = true;
}
break;
case UICASMode.FamilySelect:
if (FamiliesPanel.Selection == -1)
{
disableAccept = true;
}
break;
case UICASMode.FamilyEdit:
if (WIPFamily.Count == 0)
{
disableAccept = true;
}
break;
}
AcceptButton.Disabled = disableAccept;
//AcceptButton.ForceState = disableAccept ? 0 : -1;
//AcceptButton.Opacity = disableAccept ? 0.5f : 1;
if (Mode == UICASMode.SimEdit)
{
UpdateCarousel(state);
}
for (int i = 0; i < 18; i++)
{
var relPos = HeadPosition + i - 9;
relPos = (float)DirectionUtils.PosMod(relPos, 18);
if (relPos > 9)
{
relPos += 6;
}
var angle = (relPos / 24) * (Math.PI * 2);
var pos = new Vector3(28.5f + 4.5f * (float)Math.Cos(angle), 21.5f + 4.5f * (float)Math.Sin(angle), 0);
HeadAvatars[i].RadianDirection = (float)angle + (float)Math.PI / 2;
HeadAvatars[i].VisualPosition = pos;
}
for (int i = 0; i < 18; i++)
{
var relPos = BodyPosition + i - 9;
relPos = (float)DirectionUtils.PosMod(relPos, 18);
if (relPos > 9)
{
relPos += 6;
}
var angle = (relPos / 24) * (Math.PI * 2);
var pos = new Vector3(28.5f + 4.5f * (float)Math.Cos(angle), 21.5f + 4.5f * (float)Math.Sin(angle), 0);
BodyAvatars[i].RadianDirection = (float)angle + (float)Math.PI / 2;
BodyAvatars[i].VisualPosition = pos;
}
foreach (var fam in RepresentFamily)
{
for (int i = 0; i < 16; i++)
{
fam.SetMotiveData((VMMotive)i, 100);
}
var q = new List <FSO.SimAntics.Engine.VMQueuedAction>(fam.Thread.Queue);
foreach (var action in q)
{
fam.Thread.CancelAction(action.UID);
}
}
}
private void UpdateCutaway(UpdateState state)
{
if (vm.Context.Blueprint != null)
{
World.State.DynamicCutaway = (WallsMode == 1);
//first we need to cycle the rooms that are being cutaway. Keep this up even if we're in all-cut mode.
var mouseTilePos = World.EstTileAtPosWithScroll(new Vector2(state.MouseState.X, state.MouseState.Y) / FSOEnvironment.DPIScaleFactor);
var roomHover = vm.Context.GetRoomAt(LotTilePos.FromBigTile((short)(mouseTilePos.X), (short)(mouseTilePos.Y), World.State.Level));
var outside = (vm.Context.RoomInfo[roomHover].Room.IsOutside);
if (!outside && !CutRooms.Contains(roomHover))
{
CutRooms.Add(roomHover); //outside hover should not persist like with other rooms.
}
while (CutRooms.Count > 3)
{
CutRooms.Remove(CutRooms.ElementAt(0));
}
if (LastWallMode != WallsMode)
{
if (WallsMode == 0) //walls down
{
LastCuts = new bool[vm.Context.Architecture.Width * vm.Context.Architecture.Height];
vm.Context.Blueprint.Cutaway = LastCuts;
vm.Context.Blueprint.Damage.Add(new FSO.LotView.Model.BlueprintDamage(FSO.LotView.Model.BlueprintDamageType.WALL_CUT_CHANGED));
for (int i = 0; i < LastCuts.Length; i++)
{
LastCuts[i] = true;
}
}
else if (WallsMode == 1)
{
MouseCutRect = new Rectangle();
LastCutRooms = new HashSet <uint>()
{
uint.MaxValue
}; //must regenerate cuts
}
else //walls up or roof
{
LastCuts = new bool[vm.Context.Architecture.Width * vm.Context.Architecture.Height];
vm.Context.Blueprint.Cutaway = LastCuts;
vm.Context.Blueprint.Damage.Add(new FSO.LotView.Model.BlueprintDamage(FSO.LotView.Model.BlueprintDamageType.WALL_CUT_CHANGED));
}
LastWallMode = WallsMode;
}
if (WallsMode == 1)
{
if (RMBScroll || !MouseIsOn)
{
return;
}
int recut = 0;
var finalRooms = new HashSet <uint>(CutRooms);
var newCut = new Rectangle((int)(mouseTilePos.X - 2.5), (int)(mouseTilePos.Y - 2.5), 5, 5);
newCut.X -= VMArchitectureTools.CutCheckDir[(int)World.State.CutRotation][0] * 2;
newCut.Y -= VMArchitectureTools.CutCheckDir[(int)World.State.CutRotation][1] * 2;
if (newCut != MouseCutRect)
{
MouseCutRect = newCut;
recut = 1;
}
if (LastFloor != World.State.Level || LastRotation != World.State.CutRotation || !finalRooms.SetEquals(LastCutRooms))
{
LastCuts = VMArchitectureTools.GenerateRoomCut(vm.Context.Architecture, World.State.Level, World.State.CutRotation, finalRooms);
recut = 2;
LastFloor = World.State.Level;
LastRotation = World.State.CutRotation;
}
LastCutRooms = finalRooms;
if (recut > 0)
{
var finalCut = new bool[LastCuts.Length];
Array.Copy(LastCuts, finalCut, LastCuts.Length);
var notableChange = VMArchitectureTools.ApplyCutRectangle(vm.Context.Architecture, World.State.Level, finalCut, MouseCutRect);
if (recut > 1 || notableChange || LastRectCutNotable)
{
vm.Context.Blueprint.Cutaway = finalCut;
vm.Context.Blueprint.Damage.Add(new FSO.LotView.Model.BlueprintDamage(FSO.LotView.Model.BlueprintDamageType.WALL_CUT_CHANGED));
}
LastRectCutNotable = notableChange;
}
}
}
}
public void Update(UpdateState state, bool scrolled)
{
ushort pattern = (state.CtrlDown) ? (ushort)0 : Pattern;
var tilePos = World.EstTileAtPosWithScroll(Parent.GetScaledPoint(state.MouseState.Position).ToVector2() / FSOEnvironment.DPIScaleFactor);
Point cursor = new Point((int)tilePos.X, (int)tilePos.Y);
if (!Drawing && Commands.Count > 0)
{
vm.Context.Architecture.SignalRedraw();
Commands.Clear();
}
if (state.ShiftDown)
{
if (Commands.Count == 0 || Commands[0].Type != VMArchitectureCommandType.PATTERN_FILL)
{
Commands.Clear();
vm.Context.Architecture.SignalRedraw();
Commands.Add(new VMArchitectureCommand
{
Type = VMArchitectureCommandType.PATTERN_FILL,
level = World.State.Level,
pattern = pattern,
style = 0,
x = cursor.X,
y = cursor.Y
});
}
}
else
{
if (Commands.Count > 0 && Commands[0].Type == VMArchitectureCommandType.PATTERN_FILL)
{
Commands.Clear();
vm.Context.Architecture.SignalRedraw();
}
int dir = 0;
int altdir = 0;
Vector2 fract = new Vector2(tilePos.X - cursor.X, tilePos.Y - cursor.Y);
switch (World.State.CutRotation)
{
case WorldRotation.BottomRight:
if (fract.X - fract.Y > 0)
{
dir = 2; altdir = 3;
}
else
{
dir = 3; altdir = 2;
}
break;
case WorldRotation.TopRight:
if (fract.X + fract.Y > 1)
{
dir = 3; altdir = 0;
}
else
{
dir = 0; altdir = 3;
}
break;
case WorldRotation.TopLeft:
//+x is right down. +y is left down
if (fract.X - fract.Y > 0)
{
dir = 1; altdir = 0;
}
else
{
dir = 0; altdir = 1;
}
break;
case WorldRotation.BottomLeft:
if (fract.X + fract.Y > 1)
{
dir = 2; altdir = 1;
}
else
{
dir = 1; altdir = 2;
}
break;
}
var finalDir = VMArchitectureTools.GetPatternDirection(vm.Context.Architecture, cursor, pattern, dir, altdir, World.State.Level);
if (finalDir != -1)
{
CursorDir = finalDir;
var cmd = new VMArchitectureCommand
{
Type = VMArchitectureCommandType.PATTERN_DOT,
level = World.State.Level,
pattern = pattern,
style = 0,
x = cursor.X,
y = cursor.Y,
x2 = dir,
y2 = altdir
};
if (!Commands.Contains(cmd))
{
vm.Context.Architecture.SignalRedraw();
Commands.Add(cmd);
}
}
}
var cmds = vm.Context.Architecture.Commands;
cmds.Clear();
foreach (var cmd in Commands)
{
cmds.Add(cmd);
}
if (cmds.Count > 0)
{
var cost = vm.Context.Architecture.LastTestCost;
if (cost != 0)
{
var disallowed = Parent.ActiveEntity != null && cost > Parent.ActiveEntity.TSOState.Budget.Value;
state.UIState.TooltipProperties.Show = true;
state.UIState.TooltipProperties.Color = disallowed ? Color.DarkRed : Color.Black;
state.UIState.TooltipProperties.Opacity = 1;
state.UIState.TooltipProperties.Position = new Vector2(state.MouseState.X, state.MouseState.Y);
state.UIState.Tooltip = (cost < 0) ? ("-$" + (-cost)) : ("$" + cost);
state.UIState.TooltipProperties.UpdateDead = false;
if (disallowed)
{
HITVM.Get().PlaySoundEvent(UISounds.Error);
}
}
else
{
state.UIState.TooltipProperties.Show = false;
state.UIState.TooltipProperties.Opacity = 0;
}
}
WallCursor.SetVisualPosition(new Vector3(cursor.X + 0.5f, cursor.Y + 0.5f, (World.State.Level - 1) * 2.95f), (Direction)(1 << ((3 - CursorDir) * 2)), vm.Context);
}
public override void Update(UpdateState state)
{
base.Update(state);
Cheats.Update(state);
if (!vm.Ready)
{
return;
}
if (ActiveEntity == null || ActiveEntity.Dead || ActiveEntity.PersistID != SelectedSimID)
{
ActiveEntity = vm.Entities.FirstOrDefault(x => x is VMAvatar && x.PersistID == SelectedSimID); //try and hook onto a sim if we have none selected.
if (ActiveEntity == null)
{
ActiveEntity = vm.Entities.FirstOrDefault(x => x is VMAvatar);
}
if (!FoundMe && ActiveEntity != null)
{
vm.Context.World.State.CenterTile = new Vector2(ActiveEntity.VisualPosition.X, ActiveEntity.VisualPosition.Y);
vm.Context.World.State.ScrollAnchor = null;
FoundMe = true;
}
Queue.QueueOwner = ActiveEntity;
}
if (GotoObject == null)
{
GotoObject = vm.Context.CreateObjectInstance(GOTO_GUID, LotTilePos.OUT_OF_WORLD, Direction.NORTH, true).Objects[0];
}
if (ActiveEntity != null && BlockingDialog != null)
{
//are we still waiting on a blocking dialog? if not, cancel.
if (ActiveEntity.Thread != null && (ActiveEntity.Thread.BlockingState == null || !(ActiveEntity.Thread.BlockingState is VMDialogResult)))
{
UIScreen.RemoveDialog(BlockingDialog);
LastDialogID = 0;
BlockingDialog = null;
}
}
if (Visible)
{
if (ShowTooltip)
{
state.UIState.TooltipProperties.UpdateDead = false;
}
bool scrolled = false;
if (KBScroll)
{
World.State.ScrollAnchor = null;
int KeyboardAxisX = 0;
int KeyboardAxisY = 0;
Vector2 scrollBy = new Vector2();
if (state.KeyboardState.IsKeyDown(Keys.Up) || state.KeyboardState.IsKeyDown(Keys.W))
{
KeyboardAxisY -= 1;
}
if (state.KeyboardState.IsKeyDown(Keys.Left) || state.KeyboardState.IsKeyDown(Keys.A))
{
KeyboardAxisX -= 1;
}
if (state.KeyboardState.IsKeyDown(Keys.Down) || state.KeyboardState.IsKeyDown(Keys.S))
{
KeyboardAxisY += 1;
}
if (state.KeyboardState.IsKeyDown(Keys.Right) || state.KeyboardState.IsKeyDown(Keys.D))
{
KeyboardAxisX += 1;
}
scrollBy = new Vector2(KeyboardAxisX, KeyboardAxisY);
scrollBy *= 0.05f;
World.Scroll(scrollBy * (60f / 60));
}
if (RMBScroll)
{
World.State.ScrollAnchor = null;
Vector2 scrollBy = new Vector2();
if (state.TouchMode)
{
scrollBy = new Vector2(RMBScrollX - state.MouseState.X, RMBScrollY - state.MouseState.Y);
RMBScrollX = state.MouseState.X;
RMBScrollY = state.MouseState.Y;
scrollBy /= 128f;
scrollBy /= FSOEnvironment.DPIScaleFactor;
}
else
{
scrollBy = new Vector2(state.MouseState.X - RMBScrollX, state.MouseState.Y - RMBScrollY);
scrollBy *= 0.0005f;
var angle = (Math.Atan2(state.MouseState.X - RMBScrollX, (RMBScrollY - state.MouseState.Y) * 2) / Math.PI) * 4;
angle += 8;
angle %= 8;
CursorType type = CursorType.ArrowUp;
switch ((int)Math.Round(angle))
{
case 0: type = CursorType.ArrowUp; break;
case 1: type = CursorType.ArrowUpRight; break;
case 2: type = CursorType.ArrowRight; break;
case 3: type = CursorType.ArrowDownRight; break;
case 4: type = CursorType.ArrowDown; break;
case 5: type = CursorType.ArrowDownLeft; break;
case 6: type = CursorType.ArrowLeft; break;
case 7: type = CursorType.ArrowUpLeft; break;
}
GameFacade.Cursor.SetCursor(type);
}
World.Scroll(scrollBy * (60f / 60));
scrolled = true;
}
var nofocus = state.InputManager.GetFocus() == null;
var keyst = state.KeyboardState;
if (nofocus && (keyst.IsKeyDown(Keys.Up) || keyst.IsKeyDown(Keys.Left) || keyst.IsKeyDown(Keys.Down) || keyst.IsKeyDown(Keys.Right) ||
(keyst.IsKeyDown(Keys.W) || keyst.IsKeyDown(Keys.A) || keyst.IsKeyDown(Keys.S) || keyst.IsKeyDown(Keys.D))))
{
KBScroll = true;
}
else
{
KBScroll = false;
}
if (MouseIsOn)
{
if (state.MouseState.RightButton == ButtonState.Pressed)
{
if (RMBScroll == false)
{
RMBScroll = true;
state.InputManager.SetFocus(null);
RMBScrollX = state.MouseState.X;
RMBScrollY = state.MouseState.Y;
}
}
else
{
RMBScroll = false;
if (!scrolled && GlobalSettings.Default.EdgeScroll && !state.TouchMode)
{
scrolled = World.TestScroll(state);
}
}
}
if (state.MouseState.RightButton != ButtonState.Pressed)
{
if (RMBScroll)
{
GameFacade.Cursor.SetCursor(CursorType.Normal);
}
RMBScroll = false;
}
if (LiveMode)
{
LiveModeUpdate(state, scrolled);
}
else if (CustomControl != null)
{
CustomControl.Update(state, scrolled);
}
else
{
ObjectHolder.Update(state, scrolled);
}
//set cutaway around mouse
if (vm.Context.Blueprint != null)
{
World.State.DynamicCutaway = (WallsMode == 1);
//first we need to cycle the rooms that are being cutaway. Keep this up even if we're in all-cut mode.
var mouseTilePos = World.State.WorldSpace.GetTileAtPosWithScroll(new Vector2(state.MouseState.X, state.MouseState.Y) / FSOEnvironment.DPIScaleFactor);
var roomHover = vm.Context.GetRoomAt(LotTilePos.FromBigTile((short)(mouseTilePos.X), (short)(mouseTilePos.Y), World.State.Level));
var outside = (vm.Context.RoomInfo[roomHover].Room.IsOutside);
if (!outside && !CutRooms.Contains(roomHover))
{
CutRooms.Add(roomHover); //outside hover should not persist like with other rooms.
}
while (CutRooms.Count > 3)
{
CutRooms.Remove(CutRooms.ElementAt(0));
}
if (LastWallMode != WallsMode)
{
if (WallsMode == 0) //walls down
{
LastCuts = new bool[vm.Context.Architecture.Width * vm.Context.Architecture.Height];
vm.Context.Blueprint.Cutaway = LastCuts;
vm.Context.Blueprint.Damage.Add(new FSO.LotView.Model.BlueprintDamage(FSO.LotView.Model.BlueprintDamageType.WALL_CUT_CHANGED));
for (int i = 0; i < LastCuts.Length; i++)
{
LastCuts[i] = true;
}
}
else if (WallsMode == 1)
{
MouseCutRect = new Rectangle();
LastCutRooms = new HashSet <uint>()
{
uint.MaxValue
}; //must regenerate cuts
}
else //walls up or roof
{
LastCuts = new bool[vm.Context.Architecture.Width * vm.Context.Architecture.Height];
vm.Context.Blueprint.Cutaway = LastCuts;
vm.Context.Blueprint.Damage.Add(new FSO.LotView.Model.BlueprintDamage(FSO.LotView.Model.BlueprintDamageType.WALL_CUT_CHANGED));
}
LastWallMode = WallsMode;
}
if (WallsMode == 1)
{
int recut = 0;
var finalRooms = new HashSet <uint>(CutRooms);
var newCut = new Rectangle((int)(mouseTilePos.X - 2.5), (int)(mouseTilePos.Y - 2.5), 5, 5);
newCut.X -= VMArchitectureTools.CutCheckDir[(int)World.State.Rotation][0] * 2;
newCut.Y -= VMArchitectureTools.CutCheckDir[(int)World.State.Rotation][1] * 2;
if (newCut != MouseCutRect)
{
MouseCutRect = newCut;
recut = 1;
}
if (LastFloor != World.State.Level || LastRotation != World.State.Rotation || !finalRooms.SetEquals(LastCutRooms))
{
LastCuts = VMArchitectureTools.GenerateRoomCut(vm.Context.Architecture, World.State.Level, World.State.Rotation, finalRooms);
recut = 2;
LastFloor = World.State.Level;
LastRotation = World.State.Rotation;
}
LastCutRooms = finalRooms;
if (recut > 0)
{
var finalCut = new bool[LastCuts.Length];
Array.Copy(LastCuts, finalCut, LastCuts.Length);
var notableChange = VMArchitectureTools.ApplyCutRectangle(vm.Context.Architecture, World.State.Level, finalCut, MouseCutRect);
if (recut > 1 || notableChange || LastRectCutNotable)
{
vm.Context.Blueprint.Cutaway = finalCut;
vm.Context.Blueprint.Damage.Add(new FSO.LotView.Model.BlueprintDamage(FSO.LotView.Model.BlueprintDamageType.WALL_CUT_CHANGED));
}
LastRectCutNotable = notableChange;
}
}
}
}
}
public void Update(UpdateState state, bool scrolled)
{
ushort pattern = (state.KeyboardState.IsKeyDown(Keys.LeftControl)) ? (ushort)0 : Pattern;
var tilePos = World.State.WorldSpace.GetTileAtPosWithScroll(new Vector2(state.MouseState.X, state.MouseState.Y));
Point cursor = new Point((int)tilePos.X, (int)tilePos.Y);
if (!Drawing && Commands.Count > 0)
{
vm.Context.Architecture.SignalRedraw();
Commands.Clear();
}
if (state.KeyboardState.IsKeyDown(Keys.LeftShift))
{
if (Commands.Count == 0 || Commands[0].Type != VMArchitectureCommandType.PATTERN_FILL)
{
Commands.Clear();
vm.Context.Architecture.SignalRedraw();
}
Commands.Add(new VMArchitectureCommand
{
Type = VMArchitectureCommandType.PATTERN_FILL,
level = World.State.Level,
pattern = pattern,
style = 0,
x = cursor.X,
y = cursor.Y
});
}
else
{
if (Commands.Count > 0 && Commands[0].Type == VMArchitectureCommandType.PATTERN_FILL)
{
Commands.Clear();
vm.Context.Architecture.SignalRedraw();
}
int dir = 0;
int altdir = 0;
Vector2 fract = new Vector2(tilePos.X - cursor.X, tilePos.Y - cursor.Y);
switch (World.State.Rotation)
{
case WorldRotation.BottomRight:
if (fract.X - fract.Y > 0)
{
dir = 2; altdir = 3;
}
else
{
dir = 3; altdir = 2;
}
break;
case WorldRotation.TopRight:
if (fract.X + fract.Y > 1)
{
dir = 3; altdir = 0;
}
else
{
dir = 0; altdir = 3;
}
break;
case WorldRotation.TopLeft:
//+x is right down. +y is left down
if (fract.X - fract.Y > 0)
{
dir = 1; altdir = 0;
}
else
{
dir = 0; altdir = 1;
}
break;
case WorldRotation.BottomLeft:
if (fract.X + fract.Y > 1)
{
dir = 2; altdir = 1;
}
else
{
dir = 1; altdir = 2;
}
break;
}
var finalDir = VMArchitectureTools.GetPatternDirection(vm.Context.Architecture, cursor, pattern, dir, altdir, World.State.Level);
if (finalDir != -1)
{
CursorDir = finalDir;
var cmd = new VMArchitectureCommand
{
Type = VMArchitectureCommandType.PATTERN_DOT,
level = World.State.Level,
pattern = pattern,
style = 0,
x = cursor.X,
y = cursor.Y,
x2 = dir,
y2 = altdir
};
if (!Commands.Contains(cmd))
{
vm.Context.Architecture.SignalRedraw();
Commands.Add(cmd);
}
}
}
var cmds = vm.Context.Architecture.Commands;
cmds.Clear();
foreach (var cmd in Commands)
{
cmds.Add(cmd);
}
WallCursor.SetVisualPosition(new Vector3(cursor.X + 0.5f, cursor.Y + 0.5f, (World.State.Level - 1) * 2.95f), (Direction)(1 << ((3 - CursorDir) * 2)), vm.Context);
}
