public void OnPostRoomEvent(BasePlayerMover mover, RoomObject room)
{
foreach (IPlayerRoomEventListener listener in IterateListeners<IPlayerRoomEventListener>())
{
listener.OnPostRoomEvent(mover, room);
}
}
public ObjectsEditorFilter(Panel displayPanel, Room room)
{
_room = room;
_panel = displayPanel;
_selectedObject = null;
_propertyObjectChangedDelegate = new GUIController.PropertyObjectChangedHandler(GUIController_OnPropertyObjectChanged);
}
public static Vector2 GetRoomObjectPositionOnScreen(Room room, RoomObject roomObject)
{
Vector2 positionInWorld = new Vector2 (roomObject.transform.position.x, roomObject.transform.position.y);
float scaleX = singleton.screenRect.width / room.roomSprite.textureRect.width;
float scaleY = singleton.screenRect.height / room.roomSprite.textureRect.height;
scaleX = scaleY;
return new Vector2(singleton.screenRect.center.x + scaleX*positionInWorld.x, singleton.screenRect.center.y + scaleY*positionInWorld.y);
}
public static Rect GetRoomObjectScreenRect(Room room, RoomObject roomObject)
{
Vector2 positionInWorld = new Vector2(roomObject.transform.position.x, roomObject.transform.position.y);
float scaleX = singleton.screenRect.width / room.roomSprite.textureRect.width;
float scaleY = singleton.screenRect.height / room.roomSprite.textureRect.height;
scaleX = scaleY;
float width = roomObject.sprite.textureRect.width;
float height = roomObject.sprite.textureRect.height;
return new Rect ((int)(singleton.screenRect.center.x + scaleX * positionInWorld.x), (int)(singleton.screenRect.center.y + scaleY * positionInWorld.y), (int)(scaleX*width), (int)(scaleY*height));
}
public static RoomObject FromObject(JsonData jsonData)
{
RoomObject result = new RoomObject();
result.object_id = (int)jsonData["id"];
result.position.Set(
jsonData["x"].IsInt ? (float)((int)jsonData["x"]) : (float)((double)jsonData["x"]),
jsonData["y"].IsInt ? (float)((int)jsonData["y"]) : (float)((double)jsonData["y"]),
jsonData["z"].IsInt ? (float)((int)jsonData["z"]) : (float)((double)jsonData["z"]));
return result;
}
/// <summary>
/// Sets which buttons are active based on the doors in the current room
/// </summary>
/// <param name="currentRoom">The current room that the players are in</param>
public void PopulateMenu(RoomObject currentRoom)
{
m_currentRoom = currentRoom;
m_northButton.gameObject.SetActive(currentRoom.NorthDoor.IsDoorEnabled);
m_eastButton.gameObject.SetActive(currentRoom.EastDoor.IsDoorEnabled);
m_southButton.gameObject.SetActive(currentRoom.SouthDoor.IsDoorEnabled);
m_westButton.gameObject.SetActive(currentRoom.WestDoor.IsDoorEnabled);
if (currentRoom is ExitRoom)
{
m_nextFloorButton.gameObject.SetActive(true);
}
else
{
m_nextFloorButton.gameObject.SetActive(false);
}
}
private void TestRoomObject()
{
var TestObj = new RoomObjectObj
{
disposable = true,
id = 27,
isHidden = false,
lookDirection = Vector3.forward,
owner = "test",
position = Vector3.one,
prefab = "a test thing"
};
var fbb = new FlatBufferBuilder(1024);
var offset = TestObj.ToBuffer(fbb);
fbb.Finish(offset.Value);
var bArray = fbb.SizedByteArray();
var bb = new ByteBuffer(bArray);
var desObj = RoomObject.GetRootAsRoomObject(bb);
print("Room Object Test : " + (CompareRoomObjects(TestObj, desObj) ? "Passed" : "Failed"));
}
public virtual bool MouseDown(MouseEventArgs e, RoomEditorState state)
{
if (e.Button == MouseButtons.Middle) return false;
int x = state.WindowXToRoom(e.X);
int y = state.WindowYToRoom(e.Y);
RoomObject obj = GetObject(x, y);
if (obj != null)
{
SetSelectedObject(obj);
Factory.GUIController.SetPropertyGridObject(obj);
if (e.Button == MouseButtons.Right)
{
ShowContextMenu(e, state);
}
else if(!DesignItems[GetItemID(obj)].Locked)
{
_movingObjectWithMouse = true;
_mouseOffsetX = x - obj.StartX;
_mouseOffsetY = y - obj.StartY;
}
}
else
{
_selectedObject = null;
}
if (_selectedObject == null)
{
if (e.Button == MouseButtons.Right)
{
ShowContextMenu(e, state);
return true;
}
return false;
}
return true;
}
private void ConnectRooms()
{
var canRoomsTangle = GameSettings.Instance.roomTangling;
foreach (var roomObject in roomList)
{
foreach (var doorObject in roomObject.doors)
{
RoomObject other = null;
while (other == null || (other == roomObject && !canRoomsTangle))
{
var randomIdx = UnityEngine.Random.Range(0, roomList.Count - 1);
other = roomList[randomIdx];
}
if (other != null)
{
ConnectRoom(doorObject, other);
}
}
}
}
public RenderInfo(
RoomObject Data,
bool UseViewerFrame = true,
bool ApplyYOffset = true,
byte RootHotspotIndex = 0,
Real Quality = DEFAULTQUALITY,
bool ScalePow2 = false,
uint Width = 0,
uint Height = 0,
bool CenterVertical = false,
bool CenterHorizontal = false)
{
Clear();
BgfBitmap mainFrame = Data.ViewerFrame;
if (!UseViewerFrame)
{
mainFrame = Data.FrontFrame;
}
Calculate(Data, mainFrame, UseViewerFrame, ApplyYOffset, RootHotspotIndex, Quality, ScalePow2, Width, Height, CenterVertical, CenterHorizontal);
}
//创建房间的广播回调函数
public void CreateRoom(ProtocolBase protocol)
{
Debug.Log("来啊，我在这里");
ProtocolBytes proto = (ProtocolBytes)protocol;
int start = 0;
/*string protoName = */
proto.GetString(start, ref start);
string room_name = proto.GetString(start, ref start);
int peopleNum = proto.GetInt(start, ref start);
//将房间新房间加入 roomList 然后重新渲染 列表一
RoomObject room = new RoomObject(room_name)//简化的new
{
ExistPerNum = peopleNum
};
room.GenerateFraction();
roomList.Add(room);
//渲染 列表一 所有房间列表
RenderListOne();
}
public void lookAtObject(RoomObject obj)
{
if (defaultValues.lookAtActive)
{
if (obj == null)
{
textPrompt.printText(defaultValues.lookAtNotFoundText);
return;
}
if (System.String.IsNullOrWhiteSpace(obj.runtimeLookAtFlavorText))
{
textPrompt.printText(defaultValues.lookAtDefaultText.Replace("(NAME)", obj.name));
return;
}
textPrompt.printText(obj.runtimeLookAtFlavorText);
}
else
{
textPrompt.printText(defaultValues.unknownCommand);
}
}
private void InitGrid()
{
// RoomGridよりGrid情報取得
GameObject GObj = GameObject.FindGameObjectWithTag("RoomGrids");
RoomGrids rGrids = GObj.GetComponent(typeof(RoomGrids)) as RoomGrids;
Grids = rGrids.GetGridData();
// Playerの位置を現在位置へ
NowPos = Player._Postion.Vector2I;
// ほか必要なやつを探し出し登録していく
GameObject[] Objs = GameObject.FindGameObjectsWithTag("RoomObject");
foreach (GameObject obj in Objs)
{
RoomObject rObject = obj.GetComponent(typeof(RoomObject)) as RoomObject;
int gX = rObject._Postion.IntX;
int gY = rObject._Postion.IntY;
Grids[gX, gY] = rObject.GridDataNum;
}
}
public void FindSpecificOpenRoom_OfTypeHotelNode_AreEqual()
{
// Arrange
HumanSchematic newGuest = new Guest(null, null, null);
List <HotelNode> hotelNodes = new List <HotelNode>();
HotelRoomFactory hotelRoomFactory = new HotelRoomFactory();
RoomObject RandomObject = new RoomObject()
{
Classification = "1 Star",
ID = 11,
AreaType = "Room",
Position = new Point(7, 1),
Dimension = new Point(1, 1)
};
RoomObject expectedObject = new RoomObject()
{
Classification = "4 stars",
ID = 25,
AreaType = "Room",
Position = new Point(3, 2),
Dimension = new Point(2, 1)
};
HotelNode randomHotelNode = new HotelNode(RandomObject, 0);
HotelNode expected = new HotelNode(expectedObject, 0);
Dictionary <string, string> Data = new Dictionary <string, string>();
// Act
randomHotelNode.HotelObject = hotelRoomFactory.HotelRooms(randomHotelNode);
expected.HotelObject = hotelRoomFactory.HotelRooms(expected);
hotelNodes.Add(randomHotelNode);
hotelNodes.Add(expected);
Data.Add("Gast1", "Checkin 4stars");
HotelNode result = newGuest.FindSpecificOpenRoom(Data, hotelNodes);
// Assert
Assert.AreEqual(expected, result);
}
/// <summary>
/// Scrapes user input to find commands and the object referenced and directs it to ActionHandler.
/// </summary>
/// <param name="input">The user's input</param>
public void parseInput(string input)
{
string[] words = trimText(input);
// Player commands are separate from regular commands because actions are in the Player script rather than ActionHandler
// and regular commands need a minimum of 2 words to work whereas player commands (like "inv") can be one word.
// Check player commands. If one activates, return.
string failText = defaultValues.unknownCommand;
if (words.Length == 0)
{
textPrompt.printText(failText);
return;
}
string command = words[0];
RoomObject targetObject = findObjectFromInput(input);
// parsePlayerCommands needs input to scrape room name from input when player moves.
bool playerCommandSuccess = parsePlayerCommands(command, input);
if (playerCommandSuccess)
{
return;
}
if (words.Length == 1)
{
//textPrompt.printText(failText);
roomTracker.changeRoomViaRoomConnection(input);
return;
}
// Regular Commands: Eat, Talk, Kill, Sit, Use, Pickup, Wear
parseRegularCommands(command, targetObject);
}
public void CreateGraph_OfTypeHotelGraph_AreEqual()
{
// Arrange
List <RoomObject> roomObjects = new List <RoomObject>();
RoomObject randomRoom1 = new RoomObject()
{
Classification = "2 Star",
ID = 11,
AreaType = "Room",
Position = new Point(7, 1),
Dimension = new Point(1, 1)
};
RoomObject randomRoom2 = new RoomObject()
{
Classification = "3 stars",
ID = 12,
AreaType = "Room",
Position = new Point(6, 1),
Dimension = new Point(1, 1)
};
roomObjects.Add(randomRoom1);
roomObjects.Add(randomRoom2);
HotelGraph hotelGraph = new HotelGraph();
HotelNode randomHotelNode1 = new HotelNode(randomRoom1, 0);
HotelNode randomHotelNode2 = new HotelNode(randomRoom2, 0);
List <HotelEdge> expectedHotelEdges = new List <HotelEdge>();
HotelEdge expectedhotelEdge1 = new HotelEdge(randomHotelNode2, randomHotelNode1);
// Act
hotelGraph.GenerateGraph(roomObjects);
hotelGraph.AddHotelEdge();
expectedHotelEdges.Add(expectedhotelEdge1);
// Assert
Assert.AreEqual(expectedHotelEdges[0].RoomDestination.RoomData, hotelGraph.HotelNodeSet[0].RoomNeighbour[0].RoomDestination.RoomData);
}
static void Main()
{
// .net stuff
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// init bgf data model
CurrentFile = new BgfFile();
CurrentFile.Frames.AllowEdit = true;
// init roomobject model for viewer
RoomObject = new RoomObject();
RoomObject.Resource = CurrentFile;
// init mainform
MainForm = new MainForm();
MainForm.FormClosed += OnMainFormFormClosed;
MainForm.Show();
ImageComposerGDI <RoomObject> .Cache.IsEnabled = false;
// init shrinkform
SettingsForm = new SettingsForm();
SettingsForm.DataBindings.Add("Version", CurrentFile, "Version");
SettingsForm.DataBindings.Add("ShrinkFactor", CurrentFile, "ShrinkFactor");
SettingsForm.DataBindings.Add("Name", CurrentFile, "Name");
// init addframsetindexform
AddFrameSetIndexForm = new AddFrameSetIndexForm();
// init ticker
stopWatch = new Stopwatch();
stopWatch.Start();
// set running
IsRunning = true;
string[] args = Environment.GetCommandLineArgs();
// load file passed by arguments
if (args.Length > 1)
{
Load(args[1]);
}
// start mainthread loop
while (IsRunning)
{
long oldTick = Tick;
// update current tick
Tick = stopWatch.ElapsedTicks / MSTICKDIVISOR;
long span = Tick - oldTick;
// update roomobject
//if (IsPlaying)
RoomObject.Tick(Tick, span);
// process window messages / events
Application.DoEvents();
// sleep
Thread.Sleep(1);
}
}
public virtual void MouseDown(MouseEventArgs e, RoomEditorState state)
{
int x = (e.X + state.ScrollOffsetX) / state.ScaleFactor;
int y = (e.Y + state.ScrollOffsetY) / state.ScaleFactor;
_selectedObject = null;
for (int i = _objectBaselines.Count - 1; i >= 0; i--)
{
RoomObject obj = _objectBaselines[i];
int width = GetSpriteWidthForGameResolution(obj.Image);
int height = GetSpriteHeightForGameResolution(obj.Image);
if ((x >= obj.StartX) && (x < obj.StartX + width) &&
(y >= obj.StartY - height) && (y < obj.StartY))
{
_selectedObject = obj;
Factory.GUIController.SetPropertyGridObject(obj);
if (e.Button == MouseButtons.Right)
{
ShowContextMenu(e, state);
}
else
{
_movingObjectWithMouse = true;
_mouseOffsetX = x - obj.StartX;
_mouseOffsetY = y - obj.StartY;
}
break;
}
}
if (_selectedObject == null)
{
Factory.GUIController.SetPropertyGridObject(_room);
if (e.Button == MouseButtons.Right)
{
ShowContextMenu(e, state);
}
}
}
/// <summary> /// Draw an object /// </summary> /// <param name="RoomObject"></param> /// <param name="x"></param> /// <param name="y"></param> /// <param name="width"></param> /// <param name="height"></param> public abstract void DrawObject(RoomObject RoomObject, Real x, Real y, Real width, Real height);
public void RemoveObject(RoomObject obj)
{
objects.Remove (obj);
}
/// <summary>
/// For all IPs of an object, calculate their travel score. Set values based on the lowest score.
/// We assume the camper is already in the same room as this Room Object.
/// </summary>
/// <param name="obj">The Room Object</param>
/// <param name="lowestScore">Outputting the lowest score so far</param>
/// <param name="IPidx">Outputting the IP index of the IP with the lowest score</param>
/// <param name="targetObj">Outputting the Room Object with the lowest score</param>
/// <returns>True if an IP of a room the camper is alreayd in has the lowest score</returns>
private bool getLowestIPpathScore(RoomObject obj, ref float lowestScore, ref int IPidx, ref RoomObject targetObj)
{
bool useIPmap = false;
for (int i = 0; i < obj.interactionPoints.Count; i++)
{
//we expect that we have calculated a path to each Interaction Point
InteractionPoint IP = obj.interactionPoints[i];
if (!IPpathMap.ContainsKey(IP))
{
continue;
}
//score is the length of the path to the IP + the wait time of that IP
float score = IPpathMap[IP].GetPathLength();
score += IP.GetWaitScore();
if (score < lowestScore)
{
useIPmap = true;
IPidx = i;
targetObj = obj;
lowestScore = score;
}
}
return(useIPmap);
}
private string GetItemID(RoomObject obj)
{
// Use numeric object's ID as a "unique identifier", for now (script name is optional!)
return(obj.ID.ToString("D4"));
}
/// <summary>
/// Checks if the string is a regular command and forwards targetObject to ActionHandler.
/// </summary>
/// <param name="command">The first word in the user's input</param>
/// <param name="targetObject">The object found in user's input</param>
private void parseRegularCommands(string command, RoomObject targetObject)
{
switch (command)
{
// eat
case "eat":
case "devour":
case "consume":
actionHandler.eatObject(targetObject);
break;
// drink
case "drink":
actionHandler.drinkObject(targetObject);
break;
// talk
case "talk":
case "speak":
case "say":
actionHandler.talkToPerson(targetObject);
break;
// kill
case "kill":
case "stab":
case "cleave":
case "murder":
actionHandler.killPerson(targetObject);
break;
// break
case "break":
case "smash":
case "destroy":
actionHandler.BreakObject(targetObject);
break;
// sit
case "sit":
case "seat":
actionHandler.sitOnObject(targetObject);
break;
// use
case "use":
case "activate":
actionHandler.useObject(targetObject);
break;
// pickup
case "pickup":
case "grab":
case "pick":
case "take":
case "steal":
actionHandler.pickupObject(targetObject);
break;
// wear
case "wear":
case "equip":
case "put":
actionHandler.wearObject(targetObject);
break;
// open
case "open":
case "unlock":
case "reveal":
actionHandler.openObject(targetObject);
break;
// look at
case "look":
actionHandler.lookAtObject(targetObject);
break;
// unknown command
default:
textPrompt.printText(defaultValues.unknownCommand);
break;
}
}
public void OnExitRoom(BasePlayerMover mover, RoomObject room)
{
}
protected override void Awake()
{
m_parentRoomObject = this.GetComponentInParent<RoomObject>(true);
base.Awake();
}
private void ConnectRoom(GameObject doorObject, RoomObject b)
{
var randomIdx = UnityEngine.Random.Range(0, b.doors.Length - 1);
ConnectDoors(doorObject, b.doors[randomIdx]);
}
public void registerModelObjects()
{
_versionObject = new VersionObject();
_selfUserObject = new UserObject();
_leftUserObject = new UserObject();
_rightUserObject = new UserObject();
_roomObject = new RoomObject();
_deskObject = new DeskObject();
_userLoginObject = new UserLoginObject();
_userEditProfileObject = new UserEditProfileObject();
_userSitOnDeskObject = new UserSitOnDeskObject();
_deskJiaoDiZhuObject = new DeskJiaoDiZhuObject();
_deskCardsPromptObject = new DeskCardsPromptObject();
_deskChuPaiObject = new DeskChuPaiObject();
_deskCardsValidateObject = new DeskCardsValidateObject();
_userCheckResumePlayObject = new UserCheckResumePlayObject();
}
public void OnPostRoomEvent(BasePlayerMover mover, RoomObject room)
{
}
public void OnPreRoomEvent(BasePlayerMover mover, RoomObject room)
{
_playIdleAnimations();
}
public virtual void MouseUp(MouseEventArgs e, RoomEditorState state)
{
_movingObjectWithMouse = false;
_lastSelectedObject = _selectedObject;
if (e.Button == MouseButtons.Middle)
{
ShowCoordMenu(e, state);
}
}
/// <summary>
/// Goes through all possible paths and picks the one with the lowest score to address the next desire.
/// </summary>
private void pickNextPath()
{
if (roomPathMap.Count == 0 && IPpathMap.Count == 0)
{
return;
}
float lowestScore = float.MaxValue;
int IPidx = -1;
RoomObject targetObj = null;
bool useIPmap = false;
//get the score for each interaction point to determine the final target
foreach (RoomObject obj in objectsToTarget)
{
Room room = obj.GetRoom();
//The camper is not in the same room as this object
if (roomPathMap.ContainsKey(room))
{
if (getLowestRoomPathScore(room, obj, ref lowestScore, ref IPidx, ref targetObj))
{
useIPmap = false;
}
}
else //the camper is in the same room as this object
{
if (getLowestIPpathScore(obj, ref lowestScore, ref IPidx, ref targetObj))
{
useIPmap = true;
}
}
}
if (targetObj == null || IPidx == -1)
{
SetPathStateNone();
return; //TODO better handle
}
//set up the roomTarget with the lowest scoring path
if (roomTarget == null)
{
roomTarget = new Room.RoomTarget(targetObj.GetRoom(), targetObj, IPidx);
}
else
{
roomTarget.Initialize(targetObj.GetRoom(), targetObj, IPidx);
}
//create a path to the room, not the IP
if (useIPmap)
{
path = IPpathMap[targetObj.interactionPoints[IPidx]];
roomTarget.GetInteractionPoint().AddCamperEnRoute(this);
}
//create a path to the IP
else
{
path = roomPathMap[targetObj.GetRoom()];
//append the IP path so we go straight to that
path.AppendPathToEnd(roomTarget.GetInteractionPoint().GetPath());
roomTarget.GetInteractionPoint().AddCamperEnRoute(this);
}
pathState = PathState.TravelingOnPath;
}
private void ContextMenuEventHandler(object sender, EventArgs e)
{
ToolStripMenuItem item = (ToolStripMenuItem)sender;
if (item.Name == MENU_ITEM_DELETE)
{
if (Factory.GUIController.ShowQuestion("Are you sure you want to delete this object?") == DialogResult.Yes)
{
_room.Objects.Remove(_selectedObject);
foreach (RoomObject obj in _room.Objects)
{
if (obj.ID >= _selectedObject.ID)
{
obj.ID--;
}
}
_selectedObject = null;
Factory.GUIController.SetPropertyGridObject(_room);
SetPropertyGridList();
_room.Modified = true;
_panel.Invalidate();
}
}
else if (item.Name == MENU_ITEM_NEW)
{
if (_room.Objects.Count >= Room.MAX_OBJECTS)
{
Factory.GUIController.ShowMessage("This room already has the maximum " + Room.MAX_OBJECTS + " objects.", MessageBoxIcon.Information);
return;
}
RoomObject newObj = new RoomObject(_room);
newObj.ID = _room.Objects.Count;
newObj.StartX = SetObjectCoordinate(_menuClickX);
newObj.StartY = SetObjectCoordinate(_menuClickY);
_room.Objects.Add(newObj);
_selectedObject = newObj;
SetPropertyGridList();
Factory.GUIController.SetPropertyGridObject(newObj);
_room.Modified = true;
_panel.Invalidate();
}
else if (item.Name == MENU_ITEM_OBJECT_COORDS)
{
int tempx = _selectedObject.StartX;
int tempy = _selectedObject.StartY;
if ((Factory.AGSEditor.CurrentGame.Settings.UseLowResCoordinatesInScript) &&
(_room.Resolution == RoomResolution.HighRes))
{
tempx = tempx / 2;
tempy = tempy / 2;
}
string textToCopy = tempx.ToString() + ", " + tempy.ToString();
Utilities.CopyTextToClipboard(textToCopy);
}
}
public void OnEnteredRoom(BasePlayerMover mover, RoomObject room)
{
}
private void GUIController_OnPropertyObjectChanged(object newPropertyObject)
{
if (newPropertyObject is RoomObject)
{
_selectedObject = (RoomObject)newPropertyObject;
_panel.Invalidate();
}
else if (newPropertyObject is Room)
{
_selectedObject = null;
_panel.Invalidate();
}
}
// Use this for initialization
void Start () {
t = 0;
currentRoom = Dungeon.instance.dungeon_rooms[0];
animator = GetComponentInChildren<TinkerAnimator>();
cam = Camera.main;
}
bool lastCellInRow(Vector3 nextBottomRight, RoomObject room)
{
return(nextBottomRight.z == room.npc.boundary [0, 0].z);
}
void setupLight(RoomObject room)
{
}
/// <summary>
/// For all IPs of an object in a room, calculate their travel score. Set values based on the lowest score.
/// </summary>
/// <param name="room">The room the object is in</param>
/// <param name="obj">The object containing the IPs</param>
/// <param name="lowestScore">Outputting the lowest score</param>
/// <param name="IPidx">Outputting the IP index of the IP with the lowest score on the obj</param>
/// <param name="targetObj">Outputting the Room Object with the lowest score</param>
/// <returns>True if a room path has the lowest score. Flase otherwise.</returns>
private bool getLowestRoomPathScore(Room room, RoomObject obj, ref float lowestScore, ref int IPidx, ref RoomObject targetObj)
{
//get the path size from the camper to the room's entrance
float baseScore = roomPathMap[room].GetPathLength();
bool useRoomMap = false;
for (int i = 0; i < obj.interactionPoints.Count; i++)
{
//for each interaction point, get the path length from the IP to the room entrance + wait time
InteractionPoint ip = obj.interactionPoints[i];
float score = baseScore + ip.GetIPScore();
if (score < lowestScore)
{
useRoomMap = true;
IPidx = i;
targetObj = obj;
lowestScore = score;
}
}
return(useRoomMap);
}
/// <summary>
/// Checks to see if a room is contained in the grid.
/// </summary>
/// <param name="room">The room to check for.</param>
/// <returns>True if the room is in the grid, otherwise false.</returns>
public bool ContainsRoom(RoomObject room)
{
return m_registeredRooms.Contains(room);
}
public void MouseDownAlways(MouseEventArgs e, RoomEditorState state)
{
_selectedObject = null;
}
/// <summary>
/// Executed when roomobject list removed an item
/// </summary>
/// <param name="RoomObject"></param>
protected virtual void OnRoomObjectRemoved(RoomObject RoomObject)
{
}
/// <summary>
/// Executed when roomobject list changed an item
/// </summary>
protected virtual void OnRoomObjectChanged(RoomObject RoomObject)
{
}
protected override void OnEnable()
{
targetRoom = (RoomObject)target;
newPosition = Vector3Int.CeilToInt(targetRoom.roomPosition);
}
/// <summary>
/// Executes a Task 'cast'
/// </summary>
/// <param name="Task"></param>
protected void DoCast(BotTaskCast Task)
{
SpellObject spellObject = null;
StatList spellStat = null;
string sureTarget = Task.Target;
string sureWhere = Task.Where;
// handle selftargeting
if (sureTarget.ToLower().Equals(SpellBotConfig.XMLVALUE_SELF))
{
if (Data.AvatarObject == null)
{
Log("WARN", "Cant execute task 'cast' " + Task.Name + ". Technical interruption changed the target.");
return;
}
sureTarget = Data.AvatarObject.Name.ToLower();
sureWhere = SpellBotConfig.XMLVALUE_ROOM;
}
// try to get the spell from the spells
spellObject = Data.SpellObjects.GetItemByName(Task.Name, false);
// try to get stat for % value
if (spellObject != null)
{
spellStat = Data.AvatarSpells.GetItemByID(spellObject.ID);
}
// one not found
if (spellObject == null || spellStat == null)
{
// log
Log("WARN", "Cant execute task 'cast'. Spell " + Task.Name + " found.");
return;
}
// handle spells above cap
if (spellStat.SkillPoints >= Task.Cap)
{
if (Task.OnMax.ToLower() == SpellBotConfig.XMLVALUE_QUIT)
{
// log
Log("BOT", "Quitting.. spell " + spellObject.Name + " reached 99%.");
// prepare quit
IsRunning = false;
return;
}
else if (Task.OnMax.ToLower() == SpellBotConfig.XMLVALUE_SKIP)
{
// log
Log("BOT", "Skipped task 'cast' " + spellObject.Name + " (99%)");
return;
}
}
// spell doesn't need a target
if (spellObject.TargetsCount == 0)
{
// send castreq
SendReqCastMessage(spellObject);
// log
Log("BOT", "Executed task 'cast' " + spellObject.Name);
}
// speed needs a target
else if (spellObject.TargetsCount > 0)
{
// marked to cast on roomobject
if (sureWhere == SpellBotConfig.XMLVALUE_ROOM)
{
// try to get the target
RoomObject roomObject =
Data.RoomObjects.GetItemByName(sureTarget, false);
// target not found
if (roomObject == null)
{
// log
Log("WARN", "Can't execute task 'cast'. RoomObject " + sureTarget + " not found.");
return;
}
// send castreq
ReqCastMessage reqCastMsg = new ReqCastMessage(
spellObject.ID, new ObjectID[] { new ObjectID(roomObject.ID) });
SendGameMessage(reqCastMsg);
// log
Log("BOT", "Executed task 'cast' " + spellObject.Name);
}
// cast on inventory item
else if (sureWhere == SpellBotConfig.XMLVALUE_INVENTORY)
{
// try to get the target
InventoryObject inventoryObject =
Data.InventoryObjects.GetItemByName(sureTarget, false);
// target not found
if (inventoryObject == null)
{
// log
Log("WARN", "Can't execute task 'cast'. Item " + sureTarget + " not found.");
return;
}
// send castreq
ReqCastMessage reqCastMsg = new ReqCastMessage(
spellObject.ID, new ObjectID[] { new ObjectID(inventoryObject.ID) });
SendGameMessage(reqCastMsg);
// log
Log("BOT", "Executed task 'cast' " + spellObject.Name);
}
else
{
// log
Log("WARN", "Can't execute task 'cast'. " + sureWhere + " is unknown 'where'.");
}
}
}
public void SetRoom(RoomObject r)
{
m_room = r;
}
/// <summary>
/// Checks if the string is a regular command and forwards targetObject to ActionHandler.
/// </summary>
/// <param name="command">The first word in the user's input</param>
/// <param name="targetObject">The object found in user's input</param>
private void parseRegularCommands(string command, RoomObject targetObject)
{
switch (command)
{
// eat
case "iss":
case "esse":
case "ess":
case "essen":
case "verzehre":
case "friss":
actionHandler.eatObject(targetObject);
break;
// drink
case "trink":
actionHandler.drinkObject(targetObject);
break;
// talk
case "rede":
case "sprich":
case "sage":
actionHandler.talkToPerson(targetObject);
break;
// kill
case "kill":
case "stab":
case "cleave":
case "murder":
actionHandler.killPerson(targetObject);
break;
// break
case "zerstöre":
case "wirf":
case "kaputt":
case "zerschlage":
actionHandler.BreakObject(targetObject);
break;
// sit
case "sit":
case "sitze":
case "setz":
case "setzen":
case "hinsetzen":
actionHandler.sitOnObject(targetObject);
break;
// use
case "use":
case "benutze":
case "nutze":
case "brauche":
case "benutz":
case "schließe":
case "zumachen":
case "schhließen":
actionHandler.useObject(targetObject);
break;
// pickup
case "pickup":
case "nimm":
case "nehme":
case "take":
case "greif":
actionHandler.pickupObject(targetObject);
break;
// wear
case "wear":
case "trage":
case "anziehen":
actionHandler.wearObject(targetObject);
break;
// open
case "open":
case "öffne":
case "öffnen":
actionHandler.openObject(targetObject);
break;
// look at
case "look":
case "schau":
case "schaue":
case "anschauen":
actionHandler.lookAtObject(targetObject);
break;
// unknown command
default:
textPrompt.printText(defaultValues.unknownCommand);
break;
}
}
public static GameObject SetupRoomObject(GameObject go, RoomObject obj)
{
go.name = obj.prefabName + "_" + obj.ID;
go.transform.localPosition = new Vector3(obj.coords.x, obj.coords.y, go.transform.localPosition.z);
SpawnedData spawnedData = go.GetComponent <SpawnedData>();
if (obj.data != null && obj.data.Length != 0)
{
if (spawnedData == null)
{
Debug.LogError("Spawned prefab not have SpawnedData script: " + go.name);
return(null);
}
spawnedData.spawnedData = obj.data;
}
if (spawnedData != null)
{
spawnedData.roomObject = obj;
}
if (go.GetComponent <TypedObject>() != null)
{
TypedObject.Type type = go.GetComponent <TypedObject>().Types[obj.type];
go.GetComponent <TypedObject>().TypeIndex = obj.type;
go.transform.localScale = new Vector3(type.Size.x, type.Size.y, go.transform.localScale.z);
for (int i = 0; i < go.transform.childCount; i++)
{
go.transform.GetChild(i).position = go.transform.position + go.transform.GetChild(i).localPosition;
}
Mesh mesh = MonoBehaviour.Instantiate(GameManager.singleton.OnePlane);
mesh.SetUVs(0, new List <Vector2>()
{
new Vector2(type.MinUV.x, type.MinUV.y),
new Vector2(type.MaxUV.x, type.MinUV.y),
new Vector2(type.MaxUV.x, type.MaxUV.y),
new Vector2(type.MinUV.x, type.MaxUV.y)
});
go.GetComponent <MeshFilter>().mesh = mesh;
}
MeshFilter filter = go.GetComponent <MeshFilter>();
if (filter != null && filter.mesh != null)
{
Mesh mesh = filter.mesh;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
mesh.RecalculateTangents();
}
if (obj.mirrorX)
{
Vector3[] a = go.GetComponent <MeshFilter>().mesh.vertices;
a = null;
}
go.transform.localScale = new Vector3(go.transform.localScale.x * (obj.mirrorX ? -1 : 1), go.transform.localScale.y * (obj.mirrorY ? -1 : 1), go.transform.localScale.z);
if (filter != null && filter.mesh != null)
{
try {
go.transform.position += new Vector3(
obj.mirrorX
? (filter.mesh.vertices[1].x -
filter.mesh.vertices[0].x) * -go.transform.localScale.x
: 0,
obj.mirrorY
? (filter.mesh.vertices[2].y -
filter.mesh.vertices[0].y) * -go.transform.localScale.y
: 0, 0); // mark
}
catch (IndexOutOfRangeException e) {
Debug.Log("OutOfRange");
}
}
int childCount = go.transform.childCount;
if (go.GetComponent <SimpleObject>().NotMirrorChildrensOnSpawn)
{
for (int i = 0; i < childCount; i++)
{
go.transform.GetChild(i).localScale = new Vector3(go.transform.GetChild(i).localScale.x *(obj.mirrorX ? -1 : 1), go.transform.GetChild(i).localScale.y *(obj.mirrorY ? -1 : 1), go.transform.GetChild(i).localScale.z);
}
}
return(go);
}
private static RoomObject DeepCopyRoomObject(RoomObject obj, Room room, Game game, Player user)
{
RoomObject copy = null;
if (obj != null)
{
switch (obj.GetType().Name)
{
case "StructureSpawn":
var spawn = (StructureSpawn)obj;
copy = new StructureSpawn()
{
Game = game,
My = spawn.Owner != null && spawn.Owner.ID == user.ID,
Pos = room.GetPositionAt(spawn.Pos.X, spawn.Pos.Y),
Room = room,
Energy = spawn.Energy,
EnergyCapacity = spawn.EnergyCapacity,
HitPoints = spawn.HitPoints,
HitPointsMax = spawn.HitPointsMax,
ID = spawn.ID,
IsActive = spawn.IsActive,
Name = spawn.Name,
Owner = spawn.Owner,
Spawning = spawn.Spawning,
Type = spawn.Type,
Memory = new Dictionary <string, object>(),
};
game.Memory.Add(copy.ID, ((StructureSpawn)copy).Memory);
if (spawn.Memory != null)
{
foreach (string key in spawn.Memory.Keys)
{
((StructureSpawn)copy).Memory.Add(key, room.Memory[key]);
}
((StructureSpawn)copy).Memory["#"] = 2;
}
break;
case "StructureController":
var controller = (StructureController)obj;
copy = new StructureController()
{
Game = game,
Room = room,
Owner = controller.Owner,
My = controller.Owner != null && controller.Owner.ID == user.ID,
HitPoints = controller.HitPoints,
HitPointsMax = controller.HitPointsMax,
ID = controller.ID,
IsActive = controller.IsActive,
Pos = controller.Pos,
Type = controller.Type,
Progress = controller.Progress,
ProgressTotal = controller.ProgressTotal,
Level = controller.Level,
TicksToDowngrade = controller.TicksToDowngrade,
};
break;
case "Source":
var source = (Source)obj;
copy = new Source()
{
Game = game,
Room = room,
Energy = source.Energy,
EnergyCapacity = source.EnergyCapacity,
ID = source.ID,
Pos = source.Pos,
TicksToRegenerate = source.TicksToRegenerate,
};
break;
case "Creep":
var creep = (Creep)obj;
// TODO: Player-defined child class
copy = new Creep()
{
Game = game,
My = (creep.Owner.ID == user.ID),
Room = room,
Body = creep.Body,
Fatigue = creep.Fatigue,
HitPoints = creep.HitPoints,
HitPointsMax = creep.HitPointsMax,
ID = creep.ID,
Name = creep.Name,
NotifyWhenAttacked = creep.NotifyWhenAttacked,
Owner = creep.Owner,
Pos = creep.Pos,
Saying = creep.Saying,
Spawning = creep.Spawning,
TicksToLive = creep.TicksToLive,
Memory = new Dictionary <string, object>(),
_carrying = new Dictionary <ResourceTypes, int>(),
};
game.Memory.Add(copy.ID, ((Creep)copy).Memory);
foreach (string key in creep.Memory.Keys)
{
((Creep)copy).Memory.Add(key, creep.Memory[key]);
}
((Creep)copy).Memory["#"] = 2;
foreach (var key in creep._carrying.Keys)
{
((Creep)copy)._carrying.Add(key, creep._carrying[key]);
}
break;
default:
string type = obj.GetType().Name;
break;
}
}
return(copy);
}
/// <summary>
/// Executed when roomobjectlist added an item
/// </summary>
/// <param name="RoomObject"></param>
protected virtual void OnRoomObjectAdded(RoomObject RoomObject)
{
}
public void setup(RoomObject room)
{
setupLight(room);
base.generate(adjustPositionsBasedOnSide(room));
}
/// <summary>
/// Registers an existing room with a grid location.
/// </summary>
/// <param name="room">The room to register.</param>
public void RegisterRoom(RoomObject room)
{
Location gridPosition = room.RoomLocation;
int placeX = gridPosition.X;
int placeY = gridPosition.Y;
// Cannot register a room twice
Assert.IsFalse(ContainsRoom(room));
// Cannot have a piece hanging off
Assert.IsFalse((placeX < 0 || placeX >= m_worldMaxXSize) ||
(placeY < 0 || placeY >= m_worldMaxYSize));
// Cannot register over a room that already exists.
Assert.IsNull(m_worldGrid[placeX, placeY]);
m_worldGrid[placeX, placeY] = room;
}
