public static void OpenRoom(string File) { Room = new RooFile(File); Room.ResolveResources(ResourceManager); MainForm.Room = Room; }
protected virtual void HandlePlayerMessage(PlayerMessage Message) { double tick = GameTick.GetUpdatedTick(); RoomInfo roomInfo = Message.RoomInfo; if (roomInfo.RoomFile != String.Empty) { // try find the roofile instance RooFile rooFile = resourceManager.GetRoom(roomInfo.RoomFile); roomInfo.ResourceRoom = rooFile; // found and never "loaded" before, resolve and uncompress // otherwise don't touch it in this thread if (rooFile != null && !rooFile.IsResourcesResolved) { rooFile.ResolveResources(resourceManager); rooFile.UncompressAll(); } } double span = GameTick.GetUpdatedTick() - tick; Logger.Log(MODULENAME, LogType.Info, "Loaded BP_PLAYER: " + span.ToString() + " ms"); }
/// <summary> /// /// </summary> /// <param name="RooFile"></param> public override void ResolveIndices(RooFile RooFile) { // indices properties are not zero-based, but the arrays/lists are // get reference to parent wall if (WallReference > 0 && RooFile.Walls.Count > WallReference - 1) { Wall = RooFile.Walls[WallReference - 1]; } // get right tree child if (Right > 0 && RooFile.BSPTree.Count > Right - 1) { RightChild = RooFile.BSPTree[Right - 1]; } // get left tree child if (Left > 0 && RooFile.BSPTree.Count > Left - 1) { LeftChild = RooFile.BSPTree[Left - 1]; } }
public void ResolveResources(ResourceManager M59ResourceManager, bool RaiseChangedEvent) { // try find the roofile instance RooFile rooFile = M59ResourceManager.GetRoom(roomFile); // if found resolve room resources and uncompress all if (rooFile != null && !rooFile.IsResourcesResolved) { rooFile.ResolveResources(M59ResourceManager); rooFile.UncompressAll(); } // try find the wading sound file and load it string sound = M59ResourceManager.GetWavFile(wadingSoundFile); if (RaiseChangedEvent) { ResourceRoom = rooFile; ResourceWadingSound = sound; } else { resourceRoom = rooFile; resourceWadingSound = sound; } }
/// <summary> /// Sets the floor texture to another num /// </summary> /// <param name="TextureNum"></param> /// <param name="TextureFile"></param> public void SetFloorTexture(ushort TextureNum, BgfFile TextureFile) { string oldmaterial = MaterialNameFloor; FloorTexture = TextureNum; ResourceFloor = TextureFile; if (ResourceFloor != null && ResourceFloor.Frames.Count > 0) { TextureFloor = ResourceFloor.Frames[0]; SpeedFloor = GetSectorScrollSpeed(true, TextureFloor.Width, TextureFloor.Height); TextureNameFloor = RooFile.GetNameForTexture( ResourceFloor, 0); MaterialNameFloor = RooFile.GetNameForMaterial( ResourceFloor, 0, SpeedFloor); } else { TextureFloor = null; TextureNameFloor = null; MaterialNameFloor = null; SpeedFloor = V2.ZERO; } if (TextureChanged != null) { TextureChanged(this, new SectorTextureChangedEventArgs(this, true, oldmaterial)); } }
/// <summary> /// Sets the ceiling texture to another num /// </summary> /// <param name="TextureNum"></param> /// <param name="TextureFile"></param> public void SetCeilingTexture(ushort TextureNum, BgfFile TextureFile) { string oldmaterial = MaterialNameCeiling; CeilingTexture = TextureNum; ResourceCeiling = TextureFile; if (ResourceCeiling != null && ResourceCeiling.Frames.Count > 0) { TextureCeiling = ResourceCeiling.Frames[0]; SpeedCeiling = GetSectorScrollSpeed(false, TextureCeiling.Width, TextureCeiling.Height); TextureNameCeiling = RooFile.GetNameForTexture( ResourceCeiling, 0); MaterialNameCeiling = RooFile.GetNameForMaterial( ResourceCeiling, 0, SpeedCeiling); } else { TextureCeiling = null; TextureNameCeiling = null; MaterialNameCeiling = null; SpeedCeiling = V2.ZERO; } if (TextureChanged != null) { TextureChanged(this, new SectorTextureChangedEventArgs(this, false, oldmaterial)); } }
/// <summary> /// Tries to retrieve a ROO file from the Rooms dictionary. /// Will load the file from disk, if not yet loaded. /// </summary> /// <param name="File"></param> /// <returns></returns> public RooFile GetRoom(string File) { RooFile rooFile = null; // if the file is known if (Rooms.TryGetValue(File, out rooFile)) { // haven't loaded it yet? if (rooFile == null) { // load it rooFile = new RooFile(RoomsFolder + "/" + File); // resolve resource references (may load texture bgfs) rooFile.ResolveResources(this); // update the registry if (Rooms.TryUpdate(File, rooFile, null)) { numLoadedRooms++; } } } return(rooFile); }
public void UpdateFromModel(RoomInfo Model, bool RaiseChangedEvent) { if (RaiseChangedEvent) { AvatarID = Model.AvatarID; AvatarOverlayRID = Model.AvatarOverlayRID; AvatarNameRID = Model.AvatarNameRID; RoomID = Model.RoomID; RoomFileRID = Model.RoomFileRID; RoomNameRID = Model.RoomNameRID; RoomSecurity = Model.RoomSecurity; AmbientLight = Model.AmbientLight; AvatarLight = Model.AvatarLight; BackgroundFileRID = Model.BackgroundFileRID; WadingSoundFileRID = Model.WadingSoundFileRID; Flags = Model.Flags; Depth1 = Model.Depth1; Depth2 = Model.Depth2; Depth3 = Model.Depth3; AvatarOverlay = Model.AvatarOverlay; AvatarName = Model.AvatarName; RoomFile = Model.RoomFile; RoomName = Model.RoomName; BackgroundFile = Model.BackgroundFile; WadingSoundFile = Model.WadingSoundFile; ResourceRoom = Model.ResourceRoom; ResourceWadingSound = Model.ResourceWadingSound; } else { avatarID = Model.AvatarID; avatarOverlayRID = Model.AvatarOverlayRID; avatarNameRID = Model.AvatarNameRID; roomID = Model.RoomID; roomFileRID = Model.RoomFileRID; roomNameRID = Model.RoomNameRID; roomSecurity = Model.RoomSecurity; ambientLight = Model.AmbientLight; avatarLight = Model.AvatarLight; backgroundFileRID = Model.BackgroundFileRID; wadingSoundFileRID = Model.WadingSoundFileRID; flags = Model.Flags; depth1 = Model.Depth1; depth2 = Model.Depth2; depth3 = Model.Depth3; avatarOverlay = Model.AvatarOverlay; avatarName = Model.AvatarName; roomFile = Model.RoomFile; roomName = Model.RoomName; backgroundFile = Model.BackgroundFile; wadingSoundFile = Model.WadingSoundFile; resourceRoom = Model.ResourceRoom; resourceWadingSound = Model.ResourceWadingSound; } }
public void UpdatePosition(long TickSpan, RooFile RooFile) { if (!isMoving) { return; } // source->destination delta vector and squared distance (in 3D) V3 dvector = targetObject.Position3D - position3D; Real distance2 = dvector.LengthSquared; // end not yet reached? if (distance2 > EPSILON2) { if (Speed != (byte)MovementSpeed.Teleport) { // normalise to get plain direction dvector.Normalize(); // process another step based on time delta V3 step = dvector * (Real)speed * (Real)TickSpan * GeometryConstants.PROJECTILEMOVEBASECOEFF; // check if this step is greater than distance left if (step.LengthSquared > distance2) { // directly update for teleport-speed zero position3D.X = TargetObject.Position3D.X; position3D.Y = TargetObject.Position3D.Y; position3D.Z = TargetObject.Position3D.Z; // movement finished IsMoving = false; } else { // do the step position3D.X += step.X; position3D.Y += step.Y; position3D.Z += step.Z; } } else { // directly update for teleport-speed zero position3D.X = TargetObject.Position3D.X; position3D.Y = TargetObject.Position3D.Y; position3D.Z = TargetObject.Position3D.Z; } // trigger changed event RaisePropertyChanged(new PropertyChangedEventArgs(PROPNAME_POSITION3D)); } else { IsMoving = false; } }
/// <summary> /// Resolve all index references to object references /// </summary> /// <param name="RooFile"></param> public override void ResolveIndices(RooFile RooFile) { // indices properties are not zero-based, but the arrays/lists are // get reference to parent Sector if (SectorDefReference > 0 && RooFile.Sectors.Count > SectorDefReference - 1) { Sector = RooFile.Sectors[SectorDefReference - 1]; } }
public static void Build(RooFile Room) { if (Room == null) { return; } room = Room; if (BuildStarted != null) { BuildStarted(null, new EventArgs()); } /////////////////////////////////////////////////////////////// BoundingBox2D box = Room.GetBoundingBox2D(true); Polygon poly = new Polygon(); poly.Add(box.Min); poly.Add(box.Min + new V2(box.Max.X - box.Min.X, 0f)); poly.Add(box.Max); poly.Add(box.Max - new V2(box.Max.X - box.Min.X, 0f)); /////////////////////////////////////////////////////////////// // clean up old data from room Room.Walls.Clear(); Room.BSPTree.Clear(); foreach (RooSector sector in Room.Sectors) { sector.Walls.Clear(); sector.Sides.Clear(); } // convert roomeditor walls to roowall for (int i = 0; i < Room.WallsEditor.Count; i++) { RooWall wall = Room.WallsEditor[i].ToRooWall(RooFile.VERSIONHIGHRESGRID, Room); Room.Walls.Add(wall); } /////////////////////////////////////////////////////////////// RooBSPItem tree = BuildNode(Room.Walls, poly, 0); /////////////////////////////////////////////////////////////// FillNode(tree, Room.BSPTree); SetNums(Room.BSPTree); }
/// <summary> /// Sets middle texture to another num /// </summary> /// <param name="TextureNum"></param> /// <param name="TextureFile"></param> /// <param name="ResetAnimation"></param> public void SetMiddleTexture(ushort TextureNum, BgfFile TextureFile, bool ResetAnimation = true) { ushort group = (animation != null) ? animation.CurrentGroup : (ushort)1; int frameidx = 0; string oldmaterial = MaterialNameMiddle; MiddleTexture = TextureNum; ResourceMiddle = TextureFile; if (ResourceMiddle != null && ResourceMiddle.Frames.Count > 0) { // possibly reset animation if (animation != null && ResetAnimation) { animation.SetValues(1, ResourceMiddle.FrameSets.Count, false); group = animation.CurrentGroup; } frameidx = ResourceMiddle.GetFrameIndex(group, 0); frameidx = Math.Max(frameidx, 0); if (ResourceMiddle.Frames.Count > frameidx) { TextureMiddle = ResourceMiddle.Frames[frameidx]; SpeedMiddle = GetWallScrollSpeed(TextureMiddle.Width, TextureMiddle.Height); } else { TextureMiddle = null; SpeedMiddle = V2.ZERO; } TextureNameMiddle = RooFile.GetNameForTexture( ResourceMiddle, frameidx); MaterialNameMiddle = RooFile.GetNameForMaterial( ResourceMiddle, frameidx, SpeedMiddle); } else { TextureMiddle = null; SpeedMiddle = V2.ZERO; TextureNameMiddle = null; MaterialNameMiddle = null; } if (TextureChanged != null) { TextureChanged(this, new WallTextureChangedEventArgs(this, WallPartType.Middle, oldmaterial)); } }
/// <summary> /// Creates a RooWall instance based on this RooWallEditor instance. /// </summary> /// <param name="RooVersion"></param> /// <param name="Room"></param> /// <returns></returns> public RooWall ToRooWall(uint RooVersion, RooFile Room) { if (Room == null) { return(null); } V2 q1, q2; // first try get boundingbox as defined by 'Things' BoundingBox2D box = Room.GetBoundingBox2DFromThings(); // no thingsbox? build based on editorwalls if (box == BoundingBox2D.NULL) { box = Room.GetBoundingBox2D(false); } // 1) Convert from 1:64 to 1:1024 // 2) Modify coordinate system (y-axis different) q1.X = (P0.X - box.Min.X) * 16f; q1.Y = (box.Max.Y - P0.Y) * 16f; q2.X = (P1.X - box.Min.X) * 16f; q2.Y = (box.Max.Y - P1.Y) * 16f; // sidenum in editorwall is 0 to n ( 0=unset) // sectnum in editorwall is -1 to n (-1=unset) RooWall wall = new RooWall( RooVersion, 0, (ushort)this.FileSideDef1, // no +1 (ushort)this.FileSideDef2, // no +1 q1, q2, Side1XOffset, Side2XOffset, Side1YOffset, Side2YOffset, (ushort)(Side1Sector + 1), // +1 mapping (ushort)(Side2Sector + 1)); // +1 mapping // now resolve the object references from indices // and fill in heights wall.ResolveIndices(Room); wall.CalculateWallSideHeights(); // done return(wall); }
private void btnGO_Click(object sender, EventArgs e) { // check if (!File.Exists(txtRoomFile.Text) || !Directory.Exists(txtBGFFolder.Text) || !Directory.Exists(txtOutputFolder.Text)) { return; } // init a resourcemanager with room bgfs only ResourceManager resMan = new ResourceManager(); resMan.InitConfig(new ResourceManagerConfig( 0, false, false, false, false, null, null, null, txtBGFFolder.Text, null, null)); // load room and resolve resources RooFile rooFile = new RooFile(txtRoomFile.Text); rooFile.ResolveResources(resMan); // make output subfolder string subfolder = Path.Combine(txtOutputFolder.Text, rooFile.Filename); if (!Directory.Exists(subfolder)) { Directory.CreateDirectory(subfolder); } // extract textures Bitmap bmp; string filename; foreach (RooFile.TextureInfo texInfo in rooFile.Textures) { filename = Path.Combine( subfolder, texInfo.Container.Filename + "-" + texInfo.Container.Frames.IndexOf(texInfo.Texture) + ".png"); bmp = texInfo.Texture.GetBitmap(); bmp.MakeTransparent(System.Drawing.Color.Cyan); bmp.Save(filename, System.Drawing.Imaging.ImageFormat.Png); bmp.Dispose(); bmp = null; } }
/// <summary> /// Stars loading all rooms in a background thread. /// </summary> protected void LoadThreadRooms() { IEnumerator <KeyValuePair <string, RooFile> > it = Rooms.GetEnumerator(); RooFile file; while (it.MoveNext()) { // load file = new RooFile(Path.Combine(RoomsFolder, it.Current.Key)); // update Rooms.TryUpdate(it.Current.Key, file, null); queueAsyncFilesLoaded.Enqueue(it.Current.Key); } }
/// <summary> /// Preloads all elements in the Rooms dictionary. /// </summary> public void PreloadRooms() { IEnumerator <KeyValuePair <string, RooFile> > it = Rooms.GetEnumerator(); RooFile file; while (it.MoveNext()) { // load file = new RooFile(Path.Combine(Config.RoomsFolder, it.Current.Key)); // update Rooms.TryUpdate(it.Current.Key, file, null); } GC.Collect(2); }
/// <summary> /// Tries to retrieve a ROO file from the Rooms dictionary. /// Will load the file from disk, if not yet loaded. /// </summary> /// <param name="File"></param> /// <returns></returns> public RooFile GetRoom(string File) { RooFile rooFile = null; // if the file is known if (Rooms.TryGetValue(File, out rooFile)) { // haven't loaded it yet? if (rooFile == null) { byte[] buffer; // get file byte buffer if (!fileBuffers.TryPop(out buffer)) { buffer = new byte[FILEBUFFERSIZE]; } string file = RoomsFolder + "/" + File; // load to mem if (Util.LoadFileToBuffer(file, buffer)) { rooFile = new RooFile(file, buffer); // resolve resource references (may load texture bgfs) rooFile.ResolveResources(this); // update the registry if (Rooms.TryUpdate(File, rooFile, null)) { numLoadedRooms++; } } else { Logger.Log(MODULENAME, LogType.Error, "Failed to load file (possibly too big?): " + File); } fileBuffers.Push(buffer); } } return(rooFile); }
/// <summary> /// Sets lower texture to another num /// </summary> /// <param name="TextureNum"></param> /// <param name="TextureFile"></param> public void SetUpperTexture(ushort TextureNum, BgfFile TextureFile) { ushort group = (animation != null) ? animation.CurrentGroup : (ushort)1; int frameidx = 0; string oldmaterial = MaterialNameUpper; UpperTexture = TextureNum; ResourceUpper = TextureFile; if (ResourceUpper != null && ResourceUpper.Frames.Count > 0) { frameidx = ResourceUpper.GetFrameIndex(group, 0); frameidx = Math.Max(frameidx, 0); if (ResourceUpper.Frames.Count > frameidx) { TextureUpper = ResourceUpper.Frames[frameidx]; SpeedUpper = GetWallScrollSpeed(TextureUpper.Width, TextureUpper.Height); } else { TextureUpper = null; SpeedUpper = V2.ZERO; } TextureNameUpper = RooFile.GetNameForTexture( ResourceUpper, frameidx); MaterialNameUpper = RooFile.GetNameForMaterial( ResourceUpper, frameidx, SpeedUpper); } else { TextureUpper = null; SpeedUpper = V2.ZERO; TextureNameUpper = null; MaterialNameUpper = null; } if (TextureChanged != null) { TextureChanged(this, new WallTextureChangedEventArgs(this, WallPartType.Upper, oldmaterial)); } }
public void ResolveResources(ResourceManager M59ResourceManager, bool RaiseChangedEvent) { if (RoomFile != String.Empty) { if (RaiseChangedEvent) { ResourceRoom = M59ResourceManager.GetRoom(RoomFile); } else { resourceRoom = M59ResourceManager.GetRoom(RoomFile); } if (resourceRoom != null) { resourceRoom.ResolveResources(M59ResourceManager); } } }
/// <summary> /// Creates object references from the indices for easier access. /// </summary> /// <param name="RooFile"></param> public void ResolveIndices(RooFile RooFile) { // indices properties are not zero-based, but the arrays/lists are // get reference to right SectorDef if (RightSectorReference > 0 && RooFile.Sectors.Count > RightSectorReference - 1) { RightSector = RooFile.Sectors[RightSectorReference - 1]; // save as adjacent wall if (!RightSector.Walls.Contains(this)) { RightSector.Walls.Add(this); } } // get reference to left SectorDef if (LeftSectorReference > 0 && RooFile.Sectors.Count > LeftSectorReference - 1) { LeftSector = RooFile.Sectors[LeftSectorReference - 1]; // save as adjacent wall if (!LeftSector.Walls.Contains(this)) { LeftSector.Walls.Add(this); } } // get reference to right SideDef if (RightSideReference > 0 && RooFile.SideDefs.Count > RightSideReference - 1) { RightSide = RooFile.SideDefs[RightSideReference - 1]; // save as adjacent side if (RightSector != null && !RightSector.Sides.Contains(RightSide)) { RightSector.Sides.Add(RightSide); } // save as adjacent side if (LeftSector != null && !LeftSector.Sides.Contains(RightSide)) { LeftSector.Sides.Add(RightSide); } } // get reference to left SideDef if (LeftSideReference > 0 && RooFile.SideDefs.Count > LeftSideReference - 1) { LeftSide = RooFile.SideDefs[LeftSideReference - 1]; // save as adjacent side if (RightSector != null && !RightSector.Sides.Contains(LeftSide)) { RightSector.Sides.Add(LeftSide); } // save as adjacent side if (LeftSector != null && !LeftSector.Sides.Contains(LeftSide)) { LeftSector.Sides.Add(LeftSide); } } }
/// <summary> /// Abstract. Must be implemented. /// </summary> /// <param name="RooFile"></param> public abstract void ResolveIndices(RooFile RooFile);
/// <summary> /// Call regularly from mainthread, will possibly update mapimage and trigger event /// </summary> public void Tick(long Tick, long Span) { // get elapsed ms since last image draw long msspan = Tick - tickLastUpdate; if (DataController != null && DataController.AvatarObject != null && DataController.RoomInformation != null && DataController.RoomInformation.ResourceRoom != null && msspan >= UPDATEINVERVALMS) { RooFile RoomFile = DataController.RoomInformation.ResourceRoom; // get the deltas based on zoom, zoombase and mapsize // the center of the bounding box is the player position Real deltax = Zoom * ZOOMBASE * (Real)Width; Real deltay = Zoom * ZOOMBASE * (Real)Height; // the top left corner of bounding box int topx = Convert.ToInt32((Real)DataController.AvatarObject.CoordinateX - deltax); int topy = Convert.ToInt32((Real)DataController.AvatarObject.CoordinateY - deltay); // bottom right corner of bounding box int bottomx = Convert.ToInt32((Real)DataController.AvatarObject.CoordinateX + deltax); int bottomy = Convert.ToInt32((Real)DataController.AvatarObject.CoordinateY + deltay); // get scale between actual pixelsize of image to show and the bounding box Real boxscale = (Real)Width / (Real)(bottomx - topx); // prepare drawing PrepareDraw(); // start drawing lines from roo foreach (RooWall rld in RoomFile.Walls) { // Don't show line if: // 1) both sides not set // 2) left side set to not show up on map, right side unset // 3) right side set to not show up on map, left side unset // 4) both sides set and set to not show up on map if ((rld.LeftSide == null && rld.RightSide == null) || (rld.LeftSide != null && rld.RightSide == null && rld.LeftSide.Flags.IsMapNever) || (rld.LeftSide == null && rld.RightSide != null && rld.RightSide.Flags.IsMapNever) || (rld.LeftSide != null && rld.LeftSide != null && rld.LeftSide.Flags.IsMapNever && rld.RightSide.Flags.IsMapNever)) { continue; } // convert to traffic-coords (/16 is RSHIFT 4, +64 offset): int x1 = (rld.X1 >> 4) + 64; int y1 = (rld.Y1 >> 4) + 64; int x2 = (rld.X2 >> 4) + 64; int y2 = (rld.Y2 >> 4) + 64; // expressions whether point is in rectangle bool isX1inScope = (x1 >= topx && x1 <= bottomx); bool isY1inScope = (y1 >= topy && y1 <= bottomy); bool isX2inScope = (x2 >= topx && x2 <= bottomx); bool isY2inScope = (y2 >= topy && y2 <= bottomy); // if at least one of the line points is in the mapscope, draw the line if ((isX1inScope && isY1inScope) || (isX2inScope && isY2inScope)) { // transform points to match world of pixeldrawing Real transx1 = (x1 - topx) * boxscale; Real transy1 = (y1 - topy) * boxscale; Real transx2 = (x2 - topx) * boxscale; Real transy2 = (y2 - topy) * boxscale; // draw wall DrawWall(rld, transx1, transy1, transx2, transy2); } } // draw roomobjects foreach (RoomObject obj in DataController.RoomObjects) { Real objx = (obj.CoordinateX - topx) * boxscale; Real objy = (obj.CoordinateY - topy) * boxscale; int width = Convert.ToInt32(50.0f * boxscale); Real widthhalf = (Real)width / 2.0f; int rectx = Convert.ToInt32((Real)objx - widthhalf); int recty = Convert.ToInt32((Real)objy - widthhalf); DrawObject(obj, rectx, recty, width, width); } FinishDraw(); // trigger event RaiseImageChanged(); // save this update tick tickLastUpdate = Tick; } }
/// <summary> /// Gets references to used textures from a resource manager. /// </summary> /// <param name="M59ResourceManager"></param> /// <param name="RaiseChangedEvent"></param> public void ResolveResources(ResourceManager M59ResourceManager, bool RaiseChangedEvent) { // floor if (FloorTexture > 0) { ResourceFloor = M59ResourceManager.GetRoomTexture(FloorTexture); if (ResourceFloor != null && ResourceFloor.Frames.Count > 0) { TextureFloor = ResourceFloor.Frames[0]; SpeedFloor = GetSectorScrollSpeed(true, TextureFloor.Width, TextureFloor.Height); TextureNameFloor = RooFile.GetNameForTexture( ResourceFloor, 0); MaterialNameFloor = RooFile.GetNameForMaterial( ResourceFloor, 0, SpeedFloor); } else { TextureFloor = null; TextureNameFloor = null; MaterialNameFloor = null; SpeedFloor = V2.ZERO; } } else { TextureFloor = null; TextureNameFloor = null; MaterialNameFloor = null; SpeedFloor = V2.ZERO; } // ceiling if (CeilingTexture > 0) { ResourceCeiling = M59ResourceManager.GetRoomTexture(CeilingTexture); if (ResourceCeiling != null && ResourceCeiling.Frames.Count > 0) { TextureCeiling = ResourceCeiling.Frames[0]; SpeedCeiling = GetSectorScrollSpeed(false, TextureCeiling.Width, TextureCeiling.Height); TextureNameCeiling = RooFile.GetNameForTexture( ResourceCeiling, 0); MaterialNameCeiling = RooFile.GetNameForMaterial( ResourceCeiling, 0, SpeedCeiling); } else { TextureCeiling = null; TextureNameCeiling = null; MaterialNameCeiling = null; SpeedCeiling = V2.ZERO; } } else { TextureCeiling = null; TextureNameCeiling = null; MaterialNameCeiling = null; SpeedCeiling = V2.ZERO; } }
public void ResolveResources(ResourceManager M59ResourceManager, bool RaiseChangedEvent) { ushort group = (animation != null) ? animation.CurrentGroup : (ushort)1; int frameidx = 0; /******************************************************************************/ if (UpperTexture > 0) { ResourceUpper = M59ResourceManager.GetRoomTexture(UpperTexture); } if (MiddleTexture > 0) { ResourceMiddle = M59ResourceManager.GetRoomTexture(MiddleTexture); } if (LowerTexture > 0) { ResourceLower = M59ResourceManager.GetRoomTexture(LowerTexture); } /******************************************************************************/ if (animation != null) { // note: possibly need animation instance for each parttype? if (ResourceMiddle != null) { animation.GroupMax = ResourceMiddle.FrameSets.Count; } /*else if (ResourceLower != null) * animation.GroupMax = ResourceLower.FrameSets.Count; * * else if (ResourceUpper != null) * animation.GroupMax = ResourceUpper.FrameSets.Count;*/ } /******************************************************************************/ if (ResourceUpper != null && ResourceUpper.Frames.Count > 0) { frameidx = ResourceUpper.GetFrameIndex(group, 0); frameidx = Math.Max(frameidx, 0); if (ResourceUpper.Frames.Count > frameidx) { TextureUpper = ResourceUpper.Frames[frameidx]; SpeedUpper = GetWallScrollSpeed(TextureUpper.Width, TextureUpper.Height); } else { TextureUpper = null; SpeedUpper = V2.ZERO; } TextureNameUpper = RooFile.GetNameForTexture( ResourceUpper, frameidx); MaterialNameUpper = RooFile.GetNameForMaterial( ResourceUpper, frameidx, SpeedUpper); } else { TextureUpper = null; SpeedUpper = V2.ZERO; TextureNameUpper = null; MaterialNameUpper = null; } /******************************************************************************/ if (ResourceMiddle != null && ResourceMiddle.Frames.Count > 0) { frameidx = ResourceMiddle.GetFrameIndex(group, 0); frameidx = Math.Max(frameidx, 0); if (ResourceMiddle.Frames.Count > frameidx) { TextureMiddle = ResourceMiddle.Frames[frameidx]; SpeedMiddle = GetWallScrollSpeed(TextureMiddle.Width, TextureMiddle.Height); } else { TextureMiddle = null; SpeedMiddle = V2.ZERO; } TextureNameMiddle = RooFile.GetNameForTexture( ResourceMiddle, frameidx); MaterialNameMiddle = RooFile.GetNameForMaterial( ResourceMiddle, frameidx, SpeedMiddle); } else { TextureMiddle = null; SpeedMiddle = V2.ZERO; TextureNameMiddle = null; MaterialNameMiddle = null; } /******************************************************************************/ if (ResourceLower != null && ResourceLower.Frames.Count > 0) { frameidx = ResourceLower.GetFrameIndex(group, 0); frameidx = Math.Max(frameidx, 0); if (ResourceLower.Frames.Count > frameidx) { TextureLower = ResourceLower.Frames[frameidx]; SpeedLower = GetWallScrollSpeed(TextureLower.Width, TextureLower.Height); } else { TextureLower = null; SpeedLower = V2.ZERO; } TextureNameLower = RooFile.GetNameForTexture( ResourceLower, frameidx); MaterialNameLower = RooFile.GetNameForMaterial( ResourceLower, frameidx, SpeedLower); } else { TextureLower = null; SpeedLower = V2.ZERO; TextureNameLower = null; MaterialNameLower = null; } }
public void WriteGridHighRes(RooFile file, string Filename) { System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(file.Grids.ColumnsHighRes * 3, file.Grids.RowsHighRes * 3); int x = 1; int y = 1; for (int i = 0; i < file.Grids.RowsHighRes; i++) { x = 1; for (int j = 0; j < file.Grids.ColumnsHighRes; j++) { if (file.Grids.IsWalkableHighRes(i, j)) { bmp.SetPixel(x, y, System.Drawing.Color.White); } else { bmp.SetPixel(x, y, System.Drawing.Color.Black); } if (file.Grids.IsWalkNorthHighRes(i, j)) { bmp.SetPixel(x, y - 1, System.Drawing.Color.Green); } else { bmp.SetPixel(x, y - 1, System.Drawing.Color.Red); } if (file.Grids.IsWalkNorthEastHighRes(i, j)) { bmp.SetPixel(x + 1, y - 1, System.Drawing.Color.Green); } else { bmp.SetPixel(x + 1, y - 1, System.Drawing.Color.Red); } if (file.Grids.IsWalkEastHighRes(i, j)) { bmp.SetPixel(x + 1, y, System.Drawing.Color.Green); } else { bmp.SetPixel(x + 1, y, System.Drawing.Color.Red); } if (file.Grids.IsWalkSouthEastHighRes(i, j)) { bmp.SetPixel(x + 1, y + 1, System.Drawing.Color.Green); } else { bmp.SetPixel(x + 1, y + 1, System.Drawing.Color.Red); } if (file.Grids.IsWalkSouthHighRes(i, j)) { bmp.SetPixel(x, y + 1, System.Drawing.Color.Green); } else { bmp.SetPixel(x, y + 1, System.Drawing.Color.Red); } if (file.Grids.IsWalkSouthWestHighRes(i, j)) { bmp.SetPixel(x - 1, y + 1, System.Drawing.Color.Green); } else { bmp.SetPixel(x - 1, y + 1, System.Drawing.Color.Red); } if (file.Grids.IsWalkWestHighRes(i, j)) { bmp.SetPixel(x - 1, y, System.Drawing.Color.Green); } else { bmp.SetPixel(x - 1, y, System.Drawing.Color.Red); } if (file.Grids.IsWalkNorthWestHighRes(i, j)) { bmp.SetPixel(x - 1, y - 1, System.Drawing.Color.Green); } else { bmp.SetPixel(x - 1, y - 1, System.Drawing.Color.Red); } x += 3; } y += 3; } bmp.Save(Filename); bmp.Dispose(); }