Index:
Disclaimer
Welcome and Introduction to MappyWin32
Quickstart and Tutorials
Menubar: -
File -
Edit -
MapTools -
Brush -
Layer -
Custom
All the features in the MappyWin32 menus are described
in the corresponding menu link above
Windows: -
The Map Window -
The Block Window
The MappyWin32 editor has two windows, the Map Window
for editing the map and the Block Window for selecting and editing blocks
Keyboard Shortcuts
Using the standard and custom keys gives faster
access to more commands (fill, line etc)
Features
MapWin32 Pro documentation
How It Works
Supported image formats (BMP, PCX, PNG, TGA)
Using Mappy as a simple map editor (.MAP format)
Important information about FMP1.0, Isometric/Hexagonal/other maps
+ Hexagonal map help
+ Isometric map help
Design Considerations
Adding functionality with Lua scripts
Commandline options
TextStrings and Labels
Using Marker Blocks
Exporting map for GBA/mobile
The Playback Libraries
The FMP file format
The MAP file format
mapwin.ini settings
Glossary
Version History
This software and associated files are provided 'as is'
with no warranty or guarantees of any kind, you use them at your
own risk and in doing so agree that the author is in no way
liable and cannot be held responsible for any loss of
time/data/hair or anything else that may occur either directly or
indirectly from the use of this software or associated files.
Thankyou for using MappyWin32, hopefully you will find it a
useful tool in creating your own games. This software is freely
distributable, the only restriction is that
you are not allowed to charge for this editor or distribute a modified version of this editor
without the author's consent. You may, of course, use the maps you create as you wish.
If you like it, you can upgrade this free version to MapWin32 Pro
at the tilemap.co.uk site. The example maps provided in the MAPS folder may be
used for tests, but you must get permission for other uses.
What is it? Well, I have tried to make the most
comprehensive and powerful 2D tile map editor about. The idea is
that you make some graphic 'tiles' of a set size (such as
16 pixels wide by 16 pixels high) with some paint package like this:
Note: These are the features for Mappy Win32 other platforms
and versions have slight differences in features, but all make
the same FMP files...
Single FMP file format (0.5) compatible with all versions of
Mappy and playback libraries
User definable MAP file format for compatibility with other systems
Supports 8/15/16/24/32bit colour modes
Supports all resolutions
Imports BMP, PNG, PCX and TGA files
Supports still and animated tiles
Supports tile sizes of 8*8 upto 128*128, including
non-square tiles
30000 tiles, AND 2048 anims available
Can edit maps with rectangular, isometric, hexagonal and other shape tiles
Easy to use interface
Fill (with still/animated blocks, brush (multi-block) and
random from brush)
Lines
Zoom (1x, 2x and 4x)
Hotkeys and keyboard shortcuts, inc pickblock and
next/prev tile
New, Cut, Copy and Paste
Brush an area, then draw with it!
Various playback libraries to use with your games to load
and display the FMP map file
All colourdepths converting (display 8bit maps on 16bit
screens? no problem)
Import and Export individual components
Export data as text
Lua support for expanding functionality with scripts
Resize map array with recentering (nice)
Undo (and Undo-undo :)
Grid, for easy positioning/tile recognition
Onion skin transparency
Tidyup/space functions, gets rid of unused data
Map information, see exactly how much space things are
using
DirectX preview (MappyWin32 will run without DirectX
except preview), scroll around your animated map on any valid
DirectX mode (all valid modes for your system are listed),
includes parallax layer for transparency checking. On my
relatively lowly 200Mhz K6 I can run my monitor rate of 75fps in
800*600*16 with all layers and parallax
Layers, 4 for each block, 8 in the map including
transparency and depth.
Expansive and useful documentation (surely the best
feature?)
MappyWin32 runs under Windows 95, 98, Me, 2000, NT
and XP, it should also run under other OS with Windows emulation.
You will need your desktop in 15bit colour or higher
(high or true colour, the more colours the better). Extract the
files from the zipfile to your drive. Double click
mapwin.exe to start it, you can also associate the .FMP map files with
mapwin.exe if you want.
To try out and learn how to use MappyWin32 you can follow these
quick tutorials:
Tutorial 1: Using MappyWin32
Make the window bigger by clicking the 'maximize' gadget to the
left of the 'X' close gadget in the window's titlebar. Select
'Open' from the file menu, or simply press ctrl+o, and open the MAPS
folder. You should see the file test2.fmp (or 'test2'), double click
it and it will be loaded into the map editor.
You should now see the map in the Map Editor (larger)
window, and the still blocks in the Block Editor (smaller) window.
If you have a high resolution desktop and the tiles look a bit
small, select a 'Zoom' from the MapTools menu. Click the left mouse
button over a block in the Block Editor window, you
should see a black and white rectangle appear round it,
indicating it is the active block. Now move the mouse over to the
Map Editor window and click the left mouse button to place the
block in the map. You can hold the left button down and move the
mouse to 'paint' with the block. Try scrolling
around the map with the cursor (arrow) keys, or using the sliders
at the right and bottom edges of the Map Editor window. You can
undo the last action you made by selecting Undo from the Edit
menu (or simply ctrl+z), you can undo your undo by selecting it
again.
One of Mappy's best features are animated blocks, to see
them click the right mouse button in the Block Editor window, you
should see the title of the window change, and any animated
blocks will be displayed, you can select and use them just like
still blocks, you can right click again to get back to the still
blocks. In a new project, there are no animated blocks to start
with, you should switch to the animated blocks window, and select
'New' from the Edit menu.
Handy shortcuts are to use the ',' and
'.' keys to select
the previous/next block and the 'p' key to select the block the
mouse pointer is currently over in the Map Editor window.
You can
double click the left button on a still or animated block in the
Block Editor window to edit its properties, try it on both still
and animated blocks
to see the options. You can use any of the options in the Edit
menu to manage the blocks, a new block only uses 32 bytes of
memory and ordering them does not change the graphics order (so
you can still update your graphics from your original graphics blocks
picture with Import).
Select the Grab New Brush option
from the Brush menu, now position your mouse over the
corner of the area you want to brush in the Map Editor window.
Click the left mouse button and hold it down and move the mouse
to the opposite corner of the area you want to grab, you should
see a 'bounding box' indicating the area. When you have the area
you want selected, release the left mouse button and name it. You can now
paste that brush anywhere you like with the left button
the top left of the brush will be at the mouse pointer (you can change this
with 'Handle' in the Brushes menu).
Note that any 'block 0' blocks in the brush will be treated as
transparent so you can have non-rectangular brushes, unless you disable
this with the option in the Brushes menu. You can also
use brushes for filling, find an area with a number of identical
blocks next to each other (the black areas are good), place the
mouse pointer over the 'starting block' and press the 'f' key,
that area will now be filled with the brush, over and over with
the top left of the brush where the mouse pointer is, try it and
see. Undo the fill with ctrl+z, now do the same, but press
ctrl+f, the area will be filled with random blocks from the
brush.
If you want to save the map, select 'Save As' from the File
menu.
Tutorial 2: Making a new FMP map with MappyWin32
When you want to make a new map, you will need to create or
obtain some tile graphics. These must be in a grid like this:
This will show how the map is layed out, and allow you
to edit that layout. Simply select a block, anim, or brush and
paint with it by clicking the left mouse button on the square
where you want to place the tile, you can alter more than one
square by holding down the left mouse button and moving the
mouse. The actions performed by the mousebuttons can be defined
by selectin 'Mousebuttons' in the Custom menu. The mousewheel
can be used to scroll the blocks in the Block editor window.
You can fill an area of blocks with either a still
block, anim block or brush (depending on what is currently
selected as your drawing item) by pressing the 'f' key (make sure
caps lock isn't on) when the mouse button is over the block you
want to start the fill with. You can also fill randomly from a
brush with Ctrl+F, you can weight blocks by having more than one
in a brush (try and see, you can undo a fill with Undo, Ctrl+Z).
Another handy shortcut is to press the 'p' key while the mouse
pointer is over the block you want to pick in the Map Editor
window, this will now be your current block/anim. You can select
the next/previous block/anim by pressing the ',' and '.' keys.
You can move the area seen in the Map Editor window by
either using the scrollbars on the right and bottom edges of that
window, or by pressing the arrow (cursor) keys, hold them down to
scroll along. When you get to the right or bottom edges of the
map you will see a grey area which cannot be modified.
Information about the block under the mouse pointer is
given in the window title bar.
This shows all the still and animated blocks that have
been created, you can toggle between the still and animated
screens by right clicking the mouse over the Block Editor window.
To select a block or anim, left click the mouse button on it, you
can now draw with it in the Map Editor window.
You can add a new block/anim, cut copy and paste
(all in the Edit menu), new and paste put the block after the
currently selected one. Each block takes only 32 bytes of space
(see Map Properties). Note that cutting a block will remove any
references to it from the map array (they will be replaced with a
reference to block 0), and pasting it will not put them back, so
it's usually best not to cut blocks you are using in the map
array. Also note that cutting a block does not remove the
graphics it was using. Using new, cut, copy and paste does not
affect the graphics you imported in any way, click on the picture
above 'BG' in a block's properties to see the actual graphics.
As long as you don't use 'Remove unused or duplicate graphics'
options the graphics will never change, allowing you to update
them from the original imported image.
Undo does not work when editing the Block
Editor.
You can see more blocks/anims by scrolling up and down
with the scrollbar on the right of the Block Editor window.
To edit a block structure, double click it in the Block
Editor window. Depending on whether it is a still or animated
block, you will be shown a dialogue giving details about it and
allowing you to change it.
Editing Properties of a Still Block. You will be shown the
block you double clicked, along with it's properties. The numeric
information is not used by Mappy and is entirely for your own
use, as are the four collision detection, and 'other' bits. The BG
transparency box indicates whether BG transparency is taken into
account (you will nearly always check that in block 0 if you plan
to use transparency, as well as any blocks that have a
transparent colour in the BG graphic. An easy way to set this for
all blocks with some transparent pixels is to select 'Auto set
BG transparency' from the 'Useful functions' option in the MapTools
menu after you have imported your graphics). In the bottom left, you will see the
four layers of graphics that make up the block's appearance,
simply click them to pick a new graphic, BG is used as the back
layer, you will probably only want to use the first FG layer,
this allows you to draw the map in layers in the playback
libraries, sandwiching sprites between them to give depth. You
can go to the next/previous block by clicking the arrows next to
the OK button. TextStrings are covered in the
TextStrings and Labels section.
This has the standard file features such as Open (open
a .FMP or .MAP mapfile for editing), Save (saves current .FMP or .MAP file under
it's current name, if it hasn't been named this is the same as
Save As), Save As (requests a name to save the map, .FMP will be
added if you don't type it in then saves it), Exit (quits Mappy,
same as clicking the 'X' gadget in the window titlebar, you
will be warned if you have modified a map but not saved it), and
some Mappy specfic ones, which are:
New Map. Brings up the new map dialogue where you choose
settings for the new map, you should have carefully decided on
the values you enter here. Either the default values will be shown, or
the values for the currently loaded map (currently loaded map
will be cleared from memory if you OK from New Map), you can
modify these values to any legal value. If you are creating a
map with non-rectangular tiles click 'Advanced'.
Note: Your Windows desktop doesn't need to be in, or support,
that depth, your Windows desktop does need to be in high or true
colour though (yes, even for 8bit maps :).
Advanced dialogue:
FMP version: this allows you to specify the version
of the FMP file, you can change it in Map Properties later on.
Block gap x and y: this is the gap between blocks, if x is the same width,
the blocks will be next to each other. For isometric maps,
gapx should be the same as blockwidth, and
gapy should be the same as blockheight.
Block stagger x and y: This is the offset for every other row, for
isometric, stagger x should be half blockwidth, stagger y should be half
blockheight. You can change all these in Map Properties later on if it doesn't look right.
When you 'OK' you will be given a map
filled with one block (shown in the Block Editor 'still' window)
this is a special block, you can edit it's properties (by double
clicking) but not give it any graphics or delete or move it from
the first position. Now may be a good time to check 'Map
Properties' in MapTools to see how much space is being taken up.
Import. This is used to get your tile graphics into your
map, see supported image formats.
This contains New, Cut, Copy and Paste for use with the
blocks in the Block Editor window (see
Block Editor for how those work).
Undo is very useful, but doesn't work on everything, it
will undo everything since the last left mouse click in the Map
Editor window (including the area you can't see), especially
useful for undoing Fill or when you 'paint' by holding the
mousebutton down.
Map Properties. This allows you to put your name and a 3 line
description of the map, the length of each line is limited to 68
characters, this information is saved in the FMP file. Below is
how much memory each type of object is using in the map along
with the total space used for those objects. There are also a
variety of things you can fiddle with. The Alt Graphics: Load allows
you to add another set of graphics to support an 8bit display in
a truecolour map, if
Anim Preview is set to an 8bit mode, you can see them there... If you import
graphics, these will be freed. To make them: export tiles as a BMP, convert
to 8 bit, Load 8bit BMP as Alt graphics.
Map version allows you to select which FMP type is used, you can
freely change this at any time, FMP0.5 is most supported by
other libraries (check your playback library) but is limited
to 1024 tiles.
Colourkey allows you to choose the transparency colour for the map,
this is saved in FMP files.
You should ignore the clickmask, stagger and gap values for
normal rectangular tile maps.
A clickmask MUST be set for non-rectangular tile maps (like isometric)
you should set this to a number of a graphic tile that is a solid mask
for the shape of blocks. The gap values are the pixels between blocks,
the stagger values are the offsets of the odd rows.
Don't cache in VRAM allows you to stop a
playback lib using VRAM for certain graphics (like marker blocks), example:
1-20,28,30,35-40 would not load blocks 1 through 20, 28, 30, and 35 through
40 in VRAM, using sysmem instead. This feature requires a playback lib that supports it,
if it doesn't the map will still work and this info will be ignored.
Anim preview (DirectX). Runs the map in fullscreen
DirectDraw using the settings from 'Preview setup'. You can
scroll around the map (starting at the point where the Map Editor
window is currently viewing) and see the animated blocks animating as
well as the transparency. Zoom and flipped tiles are not used in
this preview.
Preview setup. Select the screenmode you want to
use from the list, these are reported by DirectX so only valid
ones are shown, it defaults to whatever you set as apmode in
mapwin.ini, bpp is the depth of the map
pick whichever you like,
preferably the one your game is going to run in, beware that
running excessively high resolution modes on monitors not
designed for that mode may damage the monitor. Check the boxes
below for which block layers are drawn (the default is background
(BG) with the first foreground layer). Below are the transparency
options, check the box to enable transparency on the preview, if
you want a parallax layer (very handy for checking proper
transparency) enter the number of the GRAPHIC (this may not be
the same as the block number, 0 will be plain black or colour 0,
you can see what the graphic numbers are by editing a still
block, clicking on the BG image and looking at the list) this
will be repeated over and over in any transparent regions
(remember to check the BG transparency box, in the Block properties
editor) and move at half the speed
of the other layers creating a rather lovely effect. There is also a box
specifying the logic rate, leave this at 0 if you want the logic
to match the monitor refresh rate, or specify your own. If you are
making a game you usually can't rely on the refresh rate of the
monitor to regulate speed as it varies (so speed will vary on
different machines). Most games update internally at a set rate
(try 100fps) which unfortunately leads to jerkier movement but
at least the speed is the same on all machines.
Range Edit Blocks. Allows you to selectively
adjust a set range of block structures. It is simple to
use, type the numbers for the start and end of the range of blocks
you want to alter, then adjust ONLY the things you want to change.
If any of the checkboxes are greyed out, or the user fields are
completely blank the information in each block will be left
unaltered. For more information on these fields, see
Block Editor.
Resize Map. Allows
you to resize the map array of all layers. Before resizing it is
advisable to save the map as you can't Undo it (though you can
resize back to the original size). Enter the new width and height
of the map in blocks. When you have done that, you can click one of the 9
buttons on the left which show which edges rows and columns will
be removed/added to, the default is 1, rows and columns
will be added/removed from the lower right to make the new size
map). You can alternatively enter which block position should be at
the new top left in the 'New Left' and 'New Top' boxes (negative offsets
are allowed). Click OK to resize, or Cancel to keep the old size.
Useful functions. Contains miscellaneous
functions:
Change block size/depth: Will destroy the current graphics
but keep all other data, you can then import the new size
graphics into the map (you can do this by exporting the current
graphics, resizing, then re-importing them.
Convert 16x16 blocks to 8x8 (GBA): 8bit only, download GBAMappy
to see how to use. Often used with the 'Export 16x16 GBA table'
custom export script.
Split blocks (Halve block dimensions): Splits all blocks
and graphics into four (for example, 32x32 size tiles become 16x16)>
Auto set BG transparency: Checks the BG transparency box for
every block that has any transparent colour pixels in the BG image.
Create map from big picture: Loads a large image file into the
current map (such as one exported as ?scrn.BMP), optionally
removing duplicate tiles. Select the option for full instructions.
Save FMP without graphics: Saves all information just like a
FMP file except the graphics (allowing sharing of graphics
between maps). The file is saved with a .FMA extension as
these maps are not FMP compliant. If you want to reload a
FMA file into MappyWin32 (1.4 and above only), load the
FMP with the graphics in first, then load the FMA file.
You will need to type the whole FMA name in the open
requester as FMA files are not shown (eg: level1.fma).
As only the graphics are missing, an FMA map can have
different blocks, map size, brushes, number of layers etc
to the FMP file it is using the graphics from.
In order to load an FMA file with a playback library, you
will either:
1) Modify it so the FreeAll function does not
free the graphics from the FMP file, then load the FMA
file with MapLoad, or:
2) Export the graphics as a .GFX file and modify the DecodeBGFX
function to load that after loading the FMA file, or:
3) Load the graphics from a BMP file or other.
You should consider exporting .MAR files instead as these
are supported by playback libraries.
Remove Unused or Duplicate. Useful when you have
completed a map and want to reduce its size. Make sure you have
a backup! If you select remove anims, any anims that aren't used
in the map will be removed, this probably won't save much space
on its own, but when you remove graphics you could save a lot
more, be careful, if you have made an anim sequence that is
inserted into the map in realtime by your game, it will still be
deleted if it is not in the map. Remove blocks removes any block
structures not used by the map array or anim sequences. Remove
graphics removes any raw graphics not used by block structures,
this will mean you can no longer update your graphics from your
original picture, export the blocks as a BMP if you need to
modify them after this. To check these savings, view Map
Information before and after doing this.
Show user info on tile. Lets you select
one of the Block Properties fields to show over the tile
graphic in the Map and Block Editor windows (if the field is
not 0). The value is truncated if it is too big to show on the
tile. See also: Using Marker Blocks.
Show Pillar bases only. On isometric maps
with risers, this toggles whether the whole riser is drawn
(obscuring parts of the map), or just the base.
Pillar Riser mode. Toggles riser mode,
see the Isometric section for details.
Flipped tiles mode. Toggles flipped tiles
mode, when enabled you can flip the tile graphics vertically and/or
horizontally in the block properties of each block. Most playback
libraries do not support this mode, used mainly for GBA development
and MappyGL. Flipped tiles
mode is not saved in the map file, if you use flipped tiles,
you can set this mode on by default in the mapwin.ini file.
Rotated tiles mode. Toggles rotated tiles
mode, when enabled you can rotate the tile graphics 0, 90, 180
and 270 degrees by setting the USER7 field to 0, 1, 2 or 3
repectively. The change will not be shown until you OK or
change the tile. Currently only MappyGL (see mappygl.c) supports this.
3D walls mode. When enabled, shows a line
on the side of a block where a vertical side face is. Currently only
supported in MappyGL. To make a riser,
add a block (ctrl+n or copy and paste), check the first 'other' box in
Block Properties.  The next block is
attached above a riser block, multiple attached blocks make a taller
tower. At the top of the tower you must have a block without the
first other box set, this will have the BG flat over the top of the
tower and end the chain. If you set BG and FG on the end block, BG
is drawn flat at the base of the tower, FG flat at the top.
Grid. This toggles between 'off', 'on1'
which is the default and highlights the block in the Map Editor
window the mouse cursor is over, and 'on2' which also puts a border
around the blocks in the Block Editor window. If you want to
grid all the blocks in the Map Editor window, see the
Using Marker Blocks section.
Dividers. Select to show the dividers
options. Toggle off and on with the 'Enable dividers' box. Choose
the colour with 'Line colour', 000000 is black, FFFFFF is white.
Set the spacing between dividing lines with Pixel gap X and Y.
Setting the gap the same as your tile width and height gives a
useful grid, setting the gap the size of your game screen is
useful for flipscreen type games.
Zoom (x 0.25, x 0.5, x 1, x 2, x 4).
Zoom shows things at a quarter normal size at Zoom x 0.25,
half normal size at Zoom x 0.5, normal
size at Zoom x 1, twice normal at Zoom x 2, and four times
normal size at Zoom x 4.
Often you will have 'objects' that consist of several
blocks, maybe a house or road or something, there is an easy way
to put these in. First, put the blocks in the Map Editor as they
are supposed to be layed out, then
select Grab New Brush from the Brush menu, move the mouse pointer over
one corner of the object you want to pick up as a brush, then
hold down the left mouse button and move the mouse pointer to the
opposite corner, you will see a bounding box as you do this.
Release the left mouse button to finish picking the brush. You can
name/rename a brush at any time by selecting Rename Current Brush. Now
you will be able to paste the whole object anywhere on the map
with a single click, the block the mouse pointer is over will be
the corner of the brush specified by 'Handle'. You can reselect
the brush at any time by selecting it from the Brushes menu, they
are also saved with the map so you can use them when you load it
next time. You can Fill with a brush as
well, either tiling, or randomly, see Map Editor
Window. If you want to save a bit of space (and it will be a
very small amount) choose the Destroy All Brushes option.
Grab Brush. Works like Grab New Brush,
except it will replace the currently selected brush.
Grab brush from block sequence. Allows you
to make a brush from consecutive block structures without having
to get them from the map. Size the Block Window so the area is
aligned, select the top left block of the brush to grab, then
select the bottom right block of the brush, then select
'Grab Brush from block sequence' in the Brushes menu and accept
the defaults.
Disable brush transparency. When selected,
means that block 0 parts of the brush will overwrite when pasted
rather than not affecting the map.
Handle. Selects which corner of the brush
is under the mouse pointer when it is placed in the map (useful
for pasting the brush partially on the map).
Brush. A list of the 16 brushes that can
be created per map. Selecting a brush lets you paste it in the
Map Editor window.
Rename current brush. Lets you rename
the currently selected brush.
Destroy all brushes. Destroys all brushes
in the map saving a (very small) amount of space.
There are two different layer systems in Mappy, one is
Block Layers, which are the four layers associated with Block
Properties, the other is Map Layers, which is what this menu
manipulates. Map Layers are identical in size and shape to the
numbers you specified in New Map's map width and map height. The
idea is you can use a layer for games objects (like pickup items)
or perhaps changes in a level when a lever is pulled in the game.
The options in this menu are fairly self explanatory. If you just
want to do a load of levels for a game with the same graphics and
blocks, you can export the map array (the current layer) as a .MAR
file and this
will be much smaller than a whole .FMP file.
You can export and import layers as .MAR files, but
the map you are working on MUST have identical blocks and be the
same size. This is handy if you are doing a 100 level game as
Mappy only handles 8 layers internally. Most playback libraries
have a 'MapLoadMAR' function or similar to load new levels after
loading the main FMP file for unlimited layer support.
Add Layer. Adds a new layer and makes it
the current layer.
Duplicate Layer. Adds a new layer, copies
the current layer to it and makes the new layer the current layer.
Delete Layer. Deletes the current layer.
Clear Layer. Clears the current layer to
block 0. You can fill the layer with a different block with the
'f' key.
Slide layer. Slides only the current layer
in four directions, with optional wrapping, you can use 'undo'
afterwards if you make a mistake.
Adjust values. (advanced), changes the
block numbers in the current layer by a requested amount.
Remove marker graphics. Deletes graphics
used by blocks on this layer, see also
Using Marker Blocks.
Layer (0 to 7). Select which layer to
edit in the map.
Onion Skin. Allows you to see transparently
through a layer to one other selected layer, or all other layers.
It's best to keep this
feature off if you aren't using it. The current layer (ie the one
which has the tick next to it in the layers menu) is the top
layer which will be the one altered. The background layer is
selectable in the Onion Skin dialogue and will be shown behind
the current layer, you can optionally make this appear darker so
the current layer stands out more. The background layer is drawn
as a guide and will not be altered when you are editing the
current layer. Remember to switch it off when you've finished,
and selecting a layer that doesn't exist for the background is
not advisable :) Loading a map will switch off onion skin.
Background layers darkened. Toggles
darkening of the non-current layers (for example with onion skin
or object layer).
Mousebuttons. You can define which action
each button performs. Drag map allows you to scroll the map
by holding the button and dragging the mouse over the Map Editor
window. Placer.lua runs the Placer.lua script in the luascr folder.
Lua scripts. The rest of this menu contains
a list of lua scripts which can be defined in the mapwin.ini file.
Some example scripts are provided in the luascr folder, they are
just text files with a .lua extension. For information on the
MappyWin32 lua interface, please see the
MappyWin32 Lua scripting documentation.
This is a list of shortcut keys, excluding those listed next
to items in the menus (see the menus for these, for example ctrl+m is new map).
Be sure you don't have caps lock on:
f = fill area with current block/brush (from mousepointer)
ctrl+f = fill area with current brush randomly (from mousepointer)
l = draw a line from last placed block to mousepointer (8 directions)
o = toggle picklayer (isometric)
p = pick (select) current block/anim from under mouse pointer
, = (comma) select previous numbered block/anim
. = (fullstop) select next numbered block/anim
e = edit current block/anim properties
cursor keys = scroll map
You can also set the function keys and number keys (main keyboard)
to any function you want, you will need to change the values in the
mapwin.ini file to any of these values (so keyF2=400
will run the first lua script in the custom menu when F2 is pressed,
keyF3=124 will change to layer 1 when F3 is pressed etc):
LUA01 to LUA16: 400 to 415,
EDITBLKPROP 182,
LAYERBGDARK 181,
TOOLDIVIDERS 180,
TOOLROTATILES 179,
TOOLHALVEBLOCKDIMENSIONS 178,
TOOLSAVENOGFX 177,
FILEEXPORTTEXT 176,
CUSTOMBUTTONS 175,
TOOLIMPORTBIG 174,
TOOLUSERINFO 173,
LAYERDUPLICATE 172,
TOOLFLIPTILES 171,
TOOLZOOM025 170,
TOOLZOOM05 169,
TOOLRESIZETILES 168,
TOOLAUTOBG 167,
TOOLLINE 166,
BRUSHGRABNEW 165,
LAYERADJUSTVALUES 164,
LAYERREMOVEMARKERS 163,
BRUSHHANDLEBR 162,
BRUSHHANDLEBL 161,
BRUSHHANDLETR 160,
BRUSHHANDLETL 159,
TOOL16X16TO8X8 158,
LAYERSLIDE 156,
PICKLAYER 155,
TOOLPILLARS 154,
TOOLREVEAL 153,
FILEIMPORTALT 152,
BRUSHRENAME 151,
BRUSHGRABBS 150,
BRUSHGRABNT 149,
TOOLRANGE 148,
LAYERCLEAR 137,
LAYERONION 147,
TOOLZOOM4 146,
TOOLZOOM2 145,
TOOLZOOM1 144,
TOOLREMOVEUNUSED 141,
BRUSHDESTROY 140,
TOOLANIMSETUP 139,
TOOLANIMPREVIEW 138,
EDITUNDO 135,
TOOLFILLRANDOM 210,
TOOLFILL 209,
TOOLINFO 134,
TOOLGRID 208,
FILEEXPORT 133,
TOOLRESIZE 132,
LAYER0 to LAYER7: 123 to 130,
LAYERDELETE 122,
LAYERADD 121,
PICKBLOCK 207,
BLOCKNEXT 206,
BLOCKPREV 205,
ARROWRIGHT 203,
ARROWLEFT 202,
ARROWDOWN 201,
ARROWUP 200,
HELPABOUT 120,
HELPCONTENTS 119,
BRUSH1 to BRUSH16: 300 to 315,
BRUSHGRAB 110,
EDITPASTE 109,
EDITCOPY 108,
EDITCUT 107,
EDITNEW 131,
FILEEXIT 106,
FILEIMPORT 105,
FILEIMPORTAT 136,
FILESAVEAS 104,
FILESAVE 103,
FILENEW 102,
FILEOPEN 101
I have designed Mappy to hopefully be expandable,
produce small mapfiles with lots of features, and most
importantly be fast and easy to playback. The FMP format (how the
maps are stored) is a 'chunk' based format which allows all the
information for the map (graphics, array, anims, block data etc)
to be stored in a single file, you can also add your own chunks
to this file if you want, more details in FMP
file format.The playback libraries
then provide functions to load and play the map within your game.
MappyWin32 can also read and write custom MAP formats, see
Using Mappy as a simple map editor and
export map information as text for GBA etc.
The map editor comes in several versions, this
documentation is concerned with the Win32 version. To make a FMP map
from scratch, you will need to make, or get some 'tile graphics'
(if you don't know what some of these terms mean, see the glossary) and
import them into a map (see next section). It is important to be
aware of the hierarchy of the objects within Mappy, you have the
top level which is the Map Array
(this is shown in the Map Editor window), the elements in that
are short int offsets to either Block
Structures if they are positive, or Anim
Structures if they are negative, Anim
Structures contain offsets to Block
Structures, Block Structures
have 4 offsets to the Graphics Blocks
(amongst other things).
MapArray ------> Block Structures --------> Graphics Blocks
......\............................/
........\Anim Structures/
That's about as much as you need to know if you don't intend adding your own objects, linked lists etc and are going to use the playback libraries.
MappyWin32 can import the following graphic formats:
8bit (paletted) maps:
BMP - 8bit (uncompressed)
PCX - 8bit
PNG - 4bit and 8bit (4bit is converted to 8bit on importing)
TGA - 8bit
Transparency is by a nominated palette index in MapTools:Map Properties
15/16/24/32bit (truecolour) maps (graphics are converted to the map depth on importing):
BMP - 8bit (uncompressed) and 24bit
PCX - 8bit and 24bit
PNG - 4bit, 8bit, 24bit, 32bit (with alpha on 32bit maps)
TGA - 8bit, 24bit, 32bit (with alpha on 32bit maps)
Transparency is by a nominated RGB value in MapTools:Map Properties
Alpha channel is only supported in 32bit maps, and where a playback
library supports it (eg: MappyGL). Alpha channel is shown in MappyWin32 V1.4.19 or later.
To use PNG format, two extra files are needed, libpng12.dll
and zlib.dll. These are available from the tilemap.co.uk site
and many other places and should be placed in the same folder as mapwin.exe.
When loading a MAP format map file, PNG and TGA are not supported. If you
need to use PNG or TGA with a MAP, either save the MAP from a FMP map, or
just keep a copy of your tile graphics in BMP or PCX format.
Mappy is designed for creating and editing FMP maps, these have all
the features listed in the features section, and this
is the format supported by the playback libraries. However, sometimes you may
want to use a simpler format, and in Mappy this is MAP.
New in version 1.2 of MappyWin32 is the ability to edit
'simple' maps. These maps lose nearly all the features of FMP, but
you can use them without a playback library, often with the built-in
functions of other packages. These maps have the .MAP extension,
rather than .FMP, and only contain the width and height of the map array
(optional) and the map array itself in a format of your choosing. When editing
a MAP you should not use features of Mappy that can't be saved in a .MAP
(such as animated blocks and block properties) as these will be lost
on exit. To configure the format of the .MAP files see the
MAP format section.
To create a new simple MAP, ensure you have set the correct format (see
mapwin.ini) and use New Map from the File menu. Next,
select Import from the File menu, and choose your image file with the blocks in.
You can now edit the map. To save a
MAP rather than a FMP, simply select 'Save as' from the
File menu, but type the name to save with a .map extension, for example
level1.map you will be notified you are saving a MAP. That's it!
You can now use the 'Save' option to save your map with the same name. Please
note that if you have a negative adjustment when you save the map, any blocks
that would be made negative become 0, for example, with -1 adjustment, block 0
will not change on save, all others will become 1 less. On load, all become +1
so there will be no block 0. This may sound confusing, but really it just means
block 0 will become block 1 so don't be surprised when you reload the map (block
0 is not valid with -1 adjustment) try it and you'll see... If you want to avoid
such confusion, simply fill the map with block 1 at the start.
Using the .map format you can create files compatible with CDXMap, CDXIsoMap,
and many other custom formats.
To load a .MAP, simply select Open from the File menu and open it. For the
tiles, Mappy will try to load the mapdefBMP specified in mapwin.ini, if that
doesn't exist, it will try the map name with a .BMP extension (so
level1.map will try level1.bmp in the same folder),
if these don't exist it will ask you for a BMP file to use.
Most of the rest of this documentation is to do with FMP files, which have
much more advanced features, so if you are just doing a MAP they are not relevant.
You can save a FMP as a MAP and a MAP as a FMP by changing the name when you
'Save As'. MAP files can't store all the information from FMP maps, so this
conversion may not be useful for complex FMP maps.
If neither .MAP or .FMP are suitable, you can write a
lua script to import and export data in a custom format.
The difference between this and the older FMP format is that this allows up to 30000 blocks, rather than 1024. Also, wherever a value was saved as a byte offset, it is now a 'unit' offset. The downside is you need a playback library that supports FMP1.0. You can freely change between FMP versions in MapTools>Map Properties as long as you have 1024 blocks or fewer.
This is a new feature added in version 1.3 of MappyWin32. If you are
making a map with non-rectangular tiles there are a few things you should be
aware of. Firstly, they are always drawn transparently (obviously), so if you use
block 0, this will leave trails when you scroll in Anim Preview or a playback library, so
it is best not to use block 0, fill the map with block 1 at the start. Next, you will need a playback
library that supports FMP1.0 (this should be clearly stated in the playback library),
even though you can save as FMP0.5. The 'clickmask' MUST be set in MapTools>Map Properties.
This should be the number of the graphic to detect transparent areas which allows the
editor to let you click tiles pixel-perfectly, normally 1 or 2. If you are editing a
.MAP rather than a .FMP, you should set the values correctly in
mapwin.ini for stagger and clickmask. The Block Parallax
functions are not supported. Non-rectangular tiles also take longer to draw.
As from version 1.3.1 Mappy now supports true isometric. This means that you can have
scenery that appears to rise out of the ground, and will be properly depth sorted
with both other scenery and sprites etc you may have in your game. In order to do
this, there is now a new mode which you must set by selecting MapTools:Riser mode.
To make a pillar you must first create a new block (Ctrl+N),
then select a BG graphic as usual, but the FG fields now work differently.
FG1 will overlay BG, FG2 will appear immediately above FG1, and the FG3 will
appear above FG2 (rather than overlaying it). What's that? It's not tall enough?
That's OK you can create a chain of blocks to stack on top of each other which
will be treated as just one pillar. To do this, simply check the left most of
the three 'other' boxes and the following block will be used to continue the
pillar. Any blocks which are attached will treat BG as an FG field. Attached blocks
will have a red border in the Blocks window (if Grid is on), indicating you
shouldn't use them directly.
Isometric can be quite tricky to do, so I'd recommend looking up some information
about it on the 'net. Not all block sizes tile properly, 64x31 with block gap
64x32 and block stagger 32x16 works well. I'll probably do a proper Mappy
Tutorial for Isometric at some point in the future...
Version 1.3.6 now allows you to draw the left or right half of pillars by checking
the 2nd (for left) or 3rd (for right) boxes of the 'Others' in block properties.
See iso_lr.fmp for an example, and iso_lr.bmp (in maps) to see the graphics I used.
This is common for isometric as it vastly reduces overlapping.
Also in 1.3.6 you can now specify a 'picklayer' in mapwin.ini
to allow easier picking of pillars (the blocks window is a bit confusing). Create
the picklayer just like a normal layer (in layers menu) and place your pillars on it.
Change back to your original layer, then just
press 'o' (the letter, not zero) to toggle between current layer and picklayer, move
mouse to base of pillar you want then press 'p', then 'o' again to return.
I added Isometric to MappyWin32 as it was requested and easy to do, however there
are a couple of things which may be worth noting, and if they are a problem, you
should perhaps try a different isometric editor. The first is that the isomaps
are stored staggered, rather than the more common and easier to use rotated diamond
shape maps which means pathfinding etc in games is trickier to implement. You
could write a lua script to save as a diamond shape map. The
second is that the pillars are made out of block sized parts.
Here is some brief information on using the staggered row maps produced by Mappy.
A staggered row map has all the odd rows offset by an x and y stagger value which
allows you to make hexagonal and isometric maps. This document is most helpful
if you are using a 'sprite array' see Mappy Tutorial 1, or the isometric examples
in MappyAL or MappyDX for more info on sprite arrays.
First, hex maps, here is a diagram
showing how to get to an adjacent hex from a hex at x, y (block coords, as shown in
Mappy's titlebar). There are two diagrams, use whichever your hexes resemble:
So, to get from x, y to the adjacent hex to the right and above, use a bit of code
like this:
int a = 1-(y&1);
x = (x-a)+1;
y = y-1;
To convert your block coords to pixel coords, use:
px = x*mapblockgapx;
py = (y/2)*mapblockgapy;
if (!(y&1)) { //an even (not staggered) row
// start of the map (0,0) is offset by the stagger values
px -= mapblockstaggerx;
py -= mapblockstaggery;
}
px += mapblockwidth/2; // centre of block
py += mapblockheight/2;
So now if you draw a pixel at px-scrlx, py-scrly (where scrlx and
scrly are the coords you pass to MapDraw) it should be in the centre
of the block.
The most common type of isometric map is the rotated/diamond type, but Mappy
produces a staggered row isometric map. If you really want to use a rotated/diamond
type you can change the playback libs to convert them on loading. Here's how they
compare:
To move one block in any direction use the following guide:
So, to get from x, y to the adjacent iso to the right and above, use a bit of code
like this (same as for the hex maps):
int a = 1-(y&1);
x = (x-a)+1;
y = y-1;
To convert your block coords to pixel coords (same as for the hex maps), use:
px = x*mapblockgapx;
py = (y/2)*mapblockgapy;
if (!(y&1)) { //an even (not staggered) row
// start of the map (0,0) is offset by the stagger values
px -= mapblockstaggerx;
py -= mapblockstaggery;
}
px += mapblockwidth/2; // centre of block
py += mapblockheight/2;
So now if you draw a pixel at px-scrlx, py-scrly (where scrlx and
scrly are the coords you pass to MapDraw) it should be in the centre
of the block. If you are using a sprite array MapDrawRow is usually better.
Before spending hours on a huge project it is important
to think about various aspects of it, what size are the tiles
going to be? What resolution(s) and colour depth(s) is the game
going to run in? What sort of view is it going to have (overhead,
side, oblique, isometric)? How are the other game objects going
to interact with the map? If you haven't done many tile based
games before, it may be best to do a very simple pacman or
shootemup project, just to get the hang of things.
I would recommend
that the width of the tile is a multiple of 4 (better memory
alignment), try 16pixels wide by 16pixels high for low res games
(320*240, 320*200) or 32*32pixels for 640*480 screen resolutions.
Remember that computers are advancing all the time, try to
support multiple colour depths and resolutions (if you think it's
worth it), also consider doing your map in 24bit colour even if
you are aiming for a 16bit screen, with an option to select any
high colour depth, MappyDX supports colour conversion, check the
docs for the other libs, of course, 24bit colour uses more disk
space than 16bit. If you are aiming for a lowspec machine with a
low resolution (such as VGA 320*200) use the Zoom option to get a
better idea of the graphic size in Mappy, also if you know you
aren't going to be able to access the video acceleration on the
videocard (for example using VESA under DOS) bear in mind there
will be a huge performance hit (the Anim Preview in MappyWin32
uses DirectDraw blitter acceleration found on almost all graphic
cards)...
The FMP file is ready to use from the first time you save
it, so it makes sense to develop your game code at the same time
as the map so you can see how things work and how fast they go,
also remember to adjust the preview setup in MappyWin32 to the
screen res. you are going to use...
When making your graphics for tiles, use a picturesize
that is a multiple of the tilesize, for example 32*32 and 16*16
tiles fit nicely on a 640*480 or 320*240 picture.
Most of the time, you can just double click the mapwin.exe
icon or set up a shortcut to it. You can, though, run from a
commandline or .bat file, just type mapwin (or mapwin.exe) from the
correct directory, then optionally add a lua script and map file.
Here's a couple of examples:
mapwin MAPS/TEST.FMP
mapwin "luascr/Tile graphic test.lua" maps/test.fmp
filenames with spaces must be in quotes. A handy hint, use:
mappy.sendMessage (106, 0) to exit the editor from a lua script,
the '106' is the FILEEXIT code, see 'Key Shortcuts' for more)
You can add TextStrings to a map by selecting Custom:Set Text Strings. Your strings should be on seperate lines in a .txt file. You will be prompted for the textfile and which user data field you want the string index to be stored in. These strings can be changed in the properties dialogues for blocks and objects, they will change the value in the user field you set. These text strings can be seen if enabled in MapTools:Show user info on tile (choose the user field you chose for the text strings). Text strings are stored in the FMP map file in the TSTR chunk, the first int is the offset to the strings.
These are blocks which can be used to identify
properties in the map. You can use the fields in Block
Properties to indicate what a block does, which is
parsed by your game. Usually you make some tile graphics
with symbols on them for marker blocks, such as an arrow
pointing left to show this block would push you left,
or a start location graphic. Use the transparency colour
to let you overlay them on other tiles.
Normally, you would not want these symbols to be
visible in your game, just the editor. A good way to do
this is to use the FG3 field in a block's properties,
which will show up in the editor, but not in your game
if you don't draw the FG3 field. Alternatively, you
can make a new layer (from the Layers menu), use onionskin
and put your marker blocks on this 'object layer'. Your
game can then parse this layer to find where objects start.
When you finish your map, you can remove these marker
graphics with 'Remove marker graphics' from the Layers menu
if you want.
Another way to see what properties a block has is
to use 'Show user info on tile' in the MapTools menu.
This will overlay one of the block properties fields
on the tile.
For a grid overlaying your whole map, use dividers
(in the MapTools menu) set to the width and height of your
tiles.
Tip to find what graphic number a tile is: Click
the icon above 'BG' in a block's properties, find the
graphic you want and click it, note the number and click
'cancel' so you don't change the block.
Tip: Creating new blocks (ctrl+n) uses only 32 bytes
per block, you can edit the properties and share graphics
with other blocks.
See 'Mappy Tutorial 1' for more information about
marker blocks, it can be downloaded from www.tilemap.co.uk
See also TextStrings and Labels
Download GBAMappy at www.tilemap.co.uk for full examples, sourcecode and tutorial on how to do this. In brief:
Remember, setting flippedtiles=1 in mapwin.ini (remember to restart mappy) or selecting 'flipped tiles mode' from the MapTools menu lets you use flipped tiles
in the 'Block Properties' dialogue (copy a block with ctrl+c then double click it and change it):
Also, remember, MapTools:Anim Preview will not show the tiles flipped
You can change the csvadjust value in mapwin.ini to adjust numbers up and down
Make a FMP map in 8bit with either 8x8 or 16x16 tiles.
SAVE the original FMP map, you will probably want to keep this for further editing etc
If you used 16x16 tiles, and you want to have an 8x8 map, when you want to export use Maptools:Convert 16x16... (may take several seconds).
You can keep your map as 16x16 though if you want, each graphic tile will then be exported as 4 consecutive 8x8 tiles in blockgfx (so for each tile 4 graphics will need to be set)
I found keeping 16x16 tiles to take up the least space in most cases as an 8x8 map requires 4 times the memory for the array
Select MapTools:Remove Unused or Duplicate, if you have flippedtiles=1 in mapwin.ini even flipped duplicates are removed and flip bits set which can save a lot of tiles if you have planned your graphics
Select File:Export: and tick 'Data as text' then OK
Select preferred options then OK, note the filename ending in .txt
Some of the following information is as yet untested, so maybe some mistakes:
Copy the .txt file and gbamappy.h to your source directory
You can now add this include to your GBA source file:
#include "mapdefs.h"
#include "filename.txt"
If you chose 2D array and have no anims you can access the map like this (maparray will have a layer number after it if you chose 'all layers' eg: maparray0[y][x]):
tileindex = blockstr[maparray[y][x]].bgoff;
If you don't export block structures, the bg field will be used in maparray (Auto resolve BG), you can use maparray[y][x] as your tileindex
If you enable 'merge flipbits' these will be merged to bits 10 and 11 of the tile fields of the block structures, or if you don't enable the block structures the flip bits will be merged with the BG field and written into the maparray
Tip:You could specify the bank number in a user field to choose a different colour set for a tile with same graphics
Tip:If you uncheck the 'Anim and Block structure data' box, the maparray will autoadjust to store the tileindex (with flipbits if you also check 'merge flipbits' and bank number if 16 colour tilesfrom the User7 field)
If you have animations, use this
if (maparray[y][x]<0) tileindex = blockstr[animseq[animstr[-maparray[y][x]].ancuroff]].bgoff;
else tileindex = blockstr[maparray[y][x]].bgoff;
If you want code to get the map to animate, adapt the MapUpdateAnims function from MappyAL (easy)
256 colour tiles: tileindex*64 is the byte offset for the tile graphics in blockgfx[] (as each tile graphic is 64bytes)
16 colour tiles: tileindex*32 is the byte offset for the tile graphics in blockgfx[] (as each tile graphic is 32bytes)
flip information is held in the unused2 (fliph) and unused3 (flipv) fields of blockstr[?]
Important. Although the blockgfx are saved as unsigned char, you need to write them to GBA video memory 16bits at a time, cast it to unsigned short.
I made a test GBA application with devkitadvance and it seemed to work fine. If any GBA developer would like to provide a proper example it would be appreciated. Also note the utility FMP2GBA available from www.gbadev.org
A large part of Mappy are the playback libraries, these allow you to easily load, manipulate, display, animate and scroll maps stored in .FMP files with a few simple function calls. You can get these from the Mappy Homepage, all source is supplied so you can modify them as you like. At the time of writing, there are MappyDX, for C++ compilers with the DirectX SDK, this editor uses a modified version for its Anim Preview, MappyAL (older versions were called MappyPB), MappyJV, MappyGL, CDXMappy and SDLMappy and many others. Visit www.tilemap.co.uk for a full list. You do not have to use these libraries, you could write your own, but they are very convenient.
The playback libraries are also an excellent way to add more abilities to the editor. For example, you could build a sprite editor with them for your game.
This is technical information about the FMP file structure.
You do not need to know this if you are using the playback libraries
The first 12 bytes are as follows:
4bytes ASCII = 'FORM'
long int = size of file less header (which is filesize-8)
4bytes ASCII = 'FMAP'
NOTE: The chunk size long ints like the one above are stored in Motorola
format, NOT Intel. You will have to byteswap to get the correct value, ie:
Bytes 1,2,3,4 need to become 4,3,2,1.
The chunks in the file follow on one after the other, and consist of an 8byte
header, and the information specific to that chunk. See how the playback source reads
in the information. The chunks can be in any order, and some chunks may not
be used in a particular file. Also, don't rely on chunks being a certain size, for
example the MPHD is now 4 bytes bigger than in the last version
Chunk header:
4bytes ASCII = ChunkID (example: 'MPHD')
long int = size of chunk data less header
These are the chunks as of V1.2:
ATHR - Up to 4 ASCII strings of author information, separated by 0 values,
always an even size.
MPHD - Map header, see struct in the editor source download
EDHD - Editor information, see struct in mappy.c
CMAP - Colour palette for 8bit maps, red byte, green byte, blue byte for
however many colours are needed (so usually 256*3 bytes).
BKDT - Block data. Contains BLKSTR structures for however many block
structures were made.
ANDT - Animation data. Contains ANISTR structures for however many
animation structures were made, and also animation data.
BGFX - The raw graphics in whatever format the map is in. Examples: 8bit:
mapwidth*mapheight bytes per block, in forward format *numblocks
16bit: mapwidth*mapheight*2 bytes per block, each word contains
5 bits red, 6 bits green, 5 bits blue.
BODY - An array of short ints containing positive offsets into BKDT, and
negative offsets into ANDT.
LYR? - Where ? is an ASCII number form 1 to 7. These are the same size and
format as BODY, and allow object layers to be used.
You can add your own chunks to a map file, if you load it into mappy,
when you save it, those additional chunks will be saved in the file, but
not necessarily in the same place as before.
FMP1.0 notes:
This is very similar, but the values in all the chunks refer to units rather than bytes,
ie. in BODY 0,32,64,96 would be 0,1,2,3 in FMP1.0.
MAP is a user definable format which you can use for basic maps. To
define the format you need to change the maptype line in the
mapwin.ini file to how you want it. It is also recommended to change importskip=0.
The values are between the quotes and the
default: "LW4H4A4-1" is the usual format for CDX maps. What is this
cryptic rubbish? The first letter is either L or M and specifies the endianness
of the MAP file, for Intel this is L, for Motorola M. The next parts are letters
followed by numbers, currently you can have:
W = Width of map in blocks, the next number is size of this field in bytes
H = Height of map in blocks, the next number is size of this field in bytes
A = map array, the next number is size of each cell in bytes, the number after
that is the adjuster, if the blocks look wrong, you can adjust them up or down
to match them up, -1 normally compensates. The array is stored in plain number=block
form and all layers will be saved consecutively.
So, for example, if I ONLY wanted the map array in bytes I might use
"LA1-1". This means L=Intel format, A1-1=Array 1 byte per cell,
with -1 adjustment. If I wanted to be strange I could have "MW2W4H4H2A20"
which is M=Motorola format, W2=Width as 16bit, W4=Width as 32bit, H4=Height as 32bit,
H2=Height as 16bit, A20=Array 16bits per cell, 0 adjustment.
It is very important to set the other 'map' values correctly in the
mapwin.ini file.
maptype = "LW4H4A4-1"
It is vital to set mapdefw to the width of your map (in blocks) when working with MAP files which DON'T contain map width (W)
mapdefw = 100
It is vital to set mapdefh to the height of your map (in blocks) when working with MAP files which DON'T contain map height (H)
mapdefh = 100
It is vital to set mapdefbw to the width of your tiles (in pixels) when working with MAP files, the exception is when it is 0 where a requester will be used every time a .MAP file is opened
mapdefbw = 32
It is vital to set mapdefbh to the height of your tiles (in pixels) when working with MAP files
mapdefbh = 32
It is useful to set mapstaggerx to the odd row offset (in pixels) when working with Isometric MAP files
mapstaggerx = 0
It is useful to set mapstaggery to the odd column offset (in pixels) when working with Isometric MAP files
mapstaggery = 0
It is useful to set mapclickmask to the block for the mask when working with Isometric MAP files
mapclickmask = 0
If you want to, set this to your tiles bitmap for MAP files, see
Using Mappy as a simple map editor
mapdefBMP = "nodefault.bmp"
The mapwin.ini file is in the same folder as the mapwin.exe file (the MappyWin32 map editor). Use Notepad or another plain text editor to change the values of the settings then save, normally you can double click .ini files to edit them (if the '.ini' part of the name is hidden, this is the file called mapwin with an icon that looks like a document with a gear in the corner). You must restart MappyWin32 to use the new settings (not the whole computer, just Mappy). mapwin.ini is now fully documented so read it for more information.
Anim Structure a 16 byte structure and
associated list of frames (Block Structure offsets) of unknown
length
Block I have tried to make 'block' mean
the block structures for this documentation
Block Editor The window that allows you
to select and edit both still and animated blocks. Right clicking
the mouse on it toggles between still/animated
Block Structure a 32 bytes structure
that acts as information about a particular block, it is
referenced by the Map Array and Anim Structures, and in turn
references the raw Tile Graphics
BMP Standard Windows graphic file format,
MappyWin32 only imports and exports 8bit and 24bit uncompressed
versions (Other colour depths are imported/exported as 24bit)
currently
FMP Flexible MaP format, a collection of
all the information needed to render and animate a map for a
game.
FMA A FMP file, but without the graphics
(BGFX).
MAR A map array file.
MAP MAP format, a very basic user defined
format for compatibility with other systems
Graphics Blocks See 'Tile'
Map Array an array of short int (16bit)
values that reference Block Structures (when positive) and
Anim Structures (when negative). There can be up to 8 layers of
this array by using the Map Layers
Map Editor The window where you fill in
the map array using the various tools provided
Map Layers There can be up to 8 layers of
the map array for objects, ingame changes, etc. Normally you
would only have 1 or 2 layers. These can be selected and changed
in the Playback Libraries
Mappy A 2D tile map editor with lots of
features, this is the Win32 version but there is also a DOS and
WinAllegro version
Playback Library these are available
separately for free at the Mappy homepage, there are several
versions for different platforms, they provide an easy way to
access the map in your game
Tile I have tried to make 'tile' mean the
raw graphics the block structures use for this documentation
Tile Graphics All the graphics
information for the map
This documentation is for Mappy Win32 version V1.4.23 by Robin Burrows 30/12/2009.


Thanks for your patience!
Our website is currently getting some updates ready! It will be back in 4-5 minutes!
Try Again
in a bit.


public interface XPathHandler
A XPathReader
generates callbacks into
an XPathHandler
to allow for custom
handling of the parse.
The callbacks very closely match the productions listed in the W3C XPath specification. Gratuitous productions (e.g. Expr/startExpr()/endExpr()) are not included in this API.
| Modifier and Type | Method and Description |
|---|---|
void |
endAbsoluteLocationPath()
Receive notification of the end of an absolute location path expression.
|
void |
endAdditiveExpr(int additiveOperator)
Receive notification of the end of an additive ('+' or '-') expression.
|
void |
endAllNodeStep()
Receive notification of the end of a node() step.
|
void |
endAndExpr(boolean create)
Receive notification of the end of an 'and' expression.
|
void |
endCommentNodeStep()
Receive notification of the end of a comment() step.
|
void |
endEqualityExpr(int equalityOperator)
Receive notification of the end of an equality ('=' or '!=') expression.
|
void |
endFilterExpr()
Receive notification of the end of a filter expression.
|
void |
endFunction()
Receive notification of the end of a function call
|
void |
endMultiplicativeExpr(int multiplicativeOperator)
Receive notification of the start of a multiplicative ('*', 'div' or 'mod') expression.
|
void |
endNameStep()
Receive notification of the end of a NameStep
|
void |
endOrExpr(boolean create)
Receive notification of the end of an 'or' expression.
|
void |
endPathExpr()
Receive notification of the end of a path expression.
|
void |
endPredicate()
Receive notification of the end of a predicate.
|
void |
endProcessingInstructionNodeStep()
Receive notification of the end of a processing-instruction(...) step.
|
void |
endRelationalExpr(int relationalOperator)
Receive notification of the start of a relational ('<', '>', '<=', or '>=') expression.
|
void |
endRelativeLocationPath()
Receive notification of the end of a relative location path expression.
|
void |
endTextNodeStep()
Receive notification of the end of a text() step.
|
void |
endUnaryExpr(int unaryOperator)
Receive notification of the end of a unary ('+' or '-') expression.
|
void |
endUnionExpr(boolean create)
Receive notification of the end of a union ('|') expression.
|
void |
endXPath()
Receive notification of the end of an XPath expression parse.
|
void |
literal(String literal)
Receive notification of a literal expression.
|
void |
number(double number)
Receive notification of a number expression.
|
void |
number(int number)
Receive notification of a number expression.
|
void |
startAbsoluteLocationPath()
Receive notification of the start of an absolute location path expression.
|
void |
startAdditiveExpr()
Receive notification of the start of an additive ('+' or '-') expression.
|
void |
startAllNodeStep(int axis)
Receive notification of the start of a node() step.
|
void |
startAndExpr()
Receive notification of the start of an 'and' expression.
|
void |
startCommentNodeStep(int axis)
Receive notification of the start of a comment() step.
|
void |
startEqualityExpr()
Receive notification of the start of an equality ('=' or '!=') expression.
|
void |
startFilterExpr()
Receive notification of the start of a filter expression.
|
void |
startFunction(String prefix,
String functionName)
Receive notification of a function call.
|
void |
startMultiplicativeExpr()
Receive notification of the start of a multiplicative ('*', 'div' or 'mod') expression.
|
void |
startNameStep(int axis,
String prefix,
String localName)
Receive notification of the start of a name step.
|
void |
startOrExpr()
Receive notification of the start of an 'or' expression.
|
void |
startPathExpr()
Receive notification of the start of a path expression.
|
void |
startPredicate()
Receive notification of the start of a predicate.
|
void |
startProcessingInstructionNodeStep(int axis,
String name)
Receive notification of the start of a processing-instruction(...) step.
|
void |
startRelationalExpr()
Receive notification of the start of a relational ('<', '>', '<=', or '>=') expression.
|
void |
startRelativeLocationPath()
Receive notification of the start of a relative location path expression.
|
void |
startTextNodeStep(int axis)
Receive notification of the start of a text() step.
|
void |
startUnaryExpr()
Receive notification of the start of a unary ('+' or '-') expression.
|
void |
startUnionExpr()
Receive notification of the start of a union ('|') expression.
|
void |
startXPath()
Receive notification of the start of an XPath expression parse.
|
void |
variableReference(String prefix,
String variableName)
Receive notification of a variable-reference expression.
|
void startXPath() throws SAXPathException
SAXPathException
void endXPath() throws SAXPathException
SAXPathException
void startPathExpr() throws SAXPathException
SAXPathException
void endPathExpr() throws SAXPathException
SAXPathException
void startAbsoluteLocationPath() throws SAXPathException
SAXPathException
void endAbsoluteLocationPath() throws SAXPathException
SAXPathException
void startRelativeLocationPath() throws SAXPathException
SAXPathException
void endRelativeLocationPath() throws SAXPathException
SAXPathException
void startNameStep(int axis, String prefix, String localName) throws SAXPathException
axis
- the axis of this stepprefix
- the namespace prefix for the name to test,
or the empty string if no prefix is specifiedlocalName
- the local part of the name to testSAXPathException
void endNameStep() throws SAXPathException
SAXPathException
void startTextNodeStep(int axis) throws SAXPathException
axis
- the axis of this stepSAXPathException
void endTextNodeStep() throws SAXPathException
SAXPathException
void startCommentNodeStep(int axis) throws SAXPathException
axis
- the axis of this stepSAXPathException
void endCommentNodeStep() throws SAXPathException
SAXPathException
void startAllNodeStep(int axis) throws SAXPathException
axis
- the axis of this stepSAXPathException
void endAllNodeStep() throws SAXPathException
SAXPathException
void startProcessingInstructionNodeStep(int axis, String name) throws SAXPathException
axis
- the axis of this stepname
- the name of the processing-instruction, or
the empty string if none is specifiedSAXPathException
void endProcessingInstructionNodeStep() throws SAXPathException
SAXPathException
void startPredicate() throws SAXPathException
SAXPathException
void endPredicate() throws SAXPathException
SAXPathException
void startFilterExpr() throws SAXPathException
SAXPathException
void endFilterExpr() throws SAXPathException
SAXPathException
void startOrExpr() throws SAXPathException
SAXPathException
void endOrExpr(boolean create) throws SAXPathException
create
- flag that indicates if this expression
should truly be instantiated, or if it was just
a pass-through, based upon the grammar productionsSAXPathException
void startAndExpr() throws SAXPathException
SAXPathException
void endAndExpr(boolean create) throws SAXPathException
create
- flag that indicates if this expression
should truly be instantiated, or if it was just
a pass-through, based upon the grammar productionsSAXPathException
void startEqualityExpr() throws SAXPathException
SAXPathException
void endEqualityExpr(int equalityOperator) throws SAXPathException
equalityOperator
- the operator specific to this particular
equality expression. If null, this expression
is only a pass-through, and should not actually
be instantiated.SAXPathException
void startRelationalExpr() throws SAXPathException
SAXPathException
void endRelationalExpr(int relationalOperator) throws SAXPathException
relationalOperator
- the operator specific to this particular
relational expression. If NO_OP, this expression
is only a pass-through, and should not actually
be instantiated.SAXPathException
void startAdditiveExpr() throws SAXPathException
SAXPathException
void endAdditiveExpr(int additiveOperator) throws SAXPathException
additiveOperator
- the operator specific to this particular
additive expression. If NO_OP, this expression
is only a pass-through, and should not actually
be instantiated.SAXPathException
void startMultiplicativeExpr() throws SAXPathException
SAXPathException
void endMultiplicativeExpr(int multiplicativeOperator) throws SAXPathException
multiplicativeOperator
- the operator specific to this particular
multiplicative expression. If null, this expression
is only a pass-through, and should not actually
be instantiated.SAXPathException
void startUnaryExpr() throws SAXPathException
SAXPathException
void endUnaryExpr(int unaryOperator) throws SAXPathException
unaryOperator
- the operator specific to this particular
unary expression. If NO_OP, this expression is only
a pass-through, and should not actually be instantiated.
If not Operator.NO_OP
, it will
always be Operator.NEGATIVE
.SAXPathException
void startUnionExpr() throws SAXPathException
SAXPathException
void endUnionExpr(boolean create) throws SAXPathException
create
- flag that indicates if this expression
should truly be instantiated, or if it was just
a pass-through, based upon the grammar productionsSAXPathException
void number(int number) throws SAXPathException
number
- the number valueSAXPathException
void number(double number) throws SAXPathException
number
- the number valueSAXPathException
void literal(String literal) throws SAXPathException
literal
- the string literal valueSAXPathException
void variableReference(String prefix, String variableName) throws SAXPathException
prefix
- the namespace prefix of the variablevariableName
- the local name of the variableSAXPathException
void startFunction(String prefix, String functionName) throws SAXPathException
prefix
- the namespace prefix of the functionfunctionName
- the local name of the functionSAXPathException
void endFunction() throws SAXPathException
SAXPathException
Copyright © 2016. All rights reserved.


Meet the Progressives Leading Warren's Campaign
by Beth BaumannSen. Elizabeth Warren (D-MA) on Friday announced the three co-chairs for her presidential campaign: progressive Congresswomen Deb Haaland (D-NM), Katie Porter (D-CA) and Ayanna Pressley (D-MA).
Haaland, a Native American, has received flack for supporting Warren. The reason? People feel Haaland betrayed her people. After all, the senator claimed she was Native American. It was later revealed through DNA testing that she is only 1/1024th Native American.
Freshman Congresswoman Katie Porter was going back and forth between endorsing Sen. Kamala Harris (D-CA) but eventually went with Warren. When she announced her decision to back the Massachusetts senator, she shared a picture of her with Warren when she graduated from Harvard Law.
When Rep. Ayanna Pressley announced she was endorsing Warren, she was the first member of "the Squad" to do so. Congresswomen Alexandria Ocasio-Cortez (D-NY) and Ilhan Omar (D-MN) endorsed Sen. Bernie Sanders (I-VT).
The only member of "the Squad" who has yet to make an endorsement is Rashida Tlaib (D-MI).
Rumors have swirled, saying "the Squad" is fighting over who deserves to be president. Tlaib, however, said that's the furthest thing from the truth.


Assigning A Test List Or Test List Cycle To A Unit¶
Once you have created a unit and a test list (or test list cycle) you need to create an association between the two before the test list can actually be performed. To do this click on the Assign Test Lists to Units link from the main admin page and then click Add unit test collection button in the top right hand corner.
The fields required for assigning a test list to a unit are described below.
Unit¶
The unit you want to assign the test list to.
Frequency¶
The frequency with which you want the test list (cycle) to be performed (e.g. Daily, Monthly, Yearly etc).
Optionally, you can leave the frequency blank and the test list will be assigned to be performed on an ad-hoc basis.
Due Date & Auto Schedule¶
Here you can manaully set the initial due date/time for a test list on a unit. You can also leave this blank if you like and the test list will show up as being Not Due.
If you leave Auto Schedule checked, the due date will automatically be updated according to the assigned frequency after the test list is completed on a unit.
Assigned To¶
The group of users that is generally responsible for performing the the lists. Note that the Assigned To property is used for display only and users not part of the Assigned To group will still be able to see and perform the test list.
Visible To¶
By default, all user groups will be able to see and perform a test list. If you want to restrict access/hide a test list from certain groups you can move the groups from the Chosen visible to to the Available visible to box.
Active¶
If this checkbox is unchecked, the test list will not appear in any listings on the main site. This should be used to disable test lists that are no longer performed on a unit (deleting the unit test collection would cause a loss of historical data).
Content Type¶
Choose whether you are assigning a test list or a test list cycle to this unit. After choosing the type of test collection you are adding, the Object id dropdown will be populated with the appropriate items.


PureBasic - Date
Overview
The Date library allows for the manipulation of Date and Time from 1970 up to 2038 using the Unix method (i.e. the number of seconds elapsed since the 1st of January 1970).
Note: supported date/time values are 1970-01-01, 00:00:00 for the minimum and 2038-01-19, 03:14:07 for the maximum.
Command Index
AddDate
Date
Day
DayOfWeek
DayOfYear
FormatDate
Hour
Minute
Month
ParseDate
Second
Year
Example
Date.pb
Supported OS
All


This is used to track your SUD level, for more information read LINK
1 - No real distress2 - A little bit sad or off3 - Worried4 - Negative thoughts5 - Upset/uncomfortable6 - Change is needed7 - Discomfort dominates 8 - Panic takes hold9 - Helpless10 - Unbearable


data.table
stream_in.Rd
Given a file of streaming JSON (ndjson) this function reads in the records
and creates a flat data.table
/ tbl
from it.
stream_in(path, cls = c("dt", "tbl"))
| path | path to file (supports " |
|---|---|
| cls | the package uses |
data.table
or tbl
#> [1] 100#> [1] 100


Before Change
return ComposedOp([self] * exponent)
def to_matrix(self, massive: bool = False) -> np.ndarray:
if self.num_qubits > 16 and not massive:
raise ValueError(
"to_matrix will return an exponentially large matrix, "
"in this case {0}x{0} elements."
" Set massive=True if you want to proceed.".format(2 ** self.num_qubits))
// Combination function must be able to handle classical values.
// Note: this can end up, when we have list operators containing other list operators, as a
// ragged array and numpy 1.19 raises a deprecation warning unless this is explicitly
// done as object type now - was implicit before.
mat = self.combo_fn(np.asarray([op.to_matrix() * self.coeff for op in self.oplist],
dtype=object))
// Note: As ComposedOp has a combo function of inner product we can end up here not with
// a matrix (array) but a scalar. In which case we make a single element array of it.
After Change
return ComposedOp([self] * exponent)
def to_matrix(self, massive: bool = False) -> np.ndarray:
OperatorBase._check_massive("to_matrix", True, self.num_qubits, massive)
// Combination function must be able to handle classical values.
// Note: this can end up, when we have list operators containing other list operators, as a
// ragged array and numpy 1.19 raises a deprecation warning unless this is explicitly


A hands-on software course for beginners.
Team up with other beginners and make a web app using real industry tools. You'll learn what coders actually do all day and what it's like to work in tech.
No experience needed – we start with the basics and our mentors help every step of the way.
The course costs $420 and includes eight two-hour classes.
Sign up at girlcode.co.nz


Toggle navigation
Can You Sink Me?
Applications
Registered Applications
Application Name
API Calls
Registrant
Registered
{{application.name}}
{{application.apiCalls}}
{{application.registrant}}
{{application.registered | date:'h:mm a - d MMM yyyy'}}
Create Application
Register an application
Name
Description


Hello,
I really enjoy working with the OEM project and am looking to contribute in expanding its functionality during my Master thesis.
The idea is being able to implement full monitoring of all energy flows at building block level in the Hammarby Sjöstad district of Stockholm. I am looking to additionally monitor water, gas and HVDC flows in addition to electric power and temperature currently offered by OEM.
My question is in regards to the emonTX Shield V2/Nanode RF, given the availability of extra pins in comparison to emonTX V3. Which pins can be used, without conflicting with the 4 power and 1 temperature measurements ? Also given memory limitations of the Arduino, would it make sense to measure more inputs on top of 4 power and 1 temperature reading ? Or simply make these measurements with a parallel Arduino ?
I am in the process of estimating the cost of installing such a building level full energy monitoring system, so would appreciate any advice.
Thanks in advance
Christophe
Re: Addition Of Other Building Energy Flows
Certainly, from what you write, the emonTx V2 is more attractive in terms of the availability of I/O pins, than the V3.
As far as analogue inputs are concerned, you are limited to the 6 that the Atmel 328P provides - unless of course you build your own signal conditioning front end to a more powerful processor. For temperature, the DS18B20 uses a One-Wire bus, so many devices can be connected to one I/O pin. I cannot give you a number, it depends on the configuration of the sensor network as well as cable lengths, but it's said to be larger (in number or area covered) if you use the correct external bus driver i.c. There is much data about this on the Maxim website.
The basic Arduino / emonTx with 6 analogue inputs would, I think, be on the edge of acceptable performance. Given that you would be measuring temperatures relatively infrequently, those are not likely to have a significant effect on performance.
You don't say how you intend to measure water and gas. If these are flowmeters that output a pulse at a variable rate, or instruments that send serial data by infra-red or hard-wired connection, then you might find you need a separate processor for that.
How do you intend to transmit and collate the data? That could have an influence on your choice.
Re: Addition Of Other Building Energy Flows
Thanks for your input.
I found a portmap for the emonTX V2 (http://openenergymonitor.org/emon/emontx/reference%20).
Seems like there are 4 digital and 2 analog/digital (Arduino PWM) available, for these eventual measurements.
For the water flow I intend to use what is proposed at http://www.seeedstudio.com/forum/viewtopic.php?f=4&t=989&p=3632 .
The problem is that I require an interrupt pin, which are used by other emonTX functions.
At least there, that would mean a seperate Arduino or use of Raspberry Pi GPIO where multiple inputs.
Gas and HVDC would most probably be pulse based as well.
Data would not be sent via RFM12B in a multi-person environment, for privacy reasons.
Instead I would directly use the emonTX shield in conjunction with NanodeRF/Arduino.
All data would then be sent to a web-hosted emonCMS server.
Re: Addition Of Other Building Energy Flows
Another reason for not using radio, especially if you have a large number of data nodes, is collisions in the RF band. The absence of a radio would free up a few I/O pins and an interrupt pin (but only one).
All the analogue pins are available on the NanodeRF, but I've never tried to run the Ethernet stack as well as the energy monitor sketch. If it would fit into memory, I suspect the 'discrete sample' sketches might run when merged with the Ethernet code, but I would not like to say the same thing about the 'continuous' sketches.
Re: Addition Of Other Building Energy Flows
I am running a modified version of the continuous monitoring sketch on an Uno + Ethernet clone which is publishing results using MQTT. This is monitoring 4 CT clamps and reporting all readings. Works like a dream ;-).
http://openenergymonitor.org/emon/node/5922
Re: Addition Of Other Building Energy Flows
I bow to your experience.
Re: Addition Of Other Building Energy Flows
Hardly! I wouldn't have gotten anywhere without your help and that of Robin!
Re: Addition Of Other Building Energy Flows
Thanks! But what I meant was I hadn't tried that particular combination, and while I could not foresee a problem with running Ethernet to send the data between sets of discrete samples, I wasn't certain that there would be enough slack processor time for the Ethernet with continuous sampling. You confirmed that there was. I think I'd seen your post, but it hadn't registered in my brain. So thanks again for chipping in. I'll make a note in my personal FAQ file.
Re: Addition Of Other Building Energy Flows
My pleasure - that sketch is now running Robins PV router logic as well and seems to be humming along just fine. Amazing what you can do with those little uP's!
Re: Addition Of Other Building Energy Flows
Thank you sumnerboy for confirming that Ethernet and continuous sampling can work at the same time (Ethernet stack as well as the energy monitor sketch indeed just fits into memory of the Nanode RF).
Now I just need to plan my setup in terms of available pins.
Also have some insight when exploring the MQTT module, which I will definitely make use of for remote control.


HIV NIMART training study antiretroviral management nurses ART patients implementation therapy programme PHC North {border-style ... Health West health revealed px;} #ffffff;} January facilitate framework implementation. care initiated South quality data nurse-initiated qualitative Total evident findings tested Department facilities initiation outcomes patient province December Lack challenges collab: development improve results theory (), CHC Clinic Donabedian’s Modiri Ngaka conceptual district healthcare influence model outcomes. Dickoff HIV-positive Molema PNs Research low nurse poor professional yield AIDS Furthermore, SPO activities children number px; trained {font-family According United addition, al.’s community confidence develop facility font-size human impact including influencing practice-oriented reported services strengthen viral Nations Nurse-initiated Nursing PLWH Poor Programme UNAIDS, access compliance double; increasing lack managers mentoring monitoring positive practice primary process province. refers skilled target treatment used (Table (UNAIDS ART, Africa Africa’, Again, Data Geneva. HIV/AIDS, Health, Joint LTFU NMM National PLWH. TABLE adherence audit border-color border-width conducted confirmed descriptive developed early factors guidelines guidelines, high immunodeficiency level literature negative nurses, pregnant quantitative rate receiving solid; starting strengthening student study. suppression {font-style {font-weight (Dickoff (NIMART) African BMC CF. CHC, Global International Makhado, One(), PHC, Phase University Van analysis attitudes bold clinical cohort competent contribute courier; coverage curriculum death design education em; especially evaluation facilitates findings, follow-up framework. include initiating load manage million mixed-methods months policies policy prevalence provide province’, pt;} recipient remaining resource status support total training. transmission viewed


Ctrl + c
Here is a task for tutorial_bcc_python_developer,how to deal with ctrl +c
.From stackoverflow,the answer will be performaced:
from bcc import BPF
import signal
import sys
def bpf():
BPF(text='''
int kprobe__sys_sync(void *ctx)
{ bpf_trace_printk("Hello, yubo\\n");
return 0;}'''
).trace_print()
def signal_handler(signal, frame):
print('You pressed Ctrl+c!')
bpf()
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
print('press Ctrl+c')
signal.pause()
Here, maybe some issue exist.But i thought, the model will be the same as c


Follow Org
Unfollow Org
Bulk
Backup
Erase
Enter RSI Handles
(split by commas or one name per line)
Follow
Unfollow
Restore from text file
(Names split by commas or one name per line)
Backup to text file
Experimental!!
Restore from Chrome Sync to RSI
Backup to Chrome Sync
Erase all RSI Contacts
Erase Chrome Sync backup


Places, in Singapore, where I have had wine for about SGD$10
From what I remember, a can of beer, bought from a convenience store, costs more in Singapore than in Taipei, the capital-city of Taiwan, so maybe the price of a glass of wine is more expensive in Singapore than in Taipei, too, if not elsewhere.
Having said that, I have somewhat frequented the following establishments, during so-called ‘happy hours’; the price comes up to SGD$10 to SGD$11 for a glass, at the most. I list the price of a glass of wine, whether it be red or white:
- Bruno’s Bistrot/Pizzaria & Grill. $7.50, exclusive of a ‘service charge’ of 10%. All operation-hours are ‘happy hour’, I’ve heard. A plus maybe: bottles of wine are stored openly (that is, visibly) in a chiller for that purpose. 544 Serangoon Road, Singapore 218166
- Hej Kitchen & Bar. ‘Happy hours’: 12 PM to 7 PM - it’s not clear to me whether these are for weekdays, weekends, or both. $8, exclusive of service charge (10%) and GST (7%). 180 Orchard Road, Singapore 238846.
- The Boiler (at the structure Esplanade). ‘Happy hours’: 5.30 PM to 8.30 PM, daily maybe. $8.50, exclusive of Service Charge and GST. 8 Raffles Ave, #01-13A, Esplanade Mall, Singapore 039802.
- Steakout. ‘Happy hours’: Sunday to Thursday, excluding public holidays and their eves. $2 off the regular price of wine - this works out to be approximately $10. 89 Victoria Street, #01-01, Victoria Hotel, Singapore 188017.


{{define "content"}}
Thanks for registering as a wholesaler with bangsandteeth.com. Once we verify your status we will email you an update. You will then be able to log in and purchase products from the wholesale page.


View Highscores
Theme
Light
Dark
Score: 0
Time left: 0
Coding Quiz Chanllange
Try to answer the following code-rated questions within the time limit. Keep in mind that incorrect answers will penalize your scoretime by ten seconds!
Star Quiz
All done!
Your Initials
Submit
Initial
Score
Clear History


Now, lets take a look..
After reviewing your submission , we picked up on a few things. is your current lifestyle. is your food of choice. really gets you going. Habitually, you like . You tend to have an outlook along the lines of . Now that we have a brief outlook on your lifestyle, pick a language that fits YOU!!!


FROM:MR. JAMES NGOLA. CONFIDENTIAL TEL: 233-27-587908. E-MAIL: (james_ngola2002@maktoob.com). URGENT BUSINESS ASSISTANCE AND PARTNERSHIP. DEAR FRIEND, I AM ( DR.) JAMES NGOLA, THE PERSONAL ASSISTANCE TO THE LATE CONGOLESE (PRESIDENT LAURENT KABILA) WHO WAS ASSASSINATED BY HIS BODY GUARD ON 16TH JAN. 2001.    THE (USD$25M) WAS PART OF A PROCEEDS FROM DIAMOND TRADE MEANT FOR THE LATE PRESIDENT LAURENT KABILA WHICH WAS DELIVERED THROUGH ZIMBABWE IN DIPLOMATIC BOXES.  PRESIDENT).THE CONFUSION THAT ENSUED AFTER THE ASSASSINATION AND THE SPORADIC SHOOTING AMONG THE FACTIONS, I HAVE TO RUN AWAY FROM THE COUNTRY FOR MY DEAR LIFE AS I AM NOT A SOLDIER BUT A CIVIL SERVANT I CROSSED RIVER CONGO TO OTHER SIDE OF CONGO LIBREVILLE FROM THERE I MOVED TO THE THIRD COUNTRY GHANA WHERE I AM PRESENTLY TAKING REFUGE.   THE REMAINING 5% WILL BE USED TO OFFSET ANY COST INCURRED IN THE CAUSE OF MOVING THE MONEY TO YOUR ACCOUNT.  FINALLY, IT IS IMPORTANT ALSO THAT I LET YOU UNDERSTAND THAT THERE IS NO RISK INVOLVED WHATSOEVER AS THE MONEY HAD NO RECORD IN KINSHASA FOR IT WAS MEANT FOR THE PERSONAL USE OF (MR. PRESIDEND ) BEFORE THE NEFARIOUS INCIDENT OCCURRED, AND ALSO I HAVE ALL THE NECESSARY DOCUMENTS AS REGARDS TO THE FUNDS INCLUDING THE (CERTIFICATE OF DEPOSIT), AS I AM THE DEPOSITOR OF THE CONSIGNMENT. LOOKING FORWARD TO YOUR URGENT RESPONSE. YOUR SINCERELY, MR. JAMES NGOLA.


Medieval and Roman treasures stolen from train
Medieval and Roman treasures have been stolen from a train after they were mistakenly left behind on a service to Edinburgh.
The items, a ring valued at £500 and a broach valued at £1,000, were lost when the victim disembarked at Durham station.
It is understood they were removed from the service somewhere between Durham and Edinburgh Waverley.
British Transport Police said the valuables were not handed in to lost property and are presumed stolen.
Officers believe they were taken between the evening of Friday, October 4 and 12.30am on Saturday, October 5, when the train arrived in Edinburgh.
The ring is believed to date from the mid to post-medieval period, while the broach is believed to date from the late Roman period.


OSLogEventSink
public class OSLogEventSink : EventSink
An EventSink
for logging events to the Apple unified logging system.
This is the default event sink, but you can and should create one yourself to specify the subsystem and category to use when logging your events. This will make it easier to query for your app’s events, which can help filter out log noise.
Remark
os_log
is not actually a particularly good destination for structured, high-cardinality events. The unified logging system doesn’t have any
understanding of the structure, so you can’t do sophisticated queries against your fields, and we have to circumvent the privacy protections that the system
has for dynamic values, since we render the entire log string dynamically. The main thing os_log
has going for it is that it is easily available since it is the
default logging system for Apple’s platforms.
-
Create a new
os_log
sink, optionally targeting a particular log.Declaration
Swift
public init(log: OSLog = .default)
Parameters
log
The log to send events to.
-
Create a new
os_log
sink for a particular subsystem and category.This is a shortcut, and is no different than using
init(log:)
and providing anOSLog
with the given subsystem and category.Declaration
Swift
public convenience init(subsystem: String, category: String)
Parameters
subsystem
The subsystem to log events to. This is generally structured as a reverse-DNS name, like
com.myapp.App
. If you’re unsure what it should be, use your app’s bundle identifier.category
The category to log events to. This is an arbitrary label within your subsystem, and can be used with configuration profiles to control logging policy in the unified logging system. If you’re unsure what it should be, use
"events"
. -
Declaration
Swift
public func send(event: Event, level: OSLogType)


Some applications may wish to step line by line, not node by node. See the isLine function in the source code for this page.
Click Parse, then either click Step repeatedly, or click Run once. Open your browser's console for errors.
Back to the JS-Interpreter documentation.


Green Giant cooks up 1,009 pounds of green bean casserole
by Ben HooperNov. 21 (UPI) -- Vegetable company Green Giant announced it broke a Guinness World Record by cooking up 1,009 pounds of green bean casserole in New York.
The company said it combined 1,069 cans of Green Giant Cut Green Beans, 485 cans of mushroom soup, 65 quarts of milk and 95 pounds of French fried onions to break its own record of 637 pounds, set in 2017.
The ingredients were combined and cooked by a team of 10 chefs from Stella 34 Trattoria in Macy's Herald Square.
The giant green bean casserole is being divvied up and will be served to 3,000 senior citizens in New York by Meals on Wheels.
(0) Leave a comment
upi.com/6961075
Latest Headlines
Odd News // 36 minutes ago
Zoo searching for escaped red panda in France
Nov. 21 (UPI) -- A French zoo is asking locals to keep an eye out for a red panda that escaped the facility when snowfall caused branches to fall onto its enclosure.
Odd News // 19 hours ago
Troopers, driver narrowly escape out of control truck
Nov. 20 (UPI) -- An Illinois State Police dashboard camera was recording when two troopers and a stranded driver had a near-miss with a box truck that lost control on an icy highway.
Odd News // 20 hours ago
Maryland woman wins two big Keno jackpots in one day
Nov. 20 (UPI) -- A Maryland woman is celebrating a particularly lucky day after she scored two major Keno jackpots.
Odd News // 21 hours ago
Men use tree saw to separate bucks with antlers tangled together
Nov. 20 (UPI) -- A group of Michigan neighbors used a saw to free two bucks found with their antlers stuck together in a farm field.
Odd News // 22 hours ago
Hotel room costs $1, but it's livestreamed at all times
Nov. 20 (UPI) -- A Japanese hotel offers a room that costs only $1 per night, but there's a catch -- the guest's entire stay is livestreamed on YouTube.
Odd News // 1 day ago
Territorial turkey chases Wisconsin mail carrier every day
Nov. 20 (UPI) -- A Wisconsin mail carrier said a territorial turkey has been chasing him through a neighborhood every day for about a month.
Odd News // 1 day ago
Large python crashes through spa ceiling in China
Nov. 19 (UPI) -- Workers at a spa in China were shocked when a 10-foot python fell through the ceiling -- and experts said it may have been there for up to 10 years.
Odd News // 1 day ago
Police help rescue coyote stuck in vehicle bumper
Nov. 19 (UPI) -- Authorities in Illinois came to the rescue of an unlucky coyote that was struck by a vehicle and ended up stuck in the bumper.
Odd News // 1 day ago
Georgia deputy rescues deer stuck between fence bars
Nov. 19 (UPI) -- A Georgia sheriff's deputy's body camera was recording when he came to the rescue of a small deer that had become stuck between the bars of a fence.
Odd News // 1 day ago
Family spends 153 days creating world's largest handwritten Bible
Nov. 19 (UPI) -- A United Arab Emirates family said they spent 153 days attempting a Guinness World Record for the world's largest handwritten Bible.


|
handle= variable holding the image's handle
x=starting x location of the tile; assumed 0 y=starting y location of the tile; assumed 0 frames=the frame of the image to tile; optional with imagestrip |
| If you want to make a starfield or other easy tiled background, this is YOUR command. All you have to do is specify the image handle (an image loaded with the LoadImage or LoadAnimImage command). Optionally, you can specify a starting x and y location, as well as an optional frame. You can milk some serious parallax effects with a simple imagestrip with a couple of various starfields and the TileImage command. |
|
; CreateImage/TileImage/ImageBuffer example
; Again, we'll use globals even tho we don't need them here ; One variable for the graphic we'll create, one for a timer Global gfxStarfield, tmrScreen ; Declare graphic mode Graphics 640,480,16 ; Create a blank image that is 320 pixels wide and 32 high with 10 frames of 32x32 gfxStarfield=CreateImage(32,32,10) ; loop through each frame of the graphic we just made For t = 0 To 9 ; Set the drawing buffer to the graphic frame so we can write on it SetBuffer ImageBuffer(gfxStarfield,t) ; put 50 stars in the frame at random locations For y = 1 To 50 Plot Rnd(32),Rnd(32) Next Next ; Double buffer mode for smooth screen drawing SetBuffer BackBuffer() ; Loop until ESC is pressed While Not KeyHit(1) ; Only update the screen every 300 milliseconds. Change 300 for faster or ; slower screen updates If MilliSecs() > tmrScreen+300 Then Cls ; clear the screen ; Tile the screen with a random frame from our new graphic starting at ; x=0 and y=0 location. TileImage gfxStarfield,0,0,Rnd(9) Flip ; Flip the screen into view tmrScreen=MilliSecs() ; reset the time End If Wend |


Hi, I am Himanshu Verma .
I'm pursuing BTech in the department of Computer Science and Engineering from Indian Institute of Information Technology Kota.
I am also a freelancer, bug bounty hunter and penetration tester.
I like to play chess and watch web series.


Welcome to Armando's Website!
This is a very first draft of my website, I'm going to be talking about photography allot so please bare with me.
This picture was taken by me at the top of El Castillo at the Xunantunich Mayan ruin in Belize. The picture is a composite panorama taken using a Samsung Galaxy S7 Edge
“A landscape image cuts across all political and national boundaries, it transcends the constraints of language and culture.” -David DuChemin
500px is a great site for photography. It has a very clean interface focused completely on displaying photos. The only problem I have with the site is that it does not have an easily accessible guest feature.
Potential future camera purchases
| Camera | Lens | Price |
|---|---|---|
| Nikon D3300 | 18-55mm Nikkor | $446.95 |
| Canon EOS Rebel T6 | EF-S 18-55mm IS II | $449.00 |


{% extends 'base.html' %} {% from '_macro.html' import input %} {% block contents %}
This page features 2 modal forms - one for login and the other for registering new users. To login, use username `test` and password `pass`.


Address {{addressData?.address}}
- Confirmed Balance
- Last Mined Balance
- Pending Balance
- {{addressData?.confirmedBalance?.balance}} coins
- {{addressData?.lastMinedBalance?.balance}} coins
- {{addressData?.pendingBalance?.balance}} coins
- Tx:
- From:
- To:
- Amount:
- Paid:
- Date:
- {{transaction.transactionHash}}
- {{transaction.from}}
- {{transaction.to}}
- {{transaction.value}}
- {{transaction.paid}}
- {{transaction.dateReceived}}