//****************************************************************************
//GlovePIE WiiMote Script for Operation Wolf style games in MAME
//Ted Spinks,
[email protected], updated 1/29/2009
//DIRECTIONS: In MAME, enable Joystick support. Uses joystick input instead of
// mouse input in order to allow 2 players/wiimotes, so PPJoy must be installed
// and configured with 2 virtual joysticks (picking all default mappings is fine).
// PPJoy can be downloaded from
www.geocities.com/deonvdw/PPJoy.htm//Testing: Azio USB Blootooth (Toshiba stack), Nyko wireless sensor bar, MAME 104
//Features: uses both sensor bar dots for a wider "target area", has good roll
// compensation, supports 2 players/WiiMotes, and the LED's indicate battery
// charge % when you press Home.
//****************************************************************************
//***************************** Table of Contents *****************************
//Global WiiMote Calibration
//P1 Process WiiMote Home button and set WiiMote LED's
//P1 Button Inputs
//P1 Pre-Process Sensor Bar Dots
//P1 Get Left and Right Sensor Bar Dots
//P1 Calculate the MidPoint and assign Joystick input
//P2 Process WiiMote Home button and set WiiMote LED's
//P2 Button Inputs
//P2 Pre-Process Sensor Bar Dots
//P2 Get Left and Right Sensor Bar Dots
//P2 Calculate the MidPoint and assign Joystick input
//*************************** End Table of Contents ***************************
//*********************** Global WiiMote Calibration *************************
//Set the sensitivity level of the WiiMote. These values must be at least 1.
var.SensitivityX = 1.0 //Sensitivity multiplier for X axis
var.SensitivityY = 2.0 //Sensitivity multiplier for Y axis
//Adjust these values to shift the borders of the "target area" if needed.
// For example, you could shift the top or the bottom border to compensate
// for the position of your sensor bar (I didn't need to though).
var.ShiftLeftSide = 0 //+ to shift right, - to shift left
var.ShiftRightSide = 0 //+ to shift right, - to shift left
var.ShiftTop = 0 //+ to shift down, - to shift up
var.ShiftBottom = 0 //+ to shift down, - to shift up
//Leave these values alone.
// 1023 and 767 are the max X and Y dot values that the WiiMote can sense
var.BeginRangeX = 0 + var.ShiftLeftSide
var.EndRangeX= 1023 + var.ShiftRightSide
var.BeginRangeY = 0 + var.ShiftTop
var.EndRangeY = 767 + var.ShiftBottom
var.RangeSizeX = var.EndRangeX - var.BeginRangeX
var.RangeSizeY = var.EndRangeY - var.BeginRangeY
//Set the midpoint compensation factor.
// Since the range of the mindpoint's of the 2 sensor bar dots is approx 1/3 of
// the combined ranges of the original 2 dots, after we calculate the midpoint
// we have to fix its value range by multiplying by 3.
// To figure out the 1/3 I just watched "debug = var.P1MiddleDotX" as I moved
// the WiiMote left and right.
var.MidpointMultiplierX = 3
//********************** End Global WiiMote Calibration ************************
//*********** P1 Process WiiMote Home button and set WiiMote LED's *************
//Normally Led 1 is lit to indicate this is wiimote #1,
// but when Home button is pressed the LED's display battery charge
if Pressed(wiimote1.home) then //Do this once when the button is first pressed
//Calculate and display battery charge %, full battery is 0xC0 (192)
var.P1Battery = Round( 100*wiimote1.battery/192 )
Say "Battery at " + var.P1Battery + " percent"
endif
if wiimote1.home then
var.P1Flash = !var.P1Flash
wiimote1.Led1 = var.P1Flash
If var.P1Battery > 35 then
wiimote1.Led2 = var.P1Flash
else
wiimote1.Led2 = False
endif
If var.P1Battery > 60 then
wiimote1.Led3 = var.P1Flash
else
wiimote1.Led3 = false
endif
If var.P1Battery > 85 then
wiimote1.Led4 = var.P1Flash
else
wiimote1.Led4 = false
endif
wait 100 ms //Increasing this will slow down the LED flash speed
else
wiimote1.Led1 = True
wiimote1.Led2 = False
wiimote1.Led3 = False
wiimote1.Led4 = False
endif
//*********** End P1 WiiMote Home button and set WiiMote LED's *************
//**************************** P1 Button Inputs *****************************
// (see above for Home button behavior)
key.LeftControl = Wiimote1.B
//key.B = Wiimote1.B
key.LeftAlt = Wiimote1.A
//key.E = Wiimote1.A
key.One = wiimote1.Plus
key.Five = wiimote1.Minus
key.P = wiimote1.Down
key.left= wiimote1.left
key.right= wiimote1.right
//************************** End P1 Button Inputs ***************************
//********************** P1 Pre-Process Sensor Bar Dots ***********************
//For each sensor bar dot:
//1) Convert the sensor bar dots from the wiimote's range of values to a standard
// four quadrant setup with the origin (0,0) in the center. This is needed for
// the rotation formula in #2.
//2) Do roll compensation for both dots by running them through rotation formula.
//3) Convert the dots to standard joystick input range (-1 to +1)
//Note: #3 must happen AFTER #2. The native sensor bar dot ranges have the X
// and Y ranges at a ratio of about 4:3. Since #3 stretches the Y out and makes
// the ratio 1:1, we have to do this after #2, otherwise it will skew the
// rotation formula.
//get the WiiMote's Roll degrees once
var.P1Angle = -1 * smooth(wiimote1.smoothroll, 5, 5)
//dot1
if wiimote1.dot1vis then
//Shift the dot1 so that its range starts at 0.
// Note, this will only have an effect if you adjust the borders of the
// target area at the top of the script (i.e. if you change them from 0's)
var.P1Dot1X = wiimote1.dot1x - var.BeginRangeX
var.P1Dot1Y = wiimote1.dot1y - var.BeginRangeY
//Reverse the X and Y values to make the coordinates standard
// Note: the WiiMote's dot coordinates are reversed (numbers get larger to
// the left and down), so I subtract them from the max X and Y values in
// order to flip them.
var.P1Dot1X = var.RangeSizeX - var.P1Dot1X
var.P1Dot1Y = var.RangeSizeY - var.P1Dot1Y
//Now adjust X and Y value ranges so that the origin (0,0) is in the center
// this is needed for the rotation formula below, because it rotates points
// around the origin.
var.P1Dot1X = var.P1Dot1X - (var.RangeSizeX/2)
var.P1Dot1Y = var.P1Dot1Y - (var.RangeSizeY/2)
//Compensate for roll; I used 2D rotation equations to rotate each
// dot around the origin.
http://en.wikipedia.org/wiki/Rotation_(mathematics)
// Note: every web page I found on the formulas below said they are for
// clockwise rotation, but when I put in some test values, they actually
// rotate counter clockwise.
if var.P1Angle <> 0 then
var.FixedP1dot1X = cos(var.P1Angle)*var.P1dot1X - sin(var.P1Angle)*var.P1dot1Y
var.FixedP1dot1Y = sin(var.P1Angle)*var.P1dot1X + cos(var.P1Angle)*var.P1dot1Y
else
var.FixedP1dot1X = var.P1dot1X
var.FixedP1dot1Y = var.P1dot1Y
endif
//Now convert dot1's range to (-1 to +1)
// just used good old unit conversion math here
var.FixedP1Dot1X = var.FixedP1Dot1X * (2 / var.RangeSizeX)
var.FixedP1Dot1Y = var.FixedP1Dot1Y * (2 / var.RangeSizeY)
endif
//dot2
if wiimote1.dot2vis then
//Shift the dot2 so that its range starts at 0.
// Note, this will only have an effect if you adjust the borders of the
// target area at the top of the script (i.e. if you change them from 0's)
var.P1dot2X = wiimote1.dot2x - var.BeginRangeX
var.P1dot2Y = wiimote1.dot2y - var.BeginRangeY
//Reverse the X and Y values to make the coordinates standard
// Note: the WiiMote's dot coordinates are reversed (numbers get larger to
// the left and down), so I subtract them from the max X and Y values in
// order to flip them.
var.P1dot2X = var.RangeSizeX - var.P1dot2X
var.P1dot2Y = var.RangeSizeY - var.P1dot2Y
//Now adjust X and Y value ranges so that the origin (0,0) is in the center
// this is needed for the rotation formula below, because it rotates points
// around the origin.
var.P1dot2X = var.P1dot2X - (var.RangeSizeX/2)
var.P1dot2Y = var.P1dot2Y - (var.RangeSizeY/2)
//Compensate for roll; I used 2D rotation equations to rotate each
// dot around the origin.
http://en.wikipedia.org/wiki/Rotation_(mathematics)
// Note: every web page I find on the formulas below said they are for
// clockwise rotation, but when I put in some test values, they actually
// rotate counter clockwise.
if var.P1Angle <> 0 then
var.FixedP1dot2X = cos(var.P1Angle)*var.P1dot2X - sin(var.P1Angle)*var.P1dot2Y
var.FixedP1dot2Y = sin(var.P1Angle)*var.P1dot2X + cos(var.P1Angle)*var.P1dot2Y
else
var.FixedP1dot2X = var.P1dot2X
var.FixedP1dot2Y = var.P1dot2Y
endif
//Now convert dot2's range to (-1 to +1)
// just used good old unit conversion math here
var.FixedP1dot2X = var.FixedP1dot2X * (2 / var.RangeSizeX)
var.FixedP1dot2Y = var.FixedP1dot2Y * (2 / var.RangeSizeY)
endif
//******************** End P1 Pre-Process Sensor Bar Dots *********************
//****************** P1 Get Left and Right Sensor Bar Dots ********************
if wiimote1.dot1vis and wiimote1.dot2vis then
//Both sensor bar dots are visible
//Figure out which sensor bar dot is left and which is right
if var.FixedP1Dot1X < var.FixedP1Dot2X then
//the left dot must be dot1, and the right dot must be dot2
var.P1LeftDotX = var.FixedP1Dot1X
var.P1LeftDotY = var.FixedP1Dot1Y
var.P1RightDotX = var.FixedP1Dot2X
var.P1RightDotY = var.FixedP1Dot2Y
else
//else the left dot must be dot2, and the right dot must be dot1
var.P1LeftDotX = var.FixedP1Dot2X
var.P1LeftDotY = var.FixedP1Dot2Y
var.P1RightDotX = var.FixedP1Dot1X
var.P1RightDotY = var.FixedP1Dot1Y
endif
var.P1LastMidpointX = (var.P1LeftDotx + var.P1RightDotx)/2
var.P1PointedOnScreen = True
//Save the previous distance (for use in the safety check below)
var.OldP1DistBtwDots = var.P1DistBtwDots
//Whenever both dots are visible calculate the distance between them
var.P1DistBtwDots = var.P1RightDotx - var.P1LeftDotx
//Make sure one of the dots didn't just disappear; if it did then
//throw away this data. After a dot has just disappeared and has
// stopped updating its X value, it may still register as visible
// for a split second; I've seen this cause the distance to be
// recorded at around 30. Weird.
if !(wiimote1.dot1vis and wiimote1.dot2vis) then
var.P1DistBtwDots = var.OldP1DistBtwDots
var.P1PointedOnScreen = false
endif
elseif wiimote1.dot1vis and (var.P1DistBtwDots > 0) then
//Only dot1 is visible, so we'll calculate a position for dot2
// Note, (var.P1DistBtwDots > 0) will be true as long as both dots have
// been visable at least once.
//Figure out if this is the left or the right dot
if (var.FixedP1Dot1X < var.P1LastMidpointX) then
//dot1 must be the left dot
var.P1LeftDotX = var.FixedP1Dot1X
var.P1LeftDotY = var.FixedP1Dot1Y
var.P1RightDotX = var.FixedP1Dot1X + var.P1DistBtwDots //simulate right dot
var.P1RightDotY = var.FixedP1Dot1Y
else
//else dot1 must be the right dot
var.P1LeftDotX = var.FixedP1Dot1X - var.P1DistBtwDots //simulate left dot
var.P1LeftDotY = var.FixedP1Dot1Y
var.P1RightDotX = var.FixedP1Dot1X
var.P1RightDotY = var.FixedP1Dot1Y
endif
var.P1LastMidpointX = (var.P1LeftDotx + var.P1RightDotx)/2
var.P1PointedOnScreen = True
elseif wiimote1.dot2vis and (var.P1DistBtwDots > 0) then
//Only dot2 is visible, so we'll calculate a position for dot1
// Note, (var.P1DistBtwDots > 0) will be true as long as both dots have
// been visable at least once.
//Figure out if this is the left or the right dot
if (var.FixedP1Dot2X < var.P1LastMidpointX) then
//dot2 must be the left dot
var.P1LeftDotX = var.FixedP1Dot2X
var.P1LeftDotY = var.FixedP1Dot2Y
var.P1RightDotX = var.FixedP1Dot2X + var.P1DistBtwDots //simulate right dot
var.P1RightDotY = var.FixedP1Dot2Y
else
//else dot2 must be the right dot
var.P1LeftDotX = var.FixedP1Dot2X - var.P1DistBtwDots //simulate left dot
var.P1LeftDotY = var.FixedP1Dot2Y
var.P1RightDotX = var.FixedP1Dot2X
var.P1RightDotY = var.FixedP1Dot2Y
endif
var.P1LastMidpointX = (var.P1LeftDotx + var.P1RightDotx)/2
var.P1PointedOnScreen = True
else // else no dots are visible
var.P1PointedOnScreen = False
endif
//debug=var.P1LeftDotX + "," + var.P1LeftDotY + " " + var.P1RightDotX + "," + var.P1RightDotY
//**************** End P1 Get Left and Right Sensor Bar Dots *****************
//************** P1 Calculate the MidPoint and assign Joystick input ****************
if var.P1PointedOnScreen then
//Calculate the midpoint of the sensor bar dots
var.P1MiddleDotX = (var.P1LeftDotx + var.P1RightDotx)/2
var.P1MiddleDotY = (var.P1LeftDoty + var.P1RightDoty)/2
//debug = var.P1MiddleDotX
//Since the mindpoint's range is approx 1/3 of the ranges of the original
// 2 dots, fix the range of the MidPoint's X value by multiplying by 3.
// Note, I didn't do any fancy math to figure this out, I just watched
// "debug = var.P1MiddleDotX" as I moved the WiiMote left and right. I think
// the 1/3 could change depending on the size of your sensor bar and how near/far
// it is from the WiiMote.
var.P1MiddleDotX = var.P1MiddleDotX * var.MidpointMultiplierX
//Apply sensitivity multipliers
var.P1MiddleDotX = var.P1MiddleDotX * var.SensitivityX
var.P1MiddleDotY = var.P1MiddleDotY * var.SensitivityY
//Keep values within allowable joystick range
If var.P1MiddleDotX > 1 Then var.P1MiddleDotX = 1
If var.P1MiddleDotX < -1 Then var.P1MiddleDotX = -1
If var.P1MiddleDotY > 1 Then var.P1MiddleDotY = 1
If var.P1MiddleDotY < -1 Then var.P1MiddleDotY = -1
//Flip the Y value, since joystick Y input is always reversed
var.P1MiddleDotY = var.P1MiddleDotY * -1
PPJoy1.Analog0 = var.P1MiddleDotX
PPJoy1.Analog1 = var.P1MiddleDotY
//debug = var.P1MiddleDotX + "," + var.P1MiddleDotY
endif
//************ End P1 Calculate the MidPoint and assign Joystick input **************
//*********** P2 Process WiiMote Home button and set WiiMote LED's *************
//Normally Led 2 is lit to indicate this is wiimote #2,
// but when Home button is pressed the LED's display battery charge
if Pressed(wiimote2.home) then //Do this once when the button is first pressed
//Calculate and display battery charge %, full battery is 0xC0 (192)
var.P2Battery = Round( 100*wiimote2.battery/192 )
Say "Battery at " + var.P2Battery + " percent"
endif
if wiimote2.home then
var.P2Flash = !var.P2Flash
wiimote2.Led1 = var.P2Flash
If var.P2Battery > 35 then
wiimote2.Led2 = var.P2Flash
else
wiimote2.Led2 = False
endif
If var.P2Battery > 60 then
wiimote2.Led3 = var.P2Flash
else
wiimote2.Led3 = false
endif
If var.P2Battery > 85 then
wiimote2.Led4 = var.P2Flash
else
wiimote2.Led4 = false
endif
wait 100 ms //Increasing this will slow down the LED flash speed
else
wiimote2.Led1 = False
wiimote2.Led2 = True
wiimote2.Led3 = False
wiimote2.Led4 = False
endif
//*********** End P2 WiiMote Home button and set WiiMote LED's *************
//**************************** P2 Button Inputs *****************************
// (see above for Home button behavior)
//mouse.LeftButton = wiimote2.B
key.A = wiimote2.B
key.S = wiimote2.A
key.Two = wiimote2.Plus
key.Six = wiimote2.Minus
key.P = wiimote2.Down
key.left= wiimote2.left
key.right= wiimote2.right
//************************** End P2 Button Inputs ***************************
//********************** P2 Pre-Process Sensor Bar Dots ***********************
//For each sensor bar dot:
//1) Convert the sensor bar dots from the wiimote's range of values to a standard
// four quadrant setup with the origin (0,0) in the center. This is needed for
// the rotation formula in #2.
//2) Do roll compensation for both dots by running them through rotation formula.
//3) Convert the dots to standard joystick input range (-1 to +1)
//Note: #3 must happen AFTER #2. The native sensor bar dot ranges have the X
// and Y ranges at a ratio of about 4:3. Since #3 stretches the Y out and makes
// the ratio 1:1, we have to do this after #2, otherwise it will skew the
// rotation formula.
//get the WiiMote's Roll degrees once
var.P2Angle = -1 * smooth(wiimote2.smoothroll, 5, 5)
//dot1
if wiimote2.dot1vis then
//Shift the dot1 so that its range starts at 0.
// Note, this will only have an effect if you adjust the borders of the
// target area at the top of the script (i.e. if you change them from 0's)
var.P2Dot1X = wiimote2.dot1x - var.BeginRangeX
var.P2Dot1Y = wiimote2.dot1y - var.BeginRangeY
//Reverse the X and Y values to make the coordinates standard
// Note: the WiiMote's dot coordinates are reversed (numbers get larger to
// the left and down), so I subtract them from the max X and Y values in
// order to flip them.
var.P2Dot1X = var.RangeSizeX - var.P2Dot1X
var.P2Dot1Y = var.RangeSizeY - var.P2Dot1Y
//Now adjust X and Y value ranges so that the origin (0,0) is in the center
// this is needed for the rotation formula below, because it rotates points
// around the origin.
var.P2Dot1X = var.P2Dot1X - (var.RangeSizeX/2)
var.P2Dot1Y = var.P2Dot1Y - (var.RangeSizeY/2)
//Compensate for roll; I used 2D rotation equations to rotate each
// dot around the origin.
http://en.wikipedia.org/wiki/Rotation_(mathematics)
// Note: every web page I find on the formulas below said they are for
// clockwise rotation, but when I put in some test values, they actually
// rotate counter clockwise.
if var.P2Angle <> 0 then
var.FixedP2dot1X = cos(var.P2Angle)*var.P2dot1X - sin(var.P2Angle)*var.P2dot1Y
var.FixedP2dot1Y = sin(var.P2Angle)*var.P2dot1X + cos(var.P2Angle)*var.P2dot1Y
else
var.FixedP2dot1X = var.P2dot1X
var.FixedP2dot1Y = var.P2dot1Y
endif
//Now convert dot1's range to (-1 to +1)
// just used good old unit conversion math here
var.FixedP2Dot1X = var.FixedP2Dot1X * (2 / var.RangeSizeX)
var.FixedP2Dot1Y = var.FixedP2Dot1Y * (2 / var.RangeSizeY)
endif
//dot2
if wiimote2.dot2vis then
//Shift the dot2 so that its range starts at 0.
// Note, this will only have an effect if you adjust the borders of the
// target area at the top of the script (i.e. if you change them from 0's)
var.P2dot2X = wiimote2.dot2x - var.BeginRangeX
var.P2dot2Y = wiimote2.dot2y - var.BeginRangeY
//Reverse the X and Y values to make the coordinates standard
// Note: the WiiMote's dot coordinates are reversed (numbers get larger to
// the left and down), so I subtract them from the max X and Y values in
// order to flip them.
var.P2dot2X = var.RangeSizeX - var.P2dot2X
var.P2dot2Y = var.RangeSizeY - var.P2dot2Y
//Now adjust X and Y value ranges so that the origin (0,0) is in the center
// this is needed for the rotation formula below, because it rotates points
// around the origin.
var.P2dot2X = var.P2dot2X - (var.RangeSizeX/2)
var.P2dot2Y = var.P2dot2Y - (var.RangeSizeY/2)
//Compensate for roll; I used 2D rotation equations to rotate each
// dot around the origin.
http://en.wikipedia.org/wiki/Rotation_(mathematics)
// Note: every web page I find on the formulas below said they are for
// clockwise rotation, but when I put in some test values, they actually
// rotate counter clockwise.
if var.P2Angle <> 0 then
var.FixedP2dot2X = cos(var.P2Angle)*var.P2dot2X - sin(var.P2Angle)*var.P2dot2Y
var.FixedP2dot2Y = sin(var.P2Angle)*var.P2dot2X + cos(var.P2Angle)*var.P2dot2Y
else
var.FixedP2dot2X = var.P2dot2X
var.FixedP2dot2Y = var.P2dot2Y
endif
//Now convert dot2's range to (-1 to +1)
// just used good old unit conversion math here
var.FixedP2dot2X = var.FixedP2dot2X * (2 / var.RangeSizeX)
var.FixedP2dot2Y = var.FixedP2dot2Y * (2 / var.RangeSizeY)
endif
//******************** End P2 Pre-Process Sensor Bar Dots *********************
//****************** P2 Get Left and Right Sensor Bar Dots ********************
if wiimote2.dot1vis and wiimote2.dot2vis then
//Both sensor bar dots are visible
//Figure out which sensor bar dot is left and which is right
if var.FixedP2Dot1X < var.FixedP2Dot2X then
//the left dot must be dot1, and the right dot must be dot2
var.P2LeftDotX = var.FixedP2Dot1X
var.P2LeftDotY = var.FixedP2Dot1Y
var.P2RightDotX = var.FixedP2Dot2X
var.P2RightDotY = var.FixedP2Dot2Y
else
//else the left dot must be dot2, and the right dot must be dot1
var.P2LeftDotX = var.FixedP2Dot2X
var.P2LeftDotY = var.FixedP2Dot2Y
var.P2RightDotX = var.FixedP2Dot1X
var.P2RightDotY = var.FixedP2Dot1Y
endif
var.P2LastMidpointX = (var.P2LeftDotx + var.P2RightDotx)/2
var.P2PointedOnScreen = True
//Save the previous distance (for use in the safety check below)
var.OldP2DistBtwDots = var.P2DistBtwDots
//Whenever both dots are visible calculate the distance between them
var.P2DistBtwDots = var.P2RightDotx - var.P2LeftDotx
//Make sure one of the dots didn't just disappear; if it did then
//throw away this data. After a dot has just disappeared and has
// stopped updating its X value, it may still register as visible
// for a split second; I've seen this cause the distance to be
// recorded at around 30. Weird.
if !(wiimote2.dot1vis and wiimote2.dot2vis) then
var.P2DistBtwDots = var.OldP2DistBtwDots
var.P2PointedOnScreen = false
endif
elseif wiimote2.dot1vis and (var.P2DistBtwDots > 0) then
//Only dot1 is visible, so we'll calculate a position for dot2
// Note, (var.P2DistBtwDots > 0) will be true as long as both dots have
// been visable at least once.
//Figure out if this is the left or the right dot
if (var.FixedP2Dot1X < var.P2LastMidpointX) then
//dot1 must be the left dot
var.P2LeftDotX = var.FixedP2Dot1X
var.P2LeftDotY = var.FixedP2Dot1Y
var.P2RightDotX = var.FixedP2Dot1X + var.P2DistBtwDots //simulate right dot
var.P2RightDotY = var.FixedP2Dot1Y
else
//else dot1 must be the right dot
var.P2LeftDotX = var.FixedP2Dot1X - var.P2DistBtwDots //simulate left dot
var.P2LeftDotY = var.FixedP2Dot1Y
var.P2RightDotX = var.FixedP2Dot1X
var.P2RightDotY = var.FixedP2Dot1Y
endif
var.P2LastMidpointX = (var.P2LeftDotx + var.P2RightDotx)/2
var.P2PointedOnScreen = True
elseif wiimote2.dot2vis and (var.P2DistBtwDots > 0) then
//Only dot2 is visible, so we'll calculate a position for dot1
// Note, (var.P2DistBtwDots > 0) will be true as long as both dots have
// been visable at least once.
//Figure out if this is the left or the right dot
if (var.FixedP2Dot2X < var.P2LastMidpointX) then
//dot2 must be the left dot
var.P2LeftDotX = var.FixedP2Dot2X
var.P2LeftDotY = var.FixedP2Dot2Y
var.P2RightDotX = var.FixedP2Dot2X + var.P2DistBtwDots //simulate right dot
var.P2RightDotY = var.FixedP2Dot2Y
else
//else dot2 must be the right dot
var.P2LeftDotX = var.FixedP2Dot2X - var.P2DistBtwDots //simulate left dot
var.P2LeftDotY = var.FixedP2Dot2Y
var.P2RightDotX = var.FixedP2Dot2X
var.P2RightDotY = var.FixedP2Dot2Y
endif
var.P2LastMidpointX = (var.P2LeftDotx + var.P2RightDotx)/2
var.P2PointedOnScreen = True
else // else no dots are visible
var.P2PointedOnScreen = False
endif
//debug=var.P2LeftDotX + "," + var.P2LeftDotY + " " + var.P2RightDotX + "," + var.P2RightDotY
//**************** End P2 Get Left and Right Sensor Bar Dots *****************
//************** P2 Calculate the MidPoint and assign Joystick input ****************
if var.P2PointedOnScreen then
//Calculate the midpoint of the sensor bar dots
var.P2MiddleDotX = (var.P2LeftDotx + var.P2RightDotx)/2
var.P2MiddleDotY = (var.P2LeftDoty + var.P2RightDoty)/2
//debug = var.P2MiddleDotX
//Since the mindpoint's range is approx 1/3 of the ranges of the original
// 2 dots, fix the range of the MidPoint's X value by multiplying by 3.
// Note, I didn't do any fancy math to figure this out, I just watched
// "debug = var.P2MiddleDotX" as I moved the WiiMote left and right. I think
// the 1/3 could change depending on the size of your sensor bar and how near/far
// it is from the WiiMote.
var.P2MiddleDotX = var.P2MiddleDotX * var.MidpointMultiplierX
//Apply sensitivity multipliers
var.P2MiddleDotX = var.P2MiddleDotX * var.SensitivityX
var.P2MiddleDotY = var.P2MiddleDotY * var.SensitivityY
//Keep values within allowable joystick range
If var.P2MiddleDotX > 1 Then var.P2MiddleDotX = 1
If var.P2MiddleDotX < -1 Then var.P2MiddleDotX = -1
If var.P2MiddleDotY > 1 Then var.P2MiddleDotY = 1
If var.P2MiddleDotY < -1 Then var.P2MiddleDotY = -1
//Flip the Y value, since joystick Y input is always reversed
var.P2MiddleDotY = var.P2MiddleDotY * -1
PPjoy2.Analog0 = var.P2MiddleDotX
PPjoy2.Analog1 = var.P2MiddleDotY
endif
//************ End P2 Calculate the MidPoint and assign Joystick input **************
