public ArrayLayout(Node node, space space, Address ptr, ReadOnlyCollection<Reg> dims)
{
Node = node;
Space = space;
Ptr = ptr;
Dims = dims;
}
private void move()
{
current_space.decay();
current_space = next_space;
next_space = null;
}
// Update is called once per frame
void Update()
{
// handle input
if (Input.GetKeyDown(KeyCode.W))
{
space_to_move_to = current_space.get_connection(3);
}
if (Input.GetKeyDown(KeyCode.D))
{
space_to_move_to = current_space.get_connection(0);
}
if (Input.GetKeyDown(KeyCode.S))
{
space_to_move_to = current_space.get_connection(1);
}
if (Input.GetKeyDown(KeyCode.A))
{
space_to_move_to = current_space.get_connection(2);
}
if (space_to_move_to != null)
{
move();
}
}
public ActionResult detail(int id)
{
List <space> pvm = new List <space>();
IEnumerable <space> prod = sp.GetMany(x => x.owner_id == id);
foreach (var u in prod)
{
space G = new space
{
id = u.id,
name = u.name,
description = u.description,
adress = u.adress,
loulepar = u.loulepar,
rentalPrice = u.rentalPrice,
pic = u.pic,
owner_id = u.owner_id,
user = us.GetById(id)
};
pvm.Add(G);
}
return(View(pvm));
}
private void move()
{
current_space.decay();
current_space = space_to_move_to;
space_to_move_to = null;
anim.set_clip(1);
if (!current_space.space_connected_to_goal())
{
// reload scene
hit_player();
}
am.play(sounds[sound_index]);
sound_index = (sound_index + 1) % sounds.Length;
// Unlock obstackle space if you found the key
if (current_space.is_key)
{
am.play("hover");
current_space.obstacle_space.remove_obstacle();
}
if (current_space.is_goal)
{
am.play("win");
}
}
public ArrayLayout(Node node, space space, Address ptr, ReadOnlyCollection <Reg> dims)
{
Node = node;
Space = space;
Ptr = ptr;
Dims = dims;
}
public ActionResult Create(SpaceViewModel svm, HttpPostedFileBase upload)
{
string userid = this.Session["LogedUserid"].ToString();
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
ShowroomdbContext ctx = new ShowroomdbContext();
space s = new space();
s.adress = svm.Adress;
s.rentalPrice = svm.Prix;
s.description = svm.Description;
s.owner_id = Int32.Parse(userid);
if (upload != null && upload.ContentLength > 0)
{
s.pic = Guid.NewGuid().ToString() + Path.GetFileName(upload.FileName);
upload.SaveAs(Path.Combine(Server.MapPath("~/Content/SpaceImages"), s.pic));
}
ctx.spaces.Add(s);
ctx.SaveChanges();
//service.Add(s);
//service.Commit();
return(RedirectToAction("Index"));
}
return(View());
}
catch
{
return(View());
}
}
private void Clear_Click_1(object sender, EventArgs e)
{
for (int i = 0; i < 64; i++)
{
space drawSpace = ((space)coordinates[i]);
drawSpace.setOccupied(false);
totalQueens = 0;
}
Invalidate();
}
public ActionResult DeleteConfirm(int id, FormCollection collection)
{
ShowroomdbContext cnt = new ShowroomdbContext();
space s = service.GetById(id);
service.Delete(s);
service.Commit();
//cnt.spaces.Remove(s);
//cnt.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit(int id, SpaceViewModel svm)
{
space s = service.GetById(id);
s.id = svm.Id;
s.adress = svm.Adress;
s.description = svm.Description;
s.rentalPrice = svm.Prix;
s.pic = svm.Urlimage;
service.Update(s);
service.Commit();
return(RedirectToAction("Index"));
}
private void Player_Load(object sender, EventArgs e)
{
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
int y = (40 * i + 100);
int x = (40 * j + 100);
space boardSpace = new space(x, y, i, j);
coordinates.Add(boardSpace);
}
}
}
// GET: Space/Details/5
public ActionResult Details(int id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
space space = service.GetById(id);
if (space == null)
{
return(HttpNotFound());
}
return(View(space));
}
// GET: Exposure/Details/5
public ActionResult Details(int id)
{
if (id == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
IEnumerable <artwork> ListArtworkById = serviceA.ArtworkByIdArtwork(id);
List <ArtworkForExposureModel> ArtById = new List <ArtworkForExposureModel>();
ShowroomdbContext ctx = new ShowroomdbContext();
//user Artist = ServiceU.GetById(u.fk_artist.Value);
//ExpositionArtwork ExpositionArtwork = ServicExpositionArtwork.GetOneExpoByIdExpo(id);
//space space = ServiceS.GetById(ExpositionArtwork.fk_space);
//exposure exposure = service.GetById(id);
//int? FkOwner = space.fk_owner;
//user Owner = ServiceU.GetById(FkOwner.Value);
if (ListArtworkById == null)
{
return(HttpNotFound());
}
foreach (var x in ListArtworkById)
{
ArtworkForExposureModel ar = new ArtworkForExposureModel();
user Artist = ServiceU.GetById((int)x.artist_id);
ExpositionArtwork ExpositionArtwork = ServicExpositionArtwork.GetOneExpoByIdExpo(id);
space space = ServiceS.GetById(ExpositionArtwork.fk_space);
exposure exposure = service.GetById(id);
int? FkOwner = space.owner_id;
user Owner = ServiceU.GetById(FkOwner.Value);
ar.id = x.id;
ar.name = x.name;
ar.photo = x.phot;
ar.ArtistName = Artist.firstName + Artist.lastName;
ar.StartDate = exposure.SDate.Value;
ar.EndDate = exposure.EDate.Value;
ar.SpaceName = space.name;
ar.SpaceAddress = space.adress;
ar.OwnerName = Owner.firstName + Owner.lastName;
ar.Priority = ServicExpositionArtwork.GetByIdArtworkAndIdExposure(id, x.id);
ArtById.Add(ar);
}
return(View(ArtById.OrderBy(a => a.Priority).ToList()));
}
public ActionResult louer(int id)
{
space prod = sp.GetById(id);
space a = new space
{
id = prod.id,
name = prod.name,
description = prod.description,
adress = prod.description,
rentalPrice = prod.rentalPrice,
pic = prod.pic,
user = us.GetById((int)prod.owner_id)
};
return(View(prod));
}
void find_desired_move()
{
space[] avail = current_space.get_connections();
List <space> valid = new List <space>();
foreach (space s in avail)
{
if (s != null && !s.broken && !s.is_obstacle)
{
valid.Add(s);
}
}
if (valid.Count > 0)
{
next_space = valid[(int)Random.Range(0, valid.Count)];
move();
}
}
// Returns true if the player can still reach the goal, false otherwise
// breadth first search
public bool space_connected_to_goal()
{
Queue <space> queue = new Queue <space>();
List <space> visited = new List <space>();
bool key_found = false;
bool goal_found = false;
queue.Enqueue(this);
while (queue.Count > 0)
{
space s = queue.Dequeue();
if (s.is_goal)
{
goal_found = true;
}
if (s.is_key)
{
key_found = true;
}
if ((Game_manager.key_exists && key_found && goal_found) || (!Game_manager.key_exists && goal_found))
{
return(true);
}
visited.Add(s);
for (int i = 0; i < s.connections.Length; i++)
{
// check that it is not null, that it hasn't been visited and that it can be travelled accross
if (s.connections[i] != null && !visited.Contains(s.connections[i]) && s.connections[i].broken == false)
{
queue.Enqueue(s.connections[i]);
}
}
}
return(false);
}
private void Form1_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
for (int i = 0; i < 64; i++)
{
space drawSpace = ((space)coordinates[i]);
if (drawSpace.isClicked(e.X, e.Y))
{
if (drawSpace.isValid(coordinates))
{
drawSpace.setOccupied(true);
totalQueens++;
}
else
{
System.Media.SystemSounds.Beep.Play();
}
}
}
}
if (e.Button == MouseButtons.Right)
{
for (int i = 0; i < 64; i++)
{
space drawSpace = ((space)coordinates[i]);
if (drawSpace.isClicked(e.X, e.Y))
{
if (drawSpace.isOccupied())
{
drawSpace.setOccupied(false);
totalQueens--;
}
}
}
}
Invalidate();
}
// GET: Space/Edit/5
public ActionResult Edit(int id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
space s = service.GetById(id);
SpaceViewModel svm = new SpaceViewModel();
if (s == null)
{
return(HttpNotFound());
}
else
{
svm.Id = s.id;
svm.Prix = (int)s.rentalPrice;
svm.Adress = s.adress;
svm.Description = s.description;
svm.Urlimage = s.pic;
return(View(svm));
}
}
public ActionResult confirmlouer(int id, space s)
{
space prod = sp.GetById(id);
if (prod != null)
{
rentspace r = new rentspace {
fk_artist = (int)Session["LogedUserid"],
fk_space = prod.id,
rentDate = (DateTime)s.rentdate,
price = prod.rentalPrice
};
prod.disponibility = false;
rs.Add(r);
rs.Commit();
sp.Update(prod);
sp.Commit();
return(RedirectToAction("Index", "Paypal", new { ids = id }));
}
return(View());
}
public static bool is_ptr(this Expression expr, space space)
{
if (!expr.is_ptr()) return false;
if (space == 0) return true;
var e_var = expr as Var;
if (e_var != null) return (e_var.Space & ~space) == 0;
var e_addr = expr as Address;
if (e_addr != null)
{
var ok = true;
var a_base = e_addr.Base as Var;
if (a_base != null) ok &= ((a_base.Space & ~space) == 0);
var o_base = e_addr.Offset.Base as Var;
if (o_base != null) ok &= ((o_base.Space & ~space) == 0);
return ok;
}
throw AssertionHelper.Fail();
}
cpSpatialIndexQuery(space.activeShapes, ref context, bb, new cpSpatialIndexQueryFunc(PointQuery), data);
/// <summary>
/// 获取电子围栏内所有摄像头信息
/// </summary>
public string GetElectricFenceCameraList(SafeworkcontrolEntity data)
{
string ComerId = string.Empty;
try
{
//三维监控点位服务接口地址
DataItemDetailBLL pdata = new DataItemDetailBLL();
var ThreeDApi = pdata.GetItemValue("kbsThreeMonitoringPoints");
space sp = new space();
spacedata sds = new spacedata();
List <spacegeo> geolist = new List <spacegeo>();
List <spacepnt> pntlist = new List <spacepnt>();
var comList = new KbscameramanageBLL().GetPageList("").Where(a => a.State == "在线" && a.CameraType == "枪机" && a.MonitoringArea != null).ToList();
spacegeo geo = new spacegeo();
geo.id = data.ID;
if (data.Areacode != null)
{//电子围栏坐标点
PositionsEntity alist = JsonConvert.DeserializeObject <PositionsEntity>(data.Areacode);
List <double> dlist = new List <double>();
if (data.Areastate == 0)
{//矩形
geo.type = 1;
geo.distance = 0;
//第一个点
dlist.Add(alist.positions[0].x);
dlist.Add(alist.positions[0].z);
//第二个点
dlist.Add(alist.positions[1].x);
dlist.Add(alist.positions[0].z);
//第三个点
dlist.Add(alist.positions[1].x);
dlist.Add(alist.positions[1].z);
//第四个点
dlist.Add(alist.positions[0].x);
dlist.Add(alist.positions[1].z);
//回到原点
dlist.Add(alist.positions[0].x);
dlist.Add(alist.positions[0].z);
geo.coor = dlist;
geolist.Add(geo);
}
else if (data.Areastate == 1)
{//圆形
geo.type = 0;
dlist.Add(alist.positions[0].x);
dlist.Add(alist.positions[0].z);
geo.distance = Convert.ToInt32(data.Radius);
geo.coor = dlist;
geolist.Add(geo);
}
else if (data.Areastate == 2)
{//手绘多边形
foreach (var ac in alist.positions)
{
dlist.Add(ac.x);
dlist.Add(ac.z);
}
//闭合回到原点
dlist.Add(alist.positions[0].x);
dlist.Add(alist.positions[0].z);
geo.coor = dlist;
geo.type = 1;
geo.distance = 0;
geolist.Add(geo);
}
foreach (var com in comList)
{//摄像头坐标点集
PositionsEntity alist1 = JsonConvert.DeserializeObject <PositionsEntity>(com.MonitoringArea);
if (alist1.floorID == alist.floorID)
{
List <double> dlist1 = new List <double>();
foreach (var ac in alist1.positions)
{
dlist1.Add(ac.x);
dlist1.Add(ac.z);
}
//闭合回到原点
dlist1.Add(alist1.positions[0].x);
dlist1.Add(alist1.positions[0].z);
spacepnt pnt = new spacepnt()
{
id = com.CameraId,
x = 0,
y = 0,
coor = dlist1
};
pntlist.Add(pnt);
}
}
}
sds.geo = geolist;
sds.pnt = pntlist;
sp.type = "2";
sp.data = sds;
string rtn = HttpUtillibKbs.HttpThreeDPost(ThreeDApi, JsonConvert.SerializeObject(sp));
List <RtnSpace> rss = JsonConvert.DeserializeObject <List <RtnSpace> >(rtn);
foreach (var item in rss)
{
if (string.IsNullOrEmpty(item.pntId))
{
continue;
}
ComerId += item.pntId + ',';
}
return(ComerId);
}
catch (Exception er)
{
return(ComerId);
}
}
cpSpaceLock(space); {
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
Graphics g = e.Graphics;
Image newimage = Image.FromFile("queen-icon.png");
g.DrawString("Queen Count: " + totalQueens, Font, Brushes.Black, 140, 17);
for (int i = 0; i < 64; i++)
{
space drawSpace = ((space)coordinates[i]);
Rectangle rect = drawSpace.getRect();
int X = drawSpace.getX();
int Y = drawSpace.getY();
if ((i / 8) % 2 == 0)
{
if (i % 2 == 0)
{
if (!hints)
{
g.FillRectangle(Brushes.Black, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
else
{
if (!drawSpace.isValid(coordinates))
{
g.FillRectangle(Brushes.Red, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
else
{
g.FillRectangle(Brushes.Black, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
}
}
else
{
if (!hints)
{
g.FillRectangle(Brushes.White, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
else
{
if (!drawSpace.isValid(coordinates))
{
g.FillRectangle(Brushes.Red, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
else
{
g.FillRectangle(Brushes.White, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
}
}
}
else
{
if (i % 2 == 1)
{
if (!hints)
{
g.FillRectangle(Brushes.Black, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
else
{
if (!drawSpace.isValid(coordinates))
{
g.FillRectangle(Brushes.Red, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
else
{
g.FillRectangle(Brushes.Black, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
}
}
else
{
if (!hints)
{
g.FillRectangle(Brushes.White, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
else
{
if (!drawSpace.isValid(coordinates))
{
g.FillRectangle(Brushes.Red, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
else
{
g.FillRectangle(Brushes.White, rect);
g.DrawRectangle(Pens.Black, rect);
if (drawSpace.isOccupied())
{
g.DrawImage(newimage, new RectangleF(X, Y, 40, 40));
}
}
}
}
}
}
if (totalQueens == 8)
{
for (int i = 0; i < 64; i++)
{
space drawSpace = ((space)coordinates[i]);
drawSpace.setOccupied(false);
totalQueens = 0;
}
MessageBox.Show("Bạn đã thắng!");
}
}
public String Process(String s_in)
{
// Initialize State to zero when we start
State st = State.zero;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s_in.Length; i++)
{
var c = s_in[i];
space sp = space.none;
switch (st)
{
case State.zero:
if (V1.Contains(c))
{
st = State.one;
}
else if (C1.Contains(c))
{
st = State.two;
}
else
{
throw new Exception("Invalid Input");
}
break;
case State.one:
if (C1.Contains(c))
{
st = State.two;
}
else
{
throw new Exception("Invalid Input");
}
break;
case State.two:
if (C2.Contains(c))
{
st = State.three;
}
else if (V2.Contains(c))
{
st = State.four;
}
else if (T.Contains(c))
{
st = State.five;
}
else if (V3.Contains(c))
{
st = State.six;
}
else if (C3.Contains(c))
{
sp = space.now;
st = State.zero;
}
else if (V1.Contains(c))
{
sp = space.before;
st = State.one;
}
else if (C1.Contains(c))
{
sp = space.before;
st = State.two;
}
else
{
throw new Exception("Invalid Input");
}
break;
case State.three:
if (V2.Contains(c))
{
st = State.four;
}
else if (T.Contains(c))
{
st = State.five;
}
else if (V3.Contains(c))
{
st = State.six;
}
else if (C3.Contains(c))
{
sp = space.now;
st = State.zero;
}
else
{
throw new Exception("Invalid Input");
}
break;
case State.four:
if (T.Contains(c))
{
st = State.five;
}
else if (V3.Contains(c))
{
st = State.six;
}
else if (C3.Contains(c))
{
sp = space.now;
st = State.zero;
}
else if (V1.Contains(c))
{
sp = space.before;
st = State.one;
}
else if (C1.Contains(c))
{
sp = space.before;
st = State.two;
}
else
{
throw new Exception("Invalid Input");
}
break;
case State.five:
if (V3.Contains(c))
{
st = State.six;
}
else if (C3.Contains(c))
{
sp = space.now;
st = State.zero;
}
else if (V1.Contains(c))
{
sp = space.before;
st = State.one;
}
else if (C1.Contains(c))
{
sp = space.before;
st = State.two;
}
else
{
throw new Exception("Invalid Input");
}
break;
case State.six:
if (C3.Contains(c))
{
// this will eliminate the need for a special state 7
sp = space.now;
st = State.zero;
}
else if (V1.Contains(c))
{
sp = space.before;
st = State.one;
}
else if (C1.Contains(c))
{
sp = space.before;
st = State.two;
}
else
{
throw new Exception("Invalid Input");
}
break;
default:
throw new Exception("Invalid Input");
}
switch (sp)
{
case space.none:
sb.Append(c);
break;
case space.before:
//When there is a character after the current character it will go to states 7 and 8 to trigger adding space
if (i < s_in.Length - 1)
{
sb.Append(" ");
}
sb.Append(c);
break;
case space.now:
sb.Append(c);
if (i < s_in.Length - 1)
{
sb.Append(" ");
}
break;
default:
break;
}
}
return(sb.ToString());
}
void OnServerInitialized()
{
//---------------------------------------//
//-----------------Prims-----------------//
//---------------------------------------//
//Everything in here is only done by the server.
//Having some problems, this was to work-around some dumb error.
space fakeSpace;
fakeSpace.col = 1000;
fakeSpace.row = 1000;
fakeSpace.weight = 1000000;
fakeSpace.numAdjacentInPath = 0;
fakeSpace.partOfPath = false;
//all spaces and possible starting Loc for algorithm.
space[][] allSpaces;
List <space> possibleStarts = new List <space>(); // List containing all the nodes that can be started from.
//create a randomly generated weighted graph.
allSpaces = new space[mazeSize][];
for (int i = 0; i < mazeSize; i++)
{
allSpaces[i] = new space[mazeSize];
for (int j = 0; j < mazeSize; j++)
{
allSpaces[i][j].weight = rng.Next() % 100;
allSpaces[i][j].numAdjacentInPath = 0;
allSpaces[i][j].partOfPath = false;
allSpaces[i][j].row = i;
allSpaces[i][j].col = j;
}
}
//Generation Loop.
bool isGenerated = false;
int numRuns = 0;
int curRow = 0;
int curCol = 0;
List <space> avaliableMoves = new List <space>(); //list for possible moves THIS turn. (used later).
//Kinda cheating I guess. First move is made automatically.
//Add the starting move to the list of starting moves.
possibleStarts.Add(allSpaces[0][0]);
allSpaces[0][0].partOfPath = true;
allSpaces[0][1].numAdjacentInPath++;
allSpaces[1][0].numAdjacentInPath++;
while (!isGenerated)
{
numRuns++; //Debug
//Debug.Log("running loop number " + numRuns );+
//Debug.Log("++++++ running loop number " + numRuns + ", avaliable starts: " + possibleStarts.Count+" ++++++");
//Choose a starting space.
int choice = rng.Next() % possibleStarts.Count;
curRow = possibleStarts[choice].row;
curCol = possibleStarts[choice].col;
//Debug.Log("starting at row "+ curRow + ", col "+ curCol);
//Add all possible points to path.
for (int i = 1; i < 5; i++) // this for loop gets all nearby points.
{
int row = 0;
int col = 0;
//Sloppy I know.
switch (i)
{
case 1: row = curRow; col = curCol + 1; break;
case 2: row = curRow; col = curCol - 1; break;
case 3: row = curRow + 1; col = curCol; break;
case 4: row = curRow - 1; col = curCol; break;
}
if (row >= 0 && row < mazeSize && col >= 0 && col < mazeSize) //make sure its in bounds.
{
if (allSpaces[row][col].numAdjacentInPath == 1 && !allSpaces[row][col].partOfPath) //This means it is near only one other used space! (which is what we want)
{
//Debug.Log("adding space at row" + row + ", col "+ col + "to possible moves.");
avaliableMoves.Add(allSpaces[row][col]); // adds the space onto a list of possible spaces
}
}
} //All possible moves have been added.
//dumb error work-around.
space moveChoice = fakeSpace;
//If there are moves avaliable...
if (avaliableMoves.Count != 0)
{
//Debug.Log ("There are moves avaliable");
//choose one by weight and make the move.
for (int i = 0; i < avaliableMoves.Count; i++) // count should be 1-3
{
if (avaliableMoves[i].weight < moveChoice.weight)
{
moveChoice = avaliableMoves[i];
}
}
//Debug.Log("chose to move to space at row "+moveChoice.row + "and col "+moveChoice.col + ", added it to graph");
//Move has been chosen. Add it to graph.
possibleStarts.Add(moveChoice);
for (int i = 1; i < 5; i++) // this for loop gets all nearby points.
{
int r = moveChoice.row;
int c = moveChoice.col;
allSpaces[r][c].partOfPath = true; // move choice becomes part of graph
switch (i)
{
case 1: r++; break;
case 2: r--; break;
case 3: c++; break;
case 4: c--; break;
}
//Not going out of bounds...
if (c >= 0 && c < mazeSize && r >= 0 && r < mazeSize)
{
allSpaces[r][c].numAdjacentInPath++; // spaces near choice have numAdjacent incremented.
}
}
if ((avaliableMoves.Count - 1) == 0)
{
//Debug.Log("after moving there were no more moves, removing row " + curRow +", col "+curCol +" from possible starts");
//that was our last move from this spot.
//Remove used space from starting list.
possibleStarts.RemoveAt(choice);
}
}
else // No moves?
{
//Debug.Log("no moves, removing space at row "+curRow + ",col " + curCol+ " from possible starts");
//Remove used space from starting list.
possibleStarts.RemoveAt(choice);
}
//If there are no more moves, end generation.
if (possibleStarts.Count == 0) //possibleStarts.Count == 0
{
//GGWP generation
//Debug.Log("finished with " + numRuns + "runs!");
isGenerated = true; // ends loop.
}
avaliableMoves.Clear();
}//End while. At this point, all spaces that are used have the "partofpath" bool set to true.
foreach (space[] ss in allSpaces)
{
foreach (space s in ss)
{
if (s.partOfPath)
{
WallScript ws = WallArray[s.row][s.col].GetComponent <WallScript>();
wallState[s.row][s.col] = 1; // keep track of state.
ws.SetHeight(1); //Set wall down.
}
else
{
WallScript ws = WallArray[s.row][s.col].GetComponent <WallScript>();
wallState[s.row][s.col] = 0; // keep track of state.
ws.SetHeight(0); //Set wall down.
}
}
}
}
protected bool is_ptr_or_null(Expression expr, space space)
{
return expr == null || expr.is_ptr(space);
}
//player 1= int 1
//player 2=int 2
private space GetBestMove(Board gb, int player)
{
//Console.WriteLine("i am player "+player);
space bestSpace = null;
//Dictionary<Board, int> AtateDic = new Dictionary<Board, int>();
//List<space> openSpaces = getTuple(gb);
for (int i = 0; i < gb._rows; i++)
{
for (int j = 0; j < gb._cols; j++)
{
if (gb._board[i, j] == 'X')
{
//for (int i = 0; i < openSpaces.Count; i++)
//{
// System.Console.WriteLine(" iteration " + i);
Board newBoard = new Board(gb);
// Console.WriteLine("board for player "+ player);
space newSpace = new space(new Tuple <int, int>(i, j), 0);
newBoard.fillPlayerMove(newSpace.place.Item1, newSpace.place.Item2);
//newBoard.printTheBoard();
// newBoard[newSpace.Item1, newSpace.Item2] = p;
if (hasWinner(newBoard, player) == 0)
{
space tempMove = GetBestMove(newBoard, changePlayers(player)); //a little hacky, inverts the current player
if (player == 1 && tempMove.rank == 1)
{
newSpace.rank = tempMove.rank;
return(newSpace);
}
if (player == 2 && tempMove.rank == -1)
{
newSpace.rank = tempMove.rank;
return(newSpace);
}
newSpace.rank = tempMove.rank;
//newSpace = tempMove;
}
else
{
// Console.WriteLine("reach to end");
/*
* if (player==1&& hasWinner(newBoard, player) == 1)
* {
* newSpace.rank = 1;
* return newSpace;
* }
*/
int win = hasWinner(newBoard, player);
if (player == 1 && win == 2)
{
newSpace.rank = -1;
}
/*
* else if (player==2&& hasWinner(newBoard, player) == 2)
* {
* newSpace.rank = -1;
* return newSpace;
*
* }
*/
else if (player == 2 && win == 1)
{
newSpace.rank = 1;
}
}
//If the new move is better than our previous move, take it
//1- maximum player
//2 -minimum player
if (bestSpace == null || (player == 1 && newSpace.rank > bestSpace.rank) || (player == 2 && newSpace.rank < bestSpace.rank))
{
bestSpace = newSpace;
}
}
}
}
return(bestSpace);
}
protected bool is_ptr(Expression expr, space space)
{
return expr.is_ptr(space);
}
public Tuple <int, int> playYourTurn
(
Board board,
TimeSpan timesup
)
{
stopwatch = new Stopwatch();
stopwatch.Start();
// while ((double)stopwatch.ElapsedMilliseconds < timesup.TotalMilliseconds - 10)
// {
//}
Tuple <int, int> toReturn = null;
//if the board is square
if (checkIfSquare(board))
{
toReturn = new Tuple <int, int>(1, 1);
return(toReturn);
}
//check if it is a 2*something
/*
* if (checkIfReish(board))
* {
* int numR = 0;
*
* for (int x = 0; x < board._rows; x++)
* {
* if (board._board[x, 0] == 'X')
* {
* numR++;
* }
* }
* int numCul = 0;
*
* for (int y = 0; y < board._rows; y++)
* {
* if (board._board[0, y] == 'X')
* {
* numCul++;
* }
* }
*
*
* if (numR > numCul)
* {
* toReturn = new Tuple<int, int>(numCul, 0);
* return toReturn;
*
*
* }
*
* if (numCul > numR)
* {
* toReturn = new Tuple<int, int>(0, numR);
* return toReturn;
*
*
* }
*
* }
*/
//end if the board is square
resultDicPlayer1 = new Dictionary <char[, ], space>();
resultDicPlayer2 = new Dictionary <char[, ], space>();
/*
* //Thread newThread = new Thread(Work.DoWork);
* space res = null;
* Thread newThread = new Thread(() => { res = getBestMove2(board, 1); });
* newThread.Start();
* newThread.Join((int)timesup.TotalMilliseconds - 5);
* if (res!=null)
* {
*
* return res.place;
* }
*/
//Console.WriteLine(stopwatch.ElapsedMilliseconds.ToString());
/*
*
* var result = default(space);
* Action runTask = () => result = getBestMove2(board, 1);
*
* TimeSpan time = new TimeSpan(0, 0, 0, 0, (int)timesup.TotalMilliseconds - 5);
* var task = Task.Factory.StartNew(runTask);
* if (task.Wait(time))
* {
* Console.WriteLine("1"+stopwatch.ElapsedMilliseconds.ToString());
* return result.place;
*
* }
* Console.WriteLine("2" + stopwatch.ElapsedMilliseconds.ToString());
*
*/
//Console.WriteLine(stopwatch.ElapsedMilliseconds.ToString());
/*
*
* var task = Task.Run(() => getBestMove2(board, 1));
* if (task.Wait(TimeSpan.FromSeconds(timesup.TotalMilliseconds - 20)))
* return task.Result.place;
* else
* {
*/
space res = getBestMove2(board, 1, timesup);
// space res =GetBestMove(board, 1);
if (res != null)
{
if (res.place.Item1 == 0 && res.place.Item2 == 0)
{
return(chooseTheLast(board));
}
else
{
return(res.place);
}
}
return(chooseTheLast(board));
//Console.WriteLine(stopwatch.ElapsedMilliseconds.ToString());
/**/
/*
* int randomRow;
* int randomCol;
* Random random = new Random();
* do
* {
* randomRow = random.Next(0, board._rows);
* randomCol = random.Next(0, board._cols);
* } while (board._board[randomRow, randomCol] != 'X' && check(board, randomRow, randomCol) == false); // == ' ');&& board.isTheGameEnded()
* toReturn = new Tuple<int, int>(randomRow, randomCol);
* //Random Algorithm - End
* // Console.WriteLine(stopwatch.ElapsedMilliseconds.ToString());
* return toReturn;
*/
}
void Awake()
{
instance = this;
}
private space getBestMove2(Board gb, int player, TimeSpan timesup)
{
if (stopwatch.ElapsedMilliseconds > timesup.TotalMilliseconds - 5)
{
//Console.WriteLine(stopwatch.ElapsedMilliseconds);
//Console.WriteLine(timesup.TotalMilliseconds-20);
return(null);
}
space bestSpace = null;
// Console.WriteLine("bllaaablaa");
if (player == 1)
{
foreach (char[,] item in resultDicPlayer1.Keys)
{
bool stop = false;
for (int i = 0; i < gb._rows && stop == false; i++)
{
for (int j = 0; j < gb._cols && stop == false; j++)
{
if (item[i, j].Equals(gb._board[i, j]) == false)
{
stop = true;
}
}
}
if (stop == false)
{
// Console.WriteLine("found");
return(resultDicPlayer1[item]);
}
}
}
if (player == 2)
{
foreach (char[,] item in resultDicPlayer2.Keys)
{
bool stop = false;
for (int i = 0; i < gb._rows && stop == false; i++)
{
for (int j = 0; j < gb._cols && stop == false; j++)
{
if (item[i, j].Equals(gb._board[i, j]) == false)
{
/// Console.WriteLine("stopppp2222222222222222");
stop = true;
}
}
}
if (stop == false)
{
// Console.WriteLine("found");
return(resultDicPlayer2[item]);
}
}
}
for (int i = 0; i < gb._rows; i++)
{
for (int j = 0; j < gb._cols; j++)
{
if (gb._board[i, j] == 'X')
{
//for (int i = 0; i < openSpaces.Count; i++)
//{
// System.Console.WriteLine(" iteration " + i);
Board newBoard = new Board(gb);
// Console.WriteLine("board for player "+ player);
space newSpace = new space(new Tuple <int, int>(i, j), 0);
newBoard.fillPlayerMove(newSpace.place.Item1, newSpace.place.Item2);
//newBoard.printTheBoard();
// newBoard[newSpace.Item1, newSpace.Item2] = p;
if (hasWinner(newBoard, player) == 0)
{
space tempMove = getBestMove2(newBoard, changePlayers(player), timesup);
if (stopwatch.ElapsedMilliseconds > timesup.TotalMilliseconds - 5)
{
// Console.WriteLine(stopwatch.ElapsedMilliseconds);
// Console.WriteLine(timesup.TotalMilliseconds - 20);
return(null);
}
if (player == 1 && tempMove.rank == 1)
{
newSpace.rank = tempMove.rank;
resultDicPlayer1.Add(gb._board, newSpace);
// resultDicPlayer1[gb._board] = newSpace;
return(newSpace);
}
if (player == 2 && tempMove.rank == -1)
{
newSpace.rank = tempMove.rank;
resultDicPlayer2.Add(gb._board, newSpace);
// resultDicPlayer2[gb._board] = newSpace;
return(newSpace);
}
newSpace.rank = tempMove.rank;
//newSpace = tempMove;
}
else
{
// Console.WriteLine("reach to end");
/*
* if (player==1&& hasWinner(newBoard, player) == 1)
* {
* newSpace.rank = 1;
* return newSpace;
* }
*/
int win = hasWinner(newBoard, player);
if (player == 1 && win == 2)
{
newSpace.rank = -1;
}
/*
* else if (player==2&& hasWinner(newBoard, player) == 2)
* {
* newSpace.rank = -1;
* return newSpace;
*
* }
*/
else if (player == 2 && win == 1)
{
newSpace.rank = 1;
}
}
//If the new move is better than our previous move, take it
//1- maximum player
//2 -minimum player
if (bestSpace == null || (player == 1 && newSpace.rank > bestSpace.rank) || (player == 2 && newSpace.rank < bestSpace.rank))
{
bestSpace = newSpace;
}
}
}
}
if (player == 1)
{
resultDicPlayer1.Add(gb._board, bestSpace);
}
if (player == 2)
{
resultDicPlayer2.Add(gb._board, bestSpace);
}
return(bestSpace);
}
internal AIMLTagHandler GetTagHandlerU(User user, SubQuery query, Request request, Result result, XmlNode node, bool liText)
{
AIMLTagHandler tagHandlerU = getBespokeTags(user, query, request, result, node);
string nodeNameLower = StaticAIMLUtils.ToLower(node.LocalName);
AltBot targetBot = query.TargetBot;
if (Equals(null, tagHandlerU))
{
switch (nodeNameLower)
{
case "template":
case "answer": //CML
tagHandlerU = new template(targetBot, user, query, request, result, node);
break;
case "aiml":
case "cml": //CML
tagHandlerU = new aiml(targetBot, user, query, request, result, node);
break;
case "aimlexec":
case "eval":
tagHandlerU = new aimlexec(targetBot, user, query, request, result, node);
break;
case "vars":
case "root":
case "predicates": //CML
tagHandlerU = new root(targetBot, user, query, request, result, node, (() => query.TargetSettings));
break;
case "properties":
case "bots":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.GlobalSettings));
break;
case "substitutions":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.InputSubstitutions));
break;
case "topic":
case "conversation": //CML
tagHandlerU = new topic(targetBot, user, query, request, result, node);
break;
case "category":
case "conv": //CML
tagHandlerU = new category(targetBot, user, query, request, result, node);
break;
case "and":
tagHandlerU = new and(targetBot, user, query, request, result, node);
break;
case "or":
tagHandlerU = new or(targetBot, user, query, request, result, node);
break;
case "optional":
tagHandlerU = new optional(targetBot, user, query, request, result, node);
break;
case "isa":
tagHandlerU = new isa(targetBot, user, query, request, result, node);
break;
case "bot":
tagHandlerU = new bot(targetBot, user, query, request, result, node);
break;
case "condition":
case "options": //cml
tagHandlerU = new condition_aima(targetBot, user, query, request, result, node);
break;
case "li":
if (liText)
{
tagHandlerU = new liif(targetBot, user, query, request, result, node);
}
break;
case "if":
tagHandlerU = new liif(targetBot, user, query, request, result, node);
break;
case "personf":
tagHandlerU = new format(targetBot, user, query, request, result, node,
new Func <string, string>(HttpUtility.UrlEncode),
null);
break;
case "date":
tagHandlerU = new date(targetBot, user, query, request, result, node);
break;
case "formal":
tagHandlerU = new formal(targetBot, user, query, request, result, node);
break;
case "gender":
tagHandlerU = new gender(targetBot, user, query, request, result, node);
break;
case "get":
tagHandlerU = new get(targetBot, user, query, request, result, node);
break;
case "gossip":
tagHandlerU = new gossip(targetBot, user, query, request, result, node);
break;
case "get_ip":
case "id":
tagHandlerU = new id(targetBot, user, query, request, result, node);
break;
case "inputreq":
tagHandlerU = new inputreq(targetBot, user, query, request, result, node);
break;
case "request":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "input":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "justthat": // <input index="2"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 2);
break;
case "beforethat": // <input index="3"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 3);
break;
#if !(__MonoCS__)
case "javascript":
tagHandlerU = new javascript(targetBot, user, query, request, result, node);
break;
#endif
case "learn":
case "load":
case "noload": // the commented version of <load>
tagHandlerU = new learn(targetBot, user, query, request, result, node);
break;
case "lowercase":
tagHandlerU = new lowercase(targetBot, user, query, request, result, node);
break;
case "person":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "person2":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "random":
tagHandlerU = new random(targetBot, user, query, request, result, node);
break;
case "sentence":
tagHandlerU = new sentence(targetBot, user, query, request, result, node);
break;
case "set":
tagHandlerU = new set(targetBot, user, query, request, result, node);
break;
case "size":
case "getsize":
tagHandlerU = new size(targetBot, user, query, request, result, node);
break;
case "sr":
tagHandlerU = new sr(targetBot, user, query, request, result, node);
break;
case "srai_odd":
tagHandlerU = new srai_odd(targetBot, user, query, request, result, node);
break;
case "star":
tagHandlerU = new star(targetBot, user, query, request, result, node);
break;
case "system":
tagHandlerU = new system(targetBot, user, query, request, result, node);
break;
case "that": //default <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 1);
break;
case "justbeforethat": //treated as <that index="2,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "response": //treated as <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "thatstar":
tagHandlerU = new thatstar(targetBot, user, query, request, result, node);
break;
case "think":
tagHandlerU = new think(targetBot, user, query, request, result, node);
break;
case "topicstar":
tagHandlerU = new topicstar(targetBot, user, query, request, result, node);
break;
case "uppercase":
tagHandlerU = new uppercase(targetBot, user, query, request, result, node);
break;
case "version":
case "getversion":
tagHandlerU = new version(targetBot, user, query, request, result, node);
break;
case "cycsystem":
tagHandlerU = new cycsystem(targetBot, user, query, request, result, node);
break;
case "cycretract":
tagHandlerU = new cycretract(targetBot, user, query, request, result, node);
break;
case "cycassert":
tagHandlerU = new cycassert(targetBot, user, query, request, result, node);
break;
case "cycterm":
tagHandlerU = new cycterm(targetBot, user, query, request, result, node);
break;
case "cycquery":
tagHandlerU = new cycquery(targetBot, user, query, request, result, node);
break;
case "cyccondition":
tagHandlerU = new cyccondition(targetBot, user, query, request, result, node);
break;
case "cycphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "cycparaphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "guard":
tagHandlerU = new guard(targetBot, user, query, request, result, node);
break;
case "guardstar":
tagHandlerU = new guardstar(targetBot, user, query, request, result, node);
break;
case "cycrandom":
tagHandlerU = new cycrandom(targetBot, user, query, request, result, node);
break;
case "tscore":
tagHandlerU = new tscore(targetBot, user, query, request, result, node);
break;
case "space":
tagHandlerU = new space(targetBot, user, query, request, result, node);
break;
case "markov":
tagHandlerU = new markov(targetBot, user, query, request, result, node);
break;
case "soundcode":
tagHandlerU = new soundcode(targetBot, user, query, request, result, node);
break;
// MSM
case "msm":
tagHandlerU = new msm(targetBot, user, query, request, result, node);
break;
case "processmsm":
tagHandlerU = new process_msm(targetBot, user, query, request, result, node);
break;
case "setstate":
tagHandlerU = new setstate(targetBot, user, query, request, result, node);
break;
case "state":
tagHandlerU = new state(targetBot, user, query, request, result, node);
break;
case "transition":
tagHandlerU = new transition(targetBot, user, query, request, result, node);
break;
case "setevidence":
tagHandlerU = new setevidence(targetBot, user, query, request, result, node);
break;
case "evidenceassoc":
tagHandlerU = new evidence_assoc(targetBot, user, query, request, result, node);
break;
case "evidencepattern":
tagHandlerU = new evidence_pattern(targetBot, user, query, request, result, node);
break;
case "evidencestate":
tagHandlerU = new evidencestate(targetBot, user, query, request, result, node);
break;
case "dependentmachine":
tagHandlerU = new dependentmachine(targetBot, user, query, request, result, node);
break;
case "responsetopic":
tagHandlerU = new response_topic(targetBot, user, query, request, result, node);
break;
case "push":
tagHandlerU = new push(targetBot, user, query, request, result, node);
break;
case "pop":
tagHandlerU = new pop(targetBot, user, query, request, result, node);
break;
case "peekstack":
tagHandlerU = new peekstack(targetBot, user, query, request, result, node);
break;
case "lex":
tagHandlerU = new lex(targetBot, user, query, request, result, node);
break;
case "lexset":
tagHandlerU = new lexset(targetBot, user, query, request, result, node);
break;
case "lexis":
tagHandlerU = new lexis(targetBot, user, query, request, result, node);
break;
case "dbpush":
tagHandlerU = new dbpush(targetBot, user, query, request, result, node);
break;
case "dbquery":
tagHandlerU = new dbquery(targetBot, user, query, request, result, node);
break;
case "dbupdate":
tagHandlerU = new dbupdate(targetBot, user, query, request, result, node);
break;
case "dbdelete":
tagHandlerU = new dbdelete(targetBot, user, query, request, result, node);
break;
case "dbload":
tagHandlerU = new dbload(targetBot, user, query, request, result, node);
break;
case "regex":
tagHandlerU = new regex(targetBot, user, query, request, result, node);
break;
case "bind": // <bind>#$isa</bind>
tagHandlerU = new bind(targetBot, user, query, request, result, node);
break;
case "#text":
if (!liText)
{
return(null);
}
return(new verbatum(node.Value, targetBot, user, query, request, result, node));
case "#comment":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
case "br":
return(new verbatum("\n", targetBot, user, query, request, result, node));
case "pre":
return(new verbatum(StaticXMLUtils.InnerXmlText(node), targetBot, user, query, request, result, node));
case "p":
return(new verbatum("\n\n", targetBot, user, query, request, result, node));
case "meta":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
default:
break;
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (StaticAIMLUtils.IsHtmlTag(node.Name))
{
return(new recursiveVerbatum(node, targetBot, user, query, request, result, node, true));
}
if (tagHandlerU == null)
{
// "bot", "favorite", "fav"
foreach (KeyValuePair <string, string> prefix in new[]
{
new KeyValuePair <string, string>("get_", "get"),
new KeyValuePair <string, string>("set_", "set"),
new KeyValuePair <string, string>("bot_", "bot"),
new KeyValuePair <string, string>("favorite_", "bot"),
new KeyValuePair <string, string>("favorite", "bot"),
new KeyValuePair <string, string>("fav_", "bot"),
new KeyValuePair <string, string>("fav", "bot"),
new KeyValuePair <string, string>("get", "get"),
new KeyValuePair <string, string>("set", "set"),
new KeyValuePair <string, string>("bot", "bot"),
})
{
if (nodeNameLower.StartsWith(prefix.Key) && node.Name.Length > prefix.Key.Length)
{
string name = node.Name.Substring(prefix.Key.Length);
XmlNode pn = node.ParentNode;
LineInfoElementImpl newnode = StaticXMLUtils.CopyNode(prefix.Value, node, false);
XmlAttributeLineInfo atr = (XmlAttributeLineInfo)newnode.OwnerDocument.CreateAttribute("name");
atr.ReadOnly = false;
atr.Value = name;
newnode.Attributes.Append(atr);
if (node.Name.ToLower() != newnode.Name.ToLower())
{
writeToLog("AIMLLOADER: converted " + node.OuterXml + " -> " + newnode.OuterXml);
return(targetBot.GetTagHandler(newnode, query, request, result, user, liText));
}
writeToLog("AIMLLOADER: ! convert " + node.OuterXml + " -> " + newnode.OuterXml);
}
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (nodeNameLower == "name")
{
return(new bot(targetBot, user, query, request, result, node));
}
tagHandlerU = new lazyClosure(targetBot, user, query, request, result, node);
writeToLog("AIMLLOADER: lazyClosure: " + node.OuterXml);
return(tagHandlerU);
}
? new ListView(modelListView, application.CreateCollectionSource(space, objectType, modelView.Id), application, job.SelectedObjectsCriteria)
