Esempio n. 1
0
 public PosArray<CellType> GenerateMap(LevelType type)
 {
     PosArray<CellType> result = new PosArray<CellType>(ROWS,COLS);
     Dungeon d = new Dungeon(ROWS,COLS);
     switch(type){
     case LevelType.Standard:
         while(true){
             d.CreateBasicMap();
             d.ConnectDiagonals();
             d.RemoveUnconnectedAreas();
             d.RemoveDeadEndCorridors();
             d.AddDoors(25);
             d.AlterRooms(5,2,2,1,0);
             d.MarkInterestingLocations();
             d.RemoveUnconnectedAreas();
             if(d.NumberOfFloors() < 320 || d.HasLargeUnusedSpaces(300)){
                 d.Clear();
             }
             else{
                 for(int i=0;i<ROWS;++i){
                     for(int j=0;j<COLS;++j){
                         result[i,j] = d.map[i,j];
                     }
                 }
                 return result;
             }
         }
     case LevelType.Cave:
     {
         int roll = R.Roll(2);
         if(R.OneIn(20)){
             roll = 3;
         }
         switch(roll){ //three different algorithms
         case 1:
         {
             while(true){
                 d.FillWithRandomWalls(25);
                 d.ApplyCellularAutomataXYRule(3);
                 d.ConnectDiagonals();
                 d.ImproveMapEdges(5);
                 d.RemoveDeadEndCorridors();
                 d.RemoveUnconnectedAreas();
                 d.MarkInterestingLocationsNonRectangular();
                 if(d.NumberOfFloors() < 320 || d.HasLargeUnusedSpaces(300)){
                     d.Clear();
                 }
                 else{
                     for(int i=0;i<ROWS;++i){
                         for(int j=0;j<COLS;++j){
                             result[i,j] = d.map[i,j];
                         }
                     }
                     return result;
                 }
             }
         }
         case 2:
         {
             while(true){
                 d.CreateTwistyCave(true,40);
                 U.DefaultMetric = DistanceMetric.Manhattan;
                 var dijk = d.map.GetDijkstraMap(x=>!d.map[x].IsWall(),x=>false);
                 for(int i=1;i<ROWS-1;++i){
                     for(int j=1;j<COLS-1;++j){
                         U.DefaultMetric = DistanceMetric.Manhattan;
                         if(dijk[i,j] == 1){
                             pos p = new pos(i,j);
                             List<pos> floors = null;
                             foreach(int dir in U.FourDirections){
                                 pos n = p.PosInDir(dir);
                                 if(dijk[n] == 1){
                                     if(floors == null){
                                         floors = p.PositionsAtDistance(1,dijk).Where(x=>dijk[x] == 0);
                                     }
                                     List<pos> floors2 = new List<pos>();
                                     foreach(pos n2 in n.PositionsAtDistance(1,dijk)){
                                         if(dijk[n2] == 0 && !floors.Contains(n2)){
                                             floors2.Add(n2);
                                         }
                                     }
                                     if(floors2.Count > 0 && R.OneIn(5)){ //IIRC this checks each pair twice, so that affects the chance here
                                         pos f1 = floors.Random();
                                         pos f2 = floors2.Random();
                                         U.DefaultMetric = DistanceMetric.Chebyshev;
                                         int dist = d.map.PathingDistanceFrom(f1,f2,x=>!d.map[x].IsPassable() && d.map[x] != CellType.Door);
                                         if(dist > 22 || (dist > 8 && R.OneIn(4))){
                                             CellType rubble = R.OneIn(8)? CellType.Rubble : CellType.CorridorIntersection;
                                             d[p] = R.OneIn(3)? rubble : CellType.CorridorIntersection;
                                             d[n] = R.OneIn(3)? rubble : CellType.CorridorIntersection;
                                             List<pos> neighbors = new List<pos>();
                                             foreach(pos nearby in p.PositionsAtDistance(1)){
                                                 if(nearby.BoundsCheck(d.map,false) && nearby.DistanceFrom(n) == 1){
                                                     neighbors.Add(nearby);
                                                 }
                                             }
                                             while(neighbors.Count > 0){
                                                 pos neighbor = neighbors.RemoveRandom();
                                                 if(R.OneIn(neighbors.Count + 3) && !d.SeparatesMultipleAreas(neighbor)){
                                                     d[neighbor] = R.OneIn(2)? CellType.Rubble : CellType.CorridorIntersection;
                                                 }
                                             }
                                         }
                                     }
                                     break;
                                 }
                             }
                         }
                     }
                 }
                 /*List<pos> thin_walls = d.map.AllPositions().Where(x=>d.map[x].IsWall() && x.HasOppositePairWhere(true,y=>y.BoundsCheck() && d.map[y].IsFloor()));
                 while(thin_walls.Count > 0){
                     pos p = thin_walls.Random();
                     foreach(int dir in new int[]{8,4}){
                         if(d.map[p.PosInDir(dir)] != CellType.Wall && d.map[p.PosInDir(dir.RotateDir(true,4))] != CellType.Wall){
                             var dijkstra = d.map.GetDijkstraMap(x=>d[x] == CellType.Wall,new List<pos>{p.PosInDir(dir)}); //todo: this would be better as "get distance"
                             if(Math.Abs(dijkstra[p.PosInDir(dir)] - dijkstra[p.PosInDir(dir.RotateDir(true,4))]) > 30){
                                 d.map[p] = CellType.CorridorIntersection;
                                 break;
                             }
                         }
                     }
                     thin_walls.Remove(p); //todo: move thin-wall-removal to schism
                 }*/
                 d.ConnectDiagonals();
                 d.RemoveUnconnectedAreas();
                 d.ImproveMapEdges(5);
                 d.SmoothCorners(60);
                 d.RemoveDeadEndCorridors();
                 d.MarkInterestingLocationsNonRectangular();
                 if(d.NumberOfFloors() < 320 || d.HasLargeUnusedSpaces(300)){
                     d.Clear();
                 }
                 else{
                     for(int i=0;i<ROWS;++i){
                         for(int j=0;j<COLS;++j){
                             result[i,j] = d.map[i,j];
                         }
                     }
                     U.DefaultMetric = DistanceMetric.Chebyshev;
                     return result;
                 }
             }
         }
         case 3:
         {
             d.RoomHeightMax = 3;
             d.RoomWidthMax = 3;
             while(true){
                 int successes = 0;
                 int consecutive_failures = 0;
                 while(successes < 13){
                     if(d.CreateRoom()){
                         ++successes;
                         consecutive_failures = 0;
                     }
                     else{
                         if(consecutive_failures++ >= 50){
                             d.Clear();
                             successes = 0;
                             consecutive_failures = 0;
                         }
                     }
                 }
                 d.CaveWidenRooms(100,50);
                 d.AddRockFormations(40,2);
                 List<pos> thin_walls = d.map.AllPositions().Where(x=>d.map[x].IsWall() && x.HasOppositePairWhere(true,y=>y.BoundsCheck(tile) && d.map[y].IsFloor()));
                 while(!d.IsFullyConnected() && thin_walls.Count > 0){
                     pos p = thin_walls.Random();
                     d.map[p] = CellType.CorridorIntersection;
                     foreach(pos neighbor in p.PositionsWithinDistance(1,d.map)){
                         thin_walls.Remove(neighbor);
                     }
                 }
                 d.ConnectDiagonals();
                 d.RemoveDeadEndCorridors();
                 d.RemoveUnconnectedAreas();
                 d.MarkInterestingLocationsNonRectangular();
                 if(d.NumberOfFloors() < 320 || d.HasLargeUnusedSpaces(300)){ //todo: add 'proper coverage' check here - make sure it stretches across enough of the map.
                     d.Clear();
                 }
                 else{
                     for(int i=0;i<ROWS;++i){
                         for(int j=0;j<COLS;++j){
                             result[i,j] = d.map[i,j];
                         }
                     }
                     return result;
                 }
             }
         }
         }
         break;
     }
     case LevelType.Hive:
     {
         d.RoomHeightMax = 3;
         d.RoomWidthMax = 3;
         while(true){
             int successes = 0;
             int consecutive_failures = 0;
             while(successes < 35){
                 if(d.CreateRoom()){
                     ++successes;
                     consecutive_failures = 0;
                 }
                 else{
                     if(consecutive_failures++ >= 40){
                         d.Clear();
                         successes = 0;
                         consecutive_failures = 0;
                     }
                 }
             }
             d.CaveWidenRooms(100,10);
             d.CaveWidenRooms(3,20);
             List<pos> thin_walls = d.map.AllPositions().Where(x=>d.map[x].IsWall() && x.HasOppositePairWhere(true,y=>y.BoundsCheck(tile) && d.map[y].IsFloor()));
             while(!d.IsFullyConnected() && thin_walls.Count > 0){
                 pos p = thin_walls.Random();
                 d.map[p] = CellType.CorridorIntersection;
                 foreach(pos neighbor in p.PositionsWithinDistance(2,d.map)){
                     thin_walls.Remove(neighbor);
                 }
             }
             d.ConnectDiagonals();
             d.RemoveDeadEndCorridors();
             d.RemoveUnconnectedAreas();
             d.MarkInterestingLocations();
             //to find rooms big enough for stuff in the center:
         //var dijkstra = d.map.GetDijkstraMap(x=>d.map[x].IsWall(),d.map.AllPositions().Where(x=>d.map[x].IsWall() && x.HasAdjacentWhere(y=>d.map.BoundsCheck(y) && !d.map[y].IsWall())));
             if(d.NumberOfFloors() < 340 || d.HasLargeUnusedSpaces(300)){ //todo: add 'proper coverage' check here - make sure it stretches across enough of the map.
                 d.Clear();
             }
             else{
                 for(int i=0;i<ROWS;++i){
                     for(int j=0;j<COLS;++j){
                         result[i,j] = d.map[i,j];
                     }
                 }
                 return result;
             }
         }
     }
     case LevelType.Mine:
     {
         d.CorridorExtraLengthChance = 0;
         d.CorridorChainSizeMax = 10;
         while(true){
             d.RoomHeightMin = 8;
             d.RoomWidthMin = 8;
             d.RoomHeightMax = 8;
             d.RoomWidthMax = 10;
             d.MinimumSpaceBetweenCorridors = 3;
             d.CorridorLengthMin = 3;
             d.CorridorLengthMax = 5;
             while(!d.CreateRoom()){}
             d.RoomHeightMin = 5;
             d.RoomWidthMin = 5;
             d.RoomHeightMax = 5;
             d.RoomWidthMax = 5;
             while(!d.CreateRoom()){}
             while(!d.CreateRoom()){}
             /*for(int i=0;i<10;++i){
                 d.CreateRoom();
             }
             d.AddRockFormations(100,2);*/
             d.MinimumSpaceBetweenCorridors = 5;
             d.CorridorLengthMin = 4;
             d.CorridorLengthMax = 12;
             for(int i=0;i<70;++i){
                 d.CreateCorridor();
             }
             d.CorridorLengthMin = 3;
             d.CorridorLengthMax = 5;
             d.MinimumSpaceBetweenCorridors = 3;
             for(int i=0;i<350;++i){
                 d.CreateCorridor();
             }
             d.RemoveUnconnectedAreas();
             d.ConnectDiagonals(true);
             d.RemoveUnconnectedAreas();
             d.MarkInterestingLocations();
             if(d.NumberOfFloors() < 250 || d.HasLargeUnusedSpaces(300)){
                 d.Clear();
             }
             else{
                 for(int i=0;i<ROWS;++i){
                     for(int j=0;j<COLS;++j){
                         result[i,j] = d.map[i,j];
                     }
                 }
                 return result;
             }
         }
     }
     case LevelType.Fortress:
         while(true){
             int H = ROWS;
             int W = COLS;
             for(int i=H/2-1;i<H/2+1;++i){
                 for(int j=1;j<W-1;++j){
                     if(j==1 || j==W-2){
                         d.map[i,j] = CellType.RoomCorner;
                     }
                     else{
                         d.map[i,j] = CellType.RoomEdge;
                     }
                 }
             }
             for(int i=0;i<700;++i){
                 if(R.OneIn(5)){
                     d.CreateCorridor();
                 }
                 else{
                     d.CreateRoom();
                 }
             }
             bool reflect_features = R.PercentChance(80);
             if(reflect_features){
                 d.AddDoors(25);
                 d.AddPillars(30);
             }
             d.Reflect(true,false);
             d.ConnectDiagonals();
             d.RemoveDeadEndCorridors();
             d.RemoveUnconnectedAreas();
             if(!reflect_features){
                 d.AddDoors(25);
                 d.AddPillars(30);
             }
             bool door_right = false;
             bool door_left = false;
             int rightmost_door = 0;
             int leftmost_door = 999;
             for(int j=0;j<22;++j){
                 if(d[H/2-2,j].IsCorridorType()){
                     door_left = true;
                     if(leftmost_door == 999){
                         leftmost_door = j;
                     }
                 }
                 if(d[H/2-2,W-1-j].IsCorridorType()){
                     door_right = true;
                     if(rightmost_door == 0){
                         rightmost_door = W-1-j;
                     }
                 }
             }
             if(!door_left || !door_right){
                 d.Clear();
                 continue;
             }
             for(int j=1;j<leftmost_door-6;++j){
                 d[H/2-1,j] = CellType.Wall;
                 d[H/2,j] = CellType.Wall;
             }
             for(int j=W-2;j>rightmost_door+6;--j){
                 d[H/2-1,j] = CellType.Wall;
                 d[H/2,j] = CellType.Wall;
             }
             for(int j=1;j<W-1;++j){
                 if(d[H/2-1,j].IsFloor()){
                     d[H/2-1,j] = CellType.Statue;
                     d[H/2,j] = CellType.Statue;
                     break;
                 }
                 else{
                     if(d[H/2-1,j] == CellType.Statue){
                         break;
                     }
                 }
             }
             for(int j=W-2;j>0;--j){
                 if(d[H/2-1,j].IsFloor()){
                     d[H/2-1,j] = CellType.Statue;
                     d[H/2,j] = CellType.Statue;
                     break;
                 }
                 else{
                     if(d[H/2-1,j] == CellType.Statue){
                         break;
                     }
                 }
             }
             for(int i=H/2-1;i<H/2+1;++i){
                 for(int j=1;j<W-1;++j){
                     if(d[i,j] == CellType.RoomCorner || d[i,j] == CellType.RoomEdge){
                         d[i,j] = CellType.CorridorIntersection;
                     }
                 }
             }
             d.MarkInterestingLocations();
             if(d.NumberOfFloors() < 420 || d.HasLargeUnusedSpaces(300)){
                 d.Clear();
             }
             else{
                 for(int i=0;i<ROWS;++i){
                     for(int j=0;j<COLS;++j){
                         result[i,j] = d.map[i,j];
                     }
                 }
                 return result;
             }
         }
     case LevelType.Slime:
         while(true){
             /*for(int i=1;i<ROWS-1;++i){
                 for(int j=1;j<COLS-1;++j){
                     if(d[i,j].IsWall()){
                         if(!d[i+1,j+1].IsWall()){
                             d[i,j] = d[i+1,j+1];
                         }
                         else{
                             if(!d[i+1,j].IsWall()){
                                 d[i,j] = d[i+1,j];
                             }
                             else{
                                 if(!d[i,j+1].IsWall()){
                                     d[i,j] = d[i,j+1];
                                 }
                             }
                         }
                     }
                 }
             }*/
             d.CreateBasicMap();
             d.ConnectDiagonals();
             d.RemoveUnconnectedAreas();
             d.AddDoors(25);
             d.CaveWidenRooms(30,30);
             d.RemoveDeadEndCorridors();
             d.AddPillars(30);
             d.MarkInterestingLocations();
             if(d.NumberOfFloors() < 120 || d.HasLargeUnusedSpaces(300)){
                 d.Clear();
             }
             else{
                 for(int i=0;i<ROWS;++i){
                     for(int j=0;j<COLS;++j){
                         result[i,j] = d.map[i,j];
                     }
                 }
                 return result;
             }
         }
     case LevelType.Garden:
     {
         d.RoomHeightMin = 4;
         d.RoomHeightMax = 10;
         d.RoomWidthMin = 4;
         d.RoomWidthMax = 10;
         while(true){
             d.CreateBasicMap();
             d.ConnectDiagonals();
             d.RemoveUnconnectedAreas();
             d.RemoveDeadEndCorridors();
             var dijkstra = d.map.GetDijkstraMap(x=>d[x].IsPassable(),x=>false);
             List<pos> possible_room_centers = d.map.PositionsWhere(x=>dijkstra[x] == 3 && x.row > 1 && x.row < ROWS-2 && x.col > 1 && x.col < COLS-2);
             int rooms = 0;
             while(rooms < 6 && possible_room_centers.Count > 0){
                 pos p = possible_room_centers.RemoveRandom();
                 List<int> valid_dirs = new List<int>();
                 foreach(int dir in U.FourDirections){
                     pos p2 = p.PosInDir(dir).PosInDir(dir).PosInDir(dir);
                     if(p2.BoundsCheck(d.map) && d[p2].IsPassable() && d[p2] != CellType.RoomCorner){
                         valid_dirs.Add(dir);
                     }
                 }
                 if(valid_dirs.Count > 0){
                     foreach(pos neighbor in p.PositionsWithinDistance(1,d.map)){
                         d[neighbor] = CellType.RoomInterior;
                     }
                     possible_room_centers.RemoveWhere(x=>p.DistanceFrom(x) <= 3);
                     foreach(int dir in valid_dirs){
                         d[p.PosInDir(dir).PosInDir(dir)] = CellType.CorridorIntersection;
                     }
                     ++rooms;
                 }
             }
             CellType water_type = CellType.ShallowWater;
             if(R.OneIn(8)){
                 water_type = CellType.Ice;
             }
             d.ForEachRectangularRoom((start_r,start_c,end_r,end_c)=>{
                 int room_height = (end_r - start_r) + 1;
                 int room_width = (end_c - start_c) + 1;
                 if(room_height <= 4 && room_width <= 4){
                     if(room_height == 3 && room_width == 3){
                         return true;
                     }
                     List<pos> water = new List<pos>();
                     if(!new pos(start_r+1,start_c).PositionsAtDistance(1,d.map).Any(x=>d[x].IsCorridorType())){
                         water.Add(new pos(start_r+1,start_c));
                         water.Add(new pos(start_r+2,start_c));
                     }
                     if(!new pos(start_r,start_c+1).PositionsAtDistance(1,d.map).Any(x=>d[x].IsCorridorType())){
                         water.Add(new pos(start_r,start_c+1));
                         water.Add(new pos(start_r,start_c+2));
                     }
                     if(!new pos(end_r-1,end_c).PositionsAtDistance(1,d.map).Any(x=>d[x].IsCorridorType())){
                         water.Add(new pos(end_r-1,end_c));
                         water.Add(new pos(end_r-2,end_c));
                     }
                     if(!new pos(end_r,end_c-1).PositionsAtDistance(1,d.map).Any(x=>d[x].IsCorridorType())){
                         water.Add(new pos(end_r,end_c-1));
                         water.Add(new pos(end_r,end_c-2));
                     }
                     foreach(pos p in water){
                         d[p] = water_type;
                     }
                     d[start_r,start_c] = CellType.Statue;
                     d[start_r,end_c] = CellType.Statue;
                     d[end_r,start_c] = CellType.Statue;
                     d[end_r,end_c] = CellType.Statue;
                 }
                 else{
                     CellType center_type = CellType.RoomFeature1;
                     switch(R.Roll(3)){
                     case 1:
                         center_type = water_type;
                         break;
                     case 2:
                         center_type = CellType.Poppies;
                         break;
                     case 3:
                         center_type = CellType.Brush;
                         break;
                     }
                     bool statues = R.CoinFlip();
                     CellType statue_type = CellType.Statue;
                     if(room_height <= 8 && room_width <= 8 && R.OneIn(8)){
                         statue_type = CellType.Torch;
                     }
                     CellType edge_type = CellType.ShallowWater;
                     if(center_type != water_type && !R.OneIn(4)){
                         edge_type = CellType.ShallowWater;
                     }
                     else{
                         int vine_chance = 50;
                         if(!statues){
                             vine_chance = 80;
                         }
                         if(R.PercentChance(vine_chance)){
                             edge_type = CellType.Vine;
                         }
                         else{
                             edge_type = CellType.Gravel;
                         }
                         if(R.OneIn(32)){
                             if(R.CoinFlip()){
                                 edge_type = CellType.Statue;
                             }
                             else{
                                 edge_type = CellType.GlowingFungus;
                             }
                         }
                     }
                     bool gravel = R.OneIn(16);
                     bool edges = R.CoinFlip();
                     if(room_height < 6 || room_width < 6){
                         edges = false;
                     }
                     if(room_height >= 8 && room_width >= 8){
                         edges = !R.OneIn(4);
                     }
                     if(edges){
                         for(int i=start_r;i<=end_r;++i){
                             for(int j=start_c;j<=end_c;++j){
                                 if(i == start_r || i == end_r || j == start_c || j == end_c){ //edges
                                     if(statues && (i == start_r || i == end_r) && (j == start_c || j == end_c)){ //corners
                                         d[i,j] = statue_type;
                                     }
                                     else{
                                         pos p = new pos(i,j);
                                         if(!p.CardinalAdjacentPositions().Any(x=>d[x].IsCorridorType())){
                                             d[i,j] = edge_type;
                                         }
                                     }
                                 }
                                 else{
                                     if(i == start_r+1 || i == end_r-1 || j == start_c+1 || j == end_c-1){ //the path
                                         if(gravel){
                                             d[i,j] = CellType.Gravel;
                                         }
                                     }
                                     else{
                                         d[i,j] = center_type;
                                     }
                                 }
                             }
                         }
                     }
                     else{
                         for(int i=start_r;i<=end_r;++i){
                             for(int j=start_c;j<=end_c;++j){
                                 if(i == start_r || i == end_r || j == start_c || j == end_c){
                                     if(gravel){
                                         d[i,j] = CellType.Gravel;
                                     }
                                 }
                                 else{
                                     d[i,j] = center_type;
                                 }
                             }
                         }
                     }
                     if(center_type == water_type && room_height % 2 == 1 && room_width % 2 == 1){
                         statue_type = CellType.Statue;
                         if(room_height <= 7 && room_width <= 7 && R.OneIn(12)){
                             statue_type = CellType.Torch;
                         }
                         d[(start_r+end_r)/2,(start_c+end_c)/2] = statue_type;
                     }
                 }
                 return true;
             });
             d.ConnectDiagonals();
             d.RemoveUnconnectedAreas();
             d.AddDoors(10);
             d.RemoveDeadEndCorridors();
             d.MarkInterestingLocations();
             if(d.NumberOfFloors() < 320 || d.HasLargeUnusedSpaces(300)){
                 d.Clear();
             }
             else{
                 for(int i=0;i<ROWS;++i){
                     for(int j=0;j<COLS;++j){
                         result[i,j] = d.map[i,j];
                     }
                 }
                 return result;
             }
         }
     }
     case LevelType.Crypt:
     {
         while(true){
             pos room1origin = new pos(ROWS/2,R.Roll(COLS/8 - 1) + COLS/8 - 1);
             pos room2origin = new pos(ROWS/2,R.Roll(COLS/8 - 1) + (COLS*6 / 8) - 1);
             while(!d.CreateRoom(room1origin.row,room1origin.col)){} //left half
             while(!d.CreateRoom(room2origin.row,room2origin.col)){} //right half
             d.CaveWidenRooms(100,150);
             d.MoveRoom(room1origin,4);
             d.MoveRoom(room2origin,6);
             var dijkstra = d.map.GetDijkstraMap(x=>d.map[x] == CellType.Wall,x=>false); //todo: among these Map dijkstra maps I have, like, 3 different ways of testing for walls. are these all correct?
             int distance_from_walls = 3;
             List<pos> central_room = d.map.PositionsWhere(x=>dijkstra[x] > distance_from_walls);
             int required_consecutive = 3;
             for(int i=0;i<ROWS;++i){ //first, check each row...
                 for(int j=0;j<COLS;++j){
                     List<pos> this_row = new List<pos>();
                     while(j < COLS && dijkstra[i,j] > distance_from_walls){
                         this_row.Add(new pos(i,j));
                         ++j;
                     }
                     if(this_row.Count < required_consecutive){
                         foreach(pos p in this_row){
                             central_room.Remove(p);
                         }
                     }
                 }
             }
             for(int j=0;j<COLS;++j){ //...then each column
                 for(int i=0;i<ROWS;++i){
                     List<pos> this_col = new List<pos>();
                     while(i < ROWS && dijkstra[i,j] > distance_from_walls){
                         this_col.Add(new pos(i,j));
                         ++i;
                     }
                     if(this_col.Count < required_consecutive){
                         foreach(pos p in this_col){
                             central_room.Remove(p);
                         }
                     }
                 }
             }
             central_room = d.map.GetFloodFillPositions(central_room.Where(x=>x.PositionsWithinDistance(1).All(y=>central_room.Contains(y))),false,x=>central_room.Contains(x));
             List<pos> walls = new List<pos>();
             foreach(pos p in central_room){
                 d.map[p] = CellType.InterestingLocation;
                 foreach(pos neighbor in p.PositionsAtDistance(1,d.map)){
                     if(!central_room.Contains(neighbor)){
                         d.map[neighbor] = CellType.Wall;
                         walls.Add(neighbor);
                     }
                 }
             }
             while(true){
                 List<pos> potential_doors = new List<pos>();
                 foreach(pos p in walls){
                     foreach(int dir in U.FourDirections){
                         if(d.map[p.PosInDir(dir)] == CellType.InterestingLocation && d.map[p.PosInDir(dir.RotateDir(true,4))].IsRoomType() && d.map[p.PosInDir(dir.RotateDir(true,4))] != CellType.InterestingLocation){
                             potential_doors.Add(p);
                             break;
                         }
                     }
                 }
                 if(potential_doors.Count > 0){
                     pos p = potential_doors.Random();
                     d.map[p] = CellType.Door;
                     List<pos> room = d.map.GetFloodFillPositions(p,true,x=>d.map[x] == CellType.InterestingLocation);
                     foreach(pos p2 in room){
                         d.map[p2] = CellType.RoomInterior;
                     }
                 }
                 else{
                     break;
                 }
             }
             dijkstra = d.map.GetDijkstraMap(x=>d.map[x] == CellType.Wall,x=>false);
             int num_chests = 0;
             d.ForEachRoom(list=>{
                 if(central_room.Contains(list[0])){
                     if(num_chests++ < 2){
                         d[list.Random()] = CellType.Chest;
                     }
                     return true;
                 }
                 List<pos> room = list.Where(x=>dijkstra[x] > 1);
                 int start_r = room.WhereLeast(x=>x.row)[0].row;
                 int end_r = room.WhereGreatest(x=>x.row)[0].row;
                 int start_c = room.WhereLeast(x=>x.col)[0].col;
                 int end_c = room.WhereGreatest(x=>x.col)[0].col;
                 List<List<pos>> offsets = new List<List<pos>>();
                 for(int i=0;i<4;++i){
                     offsets.Add(new List<pos>());
                 }
                 for(int i=start_r;i<=end_r;i+=2){
                     for(int j=start_c;j<=end_c;j+=2){
                         if(room.Contains(new pos(i,j))){
                             offsets[0].Add(new pos(i,j));
                         }
                         if(i+1 <= end_r && room.Contains(new pos(i+1,j))){
                             offsets[1].Add(new pos(i+1,j));
                         }
                         if(j+1 <= end_c && room.Contains(new pos(i,j+1))){
                             offsets[2].Add(new pos(i,j+1));
                         }
                         if(i+1 <= end_r && j+1 <= end_c && room.Contains(new pos(i+1,j+1))){
                             offsets[3].Add(new pos(i+1,j+1));
                         }
                     }
                 }
                 List<pos> tombstones = offsets.WhereGreatest(x=>x.Count).RandomOrDefault();
                 if(tombstones != null){
                     foreach(pos p in tombstones){
                         d.map[p] = CellType.Tombstone;
                     }
                 }
                 return true;
             });
             for(int i=0;i<ROWS;++i){
                 for(int j=0;j<COLS;++j){
                     if(d[i,j] == CellType.Door){
                         pos p = new pos(i,j);
                         List<pos> potential_statues = p.PositionsAtDistance(1,d.map).Where(x=>!d[x].IsWall() && !central_room.Contains(x) && p.DirectionOf(x) % 2 != 0 && !x.PositionsAtDistance(1,d.map).Any(y=>d[y].Is(CellType.Tombstone)));
                         if(potential_statues.Count == 2){
                             d[potential_statues[0]] = CellType.Statue;
                             d[potential_statues[1]] = CellType.Statue;
                         }
                     }
                 }
             }
             List<pos> room_one = null;
             List<pos> room_two = null;
             for(int j=0;j<COLS && room_one == null;++j){
                 for(int i=0;i<ROWS;++i){
                     if(d[i,j] != CellType.Wall){
                         room_one = d.map.GetFloodFillPositions(new pos(i,j),false,x=>!d[x].IsWall());
                         break;
                     }
                 }
             }
             for(int j=COLS-1;j>=0 && room_two == null;--j){
                 for(int i=0;i<ROWS;++i){
                     if(d[i,j] != CellType.Wall){
                         room_two = d.map.GetFloodFillPositions(new pos(i,j),false,x=>!d[x].IsWall());
                         break;
                     }
                 }
             }
             if(room_one.WhereGreatest(x=>x.col).Random().DistanceFrom(room_two.WhereLeast(x=>x.col).Random()) < 12){
                 d.Clear();
                 continue;
             }
             Dungeon d2 = new Dungeon(ROWS,COLS);
             int tries = 0;
             while(tries < 10){
                 d2.CreateBasicMap();
                 d2.ConnectDiagonals();
                 for(int i=0;i<ROWS;++i){
                     for(int j=0;j<COLS;++j){
                         if(d[i,j] != CellType.Wall){
                             pos p = new pos(i,j);
                             foreach(pos neighbor in p.PositionsAtDistance(1,d2.map)){
                                 d2[neighbor] = CellType.Wall;
                             }
                         }
                     }
                 }
                 d2.RemoveUnconnectedAreas();
                 List<pos> room_one_walls = new List<pos>();
                 List<pos> room_two_walls = new List<pos>();
                 for(int i=0;i<ROWS;++i){
                     for(int j=COLS-1;j>=0;--j){
                         pos p = new pos(i,j);
                         if(room_one.Contains(p)){
                             room_one_walls.Add(p);
                             break;
                         }
                     }
                     for(int j=0;j<COLS;++j){
                         pos p = new pos(i,j);
                         if(room_two.Contains(p)){
                             room_two_walls.Add(p);
                             break;
                         }
                     }
                 }
                 List<pos> room_one_valid_connections = new List<pos>();
                 List<pos> room_two_valid_connections = new List<pos>();
                 foreach(pos p in room_one_walls){
                     pos next = p.PosInDir(6);
                     while(BoundsCheck(next) && p.DistanceFrom(next) < 7){
                         if(d2[next] != CellType.Wall){
                             room_one_valid_connections.Add(p.PosInDir(6));
                             break;
                         }
                         next = next.PosInDir(6);
                     }
                 }
                 foreach(pos p in room_two_walls){
                     pos next = p.PosInDir(4);
                     while(BoundsCheck(next) && p.DistanceFrom(next) < 7){
                         if(d2[next] != CellType.Wall){
                             room_two_valid_connections.Add(p.PosInDir(4));
                             break;
                         }
                         next = next.PosInDir(4);
                     }
                 }
                 if(room_one_valid_connections.Count > 0 && room_two_valid_connections.Count > 0){
                     pos one = room_one_valid_connections.Random();
                     while(true){
                         if(d2[one] == CellType.Wall){
                             d2[one] = CellType.CorridorHorizontal;
                         }
                         else{
                             break;
                         }
                         one = one.PosInDir(6);
                     }
                     pos two = room_two_valid_connections.Random();
                     while(true){
                         if(d2[two] == CellType.Wall){
                             d2[two] = CellType.CorridorHorizontal;
                         }
                         else{
                             break;
                         }
                         two = two.PosInDir(4);
                     }
                     break;
                 }
                 else{
                     d2.Clear();
                 }
                 ++tries;
             }
             if(tries == 10){
                 d.Clear();
                 continue;
             }
             for(int i=0;i<ROWS;++i){
                 for(int j=0;j<COLS;++j){
                     if(d2[i,j] != CellType.Wall){
                         d[i,j] = d2[i,j];
                     }
                 }
             }
             //d.CaveWidenRooms(100,20);
             //d.MakeCavesMoreRectangular(4);
             //d.RemoveDeadEndCorridors();
             //d.MakeCavesMoreRectangular(1 + num++ / 10);
             //d.Clear();
             //continue;
             d.ConnectDiagonals();
             d.RemoveUnconnectedAreas();
             d.RemoveDeadEndCorridors();
             d.MarkInterestingLocations();
             d.RemoveUnconnectedAreas();
             if(d.NumberOfFloors() < 340 || d.HasLargeUnusedSpaces(350)){
                 d.Clear();
             }
             else{
                 for(int i=0;i<ROWS;++i){
                     for(int j=0;j<COLS;++j){
                         result[i,j] = d.map[i,j];
                     }
                 }
                 return result;
             }
         }
         }
     }
     return null;
 }
Esempio n. 2
0
 public void ActiveAI()
 {
     if(path.Count > 0){
         path.Clear();
     }
     if(!HasAttr(AttrType.AGGRESSION_MESSAGE_PRINTED)){
         PrintAggressionMessage();
     }
     switch(type){
     case ActorType.GIANT_BAT:
     case ActorType.PHANTOM_BLIGHTWING:
         if(DistanceFrom(target) == 1){
             int idx = R.Roll(1,2) - 1;
             Attack(idx,target);
             if(target != null && R.CoinFlip()){ //chance of retreating
                 AI_Step(target,true);
             }
         }
         else{
             if(R.CoinFlip()){
                 AI_Step(target);
                 QS();
             }
             else{
                 AI_Step(TileInDirection(Global.RandomDirection()));
                 QS();
             }
         }
         break;
     case ActorType.BLOOD_MOTH:
     {
         Tile brightest = null;
         if(!M.wiz_dark && !M.wiz_lite && !HasAttr(AttrType.BLIND)){
             List<Tile> valid = M.AllTiles().Where(x=>x.light_value > 0 && CanSee(x));
             valid = valid.WhereGreatest(x=>{
                 int result = x.light_radius;
                 if(x.Is(FeatureType.FIRE) && result == 0){
                     result = 1;
                 }
                 if(x.inv != null && x.inv.light_radius > result){
                     result = x.inv.light_radius;
                 }
                 if(x.actor() != null && x.actor().LightRadius() > result){
                     result = x.actor().LightRadius();
                 }
                 return result;
             });
             valid = valid.WhereLeast(x=>DistanceFrom(x));
             if(valid.Count > 0){
                 brightest = valid.RandomOrDefault();
             }
         }
         if(brightest != null){
             if(DistanceFrom(brightest) <= 1){
                 if(target != null && brightest == target.tile()){
                     Attack(0,target);
                     if(target == player && player.curhp > 0){
                         Help.TutorialTip(TutorialTopic.Torch);
                     }
                 }
                 else{
                     List<Tile> open = new List<Tile>();
                     foreach(Tile t in TilesAtDistance(1)){
                         if(t.DistanceFrom(brightest) <= 1 && t.passable && t.actor() == null){
                             open.Add(t);
                         }
                     }
                     if(open.Count > 0){
                         AI_Step(open.Random());
                     }
                     QS();
                 }
             }
             else{
                 List<Tile> tiles = new List<Tile>();
                 if(brightest.row == row || brightest.col == col){
                     int targetdir = DirectionOf(brightest);
                     for(int i=-1;i<=1;++i){
                         pos adj = p.PosInDir(targetdir.RotateDir(true,i));
                         if(M.tile[adj].passable && M.actor[adj] == null){
                             tiles.Add(M.tile[adj]);
                         }
                     }
                 }
                 if(tiles.Count > 0){
                     AI_Step(tiles.Random());
                 }
                 else{
                     AI_Step(brightest);
                 }
                 QS();
             }
         }
         else{
             int dir = Global.RandomDirection();
             if(!TileInDirection(dir).passable && TilesAtDistance(1).Where(t => !t.passable).Count > 4){
                 dir = Global.RandomDirection();
             }
             if(TileInDirection(dir).passable && ActorInDirection(dir) == null){
                 AI_Step(TileInDirection(dir));
                 QS();
             }
             else{
                 if(curhp < maxhp && target != null && ActorInDirection(dir) == target){
                     Attack(0,target);
                 }
                 else{
                     if(player.HasLOS(TileInDirection(dir)) && player.HasLOS(this)){
                         if(!TileInDirection(dir).passable){
                             B.Add(the_name + " brushes up against " + TileInDirection(dir).the_name + ". ",this);
                         }
                         else{
                             if(ActorInDirection(dir) != null){
                                 B.Add(the_name + " brushes up against " + ActorInDirection(dir).TheName(true) + ". ",this);
                             }
                         }
                     }
                     QS();
                 }
             }
         }
         /*PhysicalObject brightest = null;
         if(!M.wiz_lite && !M.wiz_dark){
             List<PhysicalObject> current_brightest = new List<PhysicalObject>();
             foreach(Tile t in M.AllTiles()){
                 int pos_radius = t.light_radius;
                 PhysicalObject pos_obj = t;
                 if(t.Is(FeatureType.FIRE) && pos_radius == 0){
                     pos_radius = 1;
                 }
                 if(t.inv != null && t.inv.light_radius > pos_radius){
                     pos_radius = t.inv.light_radius;
                     pos_obj = t.inv;
                 }
                 if(t.actor() != null && t.actor().LightRadius() > pos_radius){
                     pos_radius = t.actor().LightRadius();
                     pos_obj = t.actor();
                 }
                 if(pos_radius > 0){
                     if(current_brightest.Count == 0 && CanSee(t)){
                         current_brightest.Add(pos_obj);
                     }
                     else{
                         foreach(PhysicalObject o in current_brightest){
                             int object_radius = o.light_radius;
                             if(o is Actor){
                                 object_radius = (o as Actor).LightRadius();
                             }
                             if(object_radius == 0 && o is Tile && (o as Tile).Is(FeatureType.FIRE)){
                                 object_radius = 1;
                             }
                             if(pos_radius > object_radius){
                                 if(CanSee(t)){
                                     current_brightest.Clear();
                                     current_brightest.Add(pos_obj);
                                     break;
                                 }
                             }
                             else{
                                 if(pos_radius == object_radius && DistanceFrom(t) < DistanceFrom(o)){
                                     if(CanSee(t)){
                                         current_brightest.Clear();
                                         current_brightest.Add(pos_obj);
                                         break;
                                     }
                                 }
                                 else{
                                     if(pos_radius == object_radius && DistanceFrom(t) == DistanceFrom(o) && pos_obj == player){
                                         if(CanSee(t)){
                                             current_brightest.Clear();
                                             current_brightest.Add(pos_obj);
                                             break;
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
             if(current_brightest.Count > 0){
                 brightest = current_brightest.Random();
             }
         }
         if(brightest != null){
             if(DistanceFrom(brightest) <= 1){
                 if(brightest == target){
                     Attack(0,target);
                     if(target == player && player.curhp > 0){
                         Help.TutorialTip(TutorialTopic.Torch);
                     }
                 }
                 else{
                     List<Tile> open = new List<Tile>();
                     foreach(Tile t in TilesAtDistance(1)){
                         if(t.DistanceFrom(brightest) <= 1 && t.passable && t.actor() == null){
                             open.Add(t);
                         }
                     }
                     if(open.Count > 0){
                         AI_Step(open.Random());
                     }
                     QS();
                 }
             }
             else{
                 AI_Step(brightest);
                 QS();
             }
         }
         else{
             int dir = Global.RandomDirection();
             if(TilesAtDistance(1).Where(t => !t.passable).Count > 4 && !TileInDirection(dir).passable){
                 dir = Global.RandomDirection();
             }
             if(TileInDirection(dir).passable && ActorInDirection(dir) == null){
                 AI_Step(TileInDirection(dir));
                 QS();
             }
             else{
                 if(curhp < maxhp && target != null && ActorInDirection(dir) == target){
                     Attack(0,target);
                 }
                 else{
                     if(player.HasLOS(TileInDirection(dir)) && player.HasLOS(this)){
                         if(!TileInDirection(dir).passable){
                             B.Add(the_name + " brushes up against " + TileInDirection(dir).the_name + ". ",this);
                         }
                         else{
                             if(ActorInDirection(dir) != null){
                                 B.Add(the_name + " brushes up against " + ActorInDirection(dir).TheName(true) + ". ",this);
                             }
                         }
                     }
                     QS();
                 }
             }
         }*/
         break;
     }
     case ActorType.CARNIVOROUS_BRAMBLE:
     case ActorType.MUD_TENTACLE:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
             if(target == player && player.curhp > 0){
                 Help.TutorialTip(TutorialTopic.RangedAttacks);
             }
         }
         else{
             QS();
         }
         break;
     case ActorType.FROSTLING:
     {
         if(DistanceFrom(target) == 1){
             if(R.CoinFlip()){
                 Attack(0,target);
             }
             else{
                 if(AI_Step(target,true)){
                     QS();
                 }
                 else{
                     Attack(0,target);
                 }
             }
         }
         else{
             if(FirstActorInLine(target) == target && !HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 6){
                 int cooldown = R.Roll(1,4);
                 if(cooldown != 1){
                     RefreshDuration(AttrType.COOLDOWN_1,cooldown*100);
                 }
                 AnimateBoltProjectile(target,Color.RandomIce);
                 if(R.CoinFlip()){
                     B.Add(TheName(true) + " hits " + target.the_name + " with a blast of cold. ",target);
                     target.TakeDamage(DamageType.COLD,DamageClass.PHYSICAL,R.Roll(2,6),this,"a frostling");
                 }
                 else{
                     B.Add(TheName(true) + " misses " + target.the_name + " with a blast of cold. ",target);
                 }
                 foreach(Tile t in GetBestLineOfEffect(target)){
                     t.ApplyEffect(DamageType.COLD);
                 }
                 Q1();
             }
             else{
                 if(!HasAttr(AttrType.COOLDOWN_2)){
                     AI_Step(target);
                 }
                 else{
                     AI_Sidestep(target); //message for this? hmm.
                 }
                 QS();
             }
         }
         break;
     }
     case ActorType.SWORDSMAN:
     case ActorType.PHANTOM_SWORDMASTER:
         if(DistanceFrom(target) == 1){
             pos target_pos = target.p;
             Attack(0,target);
             if(target != null && target.p.Equals(target_pos)){
                 List<Tile> valid_dirs = new List<Tile>();
                 foreach(Tile t in target.TilesAtDistance(1)){
                     if(t.passable && t.actor() == null && DistanceFrom(t) == 1){
                         valid_dirs.Add(t);
                     }
                 }
                 if(valid_dirs.Count > 0){
                     AI_Step(valid_dirs.Random());
                 }
             }
         }
         else{
             attrs[AttrType.COMBO_ATTACK] = 0;
             AI_Step(target);
             QS();
         }
         break;
     case ActorType.DREAM_WARRIOR:
         if(DistanceFrom(target) == 1){
             if(curhp <= 10 && !HasAttr(AttrType.COOLDOWN_1)){ //todo: changed to 20hp and a 10hp threshold...better?
                 attrs[AttrType.COOLDOWN_1]++;
                 List<Tile> openspaces = new List<Tile>();
                 foreach(Tile t in target.TilesAtDistance(1)){
                     if(t.passable && t.actor() == null){
                         openspaces.Add(t);
                     }
                 }
                 foreach(Tile t in openspaces){
                     if(group == null){
                         group = new List<Actor>{this};
                     }
                     Create(ActorType.DREAM_WARRIOR_CLONE,t.row,t.col,TiebreakerAssignment.InsertAfterCurrent);
                     t.actor().player_visibility_duration = -1;
                     t.actor().attrs[AttrType.NO_ITEM]++;
                     group.Add(M.actor[t.row,t.col]);
                     M.actor[t.row,t.col].group = group;
                     group.Randomize();
                 }
                 openspaces.Add(tile());
                 Tile newtile = openspaces[R.Roll(openspaces.Count)-1];
                 if(newtile != tile()){
                     Move(newtile.row,newtile.col,false);
                 }
                 if(openspaces.Count > 1){
                     B.Add(the_name + " is suddenly standing all around " + target.the_name + ". ",this,target);
                     Q1();
                 }
                 else{
                     Attack(0,target);
                 }
             }
             else{
                 Attack(0,target);
             }
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     case ActorType.SPITTING_COBRA:
         if(DistanceFrom(target) <= 3 && !HasAttr(AttrType.COOLDOWN_1) && FirstActorInLine(target) == target){
             RefreshDuration(AttrType.COOLDOWN_1,R.Between(50,75)*100);
             B.Add(TheName(true) + " spits poison in " + target.YourVisible() + " eyes! ",this,target);
             AnimateBoltProjectile(target,Color.DarkGreen);
             if(!target.HasAttr(AttrType.NONLIVING)){
                 target.ApplyStatus(AttrType.BLIND,R.Between(5,8)*100);
                 /*B.Add(target.YouAre() + " blind! ",target);
                 target.RefreshDuration(AttrType.BLIND,R.Between(5,8)*100,target.YouAre() + " no longer blinded. ",target);*/
             }
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 List<Tile> tiles = new List<Tile>();
                 if(target.row == row || target.col == col){
                     int targetdir = DirectionOf(target);
                     for(int i=-1;i<=1;++i){
                         pos adj = p.PosInDir(targetdir.RotateDir(true,i));
                         if(M.tile[adj].passable && M.actor[adj] == null){
                             tiles.Add(M.tile[adj]);
                         }
                     }
                 }
                 if(tiles.Count > 0){
                     AI_Step(tiles.Random());
                 }
                 else{
                     AI_Step(target);
                 }
                 QS();
             }
         }
         break;
     case ActorType.KOBOLD:
         if(!HasAttr(AttrType.COOLDOWN_1)){
             if(DistanceFrom(target) > 12){
                 AI_Step(target);
                 QS();
             }
             else{
                 if(FirstActorInLine(target) != target){
                     AI_Sidestep(target);
                     QS();
                 }
                 else{
                     attrs[AttrType.COOLDOWN_1]++;
                     AnimateBoltProjectile(target,Color.DarkCyan,30);
                     if(player.CanSee(this)){
                         B.Add(the_name + " fires a dart at " + target.the_name + ". ",this,target);
                     }
                     else{
                         B.Add("A dart hits " + target.the_name + "! ",target);
                         if(player.CanSee(tile()) && !IsInvisibleHere()){
                             attrs[AttrType.TURNS_VISIBLE] = -1;
                             attrs[AttrType.NOTICED] = 1;
                             B.Add("You spot " + the_name + " that fired it. ",this);
                             //B.Add("You notice " + a_name + ". ",tile());
                         }
                     }
                     if(target.TakeDamage(DamageType.NORMAL,DamageClass.PHYSICAL,R.Roll(6),this,"a kobold's dart")){
                         target.ApplyStatus(AttrType.VULNERABLE,R.Between(2,4)*100);
                         /*if(!target.HasAttr(AttrType.VULNERABLE)){
                             B.Add(target.YouFeel() + " vulnerable. ",target);
                         }
                         target.RefreshDuration(AttrType.VULNERABLE,R.Between(2,4)*100,target.YouFeel() + " less vulnerable. ",target);*/
                         if(target == player){
                             Help.TutorialTip(TutorialTopic.Vulnerable);
                         }
                     }
                     Q1();
                 }
             }
         }
         else{
             if(DistanceFrom(target) <= 2){
                 AI_Flee();
                 QS();
             }
             else{
                 B.Add(the_name + " starts reloading. ",this);
                 attrs[AttrType.COOLDOWN_1] = 0;
                 Q1();
                 RefreshDuration(AttrType.COOLDOWN_2,R.Between(5,6)*100 - 50);
                 //Q.Add(new Event(this,R.Between(5,6)*100,EventType.MOVE));
             }
         }
         break;
     case ActorType.SPORE_POD:
         if(DistanceFrom(target) == 1){
             TakeDamage(DamageType.NORMAL,DamageClass.PHYSICAL,100,null);
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     case ActorType.FORASECT:
     {
         bool burrow = false;
         if((curhp * 2 <= maxhp || DistanceFrom(target) > 6) && R.CoinFlip()){
             burrow = true;
         }
         if(DistanceFrom(target) <= 6 && DistanceFrom(target) > 1){
             if(R.OneIn(10)){
                 burrow = true;
             }
         }
         if(burrow && !HasAttr(AttrType.COOLDOWN_1)){
             RefreshDuration(AttrType.COOLDOWN_1,R.Between(8,11)*100);
             if(curhp * 2 <= maxhp){
                 Burrow(TilesWithinDistance(6));
             }
             else{
                 Burrow(GetCone(DirectionOf(target),6,true));
             }
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     }
     case ActorType.POLTERGEIST:
         if(inv.Count == 0){
             if(DistanceFrom(target) == 1){
                 pos target_p = target.p;
                 if(Attack(0,target) && M.actor[target_p] != null && M.actor[target_p].inv.Any(i=>!i.do_not_stack)){
                     target = M.actor[target_p];
                     Item item = target.inv.Where(i=>!i.do_not_stack).Random();
                     if(item.quantity > 1){
                         inv.Add(new Item(item,-1,-1));
                         item.quantity--;
                         B.Add(YouVisible("steal") + " " + target.YourVisible() + " " + inv[0].Name() + "! ",this,target);
                     }
                     else{
                         inv.Add(item);
                         target.inv.Remove(item);
                         B.Add(YouVisible("steal") + " " + target.YourVisible() + " " + item.Name() + "! ",this,target);
                     }
                 }
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         else{
             attrs[AttrType.KEEPS_DISTANCE] = 1;
             List<Tile> line = target.GetBestExtendedLineOfEffect(this);
             Tile next = null;
             bool found = false;
             foreach(Tile t in line){
                 if(found){
                     next = t;
                     break;
                 }
                 else{
                     if(t.actor() == this){
                         found = true;
                     }
                 }
             }
             if(next != null){
                 if(next.passable && next.actor() == null && AI_Step(next)){
                     QS();
                 }
                 else{
                     if(!next.passable){
                         B.Add(the_name + " disappears into " + next.the_name + ". ",this);
                         foreach(Tile t in TilesWithinDistance(1)){
                             if(t.DistanceFrom(next) == 1 && t.name == "floor"){
                                 t.AddFeature(FeatureType.SLIME);
                             }
                         }
                         Event e = null;
                         foreach(Event e2 in Q.list){
                             if(e2.target == this && e2.type == EventType.POLTERGEIST){
                                 e = e2;
                                 break;
                             }
                         }
                         if(e != null){
      								e.target = inv[0];
                             Actor.tiebreakers[e.tiebreaker] = null;
                         }
                         inv.Clear();
                         Kill();
                     }
                     else{
                         if(next.actor() != null){
                             if(!next.actor().HasAttr(AttrType.IMMOBILE)){
                                 Move(next.row,next.col);
                                 QS();
                             }
                             else{
                                 if(next.actor().HasAttr(AttrType.IMMOBILE)){
                                     if(AI_Step(next)){
                                         QS();
                                     }
                                     else{
                                         if(DistanceFrom(target) == 1){
                                             Attack(1,target);
                                         }
                                         else{
                                             QS();
                                         }
                                     }
                                 }
                             }
                         }
                         else{
                             QS();
                         }
                     }
                 }
             }
         }
         break;
     case ActorType.CULTIST:
     case ActorType.FINAL_LEVEL_CULTIST:
         if(curhp <= 10 && !HasAttr(AttrType.COOLDOWN_1)){
             attrs[AttrType.COOLDOWN_1]++;
             string invocation;
             switch(R.Roll(4)){
             case 1:
                 invocation = "ae vatra kersai";
                 break;
             case 2:
                 invocation = "kersai dzaggath";
                 break;
             case 3:
                 invocation = "od fir od bahgal";
                 break;
             case 4:
                 invocation = "denei kersai nammat";
                 break;
             default:
                 invocation = "denommus pilgni";
                 break;
             }
             if(R.CoinFlip()){
                 B.Add(You("whisper") + " '" + invocation + "'. ",this);
             }
             else{
                 B.Add(You("scream") + " '" + invocation.ToUpper() + "'. ",this);
             }
             if(HasAttr(AttrType.SLIMED)){
                 B.Add("Nothing happens. ",this);
             }
             else{
                 B.Add("Flames erupt from " + the_name + ". ",this);
                 AnimateExplosion(this,1,Color.RandomFire,'*');
                 ApplyBurning();
                 foreach(Tile t in TilesWithinDistance(1)){
                     t.ApplyEffect(DamageType.FIRE);
                     if(t.actor() != null){
                         t.actor().ApplyBurning();
                     }
                 }
             }
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     case ActorType.GOBLIN_ARCHER:
     case ActorType.PHANTOM_ARCHER:
         switch(DistanceFrom(target)){
         case 1:
             /*if(target.EnemiesAdjacent() > 1){
                 Attack(0,target);
             }
             else{*/
                 if(AI_Flee()){
                     QS();
                 }
                 else{
                     Attack(0,target);
                 }
             //}
             break;
         case 2:
             if(FirstActorInLine(target) == target){
                 FireArrow(target);
             }
             else{
                 if(AI_Flee()){
                     QS();
                 }
                 else{
                     if(AI_Sidestep(target)){
                         B.Add(the_name + " tries to line up a shot. ",this);
                     }
                     QS();
                 }
             }
             break;
         case 3:
         case 4:
         case 5:
         case 6:
         case 7:
         case 8:
             if(FirstActorInLine(target) == target){
                 FireArrow(target);
             }
             else{
                 if(AI_Sidestep(target)){
                     B.Add(the_name + " tries to line up a shot. ",this);
                 }
                 QS();
             }
             break;
         default:
             AI_Step(target);
             QS();
             break;
         }
         break;
     case ActorType.GOBLIN_SHAMAN:
     {
         if(SilencedThisTurn()){
             return;
         }
         if(DistanceFrom(target) == 1){
             if(exhaustion > 50){
                 Attack(0,target);
             }
             else{
                 CastCloseRangeSpellOrAttack(target);
             }
         }
         else{
             if(DistanceFrom(target) > 12){
                 AI_Step(target);
                 QS();
             }
             else{
                 if(FirstActorInLine(target) != target || R.CoinFlip()){
                     AI_Step(target);
                     QS();
                 }
                 else{
                     CastRangedSpellOrMove(target);
                 }
             }
         }
         break;
     }
     case ActorType.PHASE_SPIDER:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             Tile t = target.TilesAtDistance(DistanceFrom(target)-1).Where(x=>x.passable && x.actor() == null).RandomOrDefault();
             if(t != null){
                 Move(t.row,t.col);
             }
             QS();
         }
         break;
     case ActorType.ZOMBIE:
     case ActorType.PHANTOM_ZOMBIE:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             AI_Step(target);
             if(DistanceFrom(target) == 1){
                 Attack(1,target);
             }
             else{
                 QS();
             }
         }
         break;
     case ActorType.ROBED_ZEALOT:
         if(HasAttr(AttrType.COOLDOWN_3)){
             if(DistanceFrom(target) <= 12 && HasLOS(target)){
                 target.AnimateExplosion(target,1,Color.Yellow,'*');
                 B.Add(YouVisible("smite") + " " + target.the_name + "! ",target);
                 int amount = target.curhp / 10;
                 bool still_alive = target.TakeDamage(DamageType.MAGIC,DamageClass.MAGICAL,Math.Max(amount,1),this,"a zealot's wrath");
                 attrs[AttrType.COOLDOWN_3]--;
                 attrs[AttrType.DETECTING_MONSTERS]--;
                 if(!HasAttr(AttrType.COOLDOWN_3)){
                     B.Add(YouVisible("stop") + " praying. ");
                     if(still_alive && target.EquippedWeapon.type != WeaponType.NO_WEAPON && !target.EquippedWeapon.status[EquipmentStatus.MERCIFUL]){
                         target.EquippedWeapon.status[EquipmentStatus.MERCIFUL] = true;
                         B.Add(target.You("feel") + " a strange power enter " + target.Your() + " " + target.EquippedWeapon.NameWithoutEnchantment() + "! ",target);
                         B.PrintAll();
                         Help.TutorialTip(TutorialTopic.Merciful);
                     }
                 }
             }
             else{
                 attrs[AttrType.COOLDOWN_3]--;
                 attrs[AttrType.DETECTING_MONSTERS]--;
             }
             Q1();
         }
         else{
             if(!HasAttr(AttrType.COOLDOWN_1)){
                 attrs[AttrType.COOLDOWN_1] = maxhp; //initialize this value here instead of complicating the spawning code
             }
             if(DistanceFrom(target) <= 12 && !HasAttr(AttrType.COOLDOWN_2) && curhp < attrs[AttrType.COOLDOWN_1]){ //if the ability is ready and additional damage has been taken...
                 RefreshDuration(AttrType.COOLDOWN_2,R.Between(11,13)*100);
                 attrs[AttrType.COOLDOWN_1] = curhp;
                 attrs[AttrType.COOLDOWN_3] = 4;
                 attrs[AttrType.DETECTING_MONSTERS] = 4;
                 B.Add(YouVisible("start") + " praying. ");
                 B.Add(the_name + " points directly at you. ",this);
                 Q1();
             }
             else{
                 if(DistanceFrom(target) == 1){
                     Attack(0,target);
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
         }
         /*if(HasAttr(AttrType.COOLDOWN_2)){
             attrs[AttrType.COOLDOWN_2] = 0;
             B.Add(the_name + " finishes the prayer. ",this);
             if(DistanceFrom(target) == 1 && target.EquippedWeapon.type != WeaponType.NO_WEAPON){
                 target.EquippedWeapon.status[EquipmentStatus.MERCIFUL] = true;
                 B.Add("You feel a strange power enter " + target.Your() + " " + target.EquippedWeapon.NameWithoutEnchantment() + "! ",target);
                 B.PrintAll();
                 Help.TutorialTip(TutorialTopic.Merciful);
             }
             Q1();
         }
         else{
             if((maxhp / 5) * 4 > curhp && !HasAttr(AttrType.COOLDOWN_1)){
                 RefreshDuration(AttrType.COOLDOWN_1,R.Between(14,16)*100);
                 attrs[AttrType.COOLDOWN_2]++;
                 B.Add(the_name + " starts praying. ",this);
                 B.Add("A fiery halo appears above " + the_name + ". ",this);
                 RefreshDuration(AttrType.RADIANT_HALO,R.Between(8,10)*100,Your() + " halo fades. ",this);
                 Q1();
             }
             else{
                 if(DistanceFrom(target) == 1){
                     Attack(0,target);
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
         }*/
         break;
     case ActorType.GIANT_SLUG:
     {
         if(DistanceFrom(target) == 1){
             Attack(R.Between(0,1),target);
         }
         else{
             if(!HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 12 && FirstActorInLine(target) == target){
                 RefreshDuration(AttrType.COOLDOWN_1,R.Between(11,14)*100);
                 B.Add(TheName(true) + " spits slime at " + target.the_name + ". ",target);
                 List<Tile> slimed = GetBestLineOfEffect(target);
                 List<Tile> added = new List<Tile>();
                 foreach(Tile t in slimed){
                     foreach(int dir in U.FourDirections){
                         Tile neighbor = t.TileInDirection(dir);
                         if(R.OneIn(3) && neighbor.passable && !slimed.Contains(neighbor)){
                             added.AddUnique(neighbor);
                         }
                     }
                 }
                 slimed.AddRange(added);
                 List<pos> cells = new List<pos>();
                 List<Actor> slimed_actors = new List<Actor>();
                 for(int i=0;slimed.Count > 0;++i){
                     List<Tile> removed = new List<Tile>();
                     foreach(Tile t in slimed){
                         if(DistanceFrom(t) == i){
                             t.AddFeature(FeatureType.SLIME);
                             if(t.actor() != null && t.actor() != this && !t.actor().HasAttr(AttrType.SLIMED,AttrType.FROZEN)){
                                 slimed_actors.Add(t.actor());
                             }
                             removed.Add(t);
                             if(DistanceFrom(t) > 0){
                                 cells.Add(t.p);
                             }
                         }
                     }
                     foreach(Tile t in removed){
                         slimed.Remove(t);
                     }
                     if(cells.Count > 0){
                         Screen.AnimateMapCells(cells,new colorchar(',',Color.Green),20);
                     }
                 }
                 M.Draw();
                 slimed_actors.AddUnique(target);
                 foreach(Actor a in slimed_actors){
                     a.attrs[AttrType.SLIMED] = 1;
                     a.attrs[AttrType.OIL_COVERED] = 0;
                     a.RefreshDuration(AttrType.BURNING,0);
                     B.Add(a.YouAre() + " covered in slime. ",a);
                 }
                 Q1();
             }
             else{
                 AI_Step(target);
                 if(tile().Is(FeatureType.SLIME)){
                     speed = 50;
                     QS(); //normal speed is 150
                     speed = 150;
                 }
                 else{
                     QS();
                 }
             }
         }
         break;
     }
     case ActorType.BANSHEE:
     {
         if(!HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 12){
             RefreshDuration(AttrType.COOLDOWN_1,R.Between(13,15)*100);
             if(player.CanSee(this)){
                 if(player.IsSilencedHere()){
                     B.Add(You("seem") + " to scream. ",this);
                 }
                 else{
                     B.Add(You("scream") + ". ",this);
                 }
             }
             else{
                 if(!player.IsSilencedHere()){
                     B.Add("You hear a scream! ");
                 }
             }
             if(!target.IsSilencedHere()){
                 if(target.ResistedBySpirit() || target.HasAttr(AttrType.MENTAL_IMMUNITY)){
                     B.Add(target.You("remain") + " courageous. ",target);
                 }
                 else{
                     B.Add(target.YouAre() + " terrified! ",target);
                     RefreshDuration(AttrType.TERRIFYING,R.Between(5,8)*100,target.YouAre() + " no longer afraid. ",target);
                     Help.TutorialTip(TutorialTopic.Afraid);
                 }
             }
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     }
     case ActorType.CAVERN_HAG:
         if(curhp < maxhp && HasAttr(AttrType.COOLDOWN_2) && !HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 12){
             B.Add(TheName(true) + " curses you! ");
             if(target.ResistedBySpirit()){
                 B.Add("You resist the curse. ");
             }
             else{
                 switch(R.Roll(4)){
                 case 1: //light allergy
                     B.Add("You become allergic to light! ");
                     target.RefreshDuration(AttrType.LIGHT_SENSITIVE,(R.Roll(2,20) + 70) * 100,"You are no longer allergic to light. ");
                     break;
                 case 2: //aggravate monsters
                     B.Add("Every sound you make becomes amplified and echoes across the dungeon. ");
                     target.RefreshDuration(AttrType.AGGRAVATING,(R.Roll(2,20) + 70) * 100,"Your sounds are no longer amplified. ");
                     break;
                 case 3: //cursed weapon
                     B.Add("Your " + target.EquippedWeapon + " becomes stuck to your hand! ");
                     target.EquippedWeapon.status[EquipmentStatus.STUCK] = true;
                     Help.TutorialTip(TutorialTopic.Stuck);
                     break;
                 case 4: //heavy weapon
                     B.Add("Your " + target.EquippedWeapon + " suddenly feels much heavier. ");
                     target.EquippedWeapon.status[EquipmentStatus.HEAVY] = true;
                     Help.TutorialTip(TutorialTopic.Heavy);
                     break;
                 }
             }
             attrs[AttrType.COOLDOWN_1]++;
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     case ActorType.BERSERKER:
     {
         if(HasAttr(AttrType.COOLDOWN_2)){
             int dir = attrs[AttrType.COOLDOWN_2];
             bool cw = R.CoinFlip();
             if(TileInDirection(dir).passable && ActorInDirection(dir) == null && !MovementPrevented(TileInDirection(dir))){
                 B.Add(the_name + " leaps forward swinging his axe! ",this);
                 Move(TileInDirection(dir).row,TileInDirection(dir).col);
                 M.Draw();
                 for(int i=-1;i<=1;++i){
                     Screen.AnimateBoltProjectile(new List<Tile>{tile(),TileInDirection(dir.RotateDir(cw,i))},Color.Red,30);
                 }
                 for(int i=-1;i<=1;++i){
                     Actor a = ActorInDirection(dir.RotateDir(cw,i));
                     if(a != null){
                         B.Add(YourVisible() + " axe hits " + a.TheName(true) + ". ",this,a);
                         a.TakeDamage(DamageType.NORMAL,DamageClass.PHYSICAL,R.Roll(4,6),this,"a berserker's axe");
                     }
                     TileInDirection(dir.RotateDir(cw,i)).Bump(dir.RotateDir(cw,i));
                 }
                 Q1();
             }
             else{
                 if(ActorInDirection(dir) != null || MovementPrevented(TileInDirection(dir)) || TileInDirection(dir).Is(TileType.STANDING_TORCH,TileType.BARREL,TileType.POISON_BULB)){
                     B.Add(the_name + " swings his axe furiously! ",this);
                     for(int i=-1;i<=1;++i){
                         Screen.AnimateBoltProjectile(new List<Tile>{tile(),TileInDirection(dir.RotateDir(cw,i))},Color.Red,30);
                     }
                     for(int i=-1;i<=1;++i){
                         Actor a = ActorInDirection(dir.RotateDir(cw,i));
                         if(a != null){
                             B.Add(YourVisible() + " axe hits " + a.TheName(true) + ". ",this,a);
                             a.TakeDamage(DamageType.NORMAL,DamageClass.PHYSICAL,R.Roll(4,6),this,"a berserker's axe");
                         }
                         TileInDirection(dir.RotateDir(cw,i)).Bump(dir.RotateDir(cw,i));
                     }
                     Q1();
                 }
                 else{
                     if(target != null && HasLOS(target)){
                         B.Add(the_name + " turns to face " + target.the_name + ". ",this);
                         attrs[AttrType.COOLDOWN_2] = DirectionOf(target);
                         Q1();
                     }
                 }
             }
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
                 if(target != null && R.Roll(3) == 3){
                     B.Add(the_name + " screams with fury! ",this);
                     attrs[AttrType.COOLDOWN_2] = DirectionOf(target);
                     Q.Add(new Event(this,350,AttrType.COOLDOWN_2,Your() + " rage diminishes. ",this));
                 }
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     }
     case ActorType.DIRE_RAT:
     {
         bool slip_past = false;
         if(DistanceFrom(target) == 1){
             foreach(Actor a in ActorsAtDistance(1)){
                 if(a.type == ActorType.DIRE_RAT && a.DistanceFrom(target) > this.DistanceFrom(target)){
                     bool can_walk = false;
                     foreach(Tile t in a.TilesAtDistance(1)){
                         if(t.DistanceFrom(target) < a.DistanceFrom(target) && t.passable && t.actor() == null){
                             can_walk = true;
                             break;
                         }
                     }
                     if(!can_walk){ //there's a rat that would benefit from a space opening up - now check to see whether a move is possible
                         foreach(Tile t in target.TilesAtDistance(1)){
                             if(t.passable && t.actor() == null){
                                 slip_past = true;
                                 break;
                             }
                         }
                         break;
                     }
                 }
             }
         }
         if(slip_past){
             bool moved = false;
             foreach(Tile t in TilesAtDistance(1)){
                 if(t.DistanceFrom(target) == 1 && t.passable && t.actor() == null){
                     AI_Step(t);
                     QS();
                     moved = true;
                     break;
                 }
             }
             if(!moved){
                 Tile t = target.TilesAtDistance(1).Where(x=>x.passable && x.actor() == null).RandomOrDefault();
                 if(t != null){
                     B.Add(TheName(true) + " slips past " + target.TheName(true) + ". ",this,target);
                     Move(t.row,t.col);
                     Q.Add(new Event(this,Speed() + 100,EventType.MOVE));
                 }
                 else{
                     QS();
                 }
             }
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     }
     case ActorType.SKULKING_KILLER:
     {
         if(HasAttr(AttrType.KEEPS_DISTANCE)){
             bool try_to_hide = false;
             if(AI_Flee()){
                 try_to_hide = true;
                 QS();
             }
             else{
                 if(DistanceFrom(target) == 1){
                     Attack(0,target);
                 }
                 else{ //give up on fleeing, just attack
                     attrs[AttrType.COOLDOWN_2] = 0;
                     attrs[AttrType.KEEPS_DISTANCE] = 0;
                     AI_Step(target);
                     QS();
                 }
             }
             if(try_to_hide){
                 bool visible = player.CanSee(this);
                 if(!R.OneIn(5) && (!player.HasLOE(this) || !visible || DistanceFrom(player) > 12)){ //just to add some uncertainty
                     attrs[AttrType.COOLDOWN_2]++;
                     if(attrs[AttrType.COOLDOWN_2] >= 3){
                         attrs[AttrType.KEEPS_DISTANCE] = 0;
                         attrs[AttrType.COOLDOWN_2] = 0;
                         if(!visible){
                             attrs[AttrType.TURNS_VISIBLE] = 0;
                         }
                     }
                 }
             }
         }
         else{
             if(DistanceFrom(target) == 1){
                 if(Attack(0,target)){
                     attrs[AttrType.KEEPS_DISTANCE] = 1;
                 }
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         /*if(!HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 3 && R.OneIn(3) && HasLOE(target)){
             attrs[AttrType.COOLDOWN_1]++;
             AnimateProjectile(target,Color.DarkYellow,'%');
             Input.FlushInput();
             if(target.CanSee(this)){
                 B.Add(the_name + " throws a bola at " + target.the_name + ". ",this,target);
             }
             else{
                 B.Add("A bola whirls toward " + target.the_name + ". ",this,target);
             }
             attrs[AttrType.TURNS_VISIBLE] = -1;
             target.RefreshDuration(AttrType.SLOWED,(R.Roll(3)+6)*100,target.YouAre() + " no longer slowed. ",target);
             B.Add(target.YouAre() + " slowed by the bola. ",target);
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }*/
         break;
     }
     case ActorType.WILD_BOAR:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
             if(HasAttr(AttrType.JUST_FLUNG)){ //if it just flung its target...
                 attrs[AttrType.JUST_FLUNG] = 0;
                 attrs[AttrType.COOLDOWN_1] = 0;
             }
             else{ //...otherwise it might prepare to fling again
                 if(!HasAttr(AttrType.COOLDOWN_1)){
                     if(!HasAttr(AttrType.COOLDOWN_2) || R.OneIn(5)){
                         attrs[AttrType.COOLDOWN_2]++;
                         B.Add(the_name + " lowers its head. ",this);
                         attrs[AttrType.COOLDOWN_1]++;
                     }
                 }
             }
         }
         else{
             AI_Step(target);
             if(!HasAttr(AttrType.COOLDOWN_2)){
                 attrs[AttrType.COOLDOWN_2]++;
                 B.Add(the_name + " lowers its head. ",this);
                 attrs[AttrType.COOLDOWN_1]++;
             }
             QS();
         }
         break;
     case ActorType.DREAM_SPRITE:
         if(!HasAttr(AttrType.COOLDOWN_1)){
             if(DistanceFrom(target) <= 12 && FirstActorInLine(target) == target){
                 RefreshDuration(AttrType.COOLDOWN_1,R.Between(3,4)*100);
                 bool visible = false;
                 List<List<Tile>> lines = new List<List<Tile>>{GetBestLineOfEffect(target)};
                 if(group != null && group.Count > 0){
                     foreach(Actor a in group){
                         if(target == player && player.CanSee(a)){
                             visible = true;
                         }
                         if(a.type == ActorType.DREAM_SPRITE_CLONE){
                             a.attrs[AttrType.COOLDOWN_1]++; //for them, it means 'skip next turn'
                             if(a.FirstActorInLine(target) == target){
                                 lines.Add(a.GetBestLineOfEffect(target));
                             }
                         }
                     }
                 }
                 foreach(List<Tile> line in lines){
                     if(line.Count > 0){
                         line.RemoveAt(0);
                     }
                 }
                 if(visible){
                     B.Add(the_name + " hits " + target.the_name + " with stinging magic. ",target);
                 }
                 else{
                     B.Add(TheName(true) + " hits " + target.the_name + " with stinging magic. ",target);
                 }
                 int max = lines.WhereGreatest(x=>x.Count)[0].Count;
                 for(int i=0;i<max;++i){
                     List<pos> cells = new List<pos>();
                     foreach(List<Tile> line in lines){
                         if(line.Count > i){
                             cells.Add(line[i].p);
                         }
                     }
                     Screen.AnimateMapCells(cells,new colorchar('*',Color.RandomRainbow));
                 }
                 target.TakeDamage(DamageType.MAGIC,DamageClass.MAGICAL,R.Roll(2,6),this,"a blast of fairy magic");
                 Q1();
             }
             else{
                 if(DistanceFrom(target) > 12){
                     AI_Step(target);
                 }
                 else{
                     AI_Sidestep(target);
                 }
                 QS();
             }
         }
         else{
             if(DistanceFrom(target) > 5){
                 AI_Step(target);
             }
             else{
                 if(DistanceFrom(target) < 3){
                     AI_Flee();
                 }
                 else{
                     Tile t = TilesAtDistance(1).Where(x=>x.passable && x.actor() == null).RandomOrDefault();
                     if(t != null){
                         AI_Step(t);
                     }
                 }
             }
             QS();
         }
         break;
     case ActorType.DREAM_SPRITE_CLONE:
         if(HasAttr(AttrType.COOLDOWN_1)){
             attrs[AttrType.COOLDOWN_1] = 0;
             Q1();
         }
         else{
             if(DistanceFrom(target) > 5){
                 AI_Step(target);
             }
             else{
                 if(DistanceFrom(target) < 3){
                     AI_Flee();
                 }
                 else{
                     Tile t = TilesAtDistance(1).Where(x=>x.passable && x.actor() == null).RandomOrDefault();
                     if(t != null){
                         AI_Step(t);
                     }
                 }
             }
             QS();
         }
         break;
     case ActorType.CLOUD_ELEMENTAL:
     {
         List<pos> cloud = M.tile.GetFloodFillPositions(p,false,x=>M.tile[x].features.Contains(FeatureType.FOG));
         PhysicalObject[] objs = new PhysicalObject[cloud.Count + 1];
         int idx = 0;
         foreach(pos p2 in cloud){
             objs[idx++] = M.tile[p2];
         }
         objs[idx] = this;
         List<colorchar> chars = new List<colorchar>();
         colorchar cch = new colorchar('*',Color.RandomLightning);
         if(cloud.Contains(target.p)){
             B.Add(the_name + " electrifies the cloud! ",objs);
             foreach(pos p2 in cloud){
                 if(M.actor[p2] != null && M.actor[p2] != this){
                     M.actor[p2].TakeDamage(DamageType.ELECTRIC,DamageClass.PHYSICAL,R.Roll(3,6),this,"*electrocuted by a cloud elemental");
                 }
                 if(M.actor[p2] == this){
                     chars.Add(visual);
                 }
                 else{
                     chars.Add(cch);
                 }
             }
             Screen.AnimateMapCells(cloud,chars,50);
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Tile t = TilesAtDistance(1).Where(x=>x.actor() == null && x.passable).RandomOrDefault();
                 if(t != null){
                     AI_Step(t);
                 }
                 QS();
             }
             else{
                 if(R.OneIn(4)){
                     Tile t = TilesAtDistance(1).Where(x=>x.actor() == null && x.passable).RandomOrDefault();
                     if(t != null){
                         AI_Step(t);
                     }
                     QS();
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
         }
         break;
     }
     case ActorType.DERANGED_ASCETIC:
         if(DistanceFrom(target) == 1){
             Attack(R.Roll(3)-1,target);
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     case ActorType.SNEAK_THIEF:
     {
         if(DistanceFrom(target) <= 12 && !R.OneIn(3) && AI_UseRandomItem()){
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
                 if(target != null){
                     List<Tile> valid_dirs = new List<Tile>();
                     foreach(Tile t in target.TilesAtDistance(1)){
                         if(t.passable && t.actor() == null && DistanceFrom(t) == 1){
                             valid_dirs.Add(t);
                         }
                     }
                     if(valid_dirs.Count > 0){
                         AI_Step(valid_dirs.Random());
                     }
                 }
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     }
     case ActorType.WARG:
     {
         bool howl = false;
         if(DistanceFrom(target) == 1){
             if(R.CoinFlip() || group == null || group.Count < 2 || HasAttr(AttrType.COOLDOWN_1)){
                 Attack(0,target);
             }
             else{
                 howl = true;
             }
         }
         else{
             if(group == null || group.Count < 2 || HasAttr(AttrType.COOLDOWN_1)){
                 if(AI_Step(target)){
                     QS();
                 }
                 else{
                     howl = true;
                 }
             }
             else{
                 howl = true;
             }
         }
         if(howl){
             if(group == null || group.Count < 2){
                 Q1();
                 break;
             }
             B.Add(TheName(true) + " howls. ");
             PosArray<int> paths = new PosArray<int>(ROWS,COLS);
             foreach(Actor packmate in group){
                 packmate.RefreshDuration(AttrType.COOLDOWN_1,2000);
                 if(packmate != this){
                     var dijkstra = M.tile.GetDijkstraMap(new List<pos>{target.p},x=>!M.tile[x].passable,y=>M.actor[y] != null? 5 : paths[y]+1);
                     if(!dijkstra[packmate.p].IsValidDijkstraValue()){
                         continue;
                     }
                     List<pos> new_path = new List<pos>();
                     pos p = packmate.p;
                     while(!p.Equals(target.p)){
                         p = p.PositionsAtDistance(1,dijkstra).Where(x=>dijkstra[x].IsValidDijkstraValue()).WhereLeast(x=>dijkstra[x]).Random();
                         new_path.Add(p);
                         paths[p]++;
                     }
                     packmate.path = new_path;
                 }
             }
             Q1();
         }
         break;
     }
     case ActorType.RUNIC_TRANSCENDENT:
     {
         if(SilencedThisTurn()){
             return;
         }
         if(!HasSpell(SpellType.MERCURIAL_SPHERE)){
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
             return;
         }
         if(curmp < 2){
             B.Add(the_name + " absorbs mana from the universe. ",this);
             curmp = maxmp;
             Q1();
         }
         else{
             if(M.safetymap == null){
                 M.UpdateSafetyMap(player);
             }
             Tile t = TilesAtDistance(1).Where(x=>x.DistanceFrom(target) == 3 && x.passable && x.actor() == null).WhereLeast(x=>M.safetymap[x.p]).RandomOrDefault();
             if(t != null){ //check safety map. if there's a safer spot at distance 3, step there.
                 AI_Step(t);
             }
             else{
                 if(DistanceFrom(target) > 3){
                     AI_Step(target);
                 }
                 else{
                     if(DistanceFrom(target) < 3){
                         AI_Flee();
                     }
                 }
             }
             if(DistanceFrom(target) <= 12 && FirstActorInLine(target) != null && FirstActorInLine(target).DistanceFrom(target) <= 3){
                 CastSpell(SpellType.MERCURIAL_SPHERE,target);
             }
             else{
                 QS();
             }
         }
         break;
     }
     case ActorType.CARRION_CRAWLER:
         if(DistanceFrom(target) == 1){
             if(!target.HasAttr(AttrType.PARALYZED)){
                 Attack(0,target);
             }
             else{
                 Attack(1,target);
             }
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     case ActorType.MECHANICAL_KNIGHT:
         if(attrs[AttrType.COOLDOWN_1] == 3){ //no head
             int dir = Global.RandomDirection();
             if(R.CoinFlip()){
                 Actor a = ActorInDirection(dir);
                 if(a != null){
                     if(!Attack(0,a)){
                         B.Add(the_name + " drops its guard! ",this);
                         attrs[AttrType.MECHANICAL_SHIELD] = 0;
                     }
                 }
                 else{
                     B.Add(the_name + " attacks empty space. ",this);
                     TileInDirection(dir).Bump(dir);
                     B.Add(the_name + " drops its guard! ",this);
                     attrs[AttrType.MECHANICAL_SHIELD] = 0;
                     Q1();
                 }
             }
             else{
                 Tile t = TileInDirection(dir);
                 if(t.passable){
                     if(t.actor() == null){
                         AI_Step(t);
                         QS();
                     }
                     else{
                         B.Add(the_name + " bumps into " + t.actor().TheName(true) + ". ",this);
                         QS();
                     }
                 }
                 else{
                     B.Add(the_name + " bumps into " + t.TheName(true) + ". ",this);
                     t.Bump(DirectionOf(t));
                     QS();
                 }
             }
         }
         else{
             if(DistanceFrom(target) == 1){
                 if(attrs[AttrType.COOLDOWN_1] == 1){ //no arms
                     Attack(1,target);
                 }
                 else{
                     if(!Attack(0,target)){
                         B.Add(the_name + " drops its guard! ",this);
                         attrs[AttrType.MECHANICAL_SHIELD] = 0;
                     }
                 }
             }
             else{
                 if(attrs[AttrType.COOLDOWN_1] != 2){ //no legs
                     AI_Step(target);
                 }
                 QS();
             }
         }
         break;
     case ActorType.ALASI_BATTLEMAGE:
         if(SilencedThisTurn()){
             return;
         }
         if(DistanceFrom(target) > 12){
             AI_Step(target);
             QS();
         }
         else{
             if(DistanceFrom(target) == 1){
                 if(exhaustion < 50){
                     CastCloseRangeSpellOrAttack(null,target,true);
                 }
                 else{
                     Attack(0,target);
                 }
             }
             else{
                 CastRangedSpellOrMove(target);
             }
         }
         break;
     case ActorType.ALASI_SOLDIER:
         if(DistanceFrom(target) > 2){
             AI_Step(target);
             QS();
             attrs[AttrType.COMBO_ATTACK] = 0;
         }
         else{
             if(FirstActorInLine(target) != null && !FirstActorInLine(target).name.Contains("alasi")){ //I had planned to make this attack possibly hit multiple targets, but not yet.
                 Attack(0,target);
             }
             else{
                 if(AI_Step(target)){
                     QS();
                 }
                 else{
                     AI_Sidestep(target);
                     QS();
                 }
                 attrs[AttrType.COMBO_ATTACK] = 0;
             }
         }
         break;
     case ActorType.SKITTERMOSS:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
             if(target != null && R.CoinFlip()){ //chance of retreating
                 AI_Step(target,true);
             }
         }
         else{
             if(R.CoinFlip()){
                 AI_Step(target);
                 QS();
             }
             else{
                 AI_Step(TileInDirection(Global.RandomDirection()));
                 QS();
             }
         }
         break;
     case ActorType.ALASI_SCOUT:
     {
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             if(curhp == maxhp){
                 if(FirstActorInLine(target) == target){
                     Attack(1,target);
                 }
                 else{
                     AI_Sidestep(target);
                     QS();
                 }
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     }
     case ActorType.MUD_ELEMENTAL:
     {
         int count = 0;
         int walls = 0;
         foreach(Tile t in target.TilesAtDistance(1)){
             if(t.p.BoundsCheck(M.tile,false) && t.type == TileType.WALL){
                 ++walls;
                 if(t.actor() == null){
                     ++count;
                 }
             }
         }
         if(!HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 12 && count >= 2 || (count == 1 && walls == 1)){
             RefreshDuration(AttrType.COOLDOWN_1,150);
             foreach(Tile t in target.TilesAtDistance(1)){
                 if(t.p.BoundsCheck(M.tile,false) && t.type == TileType.WALL && t.actor() == null){
                     Create(ActorType.MUD_TENTACLE,t.row,t.col,TiebreakerAssignment.InsertAfterCurrent);
                     M.actor[t.p].player_visibility_duration = -1;
                 }
             }
             if(count >= 2){
                 if(player.CanSee(this)){
                     B.Add(the_name + " calls mud tentacles from the walls! ");
                 }
                 else{
                     B.Add("Mud tentacles emerge from the walls! ");
                 }
             }
             else{
                 if(player.CanSee(this)){
                     B.Add(the_name + " calls a mud tentacle from the wall! ");
                 }
                 else{
                     B.Add("A mud tentacle emerges from the wall! ");
                 }
             }
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     }
     case ActorType.FLAMETONGUE_TOAD:
     {
         bool burrow = false;
         if((curhp * 3 <= maxhp || DistanceFrom(target) > 6) && R.CoinFlip()){
             burrow = true;
         }
         if(DistanceFrom(target) <= 6 && DistanceFrom(target) > 1){
             if(R.OneIn(20)){
                 burrow = true;
             }
         }
         if(burrow && !HasAttr(AttrType.COOLDOWN_1)){
             RefreshDuration(AttrType.COOLDOWN_1,R.Between(12,16)*100);
             if(curhp * 3 <= maxhp){
                 Burrow(TilesWithinDistance(6));
             }
             else{
                 Burrow(GetCone(DirectionOf(target),6,true));
             }
         }
         else{
             if(!HasAttr(AttrType.COOLDOWN_2) && FirstActorInLine(target) != null && FirstActorInLine(target).DistanceFrom(target) <= 1){
                 RefreshDuration(AttrType.COOLDOWN_2,R.Between(10,14)*100);
                 Actor first = FirstActorInLine(target);
                 B.Add(TheName(true) + " breathes fire! ",this,first);
                 AnimateProjectile(first,'*',Color.RandomFire);
                 AnimateExplosion(first,1,'*',Color.RandomFire);
                 foreach(Tile t in GetBestLineOfEffect(first)){
                     t.ApplyEffect(DamageType.FIRE);
                 }
                 foreach(Tile t in first.TilesWithinDistance(1)){
                     t.ApplyEffect(DamageType.FIRE);
                     if(t.actor() != null){
                         t.actor().ApplyBurning();
                     }
                 }
                 Q1();
             }
             else{
                 if(DistanceFrom(target) == 1){
                     Attack(0,target);
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
         }
         break;
     }
     case ActorType.ENTRANCER:
         if(group == null){
             if(AI_Flee()){
                 QS();
             }
             else{
                 if(DistanceFrom(target) == 1){
                     Attack(0,target);
                 }
                 else{
                     QS();
                 }
             }
         }
         else{
             Actor thrall = group[1];
             if(CanSee(thrall) && HasLOE(thrall)){ //cooldown 1 is teleport. cooldown 2 is shield.
                 //if the thrall is visible and you have LOE, the next goal is for the entrancer to be somewhere on the line that starts at the target and extends through the thrall.
                 List<Tile> line_from_target = target.GetBestExtendedLineOfEffect(thrall);
                 bool on_line = line_from_target.Contains(tile());
                 bool space_near_target = line_from_target.Count > 1 && line_from_target[1].passable && line_from_target[1].actor() == null;
                 if(on_line && DistanceFrom(target) > thrall.DistanceFrom(target)){
                     if(!HasAttr(AttrType.COOLDOWN_2) && thrall.curhp <= thrall.maxhp / 2){ //check whether you can shield it, if the thrall is low on health.
                         RefreshDuration(AttrType.COOLDOWN_2,1500);
                         B.Add(TheName(true) + " shields " + thrall.TheName(true) + ". ",this,thrall);
                         B.DisplayNow();
                         Screen.AnimateStorm(thrall.p,1,2,5,'*',Color.White);
                         thrall.attrs[AttrType.SHIELDED] = 1;
                         Q1();
                     }
                     else{ //check whether you can teleport the thrall closer.
                         if(!HasAttr(AttrType.COOLDOWN_1) && thrall.DistanceFrom(target) > 1 && space_near_target){
                             Tile dest = line_from_target[1];
                             RefreshDuration(AttrType.COOLDOWN_1,400);
                             B.Add(TheName(true) + " teleports " + thrall.TheName(true) + ". ",this,thrall);
                             M.Draw();
                             thrall.Move(dest.row,dest.col);
                             B.DisplayNow();
                             Screen.AnimateStorm(dest.p,1,1,4,thrall.symbol,thrall.color);
                             foreach(Tile t2 in thrall.GetBestLineOfEffect(dest)){
                                 Screen.AnimateStorm(t2.p,1,1,4,thrall.symbol,thrall.color);
                             }
                             Q1();
                         }
                         else{ //check whether you can shield it, if the thrall isn't low on health.
                             if(!HasAttr(AttrType.COOLDOWN_2)){
                                 RefreshDuration(AttrType.COOLDOWN_2,1500);
                                 B.Add(TheName(true) + " shields " + thrall.TheName(true) + ". ",this,thrall);
                                 B.DisplayNow();
                                 Screen.AnimateStorm(thrall.p,1,2,5,'*',Color.White);
                                 thrall.attrs[AttrType.SHIELDED] = 1;
                                 Q1();
                             }
                             else{ //check whether you are adjacent to thrall and can step away while remaining on line.
                                 List<Tile> valid = line_from_target.Where(x=>DistanceFrom(x) == 1 && x.actor() == null && x.passable);
                                 if(DistanceFrom(thrall) == 1 && valid.Count > 0){
                                     AI_Step(valid.Random());
                                 }
                                 QS();
                             }
                         }
                     }
                 }
                 else{
                     if(on_line){ //if on the line but not behind the thrall, we might be able to swap places or teleport
                         if(DistanceFrom(thrall) == 1){
                             Move(thrall.row,thrall.col);
                             QS();
                         }
                         else{
                             Tile dest = null;
                             foreach(Tile t in line_from_target){
                                 if(t.passable && t.actor() == null){
                                     dest = t;
                                     break;
                                 }
                             }
                             if(dest != null){
                                 RefreshDuration(AttrType.COOLDOWN_1,400);
                                 B.Add(TheName(true) + " teleports " + thrall.TheName(true) + ". ",this,thrall);
                                 M.Draw();
                                 thrall.Move(dest.row,dest.col);
                                 B.DisplayNow();
                                 Screen.AnimateStorm(dest.p,1,1,4,thrall.symbol,thrall.color);
                                 foreach(Tile t2 in thrall.GetBestLineOfEffect(dest)){
                                     Screen.AnimateStorm(t2.p,1,1,4,thrall.symbol,thrall.color);
                                 }
                             }
                             Q1();
                         }
                     }
                     else{ //if there's a free adjacent space on the line and behind the thrall, step there.
                         List<Tile> valid = line_from_target.From(thrall).Where(x=>x.passable && x.actor() == null && x.DistanceFrom(this) == 1);
                         if(valid.Count > 0){
                             AI_Step(valid.Random());
                             QS();
                         }
                         else{ //if you can teleport and there's a free tile on the line between you and the target, teleport the thrall there.
                             List<Tile> valid_between = GetBestLineOfEffect(target).Where(x=>x.passable && x.actor() == null && thrall.HasLOE(x));
                             if(!HasAttr(AttrType.COOLDOWN_1) && valid_between.Count > 0){
                                 Tile dest = valid_between.Random();
                                 RefreshDuration(AttrType.COOLDOWN_1,400);
                                 B.Add(TheName(true) + " teleports " + thrall.TheName(true) + ". ",this,thrall);
                                 M.Draw();
                                 thrall.Move(dest.row,dest.col);
                                 B.DisplayNow();
                                 Screen.AnimateStorm(dest.p,1,1,4,thrall.symbol,thrall.color);
                                 foreach(Tile t2 in thrall.GetBestLineOfEffect(dest)){
                                     Screen.AnimateStorm(t2.p,1,1,4,thrall.symbol,thrall.color);
                                 }
                                 Q1();
                             }
                             else{ //step toward a tile on the line (and behind the thrall)
                                 List<Tile> valid_behind_thrall = line_from_target.From(thrall).Where(x=>x.passable && x.actor() == null);
                                 if(valid_behind_thrall.Count > 0){
                                     AI_Step(valid_behind_thrall.Random());
                                 }
                                 QS();
                             }
                         }
                     }
                 }
                 //the old code:
                 /*if(DistanceFrom(target) < thrall.DistanceFrom(target) && DistanceFrom(thrall) == 1){
                     Move(thrall.row,thrall.col);
                     QS();
                 }
                 else{
                     if(DistanceFrom(target) == 1 && curhp < maxhp){
                         List<Tile> safe = TilesAtDistance(1).Where(t=>t.passable && t.actor() == null && target.GetBestExtendedLineOfEffect(thrall).Contains(t));
                         if(DistanceFrom(thrall) == 1 && safe.Count > 0){
                             AI_Step(safe.Random());
                             QS();
                         }
                         else{
                             if(AI_Flee()){
                                 QS();
                             }
                             else{
                                 Attack(0,target);
                             }
                         }
                     }
                     else{
                         if(!HasAttr(AttrType.COOLDOWN_1) && (thrall.DistanceFrom(target) > 1 || !target.GetBestExtendedLineOfEffect(thrall).Any(t=>t.actor()==this))){ //the entrancer tries to be smart about placing the thrall in a position that blocks ranged attacks
                             List<Tile> closest = new List<Tile>();
                             int dist = 99;
                             foreach(Tile t in thrall.TilesWithinDistance(2).Where(x=>x.passable && (x.actor()==null || x.actor()==thrall))){
                                 if(t.DistanceFrom(target) < dist){
                                     closest.Clear();
                                     closest.Add(t);
                                     dist = t.DistanceFrom(target);
                                 }
                                 else{
                                     if(t.DistanceFrom(target) == dist){
                                         closest.Add(t);
                                     }
                                 }
                             }
                             List<Tile> in_line = new List<Tile>();
                             foreach(Tile t in closest){
                                 if(target.GetBestExtendedLineOfEffect(t).Any(x=>x.actor()==this)){
                                     in_line.Add(t);
                                 }
                             }
                             Tile tile2 = null;
                             if(in_line.Count > 0){
                                 tile2 = in_line.Random();
                             }
                             else{
                                 if(closest.Count > 0){
                                     tile2 = closest.Random();
                                 }
                             }
                             if(tile2 != null && tile2.actor() != thrall){
                                 GainAttr(AttrType.COOLDOWN_1,400);
                                 B.Add(TheName(true) + " teleports " + thrall.TheName(true) + ". ",this,thrall);
                                 M.Draw();
                                 thrall.Move(tile2.row,tile2.col);
                                 B.DisplayNow();
                                 Screen.AnimateStorm(tile2.p,1,1,4,thrall.symbol,thrall.color);
                                 foreach(Tile t2 in thrall.GetBestLineOfEffect(tile2)){
                                     Screen.AnimateStorm(t2.p,1,1,4,thrall.symbol,thrall.color);
                                 }
                                 Q1();
                             }
                             else{
                                 List<Tile> safe = target.GetBestExtendedLineOfEffect(thrall).Where(t=>t.passable
                                 && t.actor() == null && t.DistanceFrom(target) > thrall.DistanceFrom(target)).WhereLeast(t=>DistanceFrom(t));
                                 if(safe.Count > 0){
                                     if(safe.Any(t=>t.DistanceFrom(target) > 2)){
                                         AI_Step(safe.Where(t=>t.DistanceFrom(target) > 2).Random());
                                     }
                                     else{
                                         AI_Step(safe.Random());
                                     }
                                 }
                                 QS();
                             }
                         }
                         else{
                             if(!HasAttr(AttrType.COOLDOWN_2) && thrall.attrs[AttrType.ARCANE_SHIELDED] < 25){
                                 GainAttr(AttrType.COOLDOWN_2,1500);
                                 B.Add(TheName(true) + " shields " + thrall.TheName(true) + ". ",this,thrall);
                                 B.DisplayNow();
                                 Screen.AnimateStorm(thrall.p,1,2,5,'*',Color.White);
                                 thrall.attrs[AttrType.ARCANE_SHIELDED] = 25;
                                 Q1();
                             }
                             else{
                                 List<Tile> safe = target.GetBestExtendedLineOfEffect(thrall).Where(t=>t.passable && t.actor() == null).WhereLeast(t=>DistanceFrom(t));
                                 if(safe.Count > 0){
                                     if(safe.Any(t=>t.DistanceFrom(target) > 2)){
                                         AI_Step(safe.Where(t=>t.DistanceFrom(target) > 2).Random());
                                     }
                                     else{
                                         AI_Step(safe.Random());
                                     }
                                 }
                                 QS();
                             }
                         }
                     }
                 }*/
             }
             else{
                 group[1].FindPath(this); //call for help
                 if(AI_Flee()){
                     QS();
                 }
                 else{
                     if(DistanceFrom(target) == 1){
                         Attack(0,target);
                     }
                     else{
                         QS();
                     }
                 }
             }
         }
         break;
     case ActorType.ORC_GRENADIER:
         if(!HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 8){
             attrs[AttrType.COOLDOWN_1]++;
             Q.Add(new Event(this,(R.Roll(2)*100)+150,AttrType.COOLDOWN_1));
             B.Add(TheName(true) + " tosses a grenade toward " + target.the_name + ". ",target);
             List<Tile> tiles = new List<Tile>();
             foreach(Tile tile in target.TilesWithinDistance(1)){
                 if(tile.passable && !tile.Is(FeatureType.GRENADE)){
                     tiles.Add(tile);
                 }
             }
             Tile t = tiles[R.Roll(tiles.Count)-1];
             if(t.actor() != null){
                 if(t.actor() == player){
                     B.Add("It lands under you! ");
                 }
                 else{
                     B.Add("It lands under " + t.actor().the_name + ". ",t.actor());
                 }
             }
             else{
                 if(t.inv != null){
                     B.Add("It lands under " + t.inv.TheName() + ". ",t);
                 }
             }
             t.features.Add(FeatureType.GRENADE);
             Q.Add(new Event(t,100,EventType.GRENADE));
             Q1();
         }
         else{
             if(curhp <= 18){
                 if(AI_Step(target,true)){
                     QS();
                 }
                 else{
                     if(DistanceFrom(target) == 1){
                         Attack(0,target);
                     }
                     else{
                         QS();
                     }
                 }
             }
             else{
                 if(DistanceFrom(target) == 1){
                     Attack(0,target);
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
         }
         break;
     case ActorType.MARBLE_HORROR:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     case ActorType.SPELLMUDDLE_PIXIE:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
             if(target != null && R.CoinFlip()){
                 AI_Step(target,true);
             }
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     case ActorType.OGRE_BARBARIAN:
         //if has grabbed target, check for open spaces near the opposite side.
         //if one is found, slam target into that tile, then do the attack.
         //otherwise, slam target into a solid tile (target doesn't move), then attack.
         //if nothing is grabbed yet, just keep attacking.
         if(DistanceFrom(target) == 1){
             if(target.HasAttr(AttrType.GRABBED) && attrs[AttrType.GRABBING] == DirectionOf(target) && !target.MovementPrevented(tile())){
                 Tile t = null;
                 Tile opposite = TileInDirection(DirectionOf(target).RotateDir(true,4));
                 if(opposite.passable && opposite.actor() == null){
                     t = opposite;
                 }
                 if(t == null){
                     List<Tile> near_opposite = new List<Tile>();
                     foreach(int i in new int[]{-1,1}){
                         Tile near = TileInDirection(DirectionOf(target).RotateDir(true,4+i));
                         if(near.passable && near.actor() == null){
                             near_opposite.Add(near);
                         }
                     }
                     if(near_opposite.Count > 0){
                         t = near_opposite.Random();
                     }
                 }
                 if(t != null){
                     target.attrs[AttrType.TURN_INTO_CORPSE]++;
                     Attack(1,target);
                     target.Move(t.row,t.col);
                     target.CollideWith(target.tile());
                     target.CorpseCleanup();
                 }
                 else{
                     target.attrs[AttrType.TURN_INTO_CORPSE]++;
                     Attack(1,target);
                     target.CollideWith(target.tile());
                     target.CorpseCleanup();
                 }
             }
             else{
                 Attack(0,target);
             }
         }
         else{
             if(speed == 100){
                 speed = 50;
             }
             if(!HasAttr(AttrType.COOLDOWN_1) && target == player && player.CanSee(this)){
                 B.Add(the_name + " charges! ");
                 attrs[AttrType.COOLDOWN_1] = 1;
             }
             AI_Step(target);
             if(!HasAttr(AttrType.COOLDOWN_1) && target == player && player.CanSee(this)){ //check twice so the message appears ASAP
                 B.Add(the_name + " charges! ");
                 attrs[AttrType.COOLDOWN_1] = 1;
             }
             QS();
         }
         break;
     case ActorType.MARBLE_HORROR_STATUE:
         QS();
         break;
     case ActorType.PYREN_ARCHER: //still considering some sort of fire trail movement ability for this guy
         switch(DistanceFrom(target)){
         case 1:
             if(target.EnemiesAdjacent() > 1){
                 Attack(0,target);
             }
             else{
                 if(AI_Flee()){
                     QS();
                 }
                 else{
                     Attack(0,target);
                 }
             }
             break;
         case 2:
             if(FirstActorInLine(target) == target){
                 FireArrow(target);
             }
             else{
                 if(AI_Flee()){
                     QS();
                 }
                 else{
                     if(AI_Sidestep(target)){
                         B.Add(the_name + " tries to line up a shot. ",this);
                     }
                     QS();
                 }
             }
             break;
         case 3:
         case 4:
         case 5:
         case 6:
         case 7:
         case 8:
         case 9:
         case 10:
         case 11:
         case 12:
             if(FirstActorInLine(target) == target){
                 FireArrow(target);
             }
             else{
                 if(AI_Sidestep(target)){
                     B.Add(the_name + " tries to line up a shot. ",this);
                 }
                 QS();
             }
             break;
         default:
             AI_Step(target);
             QS();
             break;
         }
         break;
     case ActorType.CYCLOPEAN_TITAN:
     {
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             if(DistanceFrom(target) > 2 && DistanceFrom(target) <= 12 && R.OneIn(15) && FirstActorInLine(target) == target){
                 B.Add(TheName(true) + " lobs a huge rock! ",this,target);
                 AnimateProjectile(target,'*',Color.Gray);
                 pos tp = target.p;
                 int plus_to_hit = -target.TotalSkill(SkillType.DEFENSE)*3;
                 if(target.IsHit(plus_to_hit)){
                     B.Add("It hits " + target.the_name + "! ",target);
                     if(target.TakeDamage(DamageType.NORMAL,DamageClass.PHYSICAL,R.Roll(4,6),this,"a cyclopean titan's rock")){
                         if(R.OneIn(8)){
                             target.ApplyStatus(AttrType.STUNNED,R.Between(3,4)*100);
                         }
                     }
                 }
                 else{
                     int armor_value = target.TotalProtectionFromArmor();
                     if(target != player){
                         armor_value = target.TotalSkill(SkillType.DEFENSE); //if monsters have Defense skill, it's from armor
                     }
                     int roll = R.Roll(25 - plus_to_hit);
                     if(roll <= armor_value * 3){
                         B.Add(target.Your() + " armor blocks it! ",target);
                     }
                     else{
                         if(target.HasAttr(AttrType.ROOTS) && roll <= (armor_value + 10) * 3){ //potion of roots gives 10 defense
                             B.Add(target.Your() + " root shell blocks it! ",target);
                         }
                         else{
                             B.Add(target.You("avoid") + " it! ",target);
                         }
                     }
                 }
                 foreach(pos neighbor in tp.PositionsWithinDistance(1,M.tile)){
                     Tile t = M.tile[neighbor];
                     if(t.Is(TileType.FLOOR) && R.OneIn(4)){
                         t.Toggle(null,TileType.GRAVEL);
                     }
                 }
                 Q1();
             }
             else{
                 bool smashed = false;
                 if(DistanceFrom(target) == 2 && !HasLOE(target)){
                     Tile t = FirstSolidTileInLine(target);
                     if(t != null && !t.passable){
                         smashed = true;
                         B.Add(You("smash",true) + " through " + t.TheName(true) + "! ",t);
                         foreach(int dir in DirectionOf(t).GetArc(1)){
                             TileInDirection(dir).Smash(dir);
                         }
                         Move(t.row,t.col);
                         QS();
                     }
                 }
                 if(!smashed){
                     AI_Step(target);
                     QS();
                 }
             }
         }
         break;
     }
     case ActorType.ALASI_SENTINEL:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
             if(HasAttr(AttrType.JUST_FLUNG)){
                 attrs[AttrType.JUST_FLUNG] = 0;
             }
             else{
                 if(target != null){
                     List<Tile> valid_dirs = new List<Tile>();
                     foreach(Tile t in target.TilesAtDistance(1)){
                         if(t.passable && t.actor() == null && DistanceFrom(t) == 1){
                             valid_dirs.Add(t);
                         }
                     }
                     if(valid_dirs.Count > 0){
                         AI_Step(valid_dirs.Random());
                     }
                 }
             }
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     case ActorType.NOXIOUS_WORM:
         if(!HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 12 && HasLOE(target)){
             B.Add(TheName(true) + " breathes poisonous gas. ");
             List<Tile> area = new List<Tile>();
             foreach(Tile t in target.TilesWithinDistance(1)){
                 if(t.passable && target.HasLOE(t)){
                     t.AddFeature(FeatureType.POISON_GAS);
                     area.Add(t);
                 }
             }
             List<Tile> area2 = target.tile().AddGaseousFeature(FeatureType.POISON_GAS,8);
             area.AddRange(area2);
             Event.RemoveGas(area,600,FeatureType.POISON_GAS,18);
             RefreshDuration(AttrType.COOLDOWN_1,(R.Roll(6) + 18) * 100);
             Q1();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     case ActorType.LASHER_FUNGUS:
     {
         if(DistanceFrom(target) <= 12){
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 if(FirstActorInLine(target) == target){
                     List<Tile> line = GetBestLineOfEffect(target.row,target.col);
                     line.Remove(line[line.Count-1]);
                     AnimateBoltBeam(line,Color.DarkGreen);
                     pos target_p = target.p;
                     if(Attack(1,target) && M.actor[target_p] != null){
                         target = M.actor[target_p];
                         int rowchange = 0;
                         int colchange = 0;
                         if(target.row < row){
                             rowchange = 1;
                         }
                         if(target.row > row){
                             rowchange = -1;
                         }
                         if(target.col < col){
                             colchange = 1;
                         }
                         if(target.col > col){
                             colchange = -1;
                         }
                         if(!target.AI_MoveOrOpen(target.row+rowchange,target.col+colchange)){
                             bool moved = false;
                             if(Math.Abs(target.row - row) > Math.Abs(target.col - col)){
                                 if(target.AI_Step(M.tile[row,target.col])){
                                     moved = true;
                                 }
                             }
                             else{
                                 if(Math.Abs(target.row - row) < Math.Abs(target.col - col)){
                                     if(target.AI_Step(M.tile[target.row,col])){
                                         moved = true;
                                     }
                                 }
                                 else{
                                     if(target.AI_Step(this)){
                                         moved = true;
                                     }
                                 }
                             }
                             if(!moved){ //todo: this still isn't ideal. maybe I need an AI_Step that only considers 3 directions - right now, it'll make you move even if it isn't closer.
                                 B.Add(target.You("do",true) + "n't move far. ",target);
                             }
                         }
                     }
                 }
                 else{
                     Q1();
                 }
             }
         }
         else{
             Q1();
         }
         break;
     }
     case ActorType.LUMINOUS_AVENGER:
     {
         if(DistanceFrom(target) <= 3){
             List<Tile> ext = GetBestExtendedLineOfEffect(target);
             int max_count = Math.Min(5,ext.Count); //look 4 spaces away unless the line is even shorter than that.
             List<Actor> targets = new List<Actor>();
             Tile destination = null;
             for(int i=0;i<max_count;++i){
                 Tile t = ext[i];
                 if(t.passable){
                     if(t.actor() == null){
                         if(targets.Contains(target)){
                             destination = t;
                         }
                     }
                     else{
                         if(t.actor() != this){
                             targets.Add(t.actor());
                         }
                     }
                 }
                 else{
                     break;
                 }
             }
             if(destination != null){
                 Move(destination.row,destination.col);
                 foreach(Tile t in ext.To(destination)){
                     colorchar cch = M.VisibleColorChar(t.row,t.col);
                     cch.bgcolor = Color.Yellow;
                     if(Global.LINUX && !Screen.GLMode){
                         cch.bgcolor = Color.DarkYellow;
                     }
                     if(cch.color == cch.bgcolor){
                         cch.color = Color.Black;
                     }
                     Screen.WriteMapChar(t.row,t.col,cch);
                     Game.GLUpdate();
                     Thread.Sleep(15);
                 }
                 foreach(Actor a in targets){
                     Attack(0,a,true);
                 }
                 Q1();
             }
             else{
                 if(DistanceFrom(target) == 1){
                     Attack(0,target);
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     }
     case ActorType.VAMPIRE:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             if(DistanceFrom(target) <= 12){
                 if(tile().IsLit() && !HasAttr(AttrType.COOLDOWN_1)){
                     attrs[AttrType.COOLDOWN_1]++;
                     B.Add(the_name + " gestures. ",this);
                     List<Tile> tiles = new List<Tile>();
                     foreach(Tile t in target.TilesWithinDistance(6)){
                         if(t.passable && t.actor() == null && DistanceFrom(t) >= DistanceFrom(target)
                         && target.HasLOS(t) && target.HasLOE(t)){
                             tiles.Add(t);
                         }
                     }
                     if(tiles.Count == 0){
                         foreach(Tile t in target.TilesWithinDistance(6)){ //same, but with no distance requirement
                             if(t.passable && t.actor() == null && target.HasLOS(t) && target.HasLOE(t)){
                                 tiles.Add(t);
                             }
                         }
                     }
                     if(tiles.Count == 0){
                         B.Add("Nothing happens. ",this);
                     }
                     else{
                         if(tiles.Count == 1){
                             B.Add("A blood moth appears! ");
                         }
                         else{
                             B.Add("Blood moths appear! ");
                         }
                         for(int i=0;i<2;++i){
                             if(tiles.Count > 0){
                                 Tile t = tiles.RemoveRandom();
                                 Create(ActorType.BLOOD_MOTH,t.row,t.col,TiebreakerAssignment.InsertAfterCurrent);
                                 M.actor[t.row,t.col].player_visibility_duration = -1;
                             }
                         }
                     }
                     Q1();
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     case ActorType.ORC_WARMAGE:
     {
         if(SilencedThisTurn()){
             return;
         }
         switch(DistanceFrom(target)){
         case 1:
         {
             List<SpellType> close_range = new List<SpellType>();
             close_range.Add(SpellType.MAGIC_HAMMER);
             close_range.Add(SpellType.MAGIC_HAMMER);
             close_range.Add(SpellType.BLINK);
             if(target.EnemiesAdjacent() > 1 || R.CoinFlip()){
                 CastCloseRangeSpellOrAttack(close_range,target,false);
             }
             else{
                 if(AI_Step(target,true)){
                     QS();
                 }
                 else{
                     CastCloseRangeSpellOrAttack(close_range,target,false);
                 }
             }
             break;
         }
         case 2:
             if(R.CoinFlip()){
                 if(AI_Step(target,true)){
                     QS();
                 }
                 else{
                     if(FirstActorInLine(target) == target){
                         CastRangedSpellOrMove(target);
                     }
                     else{
                         AI_Sidestep(target);
                         QS();
                     }
                 }
             }
             else{
                 if(FirstActorInLine(target) == target){
                     CastRangedSpellOrMove(target);
                 }
                 else{
                     if(AI_Step(target,true)){
                         QS();
                     }
                     else{
                         AI_Sidestep(target);
                         QS();
                     }
                 }
             }
             break;
         case 3:
         case 4:
         case 5:
         case 6:
         case 7:
         case 8:
         case 9:
         case 10:
         case 11:
         case 12:
             if(FirstActorInLine(target) == target){
                 CastRangedSpellOrMove(target);
             }
             else{
                 AI_Sidestep(target);
                 QS();
             }
             break;
         default:
             AI_Step(target);
             QS();
             break;
         }
         break;
     }
     case ActorType.NECROMANCER:
     {
         if(!HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 12){
             attrs[AttrType.COOLDOWN_1]++;
             Q.Add(new Event(this,(R.Roll(4)+8)*100,AttrType.COOLDOWN_1));
             B.Add(the_name + " calls out to the dead. ",this);
             ActorType summon = R.CoinFlip()? ActorType.SKELETON : ActorType.ZOMBIE;
             List<Tile> tiles = new List<Tile>();
             foreach(Tile tile in TilesWithinDistance(2)){
                 if(tile.passable && tile.actor() == null && DirectionOf(tile) == DirectionOf(target)){
                     tiles.Add(tile);
                 }
             }
             if(tiles.Count == 0){
                 foreach(Tile tile in TilesWithinDistance(2)){
                     if(tile.passable && tile.actor() == null){
                         tiles.Add(tile);
                     }
                 }
             }
             if(tiles.Count == 0 || (group != null && group.Count > 3)){
                 B.Add("Nothing happens. ",this);
             }
             else{
                 Tile t = tiles.Random();
                 B.Add(Prototype(summon).a_name + " digs through the floor! ");
                 Create(summon,t.row,t.col,TiebreakerAssignment.InsertAfterCurrent);
                 M.actor[t.row,t.col].player_visibility_duration = -1;
                 if(group == null){
                     group = new List<Actor>{this};
                 }
                 group.Add(M.actor[t.row,t.col]);
                 M.actor[t.row,t.col].group = group;
             }
             Q1();
         }
         else{
             bool blast = false;
             switch(DistanceFrom(target)){
             case 1:
                 if(AI_Step(target,true)){
                     QS();
                 }
                 else{
                     Attack(0,target);
                 }
                 break;
             case 2:
                 if(R.CoinFlip() && FirstActorInLine(target) == target){
                     blast = true;
                 }
                 else{
                     if(AI_Step(target,true)){
                         QS();
                     }
                     else{
                         blast = true;
                     }
                 }
                 break;
             case 3:
             case 4:
             case 5:
             case 6:
                 if(FirstActorInLine(target) == target){
                     blast = true;
                 }
                 else{
                     AI_Sidestep(target);
                     QS();
                 }
                 break;
             default:
                 AI_Step(target);
                 QS();
                 break;
             }
             if(blast){
                 B.Add(TheName(true) + " fires dark energy at " + target.TheName(true) + ". ",this,target);
                 AnimateBoltProjectile(target,Color.DarkBlue);
                 if(target.TakeDamage(DamageType.MAGIC,DamageClass.MAGICAL,R.Roll(6),this,"*blasted by a necromancer")){
                     target.IncreaseExhaustion(R.Roll(3));
                 }
                 Q1();
             }
         }
         break;
     }
     case ActorType.STALKING_WEBSTRIDER:
     {
         bool burrow = false;
         if(DistanceFrom(target) >= 2 && DistanceFrom(target) <= 6){
             if(R.CoinFlip() && !target.tile().Is(FeatureType.WEB)){
                 burrow = true;
             }
         }
         if((DistanceFrom(target) > 6 || target.HasAttr(AttrType.POISONED))){
             burrow = true;
         }
         if(burrow && !HasAttr(AttrType.COOLDOWN_1)){
             RefreshDuration(AttrType.COOLDOWN_1,R.Between(5,8)*100);
             if(DistanceFrom(target) <= 2){
                 Burrow(TilesWithinDistance(6));
             }
             else{
                 Burrow(GetCone(DirectionOf(target),6,true));
             }
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         break;
     }
     case ActorType.ORC_ASSASSIN:
         if(DistanceFrom(target) > 2 && attrs[AttrType.TURNS_VISIBLE] < 0){
             Tile t = TilesAtDistance(1).Where(x=>x.passable && x.actor() == null && target.DistanceFrom(x) == target.DistanceFrom(this)-1 && !target.CanSee(x)).RandomOrDefault();
             if(t != null){
                 AI_Step(t);
                 FindPath(target); //so it won't forget where the target is...
                 QS();
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 if(DistanceFrom(target) == 1){
                     Attack(1,target);
                 }
                 else{
                     QS();
                 }
             }
         }
         break;
     case ActorType.MACHINE_OF_WAR:
     {
         if(attrs[AttrType.COOLDOWN_1] % 2 == 0){ //the machine of war moves on even turns and fires on odd turns.
             AI_Step(target);
             QS();
         }
         else{
             if(DistanceFrom(target) <= 12 && FirstActorInLine(target) == target){
                 B.Add(TheName(true) + " fires a stream of scalding oil at " + target.the_name + ". ",target);
                 List<Tile> covered_in_oil = GetBestLineOfEffect(target);
                 List<Tile> added = new List<Tile>();
                 foreach(Tile t in covered_in_oil){
                     foreach(int dir in U.FourDirections){
                         Tile neighbor = t.TileInDirection(dir);
                         if(R.OneIn(3) && neighbor.passable && !covered_in_oil.Contains(neighbor)){
                             added.AddUnique(neighbor);
                         }
                     }
                 }
                 covered_in_oil.AddRange(added);
                 List<pos> cells = new List<pos>();
                 List<Actor> oiled_actors = new List<Actor>();
                 for(int i=0;covered_in_oil.Count > 0;++i){
                     List<Tile> removed = new List<Tile>();
                     foreach(Tile t in covered_in_oil){
                         if(DistanceFrom(t) == i){
                             t.AddFeature(FeatureType.OIL);
                             if(t.actor() != null && t.actor() != this){
                                 oiled_actors.Add(t.actor());
                             }
                             removed.Add(t);
                             if(DistanceFrom(t) > 0){
                                 cells.Add(t.p);
                             }
                         }
                     }
                     foreach(Tile t in removed){
                         covered_in_oil.Remove(t);
                     }
                     if(cells.Count > 0){
                         Screen.AnimateMapCells(cells,new colorchar(',',Color.DarkYellow),20);
                     }
                 }
                 oiled_actors.AddUnique(target);
                 M.Draw();
                 foreach(Actor a in oiled_actors){
                     if(a.TakeDamage(DamageType.FIRE,DamageClass.PHYSICAL,R.Roll(4,6),this,"a stream of scalding oil")){
                         if(a.IsBurning()){
                             a.ApplyBurning();
                         }
                         else{
                             if(!a.HasAttr(AttrType.SLIMED,AttrType.FROZEN)){
                                 a.attrs[AttrType.OIL_COVERED]++;
                                 B.Add(a.YouAre() + " covered in oil. ",a);
                             }
                         }
                     }
                 }
                 Q1();
             }
             else{
                 Q1();
             }
         }
         break;
     }
     case ActorType.IMPOSSIBLE_NIGHTMARE:
     {
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             Tile t = target.TilesAtDistance(DistanceFrom(target)-1).Where(x=>x.passable && x.actor() == null).RandomOrDefault();
             if(t != null){
                 Move(t.row,t.col); //todo: fear effect?
             }
             QS();
         }
         break;
     }
     case ActorType.FIRE_DRAKE:
         /*if(player.magic_trinkets.Contains(MagicTrinketType.RING_OF_RESISTANCE) && DistanceFrom(player) <= 12 && CanSee(player)){
             B.Add(the_name + " exhales an orange mist toward you. ");
             foreach(Tile t in GetBestLineOfEffect(player)){
                 Screen.AnimateStorm(t.p,1,2,3,'*',Color.Red);
             }
             B.Add("Your ring of resistance melts and drips onto the floor! ");
             player.magic_trinkets.Remove(MagicTrinketType.RING_OF_RESISTANCE);
             Q.Add(new Event(this,100,EventType.MOVE));
         }
         else{
             if(player.EquippedArmor == ArmorType.FULL_PLATE_OF_RESISTANCE && DistanceFrom(player) <= 12 && CanSee(player)){
                 B.Add(the_name + " exhales an orange mist toward you. ");
                 foreach(Tile t in GetBestLine(player)){
                     Screen.AnimateStorm(t.p,1,2,3,'*',Color.Red);
                 }
                 B.Add("The runes drip from your full plate of resistance! ");
                 player.EquippedArmor = ArmorType.FULL_PLATE;
                 player.UpdateOnEquip(ArmorType.FULL_PLATE_OF_RESISTANCE,ArmorType.FULL_PLATE);
                 Q.Add(new Event(this,100,EventType.MOVE));
             }
             else{*/
             if(!HasAttr(AttrType.COOLDOWN_1)){
                 if(DistanceFrom(target) <= 12){
                     attrs[AttrType.COOLDOWN_1]++;
                     int cooldown = (R.Roll(1,4)+1) * 100;
                     Q.Add(new Event(this,cooldown,AttrType.COOLDOWN_1));
                     AnimateBeam(target,Color.RandomFire,'*');
                     B.Add(TheName(true) + " breathes fire. ",target);
                     target.TakeDamage(DamageType.FIRE,DamageClass.PHYSICAL,R.Roll(6,6),this,"*roasted by fire breath");
                 target.ApplyBurning();
                     Q.Add(new Event(this,200,EventType.MOVE));
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
             else{
                 if(DistanceFrom(target) == 1){
                     Attack(R.Roll(1,2)-1,target);
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
             }
             //}
         //}
         break;
     case ActorType.GHOST:
     {
         attrs[AttrType.AGGRESSION_MESSAGE_PRINTED] = 1;
         bool tombstone = false;
         foreach(Tile t in TilesWithinDistance(1)){
             if(t.type == TileType.TOMBSTONE){
                 tombstone = true;
             }
         }
         if(!tombstone){
             B.Add("The ghost vanishes. ",this);
             Kill();
             return;
         }
         if(target == null || DistanceFrom(target) > 2){
             List<Tile> valid = TilesAtDistance(1).Where(x=>x.TilesWithinDistance(1).Any(y=>y.type == TileType.TOMBSTONE));
             if(valid.Count > 0){
                 AI_Step(valid.Random());
             }
             QS();
         }
         else{
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 List<Tile> valid = tile().NeighborsBetween(target.row,target.col).Where(x=>x.passable && x.actor() == null && x.TilesWithinDistance(1).Any(y=>y.type == TileType.TOMBSTONE));
                 if(valid.Count == 0){
                     valid = TilesAtDistance(1).Where(x=>x.TilesWithinDistance(1).Any(y=>y.type == TileType.TOMBSTONE));
                 }
                 if(valid.Count > 0){
                     AI_Step(valid.Random());
                 }
                 QS();
             }
         }
         break;
     }
     case ActorType.BLADE:
     {
         attrs[AttrType.AGGRESSION_MESSAGE_PRINTED] = 1;
         List<Actor> valid_targets = new List<Actor>(); //this is based on EnragedMove(), with an exception for other blades
         int max_dist = Math.Max(Math.Max(row,col),Math.Max(ROWS-row,COLS-col)); //this should find the farthest edge of the map
         for(int i=1;i<max_dist && valid_targets.Count == 0;++i){
             foreach(Actor a in ActorsAtDistance(i)){
                 if(a.type != ActorType.BLADE && CanSee(a) && HasLOE(a)){
                     valid_targets.Add(a);
                 }
             }
         }
         if(valid_targets.Count > 0){
             if(target == null || !valid_targets.Contains(target)){ //keep old target if possible
                 target = valid_targets.Random();
             }
             if(DistanceFrom(target) == 1){
                 Attack(0,target);
             }
             else{
                 AI_Step(target);
                 QS();
             }
         }
         else{
             if(target != null){
                 SeekAI();
             }
             else{
                 QS();
             }
         }
         break;
     }
     case ActorType.PHANTOM_CONSTRICTOR:
     case ActorType.PHANTOM_WASP:
     {
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             List<Tile> tiles = new List<Tile>(); //i should turn this "slither" movement into a standardized attribute or something
             if(target.row == row || target.col == col){
                 int targetdir = DirectionOf(target);
                 for(int i=-1;i<=1;++i){
                     pos adj = p.PosInDir(targetdir.RotateDir(true,i));
                     if(M.tile[adj].passable && M.actor[adj] == null){
                         tiles.Add(M.tile[adj]);
                     }
                 }
             }
             if(tiles.Count > 0){
                 AI_Step(tiles.Random());
             }
             else{
                 AI_Step(target);
             }
             QS();
         }
         break;
     }
     case ActorType.MINOR_DEMON:
     case ActorType.FROST_DEMON:
     case ActorType.BEAST_DEMON:
     case ActorType.DEMON_LORD:
     {
         int damage_threshold = 1;
         if(type == ActorType.BEAST_DEMON){
             damage_threshold = 0;
         }
         if(target == player && attrs[AttrType.COOLDOWN_2] > damage_threshold && CanSee(target)){
             switch(type){
             case ActorType.MINOR_DEMON:
             case ActorType.BEAST_DEMON:
                 if(DistanceFrom(target) == 1){
                     Attack(0,target);
                 }
                 else{
                     AI_Step(target);
                     QS();
                 }
                 break;
             case ActorType.FROST_DEMON:
                 if(!HasAttr(AttrType.COOLDOWN_1) && DistanceFrom(target) <= 12 && FirstActorInLine(target) == target){
                     attrs[AttrType.COOLDOWN_1] = 1;
                     AnimateProjectile(target,'*',Color.RandomIce);
                     foreach(Tile t in GetBestLineOfEffect(target)){
                         t.ApplyEffect(DamageType.COLD);
                     }
                     B.Add(TheName(true) + " fires a chilling sphere. ",target);
                     if(target.TakeDamage(DamageType.COLD,DamageClass.PHYSICAL,R.Roll(3,6),this,"a frost demon")){
                         target.ApplyStatus(AttrType.SLOWED,R.Between(4,7)*100);
                         //target.RefreshDuration(AttrType.SLOWED,R.Between(4,7)*100,target.YouAre() + " no longer slowed. ",target);
                     }
                     Q1();
                 }
                 else{
                     if(DistanceFrom(target) == 1){
                         Attack(0,target);
                     }
                     else{
                         AI_Step(target);
                         QS();
                     }
                 }
                 break;
             case ActorType.DEMON_LORD:
                 if(DistanceFrom(target) > 2){
                     AI_Step(target);
                     QS();
                 }
                 else{
                     if(FirstActorInLine(target) != null){
                         Attack(0,target);
                     }
                     else{
                         if(AI_Step(target)){
                             QS();
                         }
                         else{
                             AI_Sidestep(target);
                             QS();
                         }
                     }
                 }
                 break;
             }
         }
         else{
             if(row >= 7 && row <= 12 && col >= 30 && col <= 35){ //near the center
                 foreach(Actor a in ActorsAtDistance(1)){
                     if(a.IsFinalLevelDemon()){
                         List<Tile> dist2 = new List<Tile>();
                         foreach(Tile t in TilesWithinDistance(5)){
                             if(t.TilesAtDistance(2).Any(x=>x.type == TileType.FIRE_RIFT) && !t.TilesAtDistance(1).Any(x=>x.type == TileType.FIRE_RIFT)){
                                 dist2.Add(t);
                             }
                         } //if there's another distance 2 (from the center) tile with no adjacent demons, move there
                         //List<Tile> valid = dist2.Where(x=>DistanceFrom(x) == 1 && x.actor() == null && !x.TilesAtDistance(1).Any(y=>y.actor() != null && y.actor().Is(ActorType.MINOR_DEMON,ActorType.FROST_DEMON,ActorType.BEAST_DEMON,ActorType.DEMON_LORD)));
                         List<Tile> valid = dist2.Where(x=>DistanceFrom(x) == 1);
                         valid = valid.Where(x=>x.actor() == null && !x.TilesAtDistance(1).Any(y=>y.actor() != null && y.actor() != this && y.actor().IsFinalLevelDemon()));
                         if(valid.Count > 0){
                             AI_Step(valid.Random());
                         }
                         break;
                     }
                 }
                 if(player.HasLOS(this)){
                     B.Add(TheName(true) + " chants. ",this);
                 }
                 M.IncrementClock();
                 Q1();
             }
             else{
                 if(path != null && path.Count > 0){
                     if(!PathStep()){
                         QS();
                     }
                 }
                 else{
                     FindPath(9+R.Between(0,1),32+R.Between(0,1));
                     if(!PathStep()){
                         QS();
                     }
                 }
             }
         }
         break;
     }
     default:
         if(DistanceFrom(target) == 1){
             Attack(0,target);
         }
         else{
             AI_Step(target);
             QS();
         }
         break;
     }
 }