一亩三分地论坛

 找回密码
 获取更多干货,去instant注册!

扫码关注一亩三分地公众号
查看: 1739|回复: 2
收起左侧

[CS61A]Ants

[复制链接] |试试Instant~ |关注本帖
sky420 发表于 2015-6-1 14:32:34 | 显示全部楼层 |阅读模式

[其他]CS61A #3 - 04@UCBerkely

注册一亩三分地论坛,查看更多干货!

您需要 登录 才可以下载或查看,没有帐号?获取更多干货,去instant注册!

x
Project Link: http://gaotx.com/cs61a/proj/ants/
liyimeng 发表于 2016-2-19 08:05:46 | 显示全部楼层
queenant写了1个小时,也不知写没写对。。。。反正test case可以过。感觉自己阅读好烂。。。。另外extra没写,别的都可以通过,代码如下:
  1. """The ants module implements game logic for Ants Vs. SomeBees."""

  2. import random
  3. import sys
  4. from ucb import main, interact, trace
  5. from collections import OrderedDict


  6. ################
  7. # Core Classes #
  8. ################


  9. class Place:
  10.         """A Place holds insects and has an exit to another Place."""
  11.         def __init__(self, name, exit=None):
  12.                 """Create a Place with the given exit.

  13.                 name -- A string; the name of this Place.
  14.                 exit -- The Place reached by exiting this Place (may be None).
  15.                 """
  16.                 self.name = name
  17.                 self.exit = exit
  18.                 self.bees = []        # A list of Bees
  19.                 self.ant = None       # An Ant
  20.                 self.entrance = None  # A Place
  21.                 # Phase 1: Add an entrance to the exit
  22.                 if exit != None:
  23.                         exit.entrance = self


  24.         def add_insect(self, insect):
  25.                 """Add an Insect to this Place.

  26.                 There can be at most one Ant in a Place, unless exactly one of them is
  27.                 a BodyguardAnt (Phase 4), in which case there can be two. If add_insect
  28.                 tries to add more Ants than is allowed, an assertion error is raised.

  29.                 There can be any number of Bees in a Place.
  30.                 """
  31.                 if insect.is_ant:
  32.                         # Phase 4: Special handling for BodyguardAnt
  33.                         #            assert self.ant is None, 'Two ants in {0}'.format(self)
  34.                         if self.ant != None and self.ant.can_contain(insect):
  35.                                 self.ant.contain_ant(insect)
  36.                         elif self.ant != None and insect.can_contain(self.ant):
  37.                                 insect, self.ant = self.ant, insect                        # swap
  38.                                 self.ant.contain_ant(insect)
  39.                         else:
  40.                                 assert self.ant is None, 'Two ants in {0}'.format(self)
  41.                                 self.ant = insect
  42.                 else:
  43.                         self.bees.append(insect)
  44.                 insect.place = self

  45.         def remove_insect(self, insect):
  46.                 """Remove an Insect from this Place."""
  47.                 if insect.is_ant:
  48.                         assert self.ant == insect, '{0} is not in {1}'.format(insect, self)
  49.                         # Phase 4: Special handling for BodyguardAnt and QueenAnt
  50.                         if self.ant.container == True and self.ant.ant != None:
  51.                                 self.ant = self.ant.ant
  52.                         elif self.ant.__class__ is not QueenAnt or self.ant.impostor == True:
  53.                                 self.ant = None
  54.                 else:
  55.                         self.bees.remove(insect)

  56.                 insect.place = None

  57.         def __str__(self):
  58.                 return self.name


  59. class Insect:
  60.     """An Insect, the base class of Ant and Bee, has armor and a Place."""

  61.     is_ant = False
  62.     watersafe = False

  63.     def __init__(self, armor, place=None):
  64.         """Create an Insect with an armor amount and a starting Place."""
  65.         self.armor = armor
  66.         self.place = place  # set by Place.add_insect and Place.remove_insect

  67.     def reduce_armor(self, amount):
  68.         """Reduce armor by amount, and remove the insect from its place if it
  69.         has no armor remaining.

  70.         >>> test_insect = Insect(5)
  71.         >>> test_insect.reduce_armor(2)
  72.         >>> test_insect.armor
  73.         3
  74.         """
  75.         self.armor -= amount
  76.         if self.armor <= 0:
  77.             print('{0} ran out of armor and expired'.format(self))
  78.             self.place.remove_insect(self)

  79.     def action(self, colony):
  80.         """The action performed each turn.

  81.         colony -- The AntColony, used to access game state information.
  82.         """

  83.     def __repr__(self):
  84.         cname = type(self).__name__
  85.         return '{0}({1}, {2})'.format(cname, self.armor, self.place)


  86. class Bee(Insect):
  87.         """A Bee moves from place to place, following exits and stinging ants."""

  88.         name = 'Bee'
  89.         watersafe = True        # override the Insect class variable

  90.         def sting(self, ant):
  91.                 """Attack an Ant, reducing the Ant's armor by 1."""
  92.                 ant.reduce_armor(1)

  93.         def move_to(self, place):
  94.                 """Move from the Bee's current Place to a new Place."""
  95.                 self.place.remove_insect(self)
  96.                 place.add_insect(self)

  97.         def blocked(self):
  98.                 """Return True if this Bee cannot advance to the next Place."""
  99.                 # Phase 3: Special handling for NinjaAnt
  100.                 if self.place.ant == None or self.place.ant.blocks_path == False:
  101.                         return False
  102.                 return True

  103.         def action(self, colony):
  104.                 """A Bee's action stings the Ant that blocks its exit if it is blocked,
  105.                 or moves to the exit of its current place otherwise.

  106.                 colony -- The AntColony, used to access game state information.
  107.                 """
  108.                 if self.blocked():
  109.                         self.sting(self.place.ant)
  110.                 elif self.place is not colony.hive and self.armor > 0:
  111.                         self.move_to(self.place.exit)


  112. class Ant(Insect):
  113.         """An Ant occupies a place and does work for the colony."""

  114.         is_ant = True
  115.         implemented = True  # Only implemented Ant classes should be instantiated
  116.         damage = 0
  117.         food_cost = 0
  118.         blocks_path = True                # the bees can't fly by this spot
  119.         container = False                # indicats whether an ant cancontain another

  120.         def __init__(self, armor=1):
  121.                 """Create an Ant with an armor quantity."""
  122.                 Insect.__init__(self, armor)

  123.         def can_contain(self, other):
  124.                 """Return true if:
  125.                 1. This ant is a container
  126.                 2. This ant does not already contain another ant
  127.                 3. the other ant is not container"""
  128.                 if self.container == True and self.ant == None and other.container == False:
  129.                         return True
  130.                 return False

  131. class HarvesterAnt(Ant):
  132.     """HarvesterAnt produces 1 additional food per turn for the colony."""

  133.     name = 'Harvester'
  134.     implemented = True
  135.     food_cost = 2

  136.     def action(self, colony):
  137.         """Produce 1 additional food for the colony.

  138.         colony -- The AntColony, used to access game state information.
  139.         """
  140.         colony.food += 1


  141. def random_or_none(s):
  142.     """Return a random element of sequence s, or return None if s is empty."""
  143.     if s:
  144.         return random.choice(s)


  145. class ThrowerAnt(Ant):
  146.     """ThrowerAnt throws a leaf each turn at the nearest Bee in its range."""

  147.     name = 'Thrower'
  148.     implemented = True
  149.     damage = 1
  150.     food_cost = 4
  151.     min_range = 0
  152.     max_range = 10

  153.     def nearest_bee(self, hive):
  154.         """Return the nearest Bee in a Place that is not the Hive, connected to
  155.         the ThrowerAnt's Place by following entrances.

  156.         This method returns None if there is no such Bee (or none in range).
  157.         """
  158.         cur_place = self.place
  159.         index = 0
  160.         while cur_place != hive:
  161.             if len(cur_place.bees) != 0 and index >= self.min_range and index <= self.max_range:
  162.                 return random_or_none(cur_place.bees)
  163.             index += 1
  164.             cur_place = cur_place.entrance
  165.         return None

  166.     def throw_at(self, target):
  167.         """Throw a leaf at the target Bee, reducing its armor."""
  168.         if target is not None:
  169.             target.reduce_armor(self.damage)

  170.     def action(self, colony):
  171.         """Throw a leaf at the nearest Bee in range."""
  172.         self.throw_at(self.nearest_bee(colony.hive))


  173. class Hive(Place):
  174.     """The Place from which the Bees launch their assault.

  175.     assault_plan -- An AssaultPlan; when & where bees enter the colony.
  176.     """

  177.     def __init__(self, assault_plan):
  178.         self.name = 'Hive'
  179.         self.assault_plan = assault_plan
  180.         self.bees = []
  181.         for bee in assault_plan.all_bees:
  182.             self.add_insect(bee)
  183.         # The following attributes are always None for a Hive
  184.         self.entrance = None
  185.         self.ant = None
  186.         self.exit = None

  187.     def strategy(self, colony):
  188.         exits = [p for p in colony.places.values() if p.entrance is self]
  189.         for bee in self.assault_plan.get(colony.time, []):
  190.             bee.move_to(random.choice(exits))


  191. class AntColony:
  192.     """An ant collective that manages global game state and simulates time.

  193.     Attributes:
  194.     time -- elapsed time
  195.     food -- the colony's available food total
  196.     queen -- the place where the queen resides
  197.     places -- A list of all places in the colony (including a Hive)
  198.     bee_entrances -- A list of places that bees can enter
  199.     """

  200.     def __init__(self, strategy, hive, ant_types, create_places, food=2):
  201.         """Create an AntColony for simulating a game.

  202.         Arguments:
  203.         strategy -- a function to deploy ants to places
  204.         hive -- a Hive full of bees
  205.         ant_types -- a list of ant constructors
  206.         create_places -- a function that creates the set of places
  207.         """
  208.         self.time = 0
  209.         self.food = food
  210.         self.strategy = strategy
  211.         self.hive = hive
  212.         self.ant_types = OrderedDict((a.name, a) for a in ant_types)
  213.         self.configure(hive, create_places)

  214.     def configure(self, hive, create_places):
  215.         """Configure the places in the colony."""
  216.         self.queen = Place('AntQueen')
  217.         self.places = OrderedDict()
  218.         self.bee_entrances = []
  219.         def register_place(place, is_bee_entrance):
  220.             self.places[place.name] = place
  221.             if is_bee_entrance:
  222.                 place.entrance = hive
  223.                 self.bee_entrances.append(place)
  224.         register_place(self.hive, False)
  225.         create_places(self.queen, register_place)

  226.     def simulate(self):
  227.         """Simulate an attack on the ant colony (i.e., play the game)."""
  228.         while len(self.queen.bees) == 0 and len(self.bees) > 0:
  229.             self.hive.strategy(self)    # Bees invade
  230.             self.strategy(self)         # Ants deploy
  231.             for ant in self.ants:       # Ants take actions
  232.                 if ant.armor > 0:
  233.                     ant.action(self)
  234.             for bee in self.bees:       # Bees take actions
  235.                 if bee.armor > 0:
  236.                     bee.action(self)
  237.             self.time += 1
  238.         if len(self.queen.bees) > 0:
  239.             print('The ant queen has perished. Please try again.')
  240.         else:
  241.             print('All bees are vanquished. You win!')

  242.     def deploy_ant(self, place_name, ant_type_name):
  243.         """Place an ant if enough food is available.

  244.         This method is called by the current strategy to deploy ants.
  245.         """
  246.         constructor = self.ant_types[ant_type_name]
  247.         if self.food < constructor.food_cost:
  248.             print('Not enough food remains to place ' + ant_type_name)
  249.         else:
  250.             self.places[place_name].add_insect(constructor())
  251.             self.food -= constructor.food_cost

  252.     def remove_ant(self, place_name):
  253.         """Remove an Ant from the Colony."""
  254.         place = self.places[place_name]
  255.         if place.ant is not None:
  256.             place.remove_insect(place.ant)

  257.     @property
  258.     def ants(self):
  259.         return [p.ant for p in self.places.values() if p.ant is not None]

  260.     @property
  261.     def bees(self):
  262.         return [b for p in self.places.values() for b in p.bees]

  263.     @property
  264.     def insects(self):
  265.         return self.ants + self.bees

  266.     def __str__(self):
  267.         status = ' (Food: {0}, Time: {1})'.format(self.food, self.time)
  268.         return str([str(i) for i in self.ants + self.bees]) + status


  269. def ant_types():
  270.     """Return a list of all implemented Ant classes."""
  271.     all_ant_types = []
  272.     new_types = [Ant]
  273.     while new_types:
  274.         new_types = [t for c in new_types for t in c.__subclasses__()]
  275.         all_ant_types.extend(new_types)
  276.     return [t for t in all_ant_types if t.implemented]

  277. def interactive_strategy(colony):
  278.     """A strategy that starts an interactive session and lets the user make
  279.     changes to the colony.

  280.     For example, one might deploy a ThrowerAnt to the first tunnel by invoking
  281.     colony.deploy_ant('tunnel_0_0', 'Thrower')
  282.     """
  283.     print('colony: ' + str(colony))
  284.     msg = '<Control>-D (<Control>-Z <Enter> on Windows) completes a turn.\n'
  285.     interact(msg)

  286. def start_with_strategy(args, strategy):
  287.     """Reads command-line arguments and starts a game with those options."""
  288.     import argparse
  289.     parser = argparse.ArgumentParser(description="Play Ants vs. SomeBees")
  290.     parser.add_argument('-f', '--full', action='store_true',
  291.                         help='loads a full layout and assault plan')
  292.     parser.add_argument('-w', '--water', action='store_true',
  293.                         help='loads a full layout with water')
  294.     parser.add_argument('-i', '--insane', action='store_true',
  295.                         help='loads a difficult assault plan')
  296.     parser.add_argument('--food', type=int,
  297.                         help='number of food to start with', default=2)
  298.     args = parser.parse_args()

  299.     assault_plan = make_test_assault_plan()
  300.     layout = test_layout
  301.     food = args.food
  302.     if args.full:
  303.         assault_plan = make_full_assault_plan()
  304.         layout = dry_layout
  305.     if args.water:
  306.         layout = wet_layout
  307.     if args.insane:
  308.         assault_plan = make_insane_assault_plan()
  309.     hive = Hive(assault_plan)
  310.     AntColony(strategy, hive, ant_types(), layout, food).simulate()


  311. ###########
  312. # Layouts #
  313. ###########

  314. def wet_layout(queen, register_place, length=8, tunnels=3, moat_frequency=3):
  315.     """Register a mix of wet and and dry places."""
  316.     for tunnel in range(tunnels):
  317.         exit = queen
  318.         for step in range(length):
  319.             if moat_frequency != 0 and (step + 1) % moat_frequency == 0:
  320.                 exit = Water('water_{0}_{1}'.format(tunnel, step), exit)
  321.             else:
  322.                 exit = Place('tunnel_{0}_{1}'.format(tunnel, step), exit)
  323.             register_place(exit, step == length - 1)

  324. def dry_layout(queen, register_place, length=8, tunnels=3):
  325.     """Register dry tunnels."""
  326.     wet_layout(queen, register_place, length, tunnels, 0)

  327. def test_layout(queen, register_place, length=8):
  328.     """Register a single dry tunnel."""
  329.     dry_layout(queen, register_place, length, 1)


  330. #################
  331. # Assault Plans #
  332. #################


  333. class AssaultPlan(dict):
  334.     """The Bees' plan of attack for the Colony.  Attacks come in timed waves.

  335.     An AssaultPlan is a dictionary from times (int) to waves (list of Bees).

  336.     >>> AssaultPlan().add_wave(4, 2)
  337.     {4: [Bee(3, None), Bee(3, None)]}
  338.     """

  339.     def __init__(self, bee_armor=3):
  340.         self.bee_armor = bee_armor

  341.     def add_wave(self, time, count):
  342.         """Add a wave at time with count Bees that have the specified armor."""
  343.         bees = [Bee(self.bee_armor) for _ in range(count)]
  344.         self.setdefault(time, []).extend(bees)
  345.         return self

  346.     @property
  347.     def all_bees(self):
  348.         """Place all Bees in the hive and return the list of Bees."""
  349.         return [bee for wave in self.values() for bee in wave]

  350. def make_test_assault_plan():
  351.     return AssaultPlan().add_wave(2, 1).add_wave(3, 1)

  352. def make_full_assault_plan():
  353.     plan = AssaultPlan().add_wave(2, 1)
  354.     for time in range(3, 15, 2):
  355.         plan.add_wave(time, 1)
  356.     return plan.add_wave(15, 8)

  357. def make_insane_assault_plan():
  358.     plan = AssaultPlan(4).add_wave(1, 2)
  359.     for time in range(3, 15):
  360.         plan.add_wave(time, 1)
  361.     return plan.add_wave(15, 20)

  362. ##############
  363. # Extensions #
  364. ##############

  365. class Water(Place):
  366.     """Water is a place that can only hold 'watersafe' insects."""

  367.     def add_insect(self, insect):
  368.         """Add insect if it is watersafe, otherwise reduce its armor to 0."""
  369.         print('added', insect, insect.watersafe)
  370.         Place.add_insect(self, insect)      # inherit
  371.         if not insect.watersafe:
  372.             insect.reduce_armor(insect.armor)


  373. class FireAnt(Ant):
  374.     """FireAnt cooks any Bee in its Place when it expires."""

  375.     name = 'Fire'
  376.     implemented = True
  377.     food_cost = 4
  378.     damage = 3

  379.     def reduce_armor(self, amount):
  380.         "*** YOUR CODE HERE ***"
  381.         if self.armor <= amount:
  382.             for bee in self.place.bees[:]:
  383.                 # using shallow copy
  384.                 bee.reduce_armor(self.damage)
  385.         Insect.reduce_armor(self, amount)


  386. class LongThrower(ThrowerAnt):
  387.     """A ThrowerAnt that only throws leaves at Bees at least 4 places away."""

  388.     name = 'Long'
  389.     implemented = True
  390.     food_cost = 3
  391.     min_range = 4


  392. class ShortThrower(ThrowerAnt):
  393.     """A ThrowerAnt that only throws leaves at Bees less than 3 places away."""

  394.     name = 'Short'
  395.     implemented = True
  396.     food_cost = 3
  397.     max_range = 2


  398. # The WallAnt class
  399. class WallAnt(Ant):
  400.         name = "Wall"
  401.         implemenmted = True
  402.         food_cost = 4

  403.         def __init__(self, armor = 4):
  404.                 Ant.__init__(self, armor)



  405. class NinjaAnt(Ant):
  406.         """NinjaAnt does not block the path and damages all bees in its place."""

  407.         name = 'Ninja'
  408.         damage = 1
  409.         implemented = True
  410.         blocks_path = False                # the bees can fly through the NinjaAnt
  411.         food_cost = 6                        # override

  412.         def action(self, colony):
  413.                 "*** YOUR CODE HERE ***"
  414.                 for bee in self.place.bees[:]:
  415.                         # using shallow copy
  416.                         bee.reduce_armor(self.damage)


  417. # The ScubaThrower class
  418. class ScubaThrower(ThrowerAnt):
  419.         """ScubaThrower would not lose it armor when placed in Water"""
  420.         name = "Scuba"
  421.         food_cost = 5
  422.         watersafe = True                # override the class attribute
  423.         implemenmted = True


  424. class HungryAnt(Ant):
  425.         """HungryAnt will take three turns to digest a Bee in its place.
  426.         While digesting, the HungryAnt can't eat another Bee.
  427.         """
  428.         name = 'Hungry'
  429.         implemented = True
  430.         time_to_digest = 3
  431.         food_cost = 4

  432.         def __init__(self):
  433.                 Ant.__init__(self)
  434.                 self.digesting = 0

  435.         def eat_bee(self, bee):
  436.                 if bee != None:
  437.                         bee.reduce_armor(bee.armor)
  438.                         self.digesting = self.time_to_digest

  439.         def action(self, colony):
  440.                 if self.digesting != 0:
  441.                         self.digesting -= 1
  442.                 else:
  443.                         self.eat_bee(random_or_none(self.place.bees))


  444. class BodyguardAnt(Ant):
  445.         """BodyguardAnt provides protection to other Ants."""
  446.         name = 'Bodyguard'
  447.         implemented = True
  448.         food_cost = 4
  449.         container = True

  450.         def __init__(self):
  451.                 Ant.__init__(self, 2)
  452.                 self.ant = None  # The Ant hidden in this bodyguard

  453.         def contain_ant(self, ant):
  454.                 self.ant = ant

  455.         def action(self, colony):
  456.                 if self.ant != None:
  457.                         self.ant.action(colony)


  458. class QueenPlace:
  459.         """A place that represents both places in which the bees find the queen.

  460.         (1) The original colony queen location at the end of all tunnels, and
  461.         (2) The place in which the QueenAnt resides.
  462.         """
  463.         def __init__(self, colony_queen, ant_queen):
  464.                 self.colony_queen = colony_queen
  465.                 self.ant_queen = ant_queen

  466.         @property
  467.         def bees(self):
  468.                 return self.colony_queen.bees + self.ant_queen.bees



  469. class QueenAnt(ScubaThrower):  # You should change this line
  470.         """The Queen of the colony.  The game is over if a bee enters her place."""

  471.         name = 'Queen'
  472.         implemented = True
  473.         food_cost = 6
  474.         cnt = 0                        # only one queen
  475.         double_lst = []

  476.         def __init__(self):
  477.                 Ant.__init__(self, 1)
  478.                 if QueenAnt.cnt >= 1:
  479.                         self.impostor = True
  480.                 else:
  481.                         self.impostor = False
  482.                 QueenAnt.cnt += 1

  483.         def action(self, colony):
  484.                 """A queen ant throws a leaf, but also doubles the damage of ants
  485.                 in her tunnel.

  486.                 Impostor queens do only one thing: reduce their own armor to 0.
  487.                 """
  488.                 if self.impostor is True:
  489.                         self.armor = 0
  490.                         return
  491.                 colony.queen = QueenPlace(colony.queen, self.place)
  492.                 ThrowerAnt.action(self, colony)
  493.                 pos = self.place
  494.                 if pos.ant.container is True and pos.ant not in QueenAnt.double_lst:
  495.                         pos.ant.damage *= 2
  496.                         QueenAnt.double_lst.append(pos.ant)
  497.                 while pos.entrance != None:
  498.                         if pos.entrance.ant != None and pos.entrance.ant not in QueenAnt.double_lst:
  499.                                 pos.entrance.ant.damage *= 2
  500.                                 if pos.entrance.ant.container is True and pos.entrance.ant.ant != None:
  501.                                         pos.entrance.ant.ant.damage *= 2
  502.                                         QueenAnt.double_lst.append(pos.entrance.ant.ant)
  503.                                 QueenAnt.double_lst.append(pos.entrance.ant)
  504.                         pos = pos.entrance
  505.                 pos = self.place
  506.                 while pos.exit != None:
  507.                         if pos.exit.ant != None and pos.exit.ant not in QueenAnt.double_lst:
  508.                                 pos.exit.ant.damage *= 2
  509.                                 if pos.exit.ant.container is True and pos.exit.ant.ant != None:
  510.                                         pos.exit.ant.ant.damage *= 2
  511.                                         QueenAnt.double_lst.append(pos.exit.ant.ant)
  512.                                 QueenAnt.double_lst.append(pos.exit.ant)
  513.                         pos = pos.exit


  514. class AntRemover(Ant):
  515.     """Allows the player to remove ants from the board in the GUI."""

  516.     name = 'Remover'
  517.     implemented = True

  518.     def __init__(self):
  519.         Ant.__init__(self, 0)


  520. ##################
  521. # Status Effects #
  522. ##################

  523. def make_slow(action):
  524.     """Return a new action method that calls action every other turn.

  525.     action -- An action method of some Bee
  526.     """
  527.     "*** YOUR CODE HERE ***"

  528. def make_stun(action):
  529.     """Return a new action method that does nothing.

  530.     action -- An action method of some Bee
  531.     """
  532.     "*** YOUR CODE HERE ***"

  533. def apply_effect(effect, bee, duration):
  534.     """Apply a status effect to a Bee that lasts for duration turns."""
  535.     "*** YOUR CODE HERE ***"


  536. class SlowThrower(ThrowerAnt):
  537.     """ThrowerAnt that causes Slow on Bees."""

  538.     name = 'Slow'
  539.     "*** YOUR CODE HERE ***"
  540.     implemented = False

  541.     def throw_at(self, target):
  542.         if target:
  543.             apply_effect(make_slow, target, 3)


  544. class StunThrower(ThrowerAnt):
  545.     """ThrowerAnt that causes Stun on Bees."""

  546.     name = 'Stun'
  547.     "*** YOUR CODE HERE ***"
  548.     implemented = False

  549.     def throw_at(self, target):
  550.         if target:
  551.             apply_effect(make_stun, target, 1)

  552. @main
  553. def run(*args):
  554.     start_with_strategy(args, interactive_strategy)
复制代码
回复 支持 反对

使用道具 举报

本版积分规则

请点这里访问我们的新网站:一亩三分地Instant.

Instant搜索更强大,不扣积分,内容组织的更好更整洁!目前仍在beta版本,努力完善中!反馈请点这里

关闭

一亩三分地推荐上一条 /5 下一条

手机版|小黑屋|一亩三分地论坛声明 ( 沪ICP备11015994号 )

custom counter

GMT+8, 2016-12-6 03:05

Powered by Discuz! X3

© 2001-2013 Comsenz Inc. Design By HUXTeam

快速回复 返回顶部 返回列表