Merge pull request #104 from jeffreykirchner/dev

rename grove to patch.

main/consumers/staff/session_consumer_mixins/subject_updates.py

@@ -846,52 +846,52 @@ async def update_emoji(self, event):
         await self.send_message(message_to_self=event_data, message_to_group=None,
                                 message_type=event['type'], send_to_client=True, send_to_group=False)
 
-    async def grove_harvest(self, event):
+    async def patch_harvest(self, event):
         '''
-        subject harvests from grove
+        subject harvests from patch
        '''
         if self.controlling_channel != self.channel_name:
             return
 
         logger = logging.getLogger(__name__)
-        # logger.info(f"grove_harvest: {event}")
+        # logger.info(f"patch_harvest: {event}")
 
         try:
             player_id = self.session_players_local[event["player_key"]]["id"]        
-            grove_id = event["message_text"]["grove_id"]
+            patch_id = event["message_text"]["patch_id"]
         except:
-            logger.info(f"grove_harvest: invalid data, {event['message_text']}")
+            logger.info(f"patch_harvest: invalid data, {event['message_text']}")
             return
 
-        v = await sync_to_async(sync_grove_harvest)(self.session_id, player_id, grove_id)
+        v = await sync_to_async(sync_patch_harvest)(self.session_id, player_id, patch_id)
 
         result = {"status" : v["status"], "error_message" : v["error_message"]}
 
         if v["world_state"] and v["status"]=="success":
             self.world_state_local = v["world_state"]
-            result["grove"] = self.world_state_local["groves"][str(grove_id)]
+            result["patch"] = self.world_state_local["patches"][str(patch_id)]
             result["player_id"] = player_id
-            result["grove_id"] = grove_id
+            result["patch_id"] = patch_id
             result["harvest_amount"] = v["harvest_amount"]
             result["avatar"] = self.world_state_local["avatars"][str(player_id)]                
 
         else:
-            logger.info(f"grove_harvest: invalid amounts from sync, {event['message_text']} player id {player_id}")
+            logger.info(f"patch_harvest: invalid amounts from sync, {event['message_text']} player id {player_id}")
             return
 
         await SessionEvent.objects.acreate(session_id=self.session_id, 
                                            session_player_id=player_id,
-                                           type="grove_harvest",
+                                           type="patch_harvest",
                                            period_number=self.world_state_local["current_period"],
                                            time_remaining=self.world_state_local["time_remaining"],
                                            data=result)
 
         await self.send_message(message_to_self=None, message_to_group=result,
                                 message_type=event['type'], send_to_client=False, send_to_group=True)
 
-    async def update_grove_harvest(self, event):
+    async def update_patch_harvest(self, event):
         '''
-        subject harvests from grove update
+        subject harvests from patch update
         '''
 
         event_data = event["group_data"]
@@ -1236,9 +1236,9 @@ def sync_sleep(session_id, player_id):
 
     return {"status" : status, "error_message" : error_message, "world_state" : world_state}
 
-def sync_grove_harvest(session_id, player_id, grove_id):
+def sync_patch_harvest(session_id, player_id, patch_id):
     '''
-    harvest from grove
+    harvest from patch
     '''
 
     status = "success"
@@ -1252,16 +1252,16 @@ def sync_grove_harvest(session_id, player_id, grove_id):
         parameter_set = session.parameter_set.json()
 
         player_id_s = str(player_id)
-        grove_id_s = str(grove_id)
+        patch_id_s = str(patch_id)
 
         player = session.world_state['avatars'][player_id_s]
-        grove = session.world_state['groves'][grove_id_s]
+        patch = session.world_state['patches'][patch_id_s]
 
         status = "fail"     
 
         #loop backwards through levels
-        for i in range(grove["max_levels"], 0, -1):
-            level = grove["levels"][str(i)]
+        for i in range(patch["max_levels"], 0, -1):
+            level = patch["levels"][str(i)]
 
             if not level["harvested"]:
                 status = "success"               
@@ -1270,22 +1270,22 @@ def sync_grove_harvest(session_id, player_id, grove_id):
                 break
 
         if status == "fail":
-            error_message.append({"id":"grove_harvest", "message": "The grove is empty."})
+            error_message.append({"id":"patch_harvest", "message": "The patch is empty."})
 
         #check player has enough harvests remaining
-        if status == "success" and player["period_grove_harvests"] >= parameter_set["max_grove_harvests"]:
+        if status == "success" and player["period_patch_harvests"] >= parameter_set["max_patch_harvests"]:
             status = "fail"
-            error_message.append({"id":"grove_harvest", "message": "No harvests remaining this period."})
+            error_message.append({"id":"patch_harvest", "message": "No harvests remaining this period."})
 
         if status == "success":
             summary_data = current_period.summary_data[player_id_s]
 
-            player[grove["good"]] += harvest_amount
-            player["period_grove_harvests"] += 1
+            player[patch["good"]] += harvest_amount
+            player["period_patch_harvests"] += 1
 
-            summary_data["grove_harvests_count_" + grove_id_s] += 1
-            summary_data["grove_harvests_total_" + grove_id_s] += harvest_amount
-            summary_data["harvest_total_" + grove["good"]] += harvest_amount
+            summary_data["patch_harvests_count_" + patch_id_s] += 1
+            summary_data["patch_harvests_total_" + patch_id_s] += harvest_amount
+            summary_data["harvest_total_" + patch["good"]] += harvest_amount
 
             session.save()
             current_period.save()

main/consumers/staff/session_consumer_mixins/timer.py

@@ -99,11 +99,11 @@ async def continue_timer(self, event):
                 #houses update
                 result["houses"] = self.world_state_local["houses"]
 
-                #groves update
-                result["groves"] = {}
-                for i in self.world_state_local["groves"]:
-                    grove = self.world_state_local["groves"][i]
-                    result["groves"][i] = {"levels":grove["levels"], "max_levels":grove["max_levels"]}
+                #patches update
+                result["patches"] = {}
+                for i in self.world_state_local["patches"]:
+                    patch = self.world_state_local["patches"][i]
+                    result["patches"][i] = {"levels":patch["levels"], "max_levels":patch["max_levels"]}
 
             #current locations
             result["current_locations"] = {}
@@ -299,7 +299,7 @@ def sync_continue_timer(event, session_id):
                 session = last_period.do_consumption()
                 session = session.get_current_session_period().do_timer_actions(time_remaining)
                 session = session.get_current_session_period().do_production()
-                session = session.get_current_session_period().do_grove_growth()
+                session = session.get_current_session_period().do_patch_growth()
 
                 for i in world_state["avatars"]:
                     # session.world_state["session_players"][i]["earnings"] += session.world_state["session_players"][i]["inventory"][current_period_id]

main/consumers/staff/session_parameters_consumer_mixins/__init__.py

@@ -8,4 +8,4 @@
 from .parameter_set_groups import ParameterSetGroupsMixin
 from .parameter_set_notices import ParameterSetNoticesMixin
 from .parameter_set_barriers import ParameterSetBarriersMixin
-from .parameter_set_groves import ParameterSetGrovesMixin
+from .parameter_set_patches import ParameterSetPatchesMixin

main/consumers/staff/session_parameters_consumer_mixins/parameter_set_groves.py → main/consumers/staff/session_parameters_consumer_mixins/parameter_set_patches.py

@@ -5,70 +5,70 @@
 from django.core.exceptions import ObjectDoesNotExist
 
 from main.models import Session
-from main.models import ParameterSetGrove
+from main.models import ParameterSetPatch
 
-from main.forms import ParameterSetGroveForm
+from main.forms import ParameterSetPatchForm
 
 from ..session_parameters_consumer_mixins.get_parameter_set import take_get_parameter_set
 
-class ParameterSetGrovesMixin():
+class ParameterSetPatchesMixin():
     '''
-    parameter set plaeyer mixin
+    parameter set patches mixin
     '''
 
-    async def update_parameter_set_grove(self, event):
+    async def update_parameter_set_patch(self, event):
         '''
-        update a parameterset grove
+        update a parameterset patch
         '''
 
         message_data = {}
-        message_data["status"] = await take_update_parameter_set_grove(event["message_text"])
+        message_data["status"] = await take_update_parameter_set_patch(event["message_text"])
         message_data["parameter_set"] = await take_get_parameter_set(event["message_text"]["session_id"])
 
         await self.send_message(message_to_self=message_data, message_to_group=None,
                                 message_type="update_parameter_set", send_to_client=True, send_to_group=False)
 
-    async def remove_parameterset_grove(self, event):
+    async def remove_parameterset_patch(self, event):
         '''
-        remove a parameterset grove
+        remove a parameterset patch
         '''
 
         message_data = {}
-        message_data["status"] = await take_remove_parameterset_grove(event["message_text"])
+        message_data["status"] = await take_remove_parameterset_patch(event["message_text"])
         message_data["parameter_set"] = await take_get_parameter_set(event["message_text"]["session_id"])
 
         await self.send_message(message_to_self=message_data, message_to_group=None,
                                 message_type="update_parameter_set", send_to_client=True, send_to_group=False)
 
-    async def add_parameterset_grove(self, event):
+    async def add_parameterset_patch(self, event):
         '''
-        add a parameterset grove
+        add a parameterset patch
         '''
 
         message_data = {}
-        message_data["status"] = await take_add_parameterset_grove(event["message_text"])
+        message_data["status"] = await take_add_parameterset_patch(event["message_text"])
         message_data["parameter_set"] = await take_get_parameter_set(event["message_text"]["session_id"])
 
         await self.send_message(message_to_self=message_data, message_to_group=None,
                                 message_type="update_parameter_set", send_to_client=True, send_to_group=False)
 
 @sync_to_async
-def take_update_parameter_set_grove(data):
+def take_update_parameter_set_patch(data):
     '''
-    update parameterset grove
+    update parameterset patch
     '''   
     logger = logging.getLogger(__name__) 
-    logger.info(f"Update parameterset grove: {data}")
+    logger.info(f"Update parameterset patch: {data}")
 
     session_id = data["session_id"]
-    parameterset_grove_id = data["parameterset_grove_id"]
+    parameterset_patch_id = data["parameterset_patch_id"]
     form_data = data["form_data"]
 
     try:        
         session = Session.objects.get(id=session_id)
-        parameter_set_grove = ParameterSetGrove.objects.get(id=parameterset_grove_id)       
+        parameter_set_patch = ParameterSetPatch.objects.get(id=parameterset_patch_id)       
     except ObjectDoesNotExist:
-        logger.warning(f"take_update_parameter_set_grove parameterset_grove, not found ID: {parameterset_grove_id}")
+        logger.warning(f"take_update_parameter_set_patch parameterset_patch, not found ID: {parameterset_patch_id}")
         return
 
     try:
@@ -78,87 +78,88 @@ def take_update_parameter_set_grove(data):
             levels_input.remove("")
 
     except ObjectDoesNotExist:
-        logger.warning(f"take_update_parameter_set_grove levels_input, not found ID: {parameterset_grove_id}")
+        logger.warning(f"take_update_parameter_set_patch levels_input, not found ID: {parameterset_patch_id}")
         {"value":"fail", "errors" : {f"levels_input":["Invalid input."]}} 
 
     if len(levels_input) == 0:
-        logger.warning(f"take_update_parameter_set_grove levels_input, not found ID: {parameterset_grove_id}")
+        logger.warning(f"take_update_parameter_set_patch levels_input, not found ID: {parameterset_patch_id}")
         return {"value":"fail", "errors" : {f"levels_input":["Invalid input."]}} 
 
     form_data_dict = form_data    
 
     logger.info(f'form_data_dict : {form_data_dict}')
 
-    form = ParameterSetGroveForm(form_data_dict, instance=parameter_set_grove)
+    form = ParameterSetPatchForm(form_data_dict, instance=parameter_set_patch)
     form.fields["parameter_set_group"].queryset = session.parameter_set.parameter_set_groups.all()
 
     if form.is_valid():         
         form.save()           
 
-        parameter_set_grove.levels = {}   
+        parameter_set_patch.levels = {}   
 
         for i in range(len(levels_input)):
             v = levels_input[i].strip()
             if v.isdigit():
-                parameter_set_grove.levels[str(i+1)] = {"value" : int(v), "harvested" : False}
+                parameter_set_patch.levels[str(i+1)] = {"value" : int(v), "harvested" : False}
 
-        parameter_set_grove.save()
+        parameter_set_patch.save()
 
-        parameter_set_grove.parameter_set.update_json_fk(update_groves=True)
+        parameter_set_patch.parameter_set.update_json_fk(update_patches=True)
 
         return {"value" : "success"}                      
 
-    logger.info("Invalid parameterset grove form")
+    logger.info("Invalid parameterset patch form")
     return {"value" : "fail", "errors" : dict(form.errors.items())}
 
 @sync_to_async
-def take_remove_parameterset_grove(data):
+def take_remove_parameterset_patch(data):
     '''
-    remove the specifed parmeterset grove
+    remove the specifed parmeterset patch
     '''
     logger = logging.getLogger(__name__) 
-    logger.info(f"Remove parameterset grove: {data}")
+    logger.info(f"Remove parameterset patch: {data}")
 
     session_id = data["session_id"]
-    parameterset_grove_id = data["parameterset_grove_id"]
+    parameterset_patch_id = data["parameterset_patch_id"]
 
     try:        
         session = Session.objects.get(id=session_id)
-        parameter_set_grove = ParameterSetGrove.objects.get(id=parameterset_grove_id)
+        parameter_set_patch = ParameterSetPatch.objects.get(id=parameterset_patch_id)
 
     except ObjectDoesNotExist:
-        logger.warning(f"take_remove_parameterset_grove, not found ID: {parameterset_grove_id}")
+        logger.warning(f"take_remove_parameterset_patch, not found ID: {parameterset_patch_id}")
         return
 
-    parameter_set_grove.delete()
-    session.parameter_set.update_json_fk(update_groves=True)
+    parameter_set_patch.delete()
+    session.parameter_set.update_json_fk(update_patches=True)
 
     return {"value" : "success"}
 
 @sync_to_async
-def take_add_parameterset_grove(data):
+def take_add_parameterset_patch(data):
     '''
-    add a new parameter grove to the parameter set
+    add a new parameter patch to the parameter set
     '''
     logger = logging.getLogger(__name__) 
-    logger.info(f"Add parameterset grove: {data}")
+    logger.info(f"Add parameterset patch: {data}")
 
     session_id = data["session_id"]
 
     try:        
         session = Session.objects.get(id=session_id)
     except ObjectDoesNotExist:
-        logger.warning(f"take_add_parameterset_grove session, not found ID: {session_id}")
+        logger.warning(f"take_add_parameterset_patch session, not found ID: {session_id}")
         return {"value" : "fail"}
 
-    parameter_set_grove_last = ParameterSetGrove.objects.last()
+    parameter_set_patch_last = ParameterSetPatch.objects.last()
 
-    parameter_set_grove = ParameterSetGrove.objects.create(parameter_set=session.parameter_set)
-    parameter_set_grove.setup()
-    parameter_set_grove.from_dict(parameter_set_grove_last.json())
-    parameter_set_grove.parameter_set_group = parameter_set_grove_last.parameter_set_group
-    parameter_set_grove.save()
-    session.parameter_set.update_json_fk(update_groves=True)
+    parameter_set_patch = ParameterSetPatch.objects.create(parameter_set=session.parameter_set)
+    parameter_set_patch.setup()
+    if parameter_set_patch_last:
+        parameter_set_patch.from_dict(parameter_set_patch_last.json())
+        parameter_set_patch.parameter_set_group = parameter_set_patch_last.parameter_set_group
+    parameter_set_patch.save()
+    session.parameter_set.update_json_fk(update_patches=True)
 
     return {"value" : "success"}
 

main/consumers/staff/staff_session_parameters_consumer.py

@@ -17,7 +17,7 @@ class StaffSessionParametersConsumer(SocketConsumerMixin,
                                      ControlParameterSetMixin,
                                      ParameterSetNoticesMixin,
                                      ParameterSetBarriersMixin,
-                                     ParameterSetGrovesMixin,
+                                     ParameterSetPatchesMixin,
                                      SendMessageMixin):
     '''
     websocket for parameter set

main/consumers/subject/subject_home_consumer_mixins/interface.py

@@ -168,9 +168,9 @@ async def update_emoji(self, event):
         await self.send_message(message_to_self=event_data, message_to_subjects=None, message_to_staff=None, 
                                 message_type=event['type'], send_to_client=True, send_to_group=False)
 
-    async def update_grove_harvest(self, event):
+    async def update_patch_harvest(self, event):
         '''
-        update grove harvest
+        update patch harvest
         '''
 
         event_data = event["group_data"]

main/forms/__init__.py

@@ -17,7 +17,7 @@
 from .parameter_set_field_form import ParameterSetFieldForm
 from .parameter_set_notice_form import ParameterSetNoticeForm
 from .parameter_set_barrier_form import ParameterSetBarrierForm
-from .parameter_set_grove_form import ParameterSetGroveForm
+from .parameter_set_patch_form import ParameterSetPatchForm
 
 from .session_player_name_etc_form import StaffEditNameEtcForm